Hierarchy

  • Sequelize
    • SequelizeManager

Implements

  • IManager

Constructors

Properties

Sequelize: typeof Sequelize

A reference to Sequelize constructor from sequelize. Useful for accessing DataTypes, Errors etc.

_attributes: any

A similar dummy variable that doesn't exist on the real object. Do not try to access this in real code.

Deprecated

This property will become a Symbol in v7 to prevent collisions. Use Attributes instead of this property to be forward-compatible.

_creationAttributes: any

A similar dummy variable that doesn't exist on the real object. Do not try to access this in real code.

Deprecated

This property will become a Symbol in v7 to prevent collisions. Use CreationAttributes instead of this property to be forward-compatible.

_model: Model<any, any>

A dummy variable that doesn't exist on the real object. This exists so Typescript can infer the type of the attributes in static functions. Don't try to access this!

and: (<T>(...args) => {
    [and]: T;
})

Type declaration

    • <T>(...args): {
          [and]: T;
      }
    • An AND query

      Type Parameters

      • T extends any[]

      Parameters

      • Rest ...args: T

        Each argument will be joined by AND

      Returns {
          [and]: T;
      }

      • [and]: T
cast: ((val, type) => Cast)

Type declaration

    • (val, type): Cast
    • Creates a object representing a call to the cast function.

      Parameters

      • val: unknown

        The value to cast

      • type: string

        The type to cast it to

      Returns Cast

col: ((col) => Col)

Type declaration

    • (col): Col
    • Creates a object representing a column in the DB. This is often useful in conjunction with sequelize.fn, since raw string arguments to fn will be escaped.

      Parameters

      • col: string

        The name of the column

      Returns Col

config: Config

Final config that is used by sequelize.

connectionManager: ConnectionManager
fn: ((fn, ...args) => Fn)

Type declaration

    • (fn, ...args): Fn
    • Creates a object representing a database function. This can be used in search queries, both in where and order parts, and as default values in column definitions. If you want to refer to columns in your function, you should use sequelize.col, so that the columns are properly interpreted as columns and not a strings.

      Convert a user's username to upper case

      instance.update({
      username: self.sequelize.fn('upper', self.sequelize.col('username'))
      })

      Parameters

      • fn: string

        The function you want to call

      • Rest ...args: unknown[]

        All further arguments will be passed as arguments to the function

      Returns Fn

json: ((conditionsOrPath, value?) => Json)

Type declaration

    • (conditionsOrPath, value?): Json
    • Creates an object representing nested where conditions for postgres's json data-type.

      Parameters

      • conditionsOrPath: string | object

        A hash containing strings/numbers or other nested hash, a string using dot notation or a string using postgres json syntax.

      • Optional value: string | number | boolean

        An optional value to compare against. Produces a string of the form " = ''".

      Returns Json

literal: ((val) => Literal)

Type declaration

    • (val): Literal
    • Creates a object representing a literal, i.e. something that will not be escaped.

      Parameters

      • val: string

      Returns Literal

modelManager: ModelManager
models: {
    [key: string]: ModelCtor<Model>;
}

Dictionary of all models linked with this instance.

Type declaration

  • [key: string]: ModelCtor<Model>
name: string
or: (<T>(...args) => {
    [or]: T;
})

Type declaration

    • <T>(...args): {
          [or]: T;
      }
    • An OR query

      Type Parameters

      • T extends any[]

      Parameters

      • Rest ...args: T

        Each argument will be joined by OR

      Returns {
          [or]: T;
      }

      • [or]: T
where: {
    <Op>(leftOperand, operator, rightOperand): Where;
    <Op>(leftOperand, operator, rightOperand): Where;
    (leftOperand, rightOperand): Where;
}

Type declaration

    • <Op>(leftOperand, operator, rightOperand): Where
    • A way of specifying "attr = condition". Can be used as a replacement for the POJO syntax (e.g. where: { name: 'Lily' }) when you need to compare a column that the POJO syntax cannot represent.

      Type Parameters

      • Op extends keyof WhereOperators<any>

      Parameters

      • leftOperand: Where | WhereLeftOperand

        The left side of the comparison.

        • A value taken from YourModel.rawAttributes, to reference an attribute. The attribute must be defined in your model definition.
        • A Literal (using Sequelize#literal)
        • A SQL Function (using Sequelize#fn)
        • A Column name (using Sequelize#col) Note that simple strings to reference an attribute are not supported. You can use the POJO syntax instead.
      • operator: Op

        The comparison operator to use. If unspecified, defaults to Op.eq.

      • rightOperand: WhereOperators<any>[Op]

        The right side of the comparison. Its value depends on the used operator. See WhereOperators for information about what value is valid for each operator.

      Returns Where

      Example

      // Using an attribute as the left operand.
      // Equal to: WHERE first_name = 'Lily'
      where(User.rawAttributes.firstName, Op.eq, 'Lily');

      Example

      // Using a column name as the left operand.
      // Equal to: WHERE first_name = 'Lily'
      where(col('first_name'), Op.eq, 'Lily');

      Example

      // Using a SQL function on the left operand.
      // Equal to: WHERE LOWER(first_name) = 'lily'
      where(fn('LOWER', col('first_name')), Op.eq, 'lily');

      Example

      // Using raw SQL as the left operand.
      // Equal to: WHERE 'Lily' = 'Lily'
      where(literal(`'Lily'`), Op.eq, 'Lily');
    • <Op>(leftOperand, operator, rightOperand): Where
    • Type Parameters

      • Op extends keyof WhereOperators<any>

      Parameters

      • leftOperand: any
      • operator: string
      • rightOperand: any

      Returns Where

    • (leftOperand, rightOperand): Where
    • Parameters

      • leftOperand: WhereLeftOperand
      • rightOperand: any

      Returns Where

and: (<T>(...args) => {
    [and]: T;
})

An AND query

Type declaration

    • <T>(...args): {
          [and]: T;
      }
    • Type Parameters

      • T extends any[]

      Parameters

      • Rest ...args: T

        Each argument will be joined by AND

      Returns {
          [and]: T;
      }

      • [and]: T
cast: ((val, type) => Cast)

Creates a object representing a call to the cast function.

Type declaration

    • (val, type): Cast
    • Parameters

      • val: unknown

        The value to cast

      • type: string

        The type to cast it to

      Returns Cast

col: ((col) => Col)

Creates a object representing a column in the DB. This is often useful in conjunction with sequelize.fn, since raw string arguments to fn will be escaped.

Type declaration

    • (col): Col
    • Parameters

      • col: string

        The name of the column

      Returns Col

fn: ((fn, ...args) => Fn)

Creates a object representing a database function. This can be used in search queries, both in where and order parts, and as default values in column definitions. If you want to refer to columns in your function, you should use sequelize.col, so that the columns are properly interpreted as columns and not a strings.

Convert a user's username to upper case

instance.update({
username: self.sequelize.fn('upper', self.sequelize.col('username'))
})

Type declaration

    • (fn, ...args): Fn
    • Parameters

      • fn: string

        The function you want to call

      • Rest ...args: unknown[]

        All further arguments will be passed as arguments to the function

      Returns Fn

json: ((conditionsOrPath, value?) => Json)

Creates an object representing nested where conditions for postgres's json data-type.

Type declaration

    • (conditionsOrPath, value?): Json
    • Parameters

      • conditionsOrPath: string | object

        A hash containing strings/numbers or other nested hash, a string using dot notation or a string using postgres json syntax.

      • Optional value: string | number | boolean

        An optional value to compare against. Produces a string of the form " = ''".

      Returns Json

literal: ((val) => Literal)

Creates a object representing a literal, i.e. something that will not be escaped.

Type declaration

    • (val): Literal
    • Parameters

      • val: string

      Returns Literal

or: (<T>(...args) => {
    [or]: T;
})

An OR query

Type declaration

    • <T>(...args): {
          [or]: T;
      }
    • Type Parameters

      • T extends any[]

      Parameters

      • Rest ...args: T

        Each argument will be joined by OR

      Returns {
          [or]: T;
      }

      • [or]: T
type: "@storehouse/sequelize" = '@storehouse/sequelize'
where: {
    <Op>(leftOperand, operator, rightOperand): Where;
    <Op>(leftOperand, operator, rightOperand): Where;
    (leftOperand, rightOperand): Where;
}

A way of specifying attr = condition.

The attr can either be an object taken from Model.rawAttributes (for example Model.rawAttributes.id or Model.rawAttributes.name). The attribute should be defined in your model definition. The attribute can also be an object from one of the sequelize utility functions (sequelize.fn, sequelize.col etc.)

For string attributes, use the regular { where: { attr: something }} syntax. If you don't want your string to be escaped, use sequelize.literal.

Type declaration

    • <Op>(leftOperand, operator, rightOperand): Where
    • Type Parameters

      • Op extends keyof WhereOperators<any>

      Parameters

      • leftOperand: Where | WhereLeftOperand
      • operator: Op
      • rightOperand: WhereOperators<any>[Op]

      Returns Where

    • <Op>(leftOperand, operator, rightOperand): Where
    • Type Parameters

      • Op extends keyof WhereOperators<any>

      Parameters

      • leftOperand: any
      • operator: string
      • rightOperand: any

      Returns Where

    • (leftOperand, rightOperand): Where
    • Parameters

      • leftOperand: WhereLeftOperand
      • rightOperand: any

      Returns Where

Methods

  • Add a hook to the model

    Type Parameters

    • K extends keyof SequelizeHooks<M, TModelAttributes, TCreationAttributes>

    Parameters

    • hookType: K
    • name: string

      Provide a name for the hook function. It can be used to remove the hook later or to order hooks based on some sort of priority system in the future.

    • fn: SequelizeHooks<Model<any, any>, any, any>[K]

    Returns this

  • Type Parameters

    • K extends keyof SequelizeHooks<M, TModelAttributes, TCreationAttributes>

    Parameters

    • hookType: K
    • fn: SequelizeHooks<Model<any, any>, any, any>[K]

    Returns this

  • A hook that is run after creating instances in bulk

    Parameters

    • name: string
    • fn: ((instances, options) => void)

      A callback function that is called with instances, options

        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instances, options) => void)
        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • A hook that is run after destroying instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: DestroyOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: DestroyOptions<any>

          Returns void

    Returns void

  • A hook that is run after sequelize.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to sequelize.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run after updating instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run after creating a single instance

    Parameters

    • name: string
    • fn: ((attributes, options) => void)

      A callback function that is called with attributes, options

        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((attributes, options) => void)
        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • A hook that is run after a define call

    Parameters

    • name: string
    • fn: ((model) => void)

      A callback function that is called with factory

        • (model): void
        • Parameters

          • model: ModelType

          Returns void

    Returns void

  • Parameters

    • fn: ((model) => void)
        • (model): void
        • Parameters

          • model: ModelType

          Returns void

    Returns void

  • A hook that is run after destroying a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • A hook that is run after a find (select) query

    Parameters

    • name: string
    • fn: ((instancesOrInstance, options) => void)

      A callback function that is called with instance(s), options

        • (instancesOrInstance, options): void
        • Parameters

          • instancesOrInstance: null | Model<any, any> | Model<any, any>[]
          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instancesOrInstance, options) => void)
        • (instancesOrInstance, options): void
        • Parameters

          • instancesOrInstance: null | Model<any, any> | Model<any, any>[]
          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run after Sequelize() call

    Parameters

    • name: string
    • fn: ((sequelize) => void)

      A callback function that is called with sequelize

        • (sequelize): void
        • Parameters

          • sequelize: Sequelize

          Returns void

    Returns void

  • Parameters

    • fn: ((sequelize) => void)
        • (sequelize): void
        • Parameters

          • sequelize: Sequelize

          Returns void

    Returns void

  • A hook that is run after Model.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to Model.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run after updating a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run after validation

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Test the connection by trying to authenticate

    Parameters

    • Optional options: QueryOptions

      Query Options for authentication

    Returns Promise<void>

  • A hook that is run before creating instances in bulk

    Parameters

    • name: string
    • fn: ((instances, options) => void)

      A callback function that is called with instances, options

        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instances, options) => void)
        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • A hook that is run before destroying instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • A hook that is run before sequelize.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to sequelize.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run after updating instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run before creating a single instance

    Parameters

    • name: string
    • fn: ((attributes, options) => void)

      A callback function that is called with attributes, options

        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((attributes, options) => void)
        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • A hook that is run before a define call

    Parameters

    • name: string
    • fn: ((attributes, options) => void)

      A callback function that is called with attributes, options

        • (attributes, options): void
        • Parameters

          • attributes: ModelAttributes<Model<any, any>, any>
          • options: ModelOptions<Model<any, any>>

          Returns void

    Returns void

  • Parameters

    • fn: ((attributes, options) => void)
        • (attributes, options): void
        • Parameters

          • attributes: ModelAttributes<Model<any, any>, any>
          • options: ModelOptions<Model<any, any>>

          Returns void

    Returns void

  • A hook that is run before destroying a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • A hook that is run before a find (select) query

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run before a find (select) query, after all option parsing is complete

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run before Sequelize() call

    Parameters

    • name: string
    • fn: ((config, options) => void)

      A callback function that is called with config, options

        • (config, options): void
        • Parameters

          • config: Config
          • options: Options

          Returns void

    Returns void

  • Parameters

    • fn: ((config, options) => void)
        • (config, options): void
        • Parameters

          • config: Config
          • options: Options

          Returns void

    Returns void

  • A hook that is run before Model.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to Model.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run before updating a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run before validation

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Close all connections used by this sequelize instance, and free all references so the instance can be garbage collected.

    Normally this is done on process exit, so you only need to call this method if you are creating multiple instances, and want to garbage collect some of them.

    Returns Promise<void>

  • Returns Promise<void>

  • Create a new database schema.

    Note,that this is a schema in the postgres sense of the word, not a database table. In mysql and sqlite, this command will do nothing.

    Parameters

    • schema: string

      Name of the schema

    • options: Logging

      Options supplied

    Returns Promise<unknown>

  • Returns the database version

    Returns Promise<string>

  • Define a new model, representing a table in the DB.

    The table columns are defined by the hash that is given as the second argument. Each attribute of the hash represents a column. A short table definition might look like this:

    class MyModel extends Model {}
    MyModel.init({
    columnA: {
    type: Sequelize.BOOLEAN,
    validate: {
    is: ["[a-z]",'i'], // will only allow letters
    max: 23, // only allow values <= 23
    isIn: {
    args: [['en', 'zh']],
    msg: "Must be English or Chinese"
    }
    },
    field: 'column_a'
    // Other attributes here
    },
    columnB: Sequelize.STRING,
    columnC: 'MY VERY OWN COLUMN TYPE'
    }, { sequelize })

    sequelize.models.modelName // The model will now be available in models under the name given to define

    As shown above, column definitions can be either strings, a reference to one of the datatypes that are predefined on the Sequelize constructor, or an object that allows you to specify both the type of the column, and other attributes such as default values, foreign key constraints and custom setters and getters.

    For a list of possible data types, see https://sequelize.org/master/en/latest/docs/models-definition/#data-types

    For more about getters and setters, see https://sequelize.org/master/en/latest/docs/models-definition/#getters-setters

    For more about instance and class methods, see https://sequelize.org/master/en/latest/docs/models-definition/#expansion-of-models

    For more about validation, see https://sequelize.org/master/en/latest/docs/models-definition/#validations

    Type Parameters

    • M extends Model<any, any>
    • TAttributes = Attributes<M>

    Parameters

    • modelName: string

      The name of the model. The model will be stored in sequelize.models under this name

    • attributes: ModelAttributes<M, TAttributes>

      An object, where each attribute is a column of the table. Each column can be either a DataType, a string or a type-description object, with the properties described below:

    • Optional options: ModelOptions<M>

      These options are merged with the default define options provided to the Sequelize constructor

    Returns ModelCtor<M>

  • Drop all tables defined through this sequelize instance. This is done by calling Model.drop on each model

    Parameters

    • Optional options: DropOptions

      The options passed to each call to Model.drop

    Returns Promise<unknown[]>

  • Drop all schemas

    Note,that this is a schema in the postgres sense of the word, not a database table. In mysql and sqlite, this is the equivalent of drop all tables.

    Parameters

    • options: Logging

      Options supplied

    Returns Promise<unknown[]>

  • Drop a single schema

    Note,that this is a schema in the postgres sense of the word, not a database table. In mysql and sqlite, this drop a table matching the schema name

    Parameters

    • schema: string

      Name of the schema

    • options: Logging

      Options supplied

    Returns Promise<unknown[]>

  • Escape value.

    Parameters

    • value: string | number | Date

      Value that needs to be escaped

    Returns string

  • Returns Sequelize

  • Returns the database name.

    Returns string

  • Returns the specified dialect.

    Returns string

  • Fetch a Model which is already defined

    Type Parameters

    • M extends ModelStatic<Model<any, any>> = ModelStatic<Model<any, any>>

    Parameters

    • name: string

    Returns M

  • Type Parameters

    • M extends Model<any, any> = Model<any, any>

    Parameters

    • name: string

    Returns ModelStatic<M>

  • Type Parameters

    • TModelAttributes extends Record<string, unknown> = {}
    • TCreationAttributes extends Record<string, unknown> = {}

    Parameters

    • name: string

    Returns ModelStatic<Model<TModelAttributes, TCreationAttributes>>

  • Returns an instance of QueryInterface.

    Returns QueryInterface

  • Check whether the mode has any hooks of this type

    Type Parameters

    • K extends keyof SequelizeHooks<M, TModelAttributes, TCreationAttributes>

    Parameters

    • hookType: K

    Returns boolean

  • Type Parameters

    • K extends keyof SequelizeHooks<M, TModelAttributes, TCreationAttributes>

    Parameters

    • hookType: K

    Returns boolean

  • Checks whether a model with the given name is defined

    Parameters

    • modelName: string

      The name of a model defined with Sequelize.define

    Returns boolean

  • Fetch a Model which is already defined

    Parameters

    • modelName: string

      The name of a model defined with Sequelize.define

    Returns ModelCtor<Model<any, any>>

  • Execute a query on the DB, optionally bypassing all the Sequelize goodness.

    By default, the function will return two arguments: an array of results, and a metadata object, containing number of affected rows etc. Use const [results, meta] = await ... to access the results.

    If you are running a type of query where you don't need the metadata, for example a SELECT query, you can pass in a query type to make sequelize format the results:

    const [results, metadata] = await sequelize.query('SELECT...'); // Raw query - use array destructuring

    const results = await sequelize.query('SELECT...', { type: sequelize.QueryTypes.SELECT }); // SELECT query - no destructuring

    Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<UPDATE>

      Query options

    Returns Promise<[undefined, number]>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<BULKUPDATE>

    Returns Promise<number>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<INSERT>

    Returns Promise<[number, number]>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<UPSERT>

    Returns Promise<number>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<DELETE>

    Returns Promise<void>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<BULKDELETE>

    Returns Promise<number>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<SHOWTABLES>

    Returns Promise<string[]>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<DESCRIBE>

    Returns Promise<ColumnsDescription>

  • Type Parameters

    • M extends Model<any, any>

    Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithModel<M> & {
          plain: true;
      }

    Returns Promise<null | M>

  • Type Parameters

    • M extends Model<any, any>

    Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithModel<M>

    Returns Promise<M[]>

  • Type Parameters

    • T extends object

    Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<SELECT> & {
          plain: true;
      }

    Returns Promise<null | T>

  • Type Parameters

    • T extends object

    Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: QueryOptionsWithType<SELECT>

    Returns Promise<T[]>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • options: (QueryOptions | QueryOptionsWithType<RAW>) & {
          plain: true;
      }

    Returns Promise<null | {
        [key: string]: unknown;
    }>

  • Parameters

    • sql: string | {
          query: string;
          values: unknown[];
      }
    • Optional options: QueryOptions | QueryOptionsWithType<RAW>

    Returns Promise<[unknown[], unknown]>

  • Get the fn for random based on the dialect

    Returns Fn

  • Remove hook from the model

    Type Parameters

    • K extends keyof SequelizeHooks<M, TModelAttributes, TCreationAttributes>

    Parameters

    • hookType: K
    • name: string

    Returns this

  • Execute a query which would set an environment or user variable. The variables are set per connection, so this function needs a transaction.

    Only works for MySQL.

    Parameters

    • variables: object

      object with multiple variables.

    • options: QueryOptionsTransactionRequired

      Query options.

    Returns Promise<unknown>

  • Show all defined schemas

    Note,that this is a schema in the postgres sense of the word, not a database table. In mysql and sqlite, this will show all tables.

    Parameters

    • options: Logging

      Options supplied

    Returns Promise<object[]>

  • Sync all defined models to the DB.

    Parameters

    • Optional options: SyncOptions

      Sync Options

    Returns Promise<SequelizeManager>

  • Start a transaction. When using transactions, you should pass the transaction in the options argument in order for the query to happen under that transaction

      try {
    const transaction = await sequelize.transaction();
    const user = await User.findOne(..., { transaction });
    await user.update(..., { transaction });
    await transaction.commit();
    } catch(err) {
    await transaction.rollback();
    }
    })

    A syntax for automatically committing or rolling back based on the promise chain resolution is also supported:

    try {
    await sequelize.transaction(transaction => { // Note that we pass a callback rather than awaiting the call with no arguments
    const user = await User.findOne(..., {transaction});
    await user.update(..., {transaction});
    });
    // Committed
    } catch(err) {
    // Rolled back
    console.error(err);
    }

    If you have CLS enabled, the transaction will automatically be passed to any query that runs witin the callback. To enable CLS, add it do your project, create a namespace and set it on the sequelize constructor:

    const cls = require('cls-hooked');
    const namespace = cls.createNamespace('....');
    const Sequelize = require('sequelize');
    Sequelize.useCLS(namespace);

    Note, that CLS is enabled for all sequelize instances, and all instances will share the same namespace

    Type Parameters

    • T

    Parameters

    • options: TransactionOptions

      Transaction Options

    • autoCallback: ((t) => PromiseLike<T>)

      Callback for the transaction

        • (t): PromiseLike<T>
        • Parameters

          • t: Transaction

          Returns PromiseLike<T>

    Returns Promise<T>

  • Type Parameters

    • T

    Parameters

    • autoCallback: ((t) => PromiseLike<T>)
        • (t): PromiseLike<T>
        • Parameters

          • t: Transaction

          Returns PromiseLike<T>

    Returns Promise<T>

  • Parameters

    • Optional options: TransactionOptions

    Returns Promise<Transaction>

  • Truncate all tables defined through the sequelize models. This is done by calling Model.truncate() on each model.

    Parameters

    • Optional options: DestroyOptions<any>

      The options passed to Model.destroy in addition to truncate

    Returns Promise<unknown[]>

  • Parameters

    • Optional options: QueryOptions

    Returns Promise<void>

  • Add a hook to the model

    Type Parameters

    • H extends Hooks<Model<any, any>, any, any>
    • K extends keyof SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>

    Parameters

    • this: HooksStatic<H>
    • hookType: K
    • name: string

      Provide a name for the hook function. It can be used to remove the hook later or to order hooks based on some sort of priority system in the future.

    • fn: SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>[K]

    Returns HooksCtor<H>

  • Type Parameters

    • H extends Hooks<Model<any, any>, any, any>
    • K extends keyof SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>

    Parameters

    • this: HooksStatic<H>
    • hookType: K
    • fn: SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>[K]

    Returns HooksCtor<H>

  • A hook that is run after creating instances in bulk

    Parameters

    • name: string
    • fn: ((instances, options) => void)

      A callback function that is called with instances, options

        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instances, options) => void)
        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • A hook that is run after destroying instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: DestroyOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: DestroyOptions<any>

          Returns void

    Returns void

  • A hook that is run after sequelize.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to sequelize.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run after updating instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run after a connection is established

    Parameters

    • name: string
    • fn: ((connection, options) => void)

      A callback function that is called with options

        • (connection, options): void
        • Parameters

          • connection: unknown
          • options: Config

          Returns void

    Returns void

  • Parameters

    • fn: ((connection, options) => void)
        • (connection, options): void
        • Parameters

          • connection: unknown
          • options: Config

          Returns void

    Returns void

  • A hook that is run after creating a single instance

    Parameters

    • name: string
    • fn: ((attributes, options) => void)

      A callback function that is called with attributes, options

        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((attributes, options) => void)
        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • A hook that is run after a define call

    Parameters

    • name: string
    • fn: ((model) => void)

      A callback function that is called with factory

        • (model): void
        • Parameters

          • model: ModelType

          Returns void

    Returns void

  • Parameters

    • fn: ((model) => void)
        • (model): void
        • Parameters

          • model: ModelType

          Returns void

    Returns void

  • A hook that is run after destroying a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • A hook that is run after a connection is released

    Parameters

    • name: string
    • fn: ((connection) => void)

      A callback function that is called with options

        • (connection): void
        • Parameters

          • connection: unknown

          Returns void

    Returns void

  • Parameters

    • fn: ((connection) => void)
        • (connection): void
        • Parameters

          • connection: unknown

          Returns void

    Returns void

  • A hook that is run after a find (select) query

    Parameters

    • name: string
    • fn: ((instancesOrInstance, options) => void)

      A callback function that is called with instance(s), options

        • (instancesOrInstance, options): void
        • Parameters

          • instancesOrInstance: null | Model<any, any> | Model<any, any>[]
          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instancesOrInstance, options) => void)
        • (instancesOrInstance, options): void
        • Parameters

          • instancesOrInstance: null | Model<any, any> | Model<any, any>[]
          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run after Sequelize() call

    Parameters

    • name: string
    • fn: ((sequelize) => void)

      A callback function that is called with sequelize

        • (sequelize): void
        • Parameters

          • sequelize: Sequelize

          Returns void

    Returns void

  • Parameters

    • fn: ((sequelize) => void)
        • (sequelize): void
        • Parameters

          • sequelize: Sequelize

          Returns void

    Returns void

  • A hook that is run after successfully acquiring a connection from the pool

    Parameters

    • name: string
    • fn: ((connection, options) => void)

      A callback function that is called with options

        • (connection, options): void
        • Parameters

          • connection: object
          • options: GetConnectionOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((connection, options) => void)
        • (connection, options): void
        • Parameters

          • connection: object
          • options: GetConnectionOptions

          Returns void

    Returns void

  • A hook that is run after creating or updating a single instance, It proxies afterCreate and afterUpdate

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: CreateOptions<any> | UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: CreateOptions<any> | UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run after Model.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to Model.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run after updating a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run after validation

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • A hook that is run before creating instances in bulk

    Parameters

    • name: string
    • fn: ((instances, options) => void)

      A callback function that is called with instances, options

        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instances, options) => void)
        • (instances, options): void
        • Parameters

          • instances: Model<any, any>[]
          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • A hook that is run before destroying instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: BulkCreateOptions<any>

          Returns void

    Returns void

  • A hook that is run before sequelize.sync call

    Parameters

    • dname: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to sequelize.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run after updating instances in bulk

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run before a connection is established

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: DeepWriteable<Config>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: DeepWriteable<Config>

          Returns void

    Returns void

  • A hook that is run before creating a single instance

    Parameters

    • name: string
    • fn: ((attributes, options) => void)

      A callback function that is called with attributes, options

        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((attributes, options) => void)
        • (attributes, options): void
        • Parameters

          • attributes: Model<any, any>
          • options: CreateOptions<any>

          Returns void

    Returns void

  • A hook that is run before a define call

    Type Parameters

    • M extends Model<any, any>

    Parameters

    • name: string
    • fn: ((attributes, options) => void)

      A callback function that is called with attributes, options

        • (attributes, options): void
        • Parameters

          • attributes: ModelAttributes<M, CreationAttributes<M>>
          • options: ModelOptions<M>

          Returns void

    Returns void

  • Type Parameters

    • M extends Model<any, any>

    Parameters

    • fn: ((attributes, options) => void)
        • (attributes, options): void
        • Parameters

          • attributes: ModelAttributes<M, CreationAttributes<M>>
          • options: ModelOptions<M>

          Returns void

    Returns void

  • A hook that is run before destroying a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: InstanceDestroyOptions

          Returns void

    Returns void

  • A hook that is run before a connection is released

    Parameters

    • name: string
    • fn: ((connection) => void)

      A callback function that is called with options

        • (connection): void
        • Parameters

          • connection: unknown

          Returns void

    Returns void

  • Parameters

    • fn: ((connection) => void)
        • (connection): void
        • Parameters

          • connection: unknown

          Returns void

    Returns void

  • A hook that is run before a find (select) query

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run before a find (select) query, after all option parsing is complete

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: FindOptions<any>

          Returns void

    Returns void

  • A hook that is run before Sequelize() call

    Parameters

    • name: string
    • fn: ((config, options) => void)

      A callback function that is called with config, options

        • (config, options): void
        • Parameters

          • config: Config
          • options: Options

          Returns void

    Returns void

  • Parameters

    • fn: ((config, options) => void)
        • (config, options): void
        • Parameters

          • config: Config
          • options: Options

          Returns void

    Returns void

  • A hook that is run before attempting to acquire a connection from the pool

    Parameters

    • name: string
    • fn: ((options) => void)

      A callback function that is called with options

        • (options): void
        • Parameters

          • options: GetConnectionOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((options) => void)
        • (options): void
        • Parameters

          • options: GetConnectionOptions

          Returns void

    Returns void

  • A hook that is run before creating or updating a single instance, It proxies beforeCreate and beforeUpdate

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: CreateOptions<any> | UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: CreateOptions<any> | UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run before Model.sync call

    Parameters

    • name: string
    • fn: ((options) => HookReturn)

      A callback function that is called with options passed to Model.sync

        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • Parameters

    • fn: ((options) => HookReturn)
        • (options): HookReturn
        • Parameters

          • options: SyncOptions

          Returns HookReturn

    Returns void

  • A hook that is run before updating a single instance

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: UpdateOptions<any>

          Returns void

    Returns void

  • A hook that is run before validation

    Parameters

    • name: string
    • fn: ((instance, options) => void)

      A callback function that is called with instance, options

        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Parameters

    • fn: ((instance, options) => void)
        • (instance, options): void
        • Parameters

          • instance: Model<any, any>
          • options: ValidationOptions

          Returns void

    Returns void

  • Check whether the mode has any hooks of this type

    Type Parameters

    • H extends Hooks<Model<any, any>, any, any>

    Parameters

    • this: HooksStatic<H>
    • hookType: keyof SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>

    Returns boolean

  • Type Parameters

    • H extends Hooks<Model<any, any>, any, any>

    Parameters

    • this: HooksStatic<H>
    • hookType: keyof SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>

    Returns boolean

  • Remove hook from the model

    Type Parameters

    • H extends Hooks<Model<any, any>, any, any>

    Parameters

    • this: HooksStatic<H>
    • hookType: keyof SequelizeHooks<H["_model"], Attributes<H>, CreationAttributes<H>>
    • name: string

    Returns HooksCtor<H>

  • Use CLS with Sequelize. CLS namespace provided is stored as Sequelize._cls and Promise is patched to use the namespace, using cls-hooked module.

    Parameters

    • namespace: object

    Returns typeof Sequelize