@types/sequelize

interface AccessDeniedError

interface AccessDeniedError extends ConnectionError {}

interface AddCheckConstraintOptions

interface AddCheckConstraintOptions {}

interface AddDefaultConstraintOptions

interface AddDefaultConstraintOptions {}

interface AddForeignKeyConstraintOptions

interface AddForeignKeyConstraintOptions {}

interface AddPrimaryKeyConstraintOptions

interface AddPrimaryKeyConstraintOptions {}

interface AddScopeOptions

interface AddScopeOptions {}

• AddScope Options for Model.addScope

interface AddUniqueConstraintOptions

interface AddUniqueConstraintOptions {}

interface AggregateOptions

interface AggregateOptions extends LoggingOptions {}

• Options used for Model.aggregate

interface and

interface and {}

interface andStatic

interface andStatic {}

interface AnyWhereOptions

interface AnyWhereOptions {}

• A hash of attributes to describe your search, accepting any field names. See WhereOptions for details.

interface AssociationForeignKeyOptions

interface AssociationForeignKeyOptions extends ColumnOptions {}

• Foreign Key Options

  See Also

  • AssociationOptions

interface AssociationOptions

interface AssociationOptions {}

• Options provided when associating models

  See Also

  • Association class

interface AssociationOptionsBelongsTo

interface AssociationOptionsBelongsTo extends AssociationOptions {}

• Options provided when associating models with belongsTo relationship

  See Also

  • Association class belongsTo method

interface AssociationOptionsBelongsToMany

interface AssociationOptionsBelongsToMany extends AssociationOptionsManyToMany {}

• Options provided when associating models with belongsToMany relationship

  See Also

  • Association class belongsToMany method

interface AssociationOptionsHasMany

interface AssociationOptionsHasMany extends AssociationOptionsManyToMany {}

• Options provided when associating models with hasMany relationship

  See Also

  • Association class hasMany method

interface AssociationOptionsHasOne

interface AssociationOptionsHasOne extends AssociationOptions {}

• Options provided when associating models with hasOne relationship

  See Also

  • Association class hasOne method

interface AssociationOptionsManyToMany

interface AssociationOptionsManyToMany extends AssociationOptions {}

• Options provided for many-to-many relationships

  See Also

  • AssociationOptionsHasMany

  • AssociationOptionsBelongsToMany

interface Associations

interface Associations {}

• Creating assocations in sequelize is done by calling one of the belongsTo / hasOne / hasMany functions on a model (the source), and providing another model as the first argument to the function (the target).

  * hasOne - adds a foreign key to target * belongsTo - add a foreign key to source * hasMany - adds a foreign key to target, unless you also specify that target hasMany source, in which case a junction table is created with sourceId and targetId

  Creating an association will add a foreign key constraint to the attributes. All associations use CASCADE on update and SET NULL on delete, except for n:m, which also uses CASCADE on delete.

  When creating associations, you can provide an alias, via the as option. This is useful if the same model is associated twice, or you want your association to be called something other than the name of the target model.

  As an example, consider the case where users have many pictures, one of which is their profile picture. All pictures have a userId, but in addition the user model also has a profilePictureId, to be able to easily load the user's profile picture.

  User.hasMany(Picture)
  User.belongsTo(Picture, { as: 'ProfilePicture', constraints: false })
  
  user.getPictures() // gets you all pictures
  user.getProfilePicture() // gets you only the profile picture
  
  User.findAll({
    where: ...,
    include: [
      { model: Picture }, // load all pictures
      { model: Picture, as: 'ProfilePicture' }, // load the profile picture. Notice that the spelling must be
  the exact same as the one in the association
    ]
  })

  To get full control over the foreign key column added by sequelize, you can use the foreignKey option. It can either be a string, that specifies the name, or and object type definition, equivalent to those passed to sequelize.define.

  User.hasMany(Picture, { foreignKey: 'uid' })

  The foreign key column in Picture will now be called uid instead of the default userId.

  User.hasMany(Picture, {
    foreignKey: {
      name: 'uid',
      allowNull: false
    }
  })

  This specifies that the uid column can not be null. In most cases this will already be covered by the foreign key costraints, which sequelize creates automatically, but can be useful in case where the foreign keys are disabled, e.g. due to circular references (see constraints: false below).

  When fetching associated models, you can limit your query to only load some models. These queries are written in the same way as queries to find/findAll. To only get pictures in JPG, you can do:

  user.getPictures({
    where: {
      format: 'jpg'
    }
  })

  There are several ways to update and add new assoications. Continuing with our example of users and pictures:

  user.addPicture(p) // Add a single picture
  user.setPictures([p1, p2]) // Associate user with ONLY these two picture, all other associations will be
  deleted user.addPictures([p1, p2]) // Associate user with these two pictures, but don't touch any current
  associations

  You don't have to pass in a complete object to the association functions, if your associated model has a single primary key:

  user.addPicture(req.query.pid) // Here pid is just an integer, representing the primary key of the picture

  In the example above we have specified that a user belongs to their profile picture. Conceptually, this might not make sense, but since we want to add the foreign key to the user model this is the way to do it.

  Note how we also specified constraints: false for profile picture. This is because we add a foreign key from user to picture (profilePictureId), and from picture to user (userId). If we were to add foreign keys to both, it would create a cyclic dependency, and sequelize would not know which table to create first, since user depends on picture, and picture depends on user. These kinds of problems are detected by sequelize before the models are synced to the database, and you will get an error along the lines of `Error: Cyclic dependency found. 'users' is dependent of itself`. If you encounter this, you should either disable some constraints, or rethink your associations completely.

  See Also

  • Sequelize.Model

interface AssociationScope

interface AssociationScope {}

• Options for Association Scope

  See Also

  • AssociationOptionsManyToMany

interface BaseError

interface BaseError extends Error, ErrorConstructor {}

• The Base Error all Sequelize Errors inherit from.

interface BelongsToCreateAssociationMixin

interface BelongsToCreateAssociationMixin<TAttributes, TInstance> {}

• The createAssociation mixin applied to models with belongsTo. An example of usage is as follows:

  User.belongsTo(Role);
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRole...
     // setRole...
     createRole: Sequelize.BelongsToCreateAssociationMixin<RoleAttributes>;
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to/

  • Instance

interface BelongsToCreateAssociationMixinOptions

interface BelongsToCreateAssociationMixinOptions {}

• The options for the createAssociation mixin of the belongsTo association.

  See Also

  • BelongsToCreateAssociationMixin

interface BelongsToGetAssociationMixin

interface BelongsToGetAssociationMixin<TInstance> {}

• The getAssociation mixin applied to models with belongsTo. An example of usage is as follows:

  User.belongsTo(Role);
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttrib>, UserAttrib {
     getRole: Sequelize.BelongsToGetAssociationMixin<RoleInstance>;
     // setRole...
     // createRole...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to/

  • Instance

interface BelongsToGetAssociationMixinOptions

interface BelongsToGetAssociationMixinOptions {}

• The options for the getAssociation mixin of the belongsTo association.

  See Also

  • BelongsToGetAssociationMixin

interface BelongsToManyAddAssociationMixin

interface BelongsToManyAddAssociationMixin<
    TInstance,
    TInstancePrimaryKey,
    TJoinTableAttributes
> {}

• The addAssociation mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     // addRoles...
     addRole: Sequelize.BelongsToManyAddAssociationMixin<RoleInstance, RoleId, UserRoleAttributes>;
     // createRole...
     // removeRole...
     // removeRoles...
     // hasRole...
     // hasRoles...
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyAddAssociationMixinOptions

interface BelongsToManyAddAssociationMixinOptions {}

• The options for the addAssociation mixin of the belongsToMany association.

  See Also

  • BelongsToManyAddAssociationMixin

interface BelongsToManyAddAssociationsMixin

interface BelongsToManyAddAssociationsMixin<
    TInstance,
    TInstancePrimaryKey,
    TJoinTableAttributes
> {}

• The addAssociations mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     addRoles: Sequelize.BelongsToManyAddAssociationsMixin<RoleInstance, RoleId, UserRoleAttributes>;
     // addRole...
     // createRole...
     // removeRole...
     // removeRoles...
     // hasRole...
     // hasRoles...
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyAddAssociationsMixinOptions

interface BelongsToManyAddAssociationsMixinOptions {}

• The options for the addAssociations mixin of the belongsToMany association.

  See Also

  • BelongsToManyAddAssociationsMixin

interface BelongsToManyCountAssociationsMixin

interface BelongsToManyCountAssociationsMixin {}

• The countAssociations mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     // addRoles...
     // addRole...
     // createRole...
     // removeRole...
     // removeRoles...
     // hasRole...
     // hasRoles...
     countRoles: Sequelize.BelongsToManyCountAssociationsMixin;
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyCountAssociationsMixinOptions

interface BelongsToManyCountAssociationsMixinOptions {}

• The options for the countAssociations mixin of the belongsToMany association.

  See Also

  • BelongsToManyCountAssociationsMixin

interface BelongsToManyCreateAssociationMixin

interface BelongsToManyCreateAssociationMixin<
    TAttributes,
    TInstance,
    TJoinTableAttributes
> {}

• The createAssociation mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     // addRoles...
     // addRole...
     createRole: Sequelize.BelongsToManyCreateAssociationMixin<RoleAttributes, UserRoleAttributes>;
     // removeRole...
     // removeRoles...
     // hasRole...
     // hasRoles...
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyCreateAssociationMixinOptions

interface BelongsToManyCreateAssociationMixinOptions {}

• The options for the createAssociation mixin of the belongsToMany association.

  See Also

  • BelongsToManyCreateAssociationMixin

interface BelongsToManyGetAssociationsMixin

interface BelongsToManyGetAssociationsMixin<TInstance> {}

• The getAssociations mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     getRoles: Sequelize.BelongsToManyGetAssociationsMixin<RoleInstance>;
     // setRoles...
     // addRoles...
     // addRole...
     // createRole...
     // removeRole...
     // removeRoles...
     // hasRole...
     // hasRoles...
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyGetAssociationsMixinOptions

interface BelongsToManyGetAssociationsMixinOptions {}

• The options for the getAssociations mixin of the belongsToMany association.

  See Also

  • BelongsToManyGetAssociationsMixin

interface BelongsToManyHasAssociationMixin

interface BelongsToManyHasAssociationMixin<TInstance, TInstancePrimaryKey> {}

• The hasAssociation mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     // addRoles...
     // addRole...
     // createRole...
     // removeRole...
     // removeRoles...
     hasRole: Sequelize.BelongsToManyHasAssociationMixin<RoleInstance, RoleId>;
     // hasRoles...
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyHasAssociationMixinOptions

interface BelongsToManyHasAssociationMixinOptions {}

• The options for the hasAssociation mixin of the belongsToMany association.

  See Also

  • BelongsToManyHasAssociationMixin

interface BelongsToManyHasAssociationsMixin

interface BelongsToManyHasAssociationsMixin<TInstance, TInstancePrimaryKey> {}

• The removeAssociations mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     // addRoles...
     // addRole...
     // createRole...
     // removeRole...
     // removeRoles
     // hasRole...
     hasRoles: Sequelize.BelongsToManyHasAssociationsMixin<RoleInstance, RoleId>;
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyHasAssociationsMixinOptions

interface BelongsToManyHasAssociationsMixinOptions {}

• The options for the hasAssociations mixin of the belongsToMany association.

  See Also

  • BelongsToManyHasAssociationsMixin

interface BelongsToManyRemoveAssociationMixin

interface BelongsToManyRemoveAssociationMixin<TInstance, TInstancePrimaryKey> {}

• The removeAssociation mixin applied to models with belongsToMany. An example of usage is as follows:

  User.belongsToMany(Role, { through: UserRole });
  
  interface UserInstance extends Sequelize.Instance<UserInstance, UserAttributes>, UserAttributes {
     // getRoles...
     // setRoles...
     // addRoles...
     // addRole...
     // createRole...
     removeRole: Sequelize.BelongsToManyRemoveAssociationMixin<RoleInstance, RoleId>;
     // removeRoles...
     // hasRole...
     // hasRoles...
     // countRoles...
  }

  See Also

  • http://docs.sequelizejs.com/en/latest/api/associations/belongs-to-many/

  • Instance

interface BelongsToManyRemoveAssociationMixinOptions

interface BelongsToManyRemoveAssociationMixinOptions {}