This type allows using Op.or, Op.and, and Op.not recursively around another type.
It also supports using a plain Array as an alias for Op.and. (unlike AllowNotOrAndRecursive).
Example of plain-array treated as Op.and:
User.findAll({ where: [{ id: 1 }, { id: 2 }] });
Meant to be used by WhereOptions.
Returns the creation attributes of a given Model.
This returns the Attributes of a Model that have already been defined, it does not build them. If you need to build them, use InferAttributes.
The createAssociation mixin applied to models with belongsTo. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare createRole: BelongsToCreateAssociationMixin<Role>;
}
User.belongsTo(Role);
The getAssociation mixin applied to models with belongsTo. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare getRole: BelongsToGetAssociationMixin<Role>;
}
User.belongsTo(Role);
The addAssociation mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare addRole: BelongsToManyAddAssociationMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The addAssociations mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare addRoles: BelongsToManyAddAssociationsMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The countAssociations mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare countRoles: Sequelize.BelongsToManyCountAssociationsMixin;
}
User.belongsToMany(Role, { through: UserRole });
The createAssociation mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare createRole: BelongsToManyCreateAssociationMixin<Role>;
}
User.belongsToMany(Role, { through: UserRole });
The getAssociations mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare getRoles: BelongsToManyGetAssociationsMixin<Role>;
}
User.belongsToMany(Role, { through: UserRole });
The hasAssociation mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare hasRole: BelongsToManyHasAssociationMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The removeAssociations mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare hasRoles: BelongsToManyHasAssociationsMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The removeAssociation mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare removeRole: BelongsToManyRemoveAssociationMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The removeAssociations mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare removeRoles: BelongsToManyRemoveAssociationsMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The setAssociations mixin applied to models with belongsToMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare setRoles: BelongsToManySetAssociationsMixin<Role, Role['id']>;
}
User.belongsToMany(Role, { through: UserRole });
The type of the attribute that the foreign key references.
The setAssociation mixin applied to models with belongsTo. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare setRole: BelongsToSetAssociationMixin<Role, Role['id']>;
}
User.belongsTo(Role);
Internal type - prone to changes. Do not export.
Options for Model.count when GROUP BY is used
Returns the creation attributes of a given Model.
This returns the Creation Attributes of a Model, it does not build them. If you need to build them, use InferCreationAttributes.
This is a Branded Type. You can use it to tag attributes that can be ommited during Model Creation.
For use with InferCreationAttributes.
Represents acceptable Dynamic values.
Dynamic values, as opposed to StaticValues. i.e. column references, functions, etc...
This is a Branded Type. You can use it to tag fields from your class that are foreign keys. They will become optional in Model.init (as foreign keys are added by association methods, like Model.hasMany.
The addAssociation mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare addRole: HasManyAddAssociationMixin<Role, Role['id']>;
}
User.hasMany(Role);
The addAssociations mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare addRoles: HasManyAddAssociationsMixin<Role, Role['id']>;
}
User.hasMany(Role);
The countAssociations mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare countRoles: HasManyCountAssociationsMixin<Role>;
}
User.hasMany(Role);
The createAssociation mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare createRole: HasManyCreateAssociationMixin<Role>;
}
User.hasMany(Role);
The getAssociations mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare getRoles: HasManyGetAssociationsMixin<Role>;
}
User.hasMany(Role);
The hasAssociation mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare hasRole: HasManyHasAssociationMixin<Role, Role['id']>;
}
User.hasMany(Role);
The removeAssociations mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare hasRoles: HasManyHasAssociationsMixin<Role, Role['id']>;
}
User.hasMany(Role);
The removeAssociation mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare removeRole: HasManyRemoveAssociationMixin<Role, Role['id']>;
}
User.hasMany(Role);
The removeAssociations mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare removeRoles: HasManyRemoveAssociationsMixin<Role, Role['id']>;
}
User.hasMany(Role);
The setAssociations mixin applied to models with hasMany. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare setRoles: HasManySetAssociationsMixin<Role, Role['id']>;
}
User.hasMany(Role);
The createAssociation mixin applied to models with hasOne. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare createRole: HasOneCreateAssociationMixin<Role>;
}
User.hasOne(Role);
The getAssociation mixin applied to models with hasOne. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare getRole: HasOneGetAssociationMixin<Role>;
}
User.hasOne(Role);
The associated model, or null if no model is associated. HasOne associations are always nullable because the foreign key is on the target model.
The setAssociation mixin applied to models with hasOne. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare setRole: HasOneSetAssociationMixin<Role, Role['id']>;
}
User.hasOne(Role);
The setAssociation mixin applied to models with hasOne. An example of usage is as follows:
class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
declare setRole: HasOneSetAssociationMixin<Role, Role['id']>;
}
User.hasOne(Role);
Possible types for primary keys
Options for eager-loading associated models.
The association can be specified in different ways:
{ include: 'associationName' } (recommended){ include: MyModel.associations['associationName'] }{ include: Model1 }{ include: { model: Model1, as: 'Alias' } }You can also eagerly load all associations using { include: { all: true } } (not recommended outside of debugging)
Utility type to extract Attributes of a given Model class.
It returns all instance properties defined in the Model, except:
It cannot detect whether something is a getter or not, you should use the Excluded
parameter to exclude getter & setters from the attribute list.
Option bag for InferAttributes.
Utility type to extract Creation Attributes of a given Model class.
Works like InferAttributes, but fields that are tagged using CreationOptional will be optional.
Type will be true is T is branded with Brand, false otherwise
Interface for Attributes provided for all columns in a model
This is a Branded Type. You can use it to tag fields from your class that are NOT attributes. They will be ignored by InferAttributes and InferCreationAttributes
Internal type - prone to changes. Do not export.
Type helper for making certain fields of an object optional. This is helpful
for creating the CreationAttributes from your Attributes for a Model.
Please note if this is used the aliased property will not be available on the model instance
as a property but only via instance.get('alias').
This type represents the output of the RANGE data type.
Represents acceptable Static values.
Static values, as opposed to DynamicValues. i.e. booleans, strings, etc...
A pojo of values to update.
Used by Model.update
A hash of attributes to describe your search.
Possible key values:
An attribute name: { id: 1 }
A nested attribute: { '$projects.id$': 1 }
A JSON key: { 'object.key': 1 }
A cast: { 'id::integer': 1 }
A combination of the above: { '$join.attribute$.json.path::integer': 1 }
Types that can be compared to an attribute in a WHERE context.
The type accepted by every where option
Internal type - prone to changes. Do not export.
An array of type, e.g. DataTypes.ARRAY(DataTypes.DECIMAL). Only available in postgres.
A 64 bit integer.
Available properties: UNSIGNED, ZEROFILL
Binary storage. Available lengths: tiny, medium, long
A boolean / tinyint column, depending on dialect
A fixed length string. Default length 255
Case-insensitive text
Dummy Symbol used as branding by CreationOptional.
Do not export, Do not use.
A datetime column
A date only column
Decimal number. Accepts one or two arguments for precision
Floating point number (8-byte precision). Accepts one or two arguments for precision
An enumeration. DataTypes.ENUM('value', 'another value').
Floating point number (4-byte precision). Accepts one or two arguments for precision
Dummy Symbol used as branding by {@link ForeignKey}.
Do not export, Do not use.
A geography datatype represents two dimensional spacial objects in an elliptic coord system.
A geometry datatype represents two dimensional spacial objects.
A key / value column. Only available in postgres.
A 32 bit integer.
A JSON string column. Available in MySQL, Postgres and SQLite.
A pre-processed JSON data column. Only available in postgres.
A 24 bit integer.
A default value of the current timestamp
Dummy Symbol used as branding by NonAttribute.
Do not export, Do not use.
Range types are data types representing a range of values of some element type (called the range's subtype). Only available in postgres.
See Postgres documentation for more details
Floating point number (4-byte precision). Accepts one or two arguments for precision
A 16 bit integer.
A variable length string. Default length 255
An (un)limited length text column. Available lengths: tiny, medium, long
A time column
A 8 bit integer.
Full text search vector. Only available in postgres.
A column storing a unique universal identifier. Use with UUIDV1 or UUIDV4 for default values.
A default unique universal identifier generated following the UUID v1 standard
A default unique universal identifier generated following the UUID v4 standard
A virtual value that is not stored in the DB. This could for example be useful if you want to provide a default value in your model that is returned to the user but not stored in the DB.
You could also use it to validate a value before permuting and storing it. Checking password length before hashing it for example:
class User extends Model {}
User.init({
password_hash: DataTypes.STRING,
password: {
type: DataTypes.VIRTUAL,
set (val) {
this.setDataValue('password', val); // Remember to set the data value, otherwise it won't be validated
this.setDataValue('password_hash', this.salt + val);
},
validate: {
isLongEnough (val) {
if (val.length < 7) {
throw new Error("Please choose a longer password")
}
}
}
}
}, { sequelize });
VIRTUAL also takes a return type and dependency fields as arguments
If a virtual attribute is present in attributes it will automatically pull in the extra fields as well.
Return type is mostly useful for setups that rely on types like GraphQL.
{
active: {
type: new DataTypes.VIRTUAL(DataTypes.BOOLEAN, ['createdAt']),
get() {
return this.get('createdAt') > Date.now() - (7 * 24 * 60 * 60 * 1000)
}
}
}
In the above code the password is stored plainly in the password field so it can be validated, but is never stored in the DB.
An AND query
Each argument will be joined by AND
Creates a object representing a call to the cast function.
The value to cast
The type to cast it to
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.
The name of the column
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'))
})
The function you want to call
All further arguments will be passed as arguments to the function
Returns true if the value is a model subclass.
The value whose type will be checked
Returns true if a & b are the same initial model, ignoring variants created by Model.withSchema, Model.withScope, and the like.
The difference with doing a === b is that this method will also
return true if one of the models is scoped, or a variant with a different schema.
Creates an object representing nested where conditions for postgres's json data-type.
A hash containing strings/numbers or other nested hash, a string using dot notation or a string using postgres json syntax.
An optional value to compare against. Produces a string of the form "<json path> = '<value>'".
Creates a object representing a literal, i.e. something that will not be escaped.
An OR query
Each argument will be joined by OR
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.
The left side of the comparison.
The comparison operator to use. If unspecified, defaults to {@link Op.eq}.
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.
Generated using TypeDoc
This type allows using
Op.or,Op.and, andOp.notrecursively around another type. Unlike AllowNotOrAndWithImplicitAndArrayRecursive, it does not allow the 'implicit AND Array'.Example of plain-array NOT treated as Op.and: User.findAll({ where: { id: [1, 2] } });
Meant to be used by WhereAttributeHashValue.