A similar dummy variable that doesn't exist on the real object. Do not try to access this in real code.
This property will become a Symbol in v7 to prevent collisions.
Use Attributes
A similar dummy variable that doesn't exist on the real object. Do not try to access this in real code.
This property will become a Symbol in v7 to prevent collisions.
Use CreationAttributes
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!
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
Readonly configFinal config that is used by sequelize.
Readonly connectionCreates 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
Rest ...args: unknown[]All further arguments will be passed as arguments to the function
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.
Optional value: string | number | booleanAn optional value to compare against. Produces a string of the form "
Creates a object representing a literal, i.e. something that will not be escaped.
Readonly modelReadonly modelsDictionary of all models linked with this instance.
Protected nameA 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 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.
// Using an attribute as the left operand.
// Equal to: WHERE first_name = 'Lily'
where(User.rawAttributes.firstName, Op.eq, 'Lily');
// Using a column name as the left operand.
// Equal to: WHERE first_name = 'Lily'
where(col('first_name'), Op.eq, 'Lily');
// Using a SQL function on the left operand.
// Equal to: WHERE LOWER(first_name) = 'lily'
where(fn('LOWER', col('first_name')), Op.eq, 'lily');
// Using raw SQL as the left operand.
// Equal to: WHERE 'Lily' = 'Lily'
where(literal(`'Lily'`), Op.eq, 'Lily');
Static andAn AND query
Static castCreates a object representing a call to the cast function.
The value to cast
The type to cast it to
Static colCreates 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
Static fnCreates 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
Rest ...args: unknown[]All further arguments will be passed as arguments to the function
Static jsonCreates 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.
Optional value: string | number | booleanAn optional value to compare against. Produces a string of the form "
Static literalCreates a object representing a literal, i.e. something that will not be escaped.
Static orAn OR query
Static Readonly typeStatic whereA 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.
A hook that is run after creating instances in bulk
A callback function that is called with instances, options
A hook that is run after destroying instances in bulk
A callback function that is called with options
A hook that is run after sequelize.sync call
A callback function that is called with options passed to sequelize.sync
A hook that is run after updating instances in bulk
A callback function that is called with options
A hook that is run after creating a single instance
A callback function that is called with attributes, options
A hook that is run after a define call
A callback function that is called with factory
A hook that is run after destroying a single instance
A callback function that is called with instance, options
A hook that is run after a find (select) query
A callback function that is called with instance(s), options
A hook that is run after Sequelize() call
A callback function that is called with sequelize
A hook that is run after Model.sync call
A callback function that is called with options passed to Model.sync
A hook that is run after updating a single instance
A callback function that is called with instance, options
A hook that is run after validation
A callback function that is called with instance, options
A hook that is run before creating instances in bulk
A callback function that is called with instances, options
A hook that is run before destroying instances in bulk
A callback function that is called with options
A hook that is run before sequelize.sync call
A callback function that is called with options passed to sequelize.sync
A hook that is run after updating instances in bulk
A callback function that is called with options
A hook that is run before creating a single instance
A callback function that is called with attributes, options
A hook that is run before a define call
A callback function that is called with attributes, options
A hook that is run before destroying a single instance
A callback function that is called with instance, options
A hook that is run before a find (select) query
A callback function that is called with options
A hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded
A callback function that is called with options
A hook that is run before a find (select) query, after all option parsing is complete
A callback function that is called with options
A hook that is run before Sequelize() call
A callback function that is called with config, options
A hook that is run before Model.sync call
A callback function that is called with options passed to Model.sync
A hook that is run before updating a single instance
A callback function that is called with instance, options
A hook that is run before validation
A callback function that is called with instance, options
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.
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.
Name of the schema
Options supplied
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
The name of the model. The model will be stored in sequelize.models under this name
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
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.
Options supplied
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
Name of the schema
Options supplied
Fetch a Model which is already defined
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
Query options
Optional options: QueryOptions | QueryOptionsWithType<RAW>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.
object with multiple variables.
Query options.
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.
Options supplied
Sync all defined models to the DB.
Optional options: SyncOptionsSync Options
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
Optional options: TransactionOptionsStatic addStatic afterA hook that is run after creating instances in bulk
A callback function that is called with instances, options
Static afterA hook that is run after destroying instances in bulk
A callback function that is called with options
Static afterA hook that is run after sequelize.sync call
A callback function that is called with options passed to sequelize.sync
Static afterA hook that is run after updating instances in bulk
A callback function that is called with options
Static afterA hook that is run after a connection is established
A callback function that is called with options
Static afterA hook that is run after creating a single instance
A callback function that is called with attributes, options
Static afterA hook that is run after a define call
A callback function that is called with factory
Static afterA hook that is run after destroying a single instance
A callback function that is called with instance, options
Static afterA hook that is run after a connection is released
A callback function that is called with options
Static afterA hook that is run after a find (select) query
A callback function that is called with instance(s), options
Static afterA hook that is run after Sequelize() call
A callback function that is called with sequelize
Static afterA hook that is run after successfully acquiring a connection from the pool
A callback function that is called with options
Static afterA hook that is run after creating or updating a single instance, It proxies afterCreate and afterUpdate
A callback function that is called with instance, options
Static afterA hook that is run after Model.sync call
A callback function that is called with options passed to Model.sync
Static afterA hook that is run after updating a single instance
A callback function that is called with instance, options
Static afterA hook that is run after validation
A callback function that is called with instance, options
Static beforeA hook that is run before creating instances in bulk
A callback function that is called with instances, options
Static beforeA hook that is run before destroying instances in bulk
A callback function that is called with options
Static beforeA hook that is run before sequelize.sync call
A callback function that is called with options passed to sequelize.sync
Static beforeA hook that is run after updating instances in bulk
A callback function that is called with options
Static beforeA hook that is run before a connection is established
A callback function that is called with options
Static beforeA hook that is run before creating a single instance
A callback function that is called with attributes, options
Static beforeA hook that is run before a define call
A callback function that is called with attributes, options
Static beforeA hook that is run before destroying a single instance
A callback function that is called with instance, options
Static beforeA hook that is run before a connection is released
A callback function that is called with options
Static beforeA hook that is run before a find (select) query
A callback function that is called with options
Static beforeA hook that is run before a find (select) query, after any { include: {all: ...} } options are expanded
A callback function that is called with options
Static beforeA hook that is run before a find (select) query, after all option parsing is complete
A callback function that is called with options
Static beforeA hook that is run before Sequelize() call
A callback function that is called with config, options
Static beforeA hook that is run before attempting to acquire a connection from the pool
A callback function that is called with options
Static beforeA hook that is run before creating or updating a single instance, It proxies beforeCreate and beforeUpdate
A callback function that is called with instance, options
Static beforeA hook that is run before Model.sync call
A callback function that is called with options passed to Model.sync
Static beforeA hook that is run before updating a single instance
A callback function that is called with instance, options
Static beforeA hook that is run before validation
A callback function that is called with instance, options
Static hasStatic hasStatic removeStatic useCLS
A reference to Sequelize constructor from sequelize. Useful for accessing DataTypes, Errors etc.