Instantiate sequelize with name of database, username and password
// without password and options
const sequelize = new Sequelize('database', 'username')
// without options
const sequelize = new Sequelize('database', 'username', 'password')
// without password / with blank password
const sequelize = new Sequelize('database', 'username', null, {})
// with password and options
const sequelize = new Sequelize('my_database', 'john', 'doe', {})
// with uri (see below)
const sequelize = new Sequelize('mysql://localhost:3306/database', {})
The name of the database
The username which is used to authenticate against the database.
Optional password: stringThe password which is used to authenticate against the database.
Optional options: OptionsAn object with options.
Optional options: OptionsOptional options: OptionsInstantiate sequelize with an URI
A full database URI
Optional options: OptionsSee above for possible options
A reference to Sequelize constructor from sequelize. Useful for accessing DataTypes, Errors etc.
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!
An AND query
Rest ...args: TEach argument will be joined by AND
Readonly configFinal config that is used by sequelize.
Readonly connectionReadonly dialectCreates 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: anyAll 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 "<json path> = '<value>'".
Readonly modelDictionary of all models linked with this instance.
Readonly optionsAn OR query
Rest ...args: TEach argument will be joined by OR
The QueryInterface instance, dialect dependant.
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.
// 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');
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.
Static DataStatic OpStatic Readonly _clsFor internal use only.
Static andAn AND query
Rest ...args: TEach argument will be joined by AND
Static castStatic colStatic 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: anyAll 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 "<json path> = '<value>'".
Static literalStatic orAn OR query
Rest ...args: TEach argument will be joined by OR
Static whereA 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.
// 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');
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.
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.
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.
Static versionReturns the installed version of Sequelize
Add a hook to the model
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.
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 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
Test the connection by trying to authenticate
Optional options: QueryOptionsQuery Options for authentication
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 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
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
Optional options: LoggingOptions supplied
Returns the database version
Optional options: QueryRawOptionsDefine 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: DataTypes.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: DataTypes.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/docs/v7/other-topics/other-data-types
For more about getters and setters, see https://sequelize.org/docs/v7/core-concepts/getters-setters-virtuals/
For more about instance and class methods, see https://sequelize.org/docs/v7/core-concepts/model-basics/#taking-advantage-of-models-being-classes
For more about validation, see https://sequelize.org/docs/v7/core-concepts/validations-and-constraints/
The name of the model. The model will be stored in sequelize.models under this name
Optional 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
Drop all tables defined through this sequelize instance. This is done by calling Model.drop on each model
Optional options: DropOptionsThe options passed to each call to Model.drop
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.
Optional options: LoggingOptions 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
Optional options: LoggingOptions supplied
Returns the dialect-dependant QueryInterface instance.
Fetch a Model which is already defined
The name of a model defined with Sequelize.define
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>Works like query, but does not inline replacements. Only bind parameters are supported.
The SQL to execute
The options for the query. See QueryRawOptions for details.
Optional options: QueryRawOptions | QueryRawOptionsWithType<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.
Optional options: LoggingOptions 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/core');
Sequelize.useCLS(namespace);
Note, that CLS is enabled for all sequelize instances, and all instances will share the same namespace
Transaction Options
Callback for the transaction
Optional options: TransactionOptionsTruncate all tables defined through the sequelize models. This is done by calling Model.truncate() on each model.
Optional options: DestroyOptions<any>The options passed to Model.destroy in addition to truncate
Optional options: QueryOptionsStatic addAdd a hook to the model
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.
Static 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 afterStatic 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 afterStatic 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 afterStatic 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 beforeStatic 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 beforeStatic hasCheck whether the mode has any hooks of this type
Static hasStatic removeRemove hook from the model
Static useCLSUse CLS with Sequelize.
CLS namespace provided is stored as Sequelize._cls
and Promise is patched to use the namespace, using cls-hooked module.
Generated using TypeDoc
This is the main class, the entry point to sequelize. To use it, you just need to import sequelize:
In addition to sequelize, the connection library for the dialect you want to use should also be installed in your project. You don't need to import it however, as sequelize will take care of that.