Sequelize

https://sequelize.org/docs/v6
Admin
Sequelize is a promise-based Node.js ORM tool supporting multiple databases, featuring transaction...
Tokens:127,407
Snippets:906
Trust Score:9.6
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Quick example: define a model and create a record

Source: https://sequelize.org/docs/v6

Shows the minimal setup for Sequelize v6 with SQLite in-memory: define a User model, sync the database, create a record, and log its JSON. Requires Node v10 or above and the sequelize package installed.

```javascript
const { Sequelize, Model, DataTypes } = require('sequelize');

const sequelize = new Sequelize('sqlite::memory:');

class User extends Model {}
User.init(
  {
    username: DataTypes.STRING,
    birthday: DataTypes.DATE,
  },
  { sequelize, modelName: 'user' },
);

(async () => {
  await sequelize.sync();
  const jane = await User.create({
    username: 'janedoe',
    birthday: new Date(1980, 6, 20),
  });
  console.log(jane.toJSON());
})();
```

--------------------------------

### Install Sequelize with npm

Source: https://sequelize.org/docs/v6/getting-started

Installs the Sequelize library via npm. This is the first step in setting up Sequelize.

```bash
npm install --save sequelize
```

--------------------------------

### Sequelize setup with User model definition

Source: https://sequelize.org/docs/v6/core-concepts/model-instances

Sets up a Sequelize instance with an in-memory SQLite database and defines a User model with fields name, favoriteColor (default 'green'), age, and cash. The async IIFE syncs the model to the database, creating the table, and serves as the base setup for the examples on this page.

```javascript
const { Sequelize, Model, DataTypes } = require('sequelize');

const sequelize = new Sequelize('sqlite::memory:');

const User = sequelize.define('user', {
  name: DataTypes.TEXT,
  favoriteColor: {
    type: DataTypes.TEXT,
    defaultValue: 'green',
  },
  age: DataTypes.INTEGER,
  cash: DataTypes.INTEGER,
});

(async () => {
  await sequelize.sync({ force: true });
  // Code here
})();
```

--------------------------------

### Install babel-register

Source: https://sequelize.org/docs/v6/other-topics/migrations

Install babel-register as a dev dependency to enable modern JavaScript in migrations and seeders.

```bash
npm i --save-dev babel-register
```

--------------------------------

### Install Sequelize CLI

Source: https://sequelize.org/docs/v6/other-topics/migrations

Install the Sequelize CLI as a development dependency using npm.

```bash
npm install --save-dev sequelize-cli
```

--------------------------------

### Install Database Driver

Source: https://sequelize.org/docs/v6/getting-started

Installs the database driver for your chosen database. You must manually install one of these drivers; the comment indicates which driver corresponds to which database.

```bash
# One of the following:

$ npm install --save pg pg-hstore # Postgres

$ npm install --save mysql2

$ npm install --save mariadb

$ npm install --save sqlite3

$ npm install --save tedious # Microsoft SQL Server

$ npm install --save oracledb # Oracle
```

--------------------------------

### Start transaction with custom isolation level

Source: https://sequelize.org/docs/v6/other-topics/transactions

Shows how to start a managed transaction with a custom isolation level by passing it as the first argument to `sequelize.transaction`. The example uses `SERIALIZABLE`.

```javascript
const { Transaction } = require('sequelize');  

await sequelize.transaction(  
  {  
    isolationLevel: Transaction.ISOLATION_LEVELS.SERIALIZABLE,  
  },  
  async t => {  
    // Your code  
  },  
);  
```

--------------------------------

### Sequelize with SQLite in-memory database

Source: https://sequelize.org/docs/v6/getting-started

Sets up a Sequelize instance using the SQLite dialect in-memory. This is the recommended way to run code examples locally while reading the docs.

```javascript
const { Sequelize, Op, Model, DataTypes } = require('sequelize');  

const sequelize = new Sequelize('sqlite::memory:');  

  

// Code here! It works!  

```

--------------------------------

### PostgreSQL dialectOptions example

Source: https://sequelize.org/docs/v6/other-topics/dialect-specific-things

Configure Sequelize for PostgreSQL by passing custom options to the pg connector via dialectOptions. The options are passed directly to the PostgreSQL connection constructor.

```javascript
const sequelize = new Sequelize('database', 'username', 'password', {
  dialect: 'postgres',
  dialectOptions: {
    // Your pg options here
  },
});
```

--------------------------------

### MariaDB dialectOptions example

Source: https://sequelize.org/docs/v6/other-topics/dialect-specific-things

Configure Sequelize for MariaDB by passing custom options to the mariadb connector via dialectOptions. The options are passed directly to the MariaDB connection constructor.

```javascript
const sequelize = new Sequelize('database', 'username', 'password', {
  dialect: 'mariadb',
  dialectOptions: {
    // Your mariadb options here
    // connectTimeout: 1000
  },
});
```

--------------------------------

### MySQL dialectOptions example

Source: https://sequelize.org/docs/v6/other-topics/dialect-specific-things

Configure Sequelize for MySQL by passing custom options to the mysql2 connector via dialectOptions. The options are passed directly to the MySQL connection constructor.

```javascript
const sequelize = new Sequelize('database', 'username', 'password', {
  dialect: 'mysql',
  dialectOptions: {
    // Your mysql2 options here
  },
});
```

--------------------------------

### Define User and Profile models

Source: https://sequelize.org/docs/v6/advanced-association-concepts/advanced-many-to-many

Defines the User and Profile models used throughout the guide. Both models disable timestamps.

```javascript
const User = sequelize.define(  
  'user',  
  {  
    username: DataTypes.STRING,  
    points: DataTypes.INTEGER,  
  },  
  { timestamps: false },  
);  

const Profile = sequelize.define(  
  'profile',  
  {  
    name: DataTypes.STRING,  
  },  
  { timestamps: false },  
);  

```

--------------------------------

### Oracle Sequelize constructor with host and port

Source: https://sequelize.org/docs/v6/other-topics/dialect-specific-things

Connect to Oracle using the node-oracledb connector. The default port is 1521. Requires Oracle Instant Client to be installed.

```javascript
const sequelize = new Sequelize('servicename', 'username', 'password', {  

  dialect: 'oracle',  

  host: 'hostname',  

  port: 'port number', //optional  

});  

```

--------------------------------

### Initialize Sequelize project

Source: https://sequelize.org/docs/v6/other-topics/migrations

Run the init command to create the project structure with config, models, migrations, and seeders folders.

```bash
npx sequelize-cli init
```

--------------------------------

### Get the QueryInterface instance

Source: https://sequelize.org/docs/v6/other-topics/query-interface

Obtain the QueryInterface singleton instance from a Sequelize instance using getQueryInterface(). This is the starting point for all lower-level query interface operations.

```javascript
const { Sequelize, DataTypes } = require('sequelize');  

const sequelize = new Sequelize(/* ... */);  

const queryInterface = sequelize.getQueryInterface();  

```

--------------------------------

### Run migration with connection string

Source: https://sequelize.org/docs/v6/other-topics/migrations

Run migrations using a connection string with the --url option instead of a configuration file. Replace the URL with your own database credentials and host.

```bash
npx sequelize-cli db:migrate --url 'mysql://root:password@mysql_host.com/database_name'
```

--------------------------------

### Define models for non-primary-key association

Source: https://sequelize.org/docs/v6/core-concepts/assocs

Defines Ship and Captain models where Captain.name has a unique constraint, required for using a non-primary key as the association target. This setup is the prerequisite for the belongsTo example that follows.

```javascript
const Ship = sequelize.define('ship', { name: DataTypes.TEXT }, { timestamps: false });  

const Captain = sequelize.define(  
  'captain',  
  {  
    name: { type: DataTypes.TEXT, unique: true },  
  },  
  { timestamps: false },  
);  

```

--------------------------------

### Create sample posts with reactions

Source: https://sequelize.org/docs/v6/other-topics/sub-queries

Creates sample posts with reactions using the defined models. The function creates a post and bulk-creates reactions for it.

```javascript
async function makePostWithReactions(content, reactionTypes) {
  const post = await Post.create({ content });
  await Reaction.bulkCreate(reactionTypes.map(type => ({ type, postId: post.id })));
  return post;
}

await makePostWithReactions('Hello World', [
  'Like',
  'Angry',
  'Laugh',
  'Like',
  'Like',
  'Angry',
  'Sad',
  'Like',
]);
await makePostWithReactions('My Second Post', ['Laugh', 'Laugh', 'Like', 'Laugh']);
```

--------------------------------

### AWS Lambda runtime index.js - scheduleIteration call

Source: https://sequelize.org/docs/v6/other-topics/aws-lambda

The runtime schedules an iteration at the end of the initialization code. This line starts the Lambda runtime's event loop, which is essential for the race condition example.

```javascript
// (...)  

  

new Runtime(client, handler, errorCallbacks).scheduleIteration();  
```

--------------------------------

### Limit and offset pagination with Project.findAll

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Use the `limit` and `offset` options to paginate query results. The first example fetches 10 instances, the second skips 8 instances, and the third skips 5 and fetches the next 5. These options are typically used alongside the `order` option.

```javascript
// Fetch 10 instances/rows  

Project.findAll({ limit: 10 });  

  

// Skip 8 instances/rows  

Project.findAll({ offset: 8 });  

  

// Skip 5 instances and fetch the 5 after that  

Project.findAll({ offset: 5, limit: 5 });  
```

--------------------------------

### Create and save with User.create

Source: https://sequelize.org/docs/v6/core-concepts/model-instances

Combines build and save into a single create method call. The instance is immediately persisted to the database, and the returned value is a User instance.

```javascript
const jane = await User.create({ name: 'Jane' });
// Jane exists in the database now!
console.log(jane instanceof User); // true
console.log(jane.name); // "Jane"
```

--------------------------------

### Create with BelongsTo alias

Source: https://sequelize.org/docs/v6/advanced-association-concepts/creating-with-associations

Extends the previous example to use an alias for the BelongsTo association. The alias 'creator' is defined in the association setup and then used as the key in the create object, with the include option referencing the association object.

```javascript
const Creator = Product.belongsTo(User, { as: 'creator' });  

  

return Product.create(  

  {  

    title: 'Chair',  

    creator: {  

      firstName: 'Matt',  

      lastName: 'Hansen',  

    },  

  },  

  {  

    include: [Creator],  

  },  

);  
```

--------------------------------

### Create with HasMany alias

Source: https://sequelize.org/docs/v6/advanced-association-concepts/creating-with-associations

Modifies the previous example to use an alias for the HasMany association. The alias 'categories' is defined in the association setup and then used as the key in the create object, with the include option referencing the association object and alias.

```javascript
const Categories = Product.hasMany(Tag, { as: 'categories' });  

  

Product.create(  

  {  

    id: 1,  

    title: 'Chair',  

    categories: [  

      { id: 1, name: 'Alpha' },  

      { id: 2, name: 'Beta' },  

    ],  

  },  

  {  

    include: [  

      {  

        association: Categories,  

        as: 'categories',  

      },  

    ],  

  },  

);  
```

--------------------------------

### Define migration npm scripts

Source: https://sequelize.org/docs/v6/other-topics/migrations

Example package.json scripts for running migrations. When using npm scripts, add an extra '--' before flags, e.g., 'npm run migrate:up -- --url <url>'.

```json
// package.json

...
  "scripts": {
    "migrate:up": "npx sequelize-cli db:migrate",
    "migrate:undo": "npx sequelize-cli db:migrate:undo"
  },
...
```

--------------------------------

### Define Foo and Bar models for belongsToMany examples

Source: https://sequelize.org/docs/v6/core-concepts/assocs

Defines two Sequelize models, Foo and Bar, each with a unique field (name and title respectively) and timestamps disabled. This setup is used to demonstrate belongsToMany associations with custom sourceKey and targetKey options.

```javascript
const Foo = sequelize.define(  
  'foo',  
  {  
    name: { type: DataTypes.TEXT, unique: true },  
  },  
  { timestamps: false },  
);  

const Bar = sequelize.define(  
  'bar',  
  {  
    title: { type: DataTypes.TEXT, unique: true },  
  },  
  { timestamps: false },  
);  

```

--------------------------------

### Create a Sequelize Instance

Source: https://sequelize.org/docs/v6/getting-started

Creates a Sequelize instance by either passing a connection URI or passing parameters separately. The constructor accepts many options, documented in the API Reference.

```javascript
const { Sequelize } = require('sequelize');

// Option 1: Passing a connection URI
const sequelize = new Sequelize('sqlite::memory:') // Example for sqlite
const sequelize = new Sequelize('postgres://user:pass@example.com:5432/dbname') // Example for postgres

// Option 2: Passing parameters separately (sqlite)
const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: 'path/to/database.sqlite'
});

// Option 3: Passing parameters separately (other dialects)
const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: /* one of 'mysql' | 'postgres' | 'sqlite' | 'mariadb' | 'mssql' | 'db2' | 'snowflake' | 'oracle' */
});
```

--------------------------------

### Define Ship and Captain models with one-to-one association

Source: https://sequelize.org/docs/v6/core-concepts/assocs

Defines the Ship and Captain models with a one-to-one association (Captain.hasOne(Ship) and Ship.belongsTo(Captain)). Foreign keys are nullable by default, so a Ship can exist without a Captain and vice-versa. This setup is used by the examples that follow.

```javascript
// This is the setup of our models for the examples below  

const Ship = sequelize.define(  
  'ship',  
  {  
    name: DataTypes.TEXT,  
    crewCapacity: DataTypes.INTEGER,  
    amountOfSails: DataTypes.INTEGER,  
  },  
  { timestamps: false },  
);  

const Captain = sequelize.define(  
  'captain',  
  {  
    name: DataTypes.TEXT,  
    skillLevel: {  
      type: DataTypes.INTEGER,  
      validate: { min: 1, max: 10 },  
    },  
  },  
  { timestamps: false },  
);  

Captain.hasOne(Ship);  

Ship.belongsTo(Captain);  
```

--------------------------------

### Order eager loaded associations with top-level `order`

Source: https://sequelize.org/docs/v6/advanced-association-concepts/eager-loading

Use the top-level `order` option with augmented arrays to sort eager loaded associations. The array starts with the nested model (or its alias) to specify which association to sort. Examples show sorting by `Division.name` ascending/descending, using an alias, and sorting by a nested `Department` through a chain.

```javascript
Company.findAll({  
  include: Division,  
  order: [  
    // We start the order array with the model we want to sort  
    [Division, 'name', 'ASC'],  
  ],  
});  

Company.findAll({  
  include: Division,  
  order: [[Division, 'name', 'DESC']],  
});  

Company.findAll({  
  // If the include uses an alias...  
  include: { model: Division, as: 'Div' },  
  order: [  
    // ...we use the same syntax from the include  
    // in the beginning of the order array  
    [{ model: Division, as: 'Div' }, 'name', 'DESC'],  
  ],  
});  

  

Company.findAll({  
  // If we have includes nested in several levels...  
  include: {  
    model: Division,  
    include: Department,  
  },  
  order: [  
    // ... we replicate the include chain of interest  
    // at the beginning of the order array  
    [Division, Department, 'name', 'DESC'],  
  ],  
});  

```

--------------------------------

### Dynamic config.js with environment variables and dialect options

Source: https://sequelize.org/docs/v6/other-topics/migrations

Example of a dynamic config.js file for Sequelize CLI, showing environment variables for test and production, and custom dialect options like bigNumberStrings and SSL CA.

```javascript
const fs = require('fs');

module.exports = {
  development: {
    username: 'database_dev',
    password: 'database_dev',
    database: 'database_dev',
    host: '127.0.0.1',
    port: 3306,
    dialect: 'mysql',
    dialectOptions: {
      bigNumberStrings: true,
    },
  },
  test: {
    username: process.env.CI_DB_USERNAME,
    password: process.env.CI_DB_PASSWORD,
    database: process.env.CI_DB_NAME,
    host: '127.0.0.1',
    port: 3306,
    dialect: 'mysql',
    dialectOptions: {
      bigNumberStrings: true,
    },
  },
  production: {
    username: process.env.PROD_DB_USERNAME,
    password: process.env.PROD_DB_PASSWORD,
    database: process.env.PROD_DB_NAME,
    host: process.env.PROD_DB_HOSTNAME,
    port: process.env.PROD_DB_PORT,
    dialect: 'mysql',
    dialectOptions: {
      bigNumberStrings: true,
      ssl: {
        ca: fs.readFileSync(__dirname + '/mysql-ca-main.crt'),
      },
    },
  },
};

```

--------------------------------

### Configure migration storage options

Source: https://sequelize.org/docs/v6/other-topics/migrations

Configuration file example for customizing migration storage. Set migrationStorage to 'json' to store migrations in a JSON file, with migrationStoragePath to specify the file path (default: sequelize-meta.json). Alternatively, keep 'sequelize' storage and change the table name with migrationStorageTableName (default: SequelizeMeta) or provide a custom schema with migrationStorageTableSchema.

```json
{
  "development": {
    "username": "root",
    "password": null,
    "database": "database_development",
    "host": "127.0.0.1",
    "dialect": "mysql",
    // Use a different storage type. Default: sequelize
    "migrationStorage": "json",
    // Use a different file name. Default: sequelize-meta.json
    "migrationStoragePath": "sequelizeMeta.json",
    // Use a different table name. Default: SequelizeMeta
    "migrationStorageTableName": "sequelize_meta",
    // Use a different schema for the SequelizeMeta table
    "migrationStorageTableSchema": "custom_schema"
  }
}
```

--------------------------------

### SQLite dialectOptions example with storage and mode

Source: https://sequelize.org/docs/v6/other-topics/dialect-specific-things

Configure Sequelize for SQLite, specifying the storage file and custom sqlite3 options via dialectOptions. The mode option sets the opening mode; potential values include SQLite.OPEN_READONLY, SQLite.OPEN_READWRITE, or SQLite.OPEN_CREATE.

```javascript
import { Sequelize } from 'sequelize';
import SQLite from 'sqlite3';

const sequelize = new Sequelize('database', 'username', 'password', {
  dialect: 'sqlite',
  storage: 'path/to/database.sqlite', // or ':memory:'
  dialectOptions: {
    // Your sqlite3 options here
    // for instance, this is how you can configure the database opening mode:
    mode: SQLite.OPEN_READWRITE | SQLite.OPEN_CREATE | SQLite.OPEN_FULLMUTEX,
  },
});
```

--------------------------------

### Define models and associations for scope merging example

Source: https://sequelize.org/docs/v6/other-topics/scopes

Defines Foo, Bar, Baz, and Qux models with One-to-Many associations. These models are used in the subsequent scope examples.

```javascript
const Foo = sequelize.define('Foo', { name: Sequelize.STRING });  

const Bar = sequelize.define('Bar', { name: Sequelize.STRING });  

const Baz = sequelize.define('Baz', { name: Sequelize.STRING });  

const Qux = sequelize.define('Qux', { name: Sequelize.STRING });  

Foo.hasMany(Bar, { foreignKey: 'fooId' });  

Bar.hasMany(Baz, { foreignKey: 'barId' });  

Baz.hasMany(Qux, { foreignKey: 'bazId' });  


```

--------------------------------

### Create a new user with User.create()

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Creates a new user with the User.create() method and logs the auto-generated ID. The create() method is shorthand for Model.build() followed by instance.save().

```javascript
// Create a new user  

const jane = await User.create({ firstName: 'Jane', lastName: 'Doe' });  

console.log("Jane's auto-generated ID:", jane.id);  

```

--------------------------------

### Example of possible mistake with alias and foreign key

Source: https://sequelize.org/docs/v6/other-topics/naming-strategies

Using 'as' changes the foreign key name. This example shows that two different foreign keys (theSubscriptionId and subscriptionId) are created, which is likely unintended.

```javascript
// Example of possible mistake  
Invoice.belongsTo(Subscription, { as: 'TheSubscription' });  
Subscription.hasMany(Invoice);  
```

--------------------------------

### Create a table with queryInterface.createTable

Source: https://sequelize.org/docs/v6/other-topics/query-interface

Create a table using the query interface. The generated SQL (shown for SQLite) demonstrates the resulting schema. Prefer defining a Model and calling YourModel.sync() for a higher-level approach.

```javascript
queryInterface.createTable('Person', {  
  name: DataTypes.STRING,  
  isBetaMember: {  
    type: DataTypes.BOOLEAN,  
    defaultValue: false,  
    allowNull: false,  
  },  
});  

```

```sql
CREATE TABLE IF NOT EXISTS `Person` (  
  `name` VARCHAR(255),  
  `isBetaMember` TINYINT(1) NOT NULL DEFAULT 0  
);  

```

--------------------------------

### Sequelize model setup with validations and unique constraint

Source: https://sequelize.org/docs/v6/core-concepts/validations-and-constraints

Defines a User model with a username field that has allowNull false and unique true, and a hashedPassword field with a regex validation. The setup includes sequelize sync and a placeholder for code.

```javascript
const { Sequelize, Op, Model, DataTypes } = require('sequelize');  

const sequelize = new Sequelize('sqlite::memory:');  

  

const User = sequelize.define('user', {  

  username: {  

    type: DataTypes.TEXT,  

    allowNull: false,  

    unique: true,  

  },  

  hashedPassword: {  

    type: DataTypes.STRING(64),  

    validate: {  

      is: /^[0-9a-f]{64}$/i,  

    },  

  },  

});  

  

(async () => {  

  await sequelize.sync({ force: true });  

  // Code here  

})();  
```

--------------------------------

### Deprecated getterMethods and setterMethods example

Source: https://sequelize.org/docs/v6/core-concepts/getters-setters-virtuals

Shows the deprecated getterMethods and setterMethods options in a model definition. The getter returns the full name, and the setter splits the value into first and last names. The example then demonstrates creating, updating, and reading the user, logging the results. This feature is removed in Sequelize 7.

```javascript
const { Sequelize, DataTypes } = require('sequelize');  
const sequelize = new Sequelize('sqlite::memory:');  

  

const User = sequelize.define(  

  'user',  

  {  

    firstName: DataTypes.STRING,  

    lastName: DataTypes.STRING,  

  },  

  {  

    getterMethods: {  

      fullName() {  

        return this.firstName + ' ' + this.lastName;  

      },  

    },  

    setterMethods: {  

      fullName(value) {  

        // Note: this is just for demonstration.  

        // See: https://www.kalzumeus.com/2010/06/17/falsehoods-programmers-believe-about-names/  

        const names = value.split(' ');  

        const firstName = names[0];  

        const lastName = names.slice(1).join(' ');  

        this.setDataValue('firstName', firstName);  

        this.setDataValue('lastName', lastName);  

      },  

    },  

  },  

);  

  

(async () => {  

  await sequelize.sync();  

  let user = await User.create({ firstName: 'John', lastName: 'Doe' });  

  console.log(user.fullName); // 'John Doe'  

  user.fullName = 'Someone Else';  

  await user.save();  

  user = await User.findOne();  

  console.log(user.firstName); // 'Someone'  

  console.log(user.lastName); // 'Else'  

})();  

```

--------------------------------

### Shorthand OR on same field

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Shorthand for OR on the same field. More readable and generates the same behavior as the previous OR example.

```javascript
const { Op } = require('sequelize');
Post.destroy({
  where: {
    authorId: {
      [Op.or]: [12, 13],
    },
  },
});
// DELETE FROM post WHERE authorId = 12 OR authorId = 13;
```

--------------------------------

### Build a user instance and observe hashed password

Source: https://sequelize.org/docs/v6/core-concepts/getters-setters-virtuals

Builds a user instance with a plaintext password and shows that the setter hashes it automatically. The output shows the hashed value for both user.password and user.getDataValue('password').

```javascript
const user = User.build({  

  username: 'someone',  

  password: 'NotSo§tr0ngP4$SW0RD!',  

});  

console.log(user.password); // '7cfc84b8ea898bb72462e78b4643cfccd77e9f05678ec2ce78754147ba947acc'  

console.log(user.getDataValue('password')); // '7cfc84b8ea898bb72462e78b4643cfccd77e9f05678ec2ce78754147ba947acc'  

```

--------------------------------

### Event loop behavior examples for async vs non-async handlers

Source: https://sequelize.org/docs/v6/other-topics/aws-lambda

Examples illustrating the difference between async and non-async handlers regarding event loop behavior. Non-async handlers finish when the event loop is empty or when callback is invoked with callbackWaitsForEmptyEventLoop set to false; async handlers finish when the returned Promise resolves or rejects.

```javascript
// no callback invoked  
module.exports.handler = function () {  

  // Lambda finishes AFTER `doSomething()` is invoked  

  setTimeout(() => doSomething(), 1000);  

};  

// callback invoked  
module.exports.handler = function (event, context, callback) {  

  // Lambda finishes AFTER `doSomething()` is invoked  

  setTimeout(() => doSomething(), 1000);  

  callback(null, 'Hello World!');  

};  

// callback invoked, context.callbackWaitsForEmptyEventLoop = false  
module.exports.handler = function (event, context, callback) {  

  // Lambda finishes BEFORE `doSomething()` is invoked  

  context.callbackWaitsForEmptyEventLoop = false;  

  setTimeout(() => doSomething(), 2000);  

  setTimeout(() => callback(null, 'Hello World!'), 1000);  

};  

// async/await  
module.exports.handler = async function () {  

  // Lambda finishes BEFORE `doSomething()` is invoked  

  setTimeout(() => doSomething(), 1000);  

  return 'Hello World!';  

};  

// Promise  
module.exports.handler = function () {  

  // Lambda finishes BEFORE `doSomething()` is invoked  

  setTimeout(() => doSomething(), 1000);  

  return Promise.resolve('Hello World!');  

};  


```

--------------------------------

### Explicit Op.and operator

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Explicitly using Op.and to combine conditions. Equivalent to the implicit AND example.

```javascript
const { Op } = require('sequelize');
Post.findAll({
  where: {
    [Op.and]: [{ authorId: 12 }, { status: 'active' }],
  },
});
// SELECT * FROM post WHERE authorId = 12 AND status = 'active';
```

--------------------------------

### Sequelize Super Many-to-Many example with nested includes

Source: https://sequelize.org/docs/v6/advanced-association-concepts/advanced-many-to-many

Full runnable example of a Super Many-to-Many relationship (many-to-many-to-many) using Sequelize. It defines Game, Team, and Player models with two junction models (GameTeam and PlayerGameTeam), seeds data, and queries the 'Winter Showdown' game with nested includes. The output shows the expected console log for that query.

```javascript
const { Sequelize, Op, Model, DataTypes } = require('sequelize');  

const sequelize = new Sequelize('sqlite::memory:', {  

  define: { timestamps: false }, // Just for less clutter in this example  

});  

const Player = sequelize.define('Player', { username: DataTypes.STRING });  

const Team = sequelize.define('Team', { name: DataTypes.STRING });  

const Game = sequelize.define('Game', { name: DataTypes.STRING });  

  

// We apply a Super Many-to-Many relationship between Game and Team  

const GameTeam = sequelize.define('GameTeam', {  

  id: {  

    type: DataTypes.INTEGER,  

    primaryKey: true,  

    autoIncrement: true,  

    allowNull: false,  

  },  

});  

Team.belongsToMany(Game, { through: GameTeam });  

Game.belongsToMany(Team, { through: GameTeam });  

GameTeam.belongsTo(Game);  

GameTeam.belongsTo(Team);  

Game.hasMany(GameTeam);  

Team.hasMany(GameTeam);  

  

// We apply a Super Many-to-Many relationship between Player and GameTeam  

const PlayerGameTeam = sequelize.define('PlayerGameTeam', {  

  id: {  

    type: DataTypes.INTEGER,  

    primaryKey: true,  

    autoIncrement: true,  

    allowNull: false,  

  },  

});  

Player.belongsToMany(GameTeam, { through: PlayerGameTeam });  

GameTeam.belongsToMany(Player, { through: PlayerGameTeam });  

PlayerGameTeam.belongsTo(Player);  

PlayerGameTeam.belongsTo(GameTeam);  

Player.hasMany(PlayerGameTeam);  

GameTeam.hasMany(PlayerGameTeam);  

  

(async () => {  

  await sequelize.sync();  

  await Player.bulkCreate([  

    { username: 's0me0ne' },  

    { username: 'empty' },  

    { username: 'greenhead' },  

    { username: 'not_spock' },  

    { username: 'bowl_of_petunias' },  

  ]);  

  await Game.bulkCreate([  

    { name: 'The Big Clash' },  

    { name: 'Winter Showdown' },  

    { name: 'Summer Beatdown' },  

  ]);  

  await Team.bulkCreate([  

    { name: 'The Martians' },  

    { name: 'The Earthlings' },  

    { name: 'The Plutonians' },  

  ]);  

  

  // Let's start defining which teams were in which games. This can be done  

  // in several ways, such as calling `.setTeams` on each game. However, for  

  // brevity, we will use direct `create` calls instead, referring directly  

  // to the IDs we want. We know that IDs are given in order starting from 1.  

  await GameTeam.bulkCreate([  

    { GameId: 1, TeamId: 1 }, // this GameTeam will get id 1  

    { GameId: 1, TeamId: 2 }, // this GameTeam will get id 2  

    { GameId: 2, TeamId: 1 }, // this GameTeam will get id 3  

    { GameId: 2, TeamId: 3 }, // this GameTeam will get id 4  

    { GameId: 3, TeamId: 2 }, // this GameTeam will get id 5  

    { GameId: 3, TeamId: 3 }, // this GameTeam will get id 6  

  ]);  

  

  // Now let's specify players.  

  // For brevity, let's do it only for the second game (Winter Showdown).  

  // Let's say that that s0me0ne and greenhead played for The Martians, while  

  // not_spock and bowl_of_petunias played for The Plutonians:  

  await PlayerGameTeam.bulkCreate([  

    // In 'Winter Showdown' (i.e. GameTeamIds 3 and 4):  

    { PlayerId: 1, GameTeamId: 3 }, // s0me0ne played for The Martians  

    { PlayerId: 3, GameTeamId: 3 }, // greenhead played for The Martians  

    { PlayerId: 4, GameTeamId: 4 }, // not_spock played for The Plutonians  

    { PlayerId: 5, GameTeamId: 4 }, // bowl_of_petunias played for The Plutonians  

  ]);  

  

  // Now we can make queries!  

  const game = await Game.findOne({  

    where: {  

      name: 'Winter Showdown',  

    },  

    include: {  

      model: GameTeam,  

      include: [  

        {  

          model: Player,  

          through: { attributes: [] }, // Hide unwanted `PlayerGameTeam` nested object from results  

        },  

        Team,  

      ],  

    },  

  });  

  

  console.log(`Found game: "${game.name}"`);  

  for (let i = 0; i < game.GameTeams.length; i++) {  

    const team = game.GameTeams[i].Team;  

    const players = game.GameTeams[i].Players;  

    console.log(`- Team "${team.name}" played game "${game.name}" with the following players:`);  

    console.log(players.map(p => `--- ${p.username}`).join('\n'));  

  }  

})();  
```

```text
Found game: "Winter Showdown"  
- Team "The Martians" played game "Winter Showdown" with the following players:  
--- s0me0ne  
--- greenhead  
- Team "The Plutonians" played game "Winter Showdown" with the following players:  
--- not_spock  
--- bowl_of_petunias
```

--------------------------------

### Explicit Op.eq operator

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Explicitly using Op.eq to filter with equality. Equivalent to the implicit equality example.

```javascript
const { Op } = require('sequelize');
Post.findAll({
  where: {
    authorId: {
      [Op.eq]: 2,
    },
  },
});
// SELECT * FROM post WHERE authorId = 2;
```

--------------------------------

### hasOne instance methods: getBar, setBar, createBar

Source: https://sequelize.org/docs/v6/core-concepts/assocs

Demonstrates the instance methods added by a hasOne association: getBar, setBar, and createBar. Shows that getBar returns null before association, setBar associates a Bar, createBar creates and associates a new Bar, and setBar(null) un-associates.

```javascript
const foo = await Foo.create({ name: 'the-foo' });  

const bar1 = await Bar.create({ name: 'some-bar' });  

const bar2 = await Bar.create({ name: 'another-bar' });  

console.log(await foo.getBar()); // null  

await foo.setBar(bar1);  

console.log((await foo.getBar()).name); // 'some-bar'  

await foo.createBar({ name: 'yet-another-bar' });  

const newlyAssociatedBar = await foo.getBar();  

console.log(newlyAssociatedBar.name); // 'yet-another-bar'  

await foo.setBar(null); // Un-associate  

console.log(await foo.getBar()); // null  
```

--------------------------------

### Create Product with multiple tags

Source: https://sequelize.org/docs/v6/advanced-association-concepts/creating-with-associations

Creates a Product with multiple associated Tag instances in one step. The tags are provided as an array under the 'tags' key, and the include option specifies the Tag model.

```javascript
Product.create(  

  {  

    id: 1,  

    title: 'Chair',  

    tags: [{ name: 'Alpha' }, { name: 'Beta' }],  

  },  

  {  

    include: [Tag],  

  },  

);  
```

--------------------------------

### Exclude attributes with attributes.exclude

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Use `attributes.exclude` to remove specific columns from the query. The example excludes 'baz'.

```javascript
Model.findAll({
  attributes: { exclude: ['baz'] },
});
```

```sql
-- Assuming all columns are 'id', 'foo', 'bar', 'baz' and 'qux'
SELECT id, foo, bar, qux FROM ...
```

--------------------------------

### Logical combinations with Op.and and Op.or

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Demonstrates combining Op.and and Op.or to create nested logical conditions. The example shows a rank condition (rank < 1000 OR rank IS NULL), a createdAt range, and a title/description OR condition.

```javascript
const { Op } = require("sequelize");  

Foo.findAll({  
  where: {  
    rank: {  
      [Op.or]: {  
        [Op.lt]: 1000,  
        [Op.eq]: null  
      }  
    },  
    // rank < 1000 OR rank IS NULL  

    {  
      createdAt: {  
        [Op.lt]: new Date(),  
        [Op.gt]: new Date(new Date() - 24 * 60 * 60 * 1000)  
      }  
    },  
    // createdAt < [timestamp] AND createdAt > [timestamp]  

    {  
      [Op.or]: [  
        {  
          title: {  
            [Op.like]: 'Boat%'  
          }  
        },  
        {  
          description: {  
            [Op.like]: '%boat%'  
          }  
        }  
      ]  
    }  
    // title LIKE 'Boat%' OR description LIKE '%boat%'  
  }  
});  

```

--------------------------------

### SQL query generated by findAll()

Source: https://sequelize.org/docs/v6/core-concepts/model-querying-basics

Shows the SQL query that findAll() generates: SELECT * FROM ... . This is the underlying SQL for the findAll example.

```sql
SELECT * FROM ...  

```

--------------------------------

### Set up CLS with cls-hooked

Source: https://sequelize.org/docs/v6/other-topics/upgrade

Use cls-hooked for CLS support in Sequelize v6. Create a namespace and pass it to Sequelize.useCLS().

```javascript
const cls = require('cls-hooked');  

const namespace = cls.createNamespace('....');  

const Sequelize = require('sequelize');  

  

Sequelize.useCLS(namespace);  

```

--------------------------------

### Column declaration shorthand syntax

Source: https://sequelize.org/docs/v6/core-concepts/model-basics

Shows the shorthand syntax for column declaration when only the data type is specified, using DataTypes.STRING as an example.

```javascript
// This:  
sequelize.define('User', {  
  name: {  
    type: DataTypes.STRING,  
  },  
});  
  
// Can be simplified to:  
sequelize.define('User', { name: DataTypes.STRING });  
```
Tokens:
Raw