Guides Reference Source
public class | source

Transaction

The transaction object is used to identify a running transaction. It is created by calling Sequelize.transaction(). To run a query under a transaction, you should pass the transaction in the options object.

See:

Static Member Summary

Static Public Members
public static get

ISOLATION_LEVELS: {"READ_UNCOMMITTED": string, "READ_COMMITTED": string, "REPEATABLE_READ": string, "SERIALIZABLE": string}

Isolation levels can be set per-transaction by passing options.isolationLevel to sequelize.transaction.
public static get

LOCK: object: {"UPDATE": string, "SHARE": string, "KEY_SHARE": string, "NO_KEY_UPDATE": string}

Possible options for row locking.
public static get

TYPES: {"DEFERRED": string, "IMMEDIATE": string, "EXCLUSIVE": string}

Types can be set per-transaction by passing options.type to sequelize.transaction.

Constructor Summary

Public Constructor
public

constructor(sequelize: Sequelize, options: object)

Creates a new transaction instance

Member Summary

Public Members
public get

LOCK: *

Please see Transaction.LOCK

Method Summary

Public Methods
public

A hook that is run after a transaction is committed
public

async commit(): Promise

Commit the transaction
public

async forceCleanup()

Kills the connection this transaction uses.
public

Called to acquire a connection to use and set the correct options on the connection.
public

async rollback(): Promise

Rollback (abort) the transaction

Static Public Members

public static get ISOLATION_LEVELS: {"READ_UNCOMMITTED": string, "READ_COMMITTED": string, "REPEATABLE_READ": string, "SERIALIZABLE": string} source

Isolation levels can be set per-transaction by passing options.isolationLevel to sequelize.transaction. Sequelize uses the default isolation level of the database, you can override this by passing options.isolationLevel in Sequelize constructor options.

Pass in the desired level as the first argument:

Properties:

NameTypeAttributeDescription
READ_UNCOMMITTED *
READ_COMMITTED *
REPEATABLE_READ *
SERIALIZABLE *

Example:

try {
  const result = await sequelize.transaction({isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE}, transaction => {
    // your transactions
  });
  // transaction has been committed. Do something after the commit if required.
} catch(err) {
  // do something with the err.
}

public static get LOCK: object: {"UPDATE": string, "SHARE": string, "KEY_SHARE": string, "NO_KEY_UPDATE": string} source

Possible options for row locking. Used in conjunction with find calls:

Properties:

NameTypeAttributeDescription
UPDATE *
SHARE *
KEY_SHARE *

Postgres 9.3+ only
NO_KEY_UPDATE *

Postgres 9.3+ only

Return:

object

Return Properties:

NameTypeAttributeDescription
UPDATE *
SHARE *
KEY_SHARE *

Postgres 9.3+ only
NO_KEY_UPDATE *

Postgres 9.3+ only

Example:

// t1 is a transaction
Model.findAll({
  where: ...,
  transaction: t1,
  lock: t1.LOCK...
});
Postgres also supports specific locks while eager loading by using OF:
UserModel.findAll({
  where: ...,
  include: [TaskModel, ...],
  transaction: t1,
  lock: {
    level: t1.LOCK...,
    of: UserModel
  }
});

# UserModel will be locked but TaskModel won't!
You can also skip locked rows:
// t1 is a transaction
Model.findAll({
  where: ...,
  transaction: t1,
  lock: true,
  skipLocked: true
});
# The query will now return any rows that aren't locked by another transaction

public static get TYPES: {"DEFERRED": string, "IMMEDIATE": string, "EXCLUSIVE": string} source

Types can be set per-transaction by passing options.type to sequelize.transaction. Default to DEFERRED but you can override the default type by passing options.transactionType in new Sequelize. Sqlite only.

Pass in the desired level as the first argument:

Properties:

NameTypeAttributeDescription
DEFERRED *
IMMEDIATE *
EXCLUSIVE *

Example:

try {
  await sequelize.transaction({ type: Sequelize.Transaction.TYPES.EXCLUSIVE }, transaction => {
     // your transactions
  });
  // transaction has been committed. Do something after the commit if required.
} catch(err) {
  // do something with the err.
}

Public Constructors

public constructor(sequelize: Sequelize, options: object) source

Creates a new transaction instance

Params:

NameTypeAttributeDescription
sequelize Sequelize

A configured sequelize Instance
options object

An object with options
options.type string
  • optional

Sets the type of the transaction. Sqlite only
options.isolationLevel string
  • optional

Sets the isolation level of the transaction.
options.deferrable string
  • optional

Sets the constraints to be deferred or immediately checked. PostgreSQL only
options.readOnly boolean
  • optional

Whether this transaction will only be used to read data. Used to determine whether sequelize is allowed to use a read replication server.

Public Members

public get LOCK: * source

Please see Transaction.LOCK

Public Methods

public afterCommit(fn: Function) source

A hook that is run after a transaction is committed

Params:

NameTypeAttributeDescription
fn Function

A callback function that is called with the committed transaction

public async commit(): Promise source

Commit the transaction

Return:

Promise

public async forceCleanup() source

Kills the connection this transaction uses. Used as a last resort, for instance because COMMIT or ROLLBACK resulted in an error and the transaction is left in a broken state, and releasing the connection to the pool would be dangerous.

public async prepareEnvironment(useCLS: boolean): Promise source

Called to acquire a connection to use and set the correct options on the connection. We should ensure all of the environment that's set up is cleaned up in cleanup() below.

Params:

NameTypeAttributeDescription
useCLS boolean

Defaults to true: Use CLS (Continuation Local Storage) with Sequelize. With CLS, all queries within the transaction callback will automatically receive the transaction object.

Return:

Promise

public async rollback(): Promise source

Rollback (abort) the transaction

Return:

Promise