Node.js 7, как использовать транзакцию sequelize с async / await?

Question

Node.js 7 уже поддерживает синтаксис async / await, в транзакции sequelize, если использование async / await приведет к отключению транзакции, как мне использовать?

Answer 1

let transaction;    

try {
  // get transaction
  transaction = await sequelize.transaction();

  // step 1
  await Model.destroy({where: {id}, transaction});

  // step 2
  await Model.create({}, {transaction});

  // commit
  await transaction.commit();

} catch (err) {
  // Rollback transaction if any errors were encountered
  await transaction.rollback();
}

Answer 2

Принятым ответом является "неуправляемая транзакция", которая требует от вас commit а также rollback в явном виде. Для тех, кто хочет "управляемую транзакцию", это выглядит так:

try {
    // Result is whatever you returned inside the transaction
    let result = await sequelize.transaction( async (t) => {
        // step 1
        await Model.destroy({where: {id: id}, transaction: t});

        // step 2
        return await Model.create({}, {transaction: t});
    });

    // In this case, an instance of Model
    console.log(result);
} catch (err) {
    // Rollback transaction if any errors were encountered
    console.log(err);
}

Чтобы выполнить откат, просто сгенерируйте ошибку внутри функции транзакции:

try {
    // Result is whatever you returned inside the transaction
    let result = await sequelize.transaction( async (t) => {
        // step 1
        await Model.destroy({where: {id:id}, transaction: t});

        // Cause rollback
        if( false ){
            throw new Error('Rollback initiated');
        }

        // step 2
        return await Model.create({}, {transaction: t});
    });

    // In this case, an instance of Model
    console.log(result);
} catch (err) {
    // Rollback transaction if any errors were encountered
    console.log(err);
}

Если какой-либо код, который выдает ошибку в блоке транзакции, автоматически выполняется откат.

Answer 3

Если в вашем проекте включен CLS, Sequelize может использовать это, чтобы сохранить ваш объект транзакции и передать его всем запросам внутри continuation-passing цикл.

Настроить:

import { Sequelize } from "sequelize";
import { createNamespace } from "cls-hooked"; // npm i cls-hooked

const cls = createNamespace("transaction-namespace"); // any string
Sequelize.useCLS(cls);

const sequelize = new Sequelize(...);

Применение:

const removeUser = async (id) => {
    await sequelize.transaction(async () => { // no need `async (tx)`
        await removeClasses(id);
        await User.destroy({ where: { id } }); // will auto receive `tx`
    });
}

const removeClasses = async (userId) => {
    await UserClass.destroy({ where: { userId } }); // also receive the same transaction object as this function was called inside `sequelize.transaction()`
    await somethingElse(); // all queries inside this function also receive `tx`
}

Как это устроено?

Из исходного кода Sequelize: github.com/sequelize

Проверить и сохранить транзакцию в CLS

if (useCLS && this.sequelize.constructor._cls) {
    this.sequelize.constructor._cls.set('transaction', this);
}

Получить транзакцию из CSL и установить параметры

if (options.transaction === undefined && Sequelize._cls) {
    options.transaction = Sequelize._cls.get('transaction');
}

Подробнее:

1. Sequelize: автоматическая передача транзакций по всем запросам
2. CLS подключен
3. Асинхронные хуки

Answer 4

Ответ, предоставленный пользователем 7403683, описывает асинхронный / ожидающий путь для неуправляемой транзакции ( http://docs.sequelizejs.com/manual/tutorial/transactions.html)

Управляемая транзакция в стиле async / await может выглядеть следующим образом:

await sequelize.transaction( async t=>{
  const user = User.create( { name: "Alex", pwd: "2dwe3dcd" }, { transaction: t} )
  const group = Group.findOne( { name: "Admins", transaction: t} )
  // etc.
})

Если происходит ошибка, транзакция автоматически откатывается.

Answer 5

Приведенный выше код имеет ошибку в вызове destroy.

 await Model.destroy({where: {id}, transaction});

Транзакция является частью объекта опций.

Answer 6

// попробуй с этим

Answer 7

async () => {
  let t;

  try {
    t = await sequelize.transaction({ autocommit: true});

    let _user = await User.create({}, {t});

    let _userInfo = await UserInfo.create({}, {t});

    t.afterCommit((t) => {
      _user.setUserInfo(_userInfo);
      // other logic
    });
  } catch (err) {
    throw err;
  }
}

Answer 8

Для тестового покрытия решения user7403683 выше рассмотрите возможность использования sequelize-mock а также sinon:

import SequelizeMock from 'sequelize-mock';
import sinon from 'sinon';

sandbox.stub(models, 'sequelize').returns(new SequelizeMock());

для успешных транзакций:

sandbox.stub(model.sequelize, 'transaction')
          .resolves({commit() {}});

and stub everything in the transaction block

commit() {} provides stubbing of transaction.commit(), 
otherwise you'll get a "method does not exist" error in your tests

или неудачная транзакция:

sandbox.stub(models.sequelize, 'transaction').resolves({rollback() {}});

to cover transaction.rollback()

чтобы проверить catch() логика.