Node.js 7 如何使用异步/等待的续集事务？

Question

Node.js 7 及更高版本已经支持 async/await 语法。我应该如何将 async/await 与 sequelize 事务一起使用？

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 });

  // step 3
  await Model.update({}, { where: { id }, transaction });

  // commit
  await transaction.commit();

} catch (err) {
  // Rollback transaction only if the transaction object is defined
  if (transaction) await transaction.rollback();
}

Answer 2

以上代码在destroy调用中有错误。

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

事务是选项对象的一部分。

Answer 3

user7403683给出的答案描述了非托管事务的异步/等待方式（http://docs.sequelizejs.com/manual/tutorial/transactions.html#unmanaged-transaction-then-callback-）

异步/等待风格的托管事务可能如下所示：

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 4

接受的答案是“非托管事务”，它要求您显式调用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 5

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 6

如果启用了 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 removeUserClasses(id);
        await User.destroy({ where: { id } }); // will auto receive `tx`
    });
}

const removeUserClasses = 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

Check and save transaction to CLS

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

Retrieve transaction from CLS and set to options

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

了解更多：

1. Sequelize: automatically pass transactions to all queries
2. CLS hooked
3. Async Hooks

Answer 7

//试试这个

const transaction = await sequelize.transaction({ autocommit: false });
    try {
      await Model.create(data, {transaction})
    } catch (e) {
      if (transaction) await transaction.rollback();
      next(e);
      response.status(500).json({ error: e });
    }

    if (transaction) {
      await transaction.commit();
    }