transactions - node - promise all async await

Node.js 7 ¿Cómo usar la transacción de secuela con async/await?

Question

Node.js 7 ya admite la sintaxis async / await, en la transacción de secuela si el uso de async / await causará que la transacción no esté habilitada, ¿cómo debo usar?

Answer 1

El código anterior tiene un error en destruir la llamada.

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

La transacción es parte del objeto de opciones.

Answer 2

La respuesta aceptada es una "transacción no administrada", que requiere que llame al commit y rollback explícita. Para cualquier persona que quiera una "transacción administrada", esto es lo que se vería así:

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

Para revertir, simplemente lance un error dentro de la función de transacción:

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

Si cualquier código que produce un error dentro del bloque de transacción, la reversión se activa automáticamente.

Answer 3

La respuesta dada por el usuario 7403683 describe una forma asíncrona / espera para transacciones no administradas ( http://docs.sequelizejs.com/manual/tutorial/transactions.html#unmanaged-transaction-then-callback- )

La transacción administrada en estilo asíncrono / await puede tener el siguiente aspecto:

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

Si se produce un error, la transacción se revierte automáticamente.

Answer 4

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