Node.js 7 et supérieur supporte déjà la syntaxe async/wait. Comment utiliser async/wait avec des transactions séquentielles?
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();
}
La réponse acceptée est une "transaction non gérée", qui nécessite d'appeler explicitement commit
et rollback
. Pour ceux qui veulent une "transaction gérée", voici à quoi cela ressemblerait:
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);
}
Pour revenir en arrière, jetez simplement une erreur dans la fonction de transaction:
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 un code génère une erreur à l'intérieur du bloc de transaction, la restauration est automatiquement déclenchée.
La réponse donnée par user7403683 décrit la manière asynchrone/en attente d'une transaction non gérée ( http://docs.sequelizejs.com/manual/tutorial/transactions.html#unmanaged-transaction-then-callback- )
Les transactions gérées en style asynchrone/wait peuvent se présenter comme suit:
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 une erreur survient, la transaction est automatiquement annulée.
Le code ci-dessus a une erreur dans l'appel détruit.
await Model.destroy({where: {id}, transaction});
La transaction fait partie de l'objet options.
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;
}
}
Pour la couverture de test de la solution user7403683 ci-dessus, utilisez les options sequelize-mock
Et sinon
:
import SequelizeMock from 'sequelize-mock';
import sinon from 'sinon';
sandbox.stub(models, 'sequelize').returns(new SequelizeMock());
pour des transactions réussies:
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
ou transaction échouée:
sandbox.stub(models.sequelize, 'transaction').resolves({rollback() {}});
to cover transaction.rollback()
pour tester la logique catch()
.