Easy way to handle nested transactions - node.js

Question

Suppose there is an "addUser" function, inside we need to insert a record to "Account" table and "User" table, so the two steps have to be within a transaction too, so we will write the following code:
function addUser (userName, password) {
sequelize.transaction(function () {
return AccountModel.create(...)
.then(UserModel.create(...))
})
}
However, in another "addTeam" function, inside we need to insert a record to "Team" table and create a admin user using the above function. The function also need to be wrapped inside a transaction.
So the problem comes, the "addUser" function sometimes need to begin a new transaction, and sometimes need to use the transaction passed in. The most obvious ways is below:
function addUser (userName, password, transaction) {
let func = function (t) {
return AccountModel.create(..., t)
.then(()=>UserModel.create(..., t)));
if (transaction) func(t);
else sequelize.transaction(x=>func(t));
}
function addTeam() {
sequelize.transaction(x=> {
TeamModel.create(..., x)
.then(y=>addUser(x));
});
}
Obviously, it is awful. How to deal with it easily, which let transaction totally transparent to the caller like below:
#Transaction
async function addUser(userName, password) {
await AccountModel.create(...);
await UserModel.create(...);
}
#Transaction
async function addTeam(...) {
await TeamModel.create(...);
await addUser(...);
}

Answer 1

sequelize.transaction accepts an options object - If options.transaction is set, this will create a savepoint in the transaction (provided that the SQL dialects supports it), otherwise it will create a new transaction
http://docs.sequelizejs.com/en/latest/api/sequelize/#transactionoptions-promise
So you should be able to do simply
sequelize.transaction({ transaction }, x=>func(t));

Answer 2

If you use CLS, a very simple helper function will do the work.
const cls = require('continuation-local-storage');
const Sequelize = require('sequelize');
const NAMESPACE = 'your-namespace';
// Use CLS for Sequelize
Sequelize.cls = cls.createNamespace(NAMESPACE);
const sequelize = new Sequelize(...);
/* * * * * * * * * * * * * * * * * * * * *
* THE MAGIC: Create a transaction wrapper
* * * * * * * * * * * * * * * * * * * * */
function transaction(task) {
return cls.getNamespace(NAMESPACE).get('transaction') ? task() : sequelize.transaction(task);
};
/* * * * * * * * * * * * * * * * * * * * *
* Your code below
* * * * * * * * * * * * * * * * * * * * */
function addUser(userName, password) {
return transaction(function() {
return AccountModel
.create(...)
.then(() => UserModel.create(...));
});
}
function addTeam() {
return transaction(function() {
return TeamModel
.create(...)
.then(() => addUser(...));
});
}

Answer 3

I solved the problem, and feel great.
I used the CLS feature sequelize provides, like the code below:
let namespace = Sequelize.cls = cls.createNamespace('myschool');
export const db = new Sequelize(config.db.url);
export const trans = option => operation => async function () {
let t = namespace.get('transaction');
let hasTrans = !!t;
t = t || await db.transaction();
try {
let result = await operation.apply(null, arguments);
if (!hasTrans) await t.commit();
return result;
}
catch (e) {
if (!hasTrans) await t.rollback();
throw e;
}
};
The above code just create a transaction and commit it if there is no transaction in the local context, otherwise just leave it.
And each business function want a transaction just need to use the above high order function to wrap like below:
export const createSchool = trans()( async (name, accountProps) => {
let school = await SchoolModel.create({name});
let teacher = await createTeacher({...accountProps, schoolId: school.get('id')});
return {school, teacher};
});

Answer 4

Although there is an accepted answer, below answer refers to a chain of commands (not necessarily nested) we may want to execute in the same transaction, using async-await:
try{
// create a transaction
let transaction = await sequelize.transaction();
// "parent" insertion, id is auto increment, so we will need the id of inserted data
let record = await Parent_Record.create({
data_1: req.params.data1,
data_2: req.params.data2,
....
}, {transaction});
//the array contains data depending upon the id of inserted parent transaction
for ( x in dataForChildTable) {
result = await Child_Record.create({
id: record.id, //same transaction so we can use record.id of parent
.....
other_data: dataForChildTable[x].otherData}, {transaction});
}
//commit the transaction
await transaction.commit();
} catch (err) {
console.log(err.message);
}

Answer 5

You could use zb-sequelize which adds transactional decorators.
import { Transactional, Tx } from 'zb-sequelize';
#Transactional
function addUser(user, password, #Tx transaction) {
// no need to create, commit or rollback a transaction.
}
You do need to initialize it with your sequelize instance.
import { Sequelize } from 'sequelize';
import { initSequelizeResolver } from 'zb-sequelize';
// you already have this somewhere.
const sequelize = new Sequelize(options);
// you need to add this:
initSequelizeResolver((args) => sequelize);