orange-orm 4.4.2 → 4.5.0-beta.1

package/src/table/tryGetFromDbById/extractStrategy.js

@@ -1,6 +1,6 @@
 
-function extract(table) {
-	var lengthWithStrategy = table._primaryColumns.length  + 2;
+function extract(_context, table) {
+	var lengthWithStrategy = table._primaryColumns.length  + 3;
 	if (arguments.length === lengthWithStrategy)
 		return arguments[lengthWithStrategy-1];
 	return;

package/src/table/tryGetFromDbById.js

@@ -2,18 +2,20 @@ var newPrimaryKeyFilter = require('./newPrimaryKeyFilter');
 var tryGetFirstFromDb = require('./tryGetFirstFromDb');
 var extractStrategy = require('./tryGetFromDbById/extractStrategy');
 
-function tryGet() {
+function tryGet(context) {
 	var filter = newPrimaryKeyFilter.apply(null, arguments);
-	var table = arguments[0];
+	var table = arguments[1];
 	var strategy = extractStrategy.apply(null, arguments);
-	return tryGetFirstFromDb(table, filter, strategy);
+	return tryGetFirstFromDb(context, table, filter, strategy);
 }
 
-tryGet.exclusive = function tryGet() {
+tryGet.exclusive = function tryGet(context) {
 	var filter = newPrimaryKeyFilter.apply(null, arguments);
-	var table = arguments[0];
+	var table = arguments[1];
 	var strategy = extractStrategy.apply(null, arguments);
-	return tryGetFirstFromDb.exclusive(table, filter, strategy);
+	return tryGetFirstFromDb.exclusive(context, table, filter, strategy);
+
+
 };
 
 module.exports = tryGet;

package/src/table/tryGetSessionContext.js

@@ -1,15 +1,10 @@
-let useHook = require('../useHook');
-let cls;
+const process = require('node:process');
 
-
-function tryGetSessionContext() {
-	if (useHook()) {
-		if (!cls)
-			cls = require('node-cls');
-		let context = cls.getContext('rdb');
-		return context && context.rdb;
-	}
+function tryGetSessionContext(context) {
+	if (context)
+		return context.rdb;
 	else
+		// @ts-ignore
 		return process.domain && process.domain.rdb;
 }
 

package/src/table/tryReleaseDbClient.js

@@ -1,8 +1,8 @@
 var release = require('./releaseDbClient');
 
-function tryReleaseDbClient() {
+function tryReleaseDbClient(context) {
 	try {
-		release();
+		release(context);
 	}
 	// eslint-disable-next-line no-empty
 	catch (e) {

package/src/table/updateField.js

@@ -2,11 +2,11 @@ var newUpdateCommand = require('./commands/newUpdateCommand');
 var pushCommand = require('./commands/pushCommand');
 var lastCommandMatches = require('./commands/lastCommandMatches');
 
-function updateField(table, column, row, oldValue) {
-	if (lastCommandMatches(row))
+function updateField(context, table, column, row) {
+	if (lastCommandMatches(context, row))
 		return;
-	var command = newUpdateCommand(table, column, row, oldValue);
-	pushCommand(command);
+	var command = newUpdateCommand(context, table, column, row);
+	pushCommand(context, command);
 }
 
 module.exports = updateField;

package/src/table/where.js

@@ -2,9 +2,9 @@ const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 
 function newWhere(table) {
 
-	function where(fn) {
+	function where(context, fn) {
 		let arg = typeof fn === 'function' ? fn(table) : fn;
-		return negotiateRawSqlFilter(arg);
+		return negotiateRawSqlFilter(context, arg);
 	}
 	return where;
 }

package/src/table.js

@@ -16,11 +16,10 @@ const _delete = require('./table/delete');
 const cascadeDelete = require('./table/cascadeDelete');
 const createReadStream = require('./table/createReadStream');
 const createJSONReadStream = require('./table/createJSONReadStream');
-const getIdArgs = require('./table/getIdArgs');
 const patchTable = require('./patchTable');
 const newEmitEvent = require('./emitEvent');
 const hostLocal = require('./hostLocal');
-const getTSDefinition = require('./getTSDefinition');
+// const getTSDefinition = require('./getTSDefinition'); //todo: unused ?
 const where = require('./table/where');
 const aggregate = require('./table/aggregate');
 const groupBy = require('./table/groupBy');
@@ -62,63 +61,63 @@ function _new(tableName) {
 		return hasOne(joinRelation);
 	};
 
-	table.count = function(filter) {
-		return Promise.resolve().then(() => count(table, filter));
+	table.count = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => count.apply(null, args));
 	};
 
-	table.getMany = function(filter, strategy) {
-		return Promise.resolve().then(() => getMany(table, filter, strategy));
+	table.getMany = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getMany.apply(null, args));
 	};
-	table.getManyDto = function(filter, strategy) {
-		return Promise.resolve().then(() => getManyDto(table, filter, strategy));
+	table.getManyDto = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getManyDto.apply(null, args));
 	};
 
-	table.aggregate = function(filter, strategy) {
-		return groupBy(table, filter, strategy);
+	table.aggregate = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return groupBy.apply(null, args);
 	};
 
-	table.getMany.exclusive = function(filter, strategy) {
-		return Promise.resolve().then(() => getMany.exclusive(table, filter, strategy));
+	table.getMany.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getMany.exclusive.apply(null, args));
 	};
 
-	table.tryGetFirst = function(filter, strategy) {
-		return Promise.resolve().then(() => tryGetFirst(table, filter, strategy));
+	table.tryGetFirst = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetFirst.apply(null, args));
 	};
-	table.tryGetFirst.exclusive = function(filter, strategy) {
-		return Promise.resolve().then(() => tryGetFirst.exclusive(table, filter, strategy));
+	table.tryGetFirst.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetFirst.exclusive.apply(null, args));
 	};
+
 	table.getOne = table.tryGetFirst;
 	table.getOne.exclusive = table.tryGetFirst.exclusive;
 
-	function callAsync(func, args) {
-		return Promise.resolve().then(() => call(func, args));
-	}
-
-	function call(func, args) {
-		var mergedArgs = [table];
-		for (var i = 0; i < args.length; i++) {
-			mergedArgs.push(args[i]);
-		}
-		return func.apply(null, mergedArgs);
-	}
-
-	table.getById = function() {
-		return callAsync(getById, getIdArgs(table, arguments));
+	table.getById = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getById.apply(null, args));
 	};
 
-	table.getById.exclusive = function() {
-
-		return callAsync(getById.exclusive, getIdArgs(table, arguments));
+	table.getById.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => getById.exclusive.apply(null, args));
 	};
 
-	table.tryGetById = function() {
-		return callAsync(tryGetById, getIdArgs(table, arguments));
+	table.tryGetById = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetById.apply(null, args));
 	};
 
-	table.tryGetById.exclusive = function() {
-		return callAsync(tryGetById.exclusive, getIdArgs(table, arguments));
+	table.tryGetById.exclusive = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return Promise.resolve().then(() => tryGetById.exclusive.apply(null, args));
 	};
 
+
 	table.columnDiscriminators = function() {
 		for (var i = 0; i < arguments.length; i++) {
 			table._columnDiscriminators.push(arguments[i]);
@@ -133,37 +132,45 @@ function _new(tableName) {
 		return table;
 	};
 
-	table.insert = function() {
+	table.insert = function(context, ...rest) {
 		const concurrency = undefined;
-		let args = [{table, concurrency}].concat([].slice.call(arguments));
+		let args = [context, {table, concurrency}, ...rest];
 		return insert.apply(null, args);
 	};
 
-	table.insertWithConcurrency = function(options, ...rows) {
-		let args = [{table, options}].concat([].slice.call(rows));
+	table.insertWithConcurrency = function(context, options, ...rows) {
+		let args = [context, {table, options}].concat([].slice.call(rows));
 		return insert.apply(null, args);
 	};
 
 	table.delete = _delete.bind(null, table);
-	table.cascadeDelete = cascadeDelete.bind(null, table);
-	table.deleteCascade = cascadeDelete.bind(null, table);
-	table.createReadStream = createReadStream.bind(null, table);
-	table.createJSONReadStream = createJSONReadStream.bind(null, table);
+	table.cascadeDelete = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return cascadeDelete.apply(null, args);
+	};
+
+	table.deleteCascade = table.cascadeDelete;
+	table.createReadStream = createReadStream.bind(null, table); //legacy
+	table.createJSONReadStream = createJSONReadStream.bind(null, table); //legacy
 	table.exclusive = function() {
 		table._exclusive = true;
 		return table;
 	};
-	table.patch = patchTable.bind(null, table);
-	table.subscribeChanged = table._emitChanged.add;
-	table.unsubscribeChanged = table._emitChanged.remove;
+	table.patch = function(context, ...rest) {
+		const args = [context, table, ...rest];
+		return patchTable.apply(null, args);
+	};
+
+	// table.subscribeChanged = table._emitChanged.add; //legacy
+	// table.unsubscribeChanged = table._emitChanged.remove; //legacy
 
 	table.hostLocal = function(options) {
 		return hostLocal({table, ...options});
 	};
 
-	table.ts = function(name) {
-		return getTSDefinition(table, {name});
-	};
+	// table.ts = function(name) { //unused ?
+	// 	return getTSDefinition(table, {name});
+	// };
 
 	table.where = where(table);
 	table._aggregate = aggregate(table);

package/src/tedious/deleteFromSql.js

@@ -1,6 +1,6 @@
 var format = 'delete %s from %s as %s%s';
 var util = require('util');
-const quote = require('../table/quote');
+const quote = require('./quote');
 
 function deleteFromSql(table, alias, whereSql) {
 	var name = quote(table._dbName);

package/src/tedious/formatDateOut.js

@@ -1,4 +1,4 @@
-const quote = require('../table/quote');
+const quote = require('./quote');
 
 function formatDateOut(column, alias) {
 	return `CONVERT(VARCHAR, ${alias}.${quote(column._dbName)}, 121)`;

package/src/tedious/getManyDto/newQueryCore.js

@@ -5,14 +5,14 @@ var extractOrderBy = require('../../table/query/extractOrderBy');
 var extractLimit = require('../../table/query/extractLimit');
 var limitAndOffset = require('../limitAndOffset');
 
-function newQuery(table,filter,span,alias) {
+function newQuery(context, table, filter, span, alias) {
 	filter = extractFilter(filter);
-	var orderBy = extractOrderBy(table,alias,span.orderBy);
-	var limit = extractLimit(span);
+	var orderBy = extractOrderBy(context, table, alias, span.orderBy);
+	var limit = extractLimit(context, span);
 	var offset = limitAndOffset(span);
 
-	var subQueries = newSubQueries(table,span,alias);
-	return newSingleQuery(table,filter,span,alias,subQueries,orderBy,limit,offset);
+	var subQueries = newSubQueries(context, table, span, alias);
+	return newSingleQuery(context, table, filter, span, alias, subQueries, orderBy, limit, offset);
 }
 
 module.exports = newQuery;

package/src/tedious/getManyDto/query/newSingleQuery.js

@@ -2,17 +2,17 @@ var newColumnSql = require('./singleQuery/newShallowColumnSql');
 var newWhereSql = require('../../../table/query/singleQuery/newWhereSql');
 var newParameterized = require('../../../table/query/newParameterized');
 
-function _new(table, filter, span, alias, subQueries, orderBy, limit, offset) {
-	var columnSql = newColumnSql(table, alias, span);
-	var whereSql = newWhereSql(table, filter, alias);
+function _new(context, table, filter, span, alias, subQueries, orderBy, limit, offset) {
+	var columnSql = newColumnSql(context, table, alias, span);
+	var whereSql = newWhereSql(context, table, filter, alias);
 	if (limit)
 		limit = limit + ' ';
 
 	let join = '';
 	const set = new Set();
-	for(let key in span.aggregates) {
+	for (let key in span.aggregates) {
 		const agg = span.aggregates[key];
-		for(let sql of agg.joins) {
+		for (let sql of agg.joins) {
 			if (!set.has(sql)) {
 				join = join + sql;
 				set.add(sql);

package/src/tedious/getManyDto/query/newSubQueries/joinLegToQuery.js

@@ -1,15 +1,15 @@
 var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
 var newQuery = require('../../newQueryCore');
 
-function joinLegToQuery(parentAlias,leg,_legNo) {
+function joinLegToQuery(context, parentAlias, leg, _legNo) {
 	var childAlias = parentAlias + leg.name;
 	var span = leg.span;
 	var parentTable = leg.table;
 	var childColumns = span.table._primaryColumns;
 	var parentColumns = leg.columns;
 
-	var filter  = newShallowJoinSql(parentTable,childColumns,parentColumns,childAlias,parentAlias,leg.span.where);
-	var query = newQuery(span.table,filter,span,childAlias);
+	var filter = newShallowJoinSql(context, parentTable, childColumns, parentColumns, childAlias, parentAlias, leg.span.where);
+	var query = newQuery(context, span.table, filter, span, childAlias);
 	return query.prepend('JSON_QUERY((').append(` FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "${leg.name}"`);
 }
 

package/src/tedious/getManyDto/query/newSubQueries/manyLegToQuery.js

@@ -1,15 +1,15 @@
 var newShallowJoinSql = require('../../../../table/query/singleQuery/joinSql/newShallowJoinSqlCore');
 var newQuery = require('../../newQueryCore');
 
-function manyLegToQuery(rightAlias, leg, _legNo) {
+function manyLegToQuery(context, rightAlias, leg, _legNo) {
 	var leftAlias = rightAlias + leg.name;
 	var span = leg.span;
 	var rightTable = leg.table;
 	var rightColumns = rightTable._primaryColumns;
 	var leftColumns = leg.columns;
 
-	var filter = newShallowJoinSql(rightTable, leftColumns, rightColumns, leftAlias, rightAlias, leg.span.where);
-	var query = newQuery(span.table, filter, span, leftAlias);
+	var filter = newShallowJoinSql(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, leg.span.where);
+	var query = newQuery(context, span.table, filter, span, leftAlias);
 	return query.prepend('JSON_QUERY( coalesce((').append(` FOR JSON PATH, INCLUDE_NULL_VALUES),'[]')) "${leg.name}"`);
 }
 

package/src/tedious/getManyDto/query/newSubQueries/oneLegToQuery.js

@@ -3,17 +3,17 @@ var newQuery = require('../../newQueryCore');
 var newParameterized = require('../../../../table/query/newParameterized');
 var util = require('util');
 
-function oneLegToQuery(rightAlias,leg,_legNo) {
+function oneLegToQuery(context, rightAlias, leg, _legNo) {
 	var leftAlias = rightAlias + leg.name;
 	var span = leg.span;
 	var rightTable = leg.table;
 	var rightColumns = rightTable._primaryColumns;
 	var leftColumns = leg.columns;
 
-	var filter  = newShallowJoinSql(rightTable,leftColumns,rightColumns,leftAlias,rightAlias,leg.span.where);
-	var query = newQuery(span.table,filter,span,leftAlias);
+	var filter = newShallowJoinSql(context, rightTable, leftColumns, rightColumns, leftAlias, rightAlias, leg.span.where);
+	var query = newQuery(context, span.table, filter, span, leftAlias);
 	var sql = 'SELECT TOP 1' + query.sql().substring(6);
-	return newParameterized(util.format('JSON_QUERY((%s FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "%s"',sql, leg.name ), query.parameters);
+	return newParameterized(util.format('JSON_QUERY((%s FOR JSON PATH, INCLUDE_NULL_VALUES, WITHOUT_ARRAY_WRAPPER)) "%s"', sql, leg.name), query.parameters);
 }
 
 module.exports = oneLegToQuery;

package/src/tedious/getManyDto/query/newSubQueries.js

@@ -3,24 +3,24 @@ var oneLegToQuery = _oneLegToQuery;
 var manyLegToQuery = _manyLegToQuery;
 var newParameterized = require('../../../table/query/newParameterized');
 
-function newSubQueries(_table,span,alias) {
+function newSubQueries(context, _table, span, alias) {
 	var result = newParameterized('', []);
 	var c = {};
 	var _legNo;
 
 	c.visitJoin = function(leg) {
-		result = result.append(',').append(joinLegToQuery( alias,leg,_legNo));
+		result = result.append(',').append(joinLegToQuery(context, alias, leg, _legNo));
 	};
 	c.visitOne = function(leg) {
-		result = result.append(',').append(oneLegToQuery( alias,leg,_legNo));
+		result = result.append(',').append(oneLegToQuery(context, alias, leg, _legNo));
 	};
 	c.visitMany = function(leg) {
-		result = result.append(',').append(manyLegToQuery( alias,leg,_legNo));
+		result = result.append(',').append(manyLegToQuery(context, alias, leg, _legNo));
 	};
 
 	span.legs.forEach(onEachLeg);
 
-	function onEachLeg(leg,legNo) {
+	function onEachLeg(leg, legNo) {
 		_legNo = legNo;
 		leg.accept(c);
 	}
@@ -30,17 +30,17 @@ function newSubQueries(_table,span,alias) {
 
 function _joinLegToQuery() {
 	joinLegToQuery = require('./newSubQueries/joinLegToQuery');
-	return joinLegToQuery.apply(null,arguments);
+	return joinLegToQuery.apply(null, arguments);
 }
 
 function _oneLegToQuery() {
 	oneLegToQuery = require('./newSubQueries/oneLegToQuery');
-	return oneLegToQuery.apply(null,arguments);
+	return oneLegToQuery.apply(null, arguments);
 }
 
 function _manyLegToQuery() {
 	manyLegToQuery = require('./newSubQueries/manyLegToQuery');
-	return manyLegToQuery.apply(null,arguments);
+	return manyLegToQuery.apply(null, arguments);
 }
 
 

package/src/tedious/getManyDto/query/singleQuery/newShallowColumnSql.js

@@ -1,7 +1,6 @@
-const getSessionSingleton = require('../../../../table/getSessionSingleton');
+const quote = require('../../../quote');
 
-function _new(table,alias, span) {
-	const quote = getSessionSingleton('quote');
+function _new(context, table, alias, span) {
 	alias = quote(alias);
 	let columnsMap = span.columns;
 	var columns = table._columns;
@@ -11,7 +10,7 @@ function _new(table,alias, span) {
 	for (var i = 0; i < columns.length; i++) {
 		var column = columns[i];
 		if (!columnsMap || (columnsMap.get(column))) {
-			sql = sql + separator  + formatColumn(column) + ' as ' + quote(column.alias);
+			sql = sql + separator + formatColumn(column) + ' as ' + quote(column.alias);
 			separator = ',';
 		}
 	}
@@ -24,11 +23,11 @@ function _new(table,alias, span) {
 
 	function formatColumn(column) {
 
-		const formatted = column.formatOut && column.tsType !== 'DateColumn' ? column.formatOut(alias) : alias + '.' + quote(column._dbName);
+		const formatted = column.formatOut && column.tsType !== 'DateColumn' ? column.formatOut(context, alias) : alias + '.' + quote(column._dbName);
 		if (column.dbNull === null)
 			return formatted;
 		else {
-			const encoded = column.encode.unsafe(column.dbNull);
+			const encoded = column.encode.unsafe(context, column.dbNull);
 			return `CASE WHEN ${formatted}=${encoded} THEN null ELSE ${formatted} END`;
 		}
 

package/src/tedious/getManyDto.js

@@ -3,17 +3,17 @@ const negotiateRawSqlFilter = require('../table/column/negotiateRawSqlFilter');
 const strategyToSpan = require('../table/strategyToSpan');
 const executeQueries = require('../table/executeQueries');
 
-async function getManyDto(table, filter, strategy) {
-	filter = negotiateRawSqlFilter(filter, table);
+async function getManyDto(context, table, filter, strategy) {
+	filter = negotiateRawSqlFilter(context, filter, table);
 	if (strategy && strategy.where) {
 		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
-		filter = filter.and(arg);
+		filter = filter.and(context, arg);
 	}
-	let span = strategyToSpan(table,strategy);
+	let span = strategyToSpan(table, strategy);
 	let alias = table._dbName;
 
-	const query = newQuery(table, filter, span, alias);
-	const res =  await executeQueries([query]);
+	const query = newQuery(context, table, filter, span, alias);
+	const res = await executeQueries(context, [query]);
 	const rows = await res[0];
 	if (rows.length === 0)
 		return [];

package/src/tedious/insert.js

@@ -2,11 +2,11 @@ let newInsertCommand = require('../table/commands/newInsertCommand');
 let newInsertCommandCore = require('../table/commands/newInsertCommandCore');
 let executeQueries = require('../table/executeQueries');
 
-async function insertDefault(table, row, options) {
-	let insertCmd = newInsertCommand(newInsertCommandCore, table, row, options);
+async function insertDefault(context, table, row, options) {
+	let insertCmd = newInsertCommand(newInsertCommandCore.bind(null, context), table, row, options);
 	insertCmd.disallowCompress = true;
 
-	return executeQueries([insertCmd]).then((result) => result[result.length - 1]);
+	return executeQueries(context, [insertCmd]).then((result) => result[result.length - 1]);
 
 }
 

package/src/tedious/insertSql.js

@@ -1,11 +1,11 @@
 let outputInsertedSql = require('./outputInsertedSql');
 let mergeSql = require('./mergeSql');
 
-function getSqlTemplate(_table, _row, options) {
+function getSqlTemplate(_context, _table, _row, options) {
 	if (hasConcurrency(_table, options) && hasColumns())
-		return mergeSql.apply(null, arguments);
+		return mergeSql.apply(null, [...arguments].slice(1));
 	else
-		return insertSql.apply(null, arguments);
+		return insertSql.apply(null, [...arguments].slice(1));
 
 	function hasColumns() {
 		for(let p in _row) {

package/src/tedious/newDatabase.js

@@ -4,10 +4,6 @@ let _begin = require('../table/begin');
 let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
-let useHook = require('../useHook');
-let promise = require('promise/domains');
-let versionArray = process.version.replace('v', '').split('.');
-let major = parseInt(versionArray[0]);
 let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
@@ -34,15 +30,11 @@ function newDatabase(connectionString, poolOptions) {
 
 		if (fn)
 			return domain.run(runInTransaction);
-		else if ((major >= 12) && useHook()) {
-			domain.exitContext = true;
-			return domain.start().then(run);
-		}
 		else
 			return domain.run(run);
 
 		function begin() {
-			return _begin(options?.readonly);
+			return _begin(domain, options);
 		}
 
 		async function runInTransaction() {
@@ -50,10 +42,10 @@ function newDatabase(connectionString, poolOptions) {
 			let transaction = newTransaction(domain, pool, options);
 			await new Promise(transaction)
 				.then(begin)
-				.then(fn)
+				.then(() => fn(domain))
 				.then((res) => result = res)
-				.then(c.commit)
-				.then(null, c.rollback);
+				.then(() => c.commit(domain))
+				.then(null, (e) => c.rollback(domain,e));
 			return result;
 		}
 
@@ -61,53 +53,48 @@ function newDatabase(connectionString, poolOptions) {
 		function run() {
 			let p;
 			let transaction = newTransaction(domain, pool, options);
-			if (useHook())
-				p = new Promise(transaction);
-			else
-				p = new promise(transaction);
+			p = new Promise(transaction);
 
 			return p.then(begin);
 		}
 
 	};
 
-	c.createTransaction = function() {
+	c.createTransaction = function(options) {
 		let domain = createDomain();
 		let transaction = newTransaction(domain, pool);
-		let p = domain.run(() => new Promise(transaction).then(_begin));
+		let p = domain.run(() => new Promise(transaction).then(begin));
 
 		function run(fn) {
 			return p.then(domain.run.bind(domain, fn));
 		}
+
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
 		return run;
-	};
 
-	c.bindTransaction = function() {
-		// @ts-ignore
-		var domain = process.domain;
-		let p = domain.run(() => true);
 
-		function run(fn) {
-			return p.then(domain.run.bind(domain, fn));
+		function begin() {
+			return _begin(domain, options);
 		}
-		return run;
+
 	};
 
 	c.query = function(query) {
 		let domain = createDomain();
 		let transaction = newTransaction(domain, pool);
 		let p = domain.run(() => new Promise(transaction)
-			.then(() => setSessionSingleton('changes', []))
-			.then(() => doQuery(query).then(onResult, onError)));
+			.then(() => setSessionSingleton(domain, 'changes', []))
+			.then(() => doQuery(domain, query).then(onResult, onError)));
 		return p;
 
 		function onResult(result) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			return result;
 		}
 
 		function onError(e) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			throw e;
 		}
 	};