orange-orm 4.5.0-beta.0 → 4.5.0-beta.2

package/src/table/commands/delete/singleCommand/subFilter.js

@@ -1,17 +1,17 @@
-var newSelect = require('./selectSql');
-var newJoin = require('./joinSql');
-var newWhere = require('./whereSql');
-var createAlias = require('../createAlias');
+const newSelect = require('./selectSql');
+const newJoin = require('./joinSql');
+const newWhere = require('./whereSql');
+const createAlias = require('../createAlias');
 
-function newSubFilter(relations, shallowFilter) {
-	var relationCount = relations.length;
+function newSubFilter(context,relations, shallowFilter) {
+	const relationCount = relations.length;
 	if (relationCount === 0)
 		return shallowFilter;
-	var table = relations[0].childTable;
-	var alias = createAlias(table, relationCount -1);
-	var filter = newSelect(table,alias).prepend('EXISTS (');
-	var join = newJoin(relations.slice(1));
-	var where = newWhere(relations,shallowFilter,alias);
+	const table = relations[0].childTable;
+	const alias = createAlias(table, relationCount -1);
+	const filter = newSelect(context,table,alias).prepend('EXISTS (');
+	const join = newJoin(context, relations.slice(1));
+	const where = newWhere(context,relations,shallowFilter,alias);
 	return filter.append(join).append(where).append(')');
 
 }

package/src/table/commands/delete/singleCommand/whereSql.js

@@ -1,6 +1,6 @@
 var newShallowJoinSql = require('../../../query/singleQuery/joinSql/newShallowJoinSqlCore');
 
-function newWhereSql(relations, shallowFilter, rightAlias) {
+function newWhereSql(context, relations, shallowFilter, rightAlias) {
 	var sql;
 	var relationCount = relations.length;
 	var relation = relations[0];
@@ -12,7 +12,7 @@ function newWhereSql(relations, shallowFilter, rightAlias) {
 
 	function where() {
 		var table = relation.childTable;
-		var joinCore = newShallowJoinSql(table, leftColumns, rightColumns, leftAlias, rightAlias);
+		var joinCore = newShallowJoinSql(context, table, leftColumns, rightColumns, leftAlias, rightAlias);
 		if (shallowFilter.sql())
 			sql = shallowFilter.prepend(' AND ').prepend(joinCore).prepend(' WHERE ');
 		else

package/src/table/commands/getChangeSet.js

@@ -1,6 +1,6 @@
 var getSessionSingleton = require('../getSessionSingleton');
-function getChangeSet() {
-	return getSessionSingleton('changes');
+function getChangeSet(context) {
+	return getSessionSingleton(context, 'changes');
 }
 
 module.exports = getChangeSet;

package/src/table/commands/insert/getSqlTemplate.js

@@ -1,19 +1,19 @@
 let getSessionContext = require('../../getSessionContext');
 let quote = require('../../quote');
 
-function getSqlTemplate(_table, _row) {
-	let context = getSessionContext();
-	if (context.insertSql)
-		return context.insertSql.apply(null, arguments);
+function getSqlTemplate(context, _table, _row) {
+	let rdb = getSessionContext(context);
+	if (rdb.insertSql)
+		return rdb.insertSql.apply(null, arguments);
 	else
 		return getSqlTemplateDefault.apply(null, arguments);
 
 }
 
-function getSqlTemplateDefault(table, row) {
+function getSqlTemplateDefault(context, table, row) {
 	let columnNames = [];
 	let values = [];
-	let sql = 'INSERT INTO ' + quote(table._dbName) + ' ';
+	let sql = 'INSERT INTO ' + quote(context, table._dbName) + ' ';
 	addDiscriminators();
 	addColumns();
 	if (columnNames.length === 0)
@@ -26,7 +26,7 @@ function getSqlTemplateDefault(table, row) {
 		let discriminators = table._columnDiscriminators;
 		for (let i = 0; i < discriminators.length; i++) {
 			let parts = discriminators[i].split('=');
-			columnNames.push(quote(parts[0]));
+			columnNames.push(quote(context, parts[0]));
 			values.push(parts[1]);
 		}
 	}
@@ -36,29 +36,29 @@ function getSqlTemplateDefault(table, row) {
 		for (let i = 0; i < columns.length; i++) {
 			let column = columns[i];
 			if (row['__' + column.alias] !== undefined) {
-				columnNames.push(quote(column._dbName));
+				columnNames.push(quote(context, column._dbName));
 				values.push('%s');
 			}
 		}
 	}
 
 	function lastInserted() {
-		let context = getSessionContext();
-		if (!context.lastInsertedIsSeparate && context.lastInsertedSql)
-			return ' ' + context.lastInsertedSql(table);
+		let rdb = getSessionContext(context);
+		if (!rdb.lastInsertedIsSeparate && rdb.lastInsertedSql)
+			return ' ' + rdb.lastInsertedSql(table);
 		return '';
 	}
 
 	function outputInserted() {
-		let context = getSessionContext();
-		if (!context.lastInsertedIsSeparate && context.outputInsertedSql)
-			return ' ' + context.outputInsertedSql(table) + ' ';
+		let rdb = getSessionContext(context);
+		if (!rdb.lastInsertedIsSeparate && rdb.outputInsertedSql)
+			return ' ' + rdb.outputInsertedSql(table) + ' ';
 		return '';
 	}
 
 	function defaultValues() {
-		let context = getSessionContext();
-		let _default = context.insertDefault || 'DEFAULT VALUES';
+		let rdb = getSessionContext(context);
+		let _default = rdb.insertDefault || 'DEFAULT VALUES';
 		return `${_default}${lastInserted()}`;
 
 	}

package/src/table/commands/lastCommandMatches.js

@@ -1,7 +1,7 @@
 var getChangeSet = require('./getChangeSet');
 
-function lastCommandMatches(row) {
-	var changeSet = getChangeSet();
+function lastCommandMatches(context, row) {
+	var changeSet = getChangeSet(context);
 	var lastIndex = changeSet.length-1;
 	if (lastIndex >= 0 && changeSet[lastIndex].matches)
 		return changeSet[lastIndex].matches(row);

package/src/table/commands/newDeleteCommand.js

@@ -1,20 +1,15 @@
 var newSingleCommand = require('./delete/newSingleCommand');
 
-var nextCommand = function() {
-	nextCommand = require('./newDeleteCommand');
-	nextCommand.apply(null, arguments);
-};
-
-function newCommand(queries,table,filter,strategy,relations) {
-	var singleCommand = newSingleCommand(table,filter,relations);
-	for(var name in strategy) {
+function newCommand(context, queries, table, filter, strategy, relations) {
+	var singleCommand = newSingleCommand(context, table, filter, relations);
+	for (var name in strategy) {
 		if (!(strategy[name] === null || strategy[name]))
 			continue;
 		var childStrategy = strategy[name];
 		var childRelation = table._relations[name];
 		var joinRelation = childRelation.joinRelation;
-		var	childRelations = [joinRelation].concat(relations);
-		nextCommand(queries,childRelation.childTable,filter,childStrategy,childRelations);
+		var childRelations = [joinRelation].concat(relations);
+		newCommand(context, queries, childRelation.childTable, filter, childStrategy, childRelations);
 	}
 	queries.push(singleCommand);
 	return queries;

package/src/table/commands/newGetLastInsertedCommand.js

@@ -1,15 +1,15 @@
 var newGetLastInsertedCommandCore = require('./newGetLastInsertedCommandCore');
 var newImmutable = require('../../newImmutable');
 
-function newGetLastInsertedCommand(table, row, insertCommand) {
-	let cmd =  new InsertCommand(table, row, insertCommand);
+function newGetLastInsertedCommand(context, table, row, insertCommand) {
+	let cmd =  new InsertCommand(context, table, row, insertCommand);
 	insertCommand.endEdit = () => {};
 	return cmd;
 }
 
-function InsertCommand(table, row, insertCommand) {
+function InsertCommand(context, table, row, insertCommand) {
 	this._insertCommand = insertCommand;
-	this.__getCoreCommand = newImmutable(newGetLastInsertedCommandCore);
+	this.__getCoreCommand = newImmutable(newGetLastInsertedCommandCore.bind(null, context));
 	this._table = table;
 	this._row = row;
 }

package/src/table/commands/newGetLastInsertedCommandCore.js

@@ -3,19 +3,19 @@ const getSessionContext = require('../getSessionContext');
 const newDiscriminatorSql = require('../query/singleQuery/newDiscriminatorSql');
 const quote = require('../quote');
 
-function newGetLastInsertedCommandCore(table, row) {
+function newGetLastInsertedCommandCore(context, table, row) {
 	let parameters = [];
 	let keyValues = table._primaryColumns.map(column => row['__' + column.alias]);
-	let sql = `SELECT ${columnNames()} FROM ${quote(table._dbName)} WHERE ${whereSql()}`;
+	let sql = `SELECT ${columnNames()} FROM ${quote(context, table._dbName)} WHERE ${whereSql()}`;
 	return newParameterized(sql, parameters);
 
 	function columnNames() {
-		return table._columns.map(col => quote(col._dbName)).join(',');
+		return table._columns.map(col => quote(context, col._dbName)).join(',');
 	}
 
 	function whereSql() {
 		let parameterized;
-		let filter = getSessionContext().lastInsertedSql(table, keyValues);
+		let filter = getSessionContext(context).lastInsertedSql(context, table, keyValues);
 		if (Array.isArray(filter)) {
 			for (let i = 0; i < filter.length; i++) {
 				const sep = i === 0 ? '' : ' AND ';
@@ -37,7 +37,7 @@ function newGetLastInsertedCommandCore(table, row) {
 	}
 
 	function discriminators() {
-		return newDiscriminatorSql(table, table._dbName);
+		return newDiscriminatorSql(context, table, table._dbName);
 	}
 }
 

package/src/table/commands/newInsertCommand.js

@@ -1,4 +1,3 @@
-// var newInsertCommandCore = require('./newInsertCommandCore');
 var newImmutable = require('../../newImmutable');
 var createPatch = require('../../client/createPatch');
 var createDto = require('../resultToRows/toDto/createDto');
@@ -30,7 +29,7 @@ InsertCommand.prototype.matches = function(otherRow) {
 InsertCommand.prototype.endEdit = function() {
 	this.sql();
 	var dto = createDto(this._table, this._row);
-	if (this._table._emitChanged.callbacks.length > 0)
+	if (this._disallowCompress || this._table._emitChanged.callbacks.length > 0)
 		this._patch = createPatch([], [dto]);
 };
 
@@ -47,8 +46,11 @@ Object.defineProperty(InsertCommand.prototype, 'parameters', {
 
 Object.defineProperty(InsertCommand.prototype, 'disallowCompress', {
 	get: function() {
-		return this._table._emitChanged.callbacks.length > 0;
+		return this._disallowCompress || this._table._emitChanged.callbacks.length > 0;
 
+	},
+	set: function(value) {
+		this._disallowCompress = value;
 	}
 });
 

package/src/table/commands/newInsertCommandCore.js

@@ -1,17 +1,17 @@
-var newParameterized = require('../query/newParameterized');
-var getSqlTemplate = require('./insert/getSqlTemplate');
-var util = require('util');
+const newParameterized = require('../query/newParameterized');
+const getSqlTemplate = require('./insert/getSqlTemplate');
+const formatString = require('../../format');
 
-function newInsertCommandCore(table, row, options = {}) {
-	var parameters = [];
-	var values = [getSqlTemplate(table, row, options)];
+function newInsertCommandCore(context, table, row, options = {}) {
+	let parameters = [];
+	let values = [getSqlTemplate(context, table, row, options)];
 
-	var columns = table._columns;
-	for (var i = 0; i < columns.length; i++) {
-		var column = columns[i];
-		var alias = column.alias;
+	let columns = table._columns;
+	for (let i = 0; i < columns.length; i++) {
+		let column = columns[i];
+		let alias = column.alias;
 		if (row['__' + column.alias] !== undefined) {
-			var encoded = column.encode(row[alias]);
+			let encoded = column.encode(context, row[alias]);
 			if (encoded.parameters.length > 0) {
 				values.push('?');
 				parameters.push(encoded.parameters[0]);
@@ -20,7 +20,7 @@ function newInsertCommandCore(table, row, options = {}) {
 		}
 	}
 
-	var sql = util.format.apply(null, values);
+	let sql = formatString.apply(null, values);
 	return newParameterized(sql, parameters);
 }
 

package/src/table/commands/newRow.js

@@ -1,7 +1,7 @@
 var decodeDbRow = require('../resultToRows/decodeDbRow');
 var flags = require('../../flags');
 
-function newRow({table, _options}) {
+function newRow(context, {table, _options}) {
 	var dto = {};
 	table._columns.forEach(addColumn);
 
@@ -28,20 +28,20 @@ function newRow({table, _options}) {
 		else
 			dto[alias] = undefined;
 	}
-	const arg = arguments[1];
+	const arg = arguments[2];
 	if (isObject(arg))
 		for (let name in arg) {
 			if (table[name] && table[name].equal)
 				dto[name] = arg[name];
 		}
 	else
-		for (var i = 1; i < arguments.length; i++) {
+		for (var i = 2; i < arguments.length; i++) {
 			var pkValue = arguments[i];
 			var column = table._primaryColumns[i - 1];
 			dto[column.alias] = pkValue;
 		}
 
-	return decodeDbRow(table, table, dto, true, true);
+	return decodeDbRow(context, table, table, dto, true, true);
 }
 
 function isObject(object) {

package/src/table/commands/newUpdateCommand.js

@@ -4,14 +4,14 @@ let newColumnList = require('../../newObject');
 var createPatch = require('../../client/createPatch');
 let createDto = require('../resultToRows/toDto/createDto');
 
-function newUpdateCommand(table, column, row) {
-	return new UpdateCommand(table, column, row);
+function newUpdateCommand(context, table, column, row) {
+	return new UpdateCommand(context, table, column, row);
 }
 
-function UpdateCommand(table, column, row) {
+function UpdateCommand(context, table, column, row) {
 	this._table = table;
 	this._row = row;
-	this.__getCoreCommand = newImmutable(newUpdateCommandCore);
+	this.__getCoreCommand = newImmutable(newUpdateCommandCore.bind(null, context));
 	this._columnList = newColumnList();
 	this._columnList[column.alias] = column;
 	this.onFieldChanged = this.onFieldChanged.bind(this);

package/src/table/commands/newUpdateCommandCore.js

@@ -1,8 +1,8 @@
 const getSessionSingleton = require('../getSessionSingleton');
 var newParameterized = require('../query/newParameterized');
 
-function newUpdateCommandCore(table, columns, row) {
-	const quote = getSessionSingleton('quote');
+function newUpdateCommandCore(context, table, columns, row) {
+	const quote = getSessionSingleton(context, 'quote');
 	var command = newParameterized('UPDATE ' + quote(table._dbName) + ' SET');
 	var separator = ' ';
 
@@ -13,7 +13,7 @@ function newUpdateCommandCore(table, columns, row) {
 	function addColumns() {
 		for (var alias in columns) {
 			var column = columns[alias];
-			var encoded = column.encode(row[alias]);
+			var encoded = column.encode(context, row[alias]);
 			command = command.append(separator + quote(column._dbName) + '=').append(encoded);
 			separator = ',';
 		}
@@ -25,7 +25,7 @@ function newUpdateCommandCore(table, columns, row) {
 		for (var i = 0; i < columns.length; i++) {
 			var column = columns[i];
 			var value = row[column.alias];
-			var encoded = column.encode(value);
+			var encoded = column.encode(context, value);
 			command = command.append(separator + quote(column._dbName) + '=').append(encoded);
 			separator = ' AND ';
 		}

package/src/table/commands/pushCommand.js

@@ -1,8 +1,8 @@
 var getChangeSet = require('./getChangeSet');
 var negotiateEndEdit = require('./negotiateEndEdit');
 
-function pushCommand(command) {
-	var changes = getChangeSet();
+function pushCommand(context, command) {
+	var changes = getChangeSet(context);
 	negotiateEndEdit(changes);
 	changes.push(command);
 }

package/src/table/commit.js

@@ -5,9 +5,9 @@ let releaseDbClient = require('./releaseDbClient');
 let popChanges = require('./popChanges');
 const getSessionSingleton = require('./getSessionSingleton');
 
-function commit(result) {
+function _commit(context, result) {
 	return popAndPushChanges()
-		.then(releaseDbClient)
+		.then(releaseDbClient.bind(null, context))
 		.then(onReleased);
 
 	function onReleased() {
@@ -15,18 +15,20 @@ function commit(result) {
 	}
 
 	async function popAndPushChanges() {
-		let changes = popChanges();
+		let changes = popChanges(context);
 		while (changes.length > 0) {
-			await executeChanges(changes);
-			changes = popChanges();
+			await executeChanges(context, changes);
+			changes = popChanges(context);
 		}
-		if (!getSessionSingleton('transactionLess'))
-			pushCommand(commitCommand);
-		return executeChanges(popChanges());
+		if (!getSessionSingleton(context, 'transactionLess'))
+			pushCommand(context, commitCommand);
+		return executeChanges(context, popChanges(context));
 	}
 }
 
-module.exports = function(result) {
+function commit(context, result) {
 	return Promise.resolve()
-		.then(() => commit(result));
-};
+		.then(() => _commit(context, result));
+}
+
+module.exports = commit;

package/src/table/count.js

@@ -4,11 +4,11 @@ const extractFilter = require('./query/extractFilter');
 const newWhereSql = require('./query/singleQuery/newWhereSql');
 const quote = require('./quote');
 
-async function count(table, filter) {
+async function count(context, table, filter) {
 	let alias = table._dbName;
-	filter = negotiateRawSqlFilter(filter, table);
-	let query = newQuery(table, filter, alias);
-	let allResults = await executeQueries([query]);
+	filter = negotiateRawSqlFilter(context,filter, table);
+	let query = newQuery(context, table, filter, alias);
+	let allResults = await executeQueries(context, [query]);
 	let count = await allResults[0].then((rows) => {
 
 		const count = Number.parseInt(rows[0]._count);
@@ -17,11 +17,11 @@ async function count(table, filter) {
 	return count;
 }
 
-function newQuery(table, filter, alias) {
+function newQuery(context, table, filter, alias) {
 	filter = extractFilter(filter);
-	var name = quote(table._dbName);
-	alias = quote(alias);
-	var whereSql = newWhereSql(table, filter, alias);
+	var name = quote(context, table._dbName);
+	alias = quote(context, alias);
+	var whereSql = newWhereSql(context, table, filter, alias);
 
 	return whereSql.prepend('select count(*) "_count" from ' + name + ' ' + alias);
 

package/src/table/delete.js

@@ -4,15 +4,15 @@ var extractDeleteStrategy = require('./extractDeleteStrategy');
 var negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 var emptyPromise = require('./resultToPromise')();
 
-function _delete(table, filter, strategy) {
-	filter = negotiateRawSqlFilter(filter, table);
+function _delete(context, table, filter, strategy) {
+	filter = negotiateRawSqlFilter(context, filter, table);
 	strategy = extractDeleteStrategy(strategy);
 	var relations = [];
 	var cmds = [];
 
-	cmds = newDeleteCommand(cmds, table, filter, strategy, relations);
+	cmds = newDeleteCommand(context, cmds, table, filter, strategy, relations);
 	cmds.forEach(function(cmd) {
-		pushCommand(cmd);
+		pushCommand(context, cmd);
 	});
 	return emptyPromise;
 }

package/src/table/deleteSessionContext.js

@@ -1,17 +1,5 @@
-let useHook = require('../useHook');
-let cls;
-
-function deleteSessionContext() {
-	if (useHook()) {
-		if (!cls)
-			cls = require('node-cls');
-		let context = cls.get('rdb');
-		delete context.rdb;
-		if (context.exit)
-			cls.exit('rdb');
-	}
-	else
-		delete process.domain.rdb;
+function deleteSessionContext(context) {
+	delete context.rdb;
 }
 
 module.exports = deleteSessionContext;

package/src/table/executeQueries/executeChanges.js

@@ -1,7 +1,7 @@
 var executeQuery = require('./executeQuery');
 var newPromise = require('../promise');
 
-function executeChanges(queries) {
+function executeChanges(context, queries) {
 	if (queries.length === 0)
 		return newPromise();
 	var i = -1;
@@ -11,9 +11,9 @@ function executeChanges(queries) {
 	function execute() {
 		i++;
 		if (i + 1 === queries.length)
-			return executeQuery(queries[i]).then(notifyListener);
+			return executeQuery(context, queries[i]).then(notifyListener);
 		else {
-			return executeQuery(queries[i]).then(notifyListener).then(execute);
+			return executeQuery(context, queries[i]).then(notifyListener).then(execute);
 		}
 	}
 

package/src/table/executeQueries/executeQueriesCore.js

@@ -1,9 +1,9 @@
 var executeQuery = require('./executeQuery');
 
-function executeQueriesCore(queries) {
+function executeQueriesCore(context, queries) {
 	var promises = [];
 	for (var i = 0; i < queries.length; i++) {
-		var q = executeQuery(queries[i]);
+		var q = executeQuery(context, queries[i]);
 		promises.push(q);
 	}
 	return promises;

package/src/table/executeQueries/executeQuery.js

@@ -1,7 +1,7 @@
 var newResolver = require('./resolveExecuteQuery');
 
-function executeQuery(query) {
-	var resolver = newResolver(query);
+function executeQuery(context, query) {
+	var resolver = newResolver(context, query);
 	return new Promise(resolver);
 }
 

package/src/table/executeQueries/resolveExecuteQuery.js

@@ -1,18 +1,11 @@
-var getSessionSingleton = require('../getSessionSingleton');
+const getSessionSingleton = require('../getSessionSingleton');
 
-function resolveExecuteQuery(query) {
+function resolveExecuteQuery(context, query) {
 	return resolve;
 
 	function resolve(success, failed) {
 		try {
-
-			var domain = process.domain;
-			if (domain) {
-				success = process.domain.bind(success);
-				failed = process.domain.bind(failed);
-			}
-
-			var client = getSessionSingleton('dbClient');
+			var client = getSessionSingleton(context, 'dbClient');
 			query = negotiateNullParams(query);
 			client.executeQuery(query, onCompleted);
 		} catch (e) {

package/src/table/executeQueries.js

@@ -2,13 +2,13 @@ var executeChanges = require('./executeQueries/executeChanges');
 var popChanges = require('./popChanges');
 var executeQueriesCore = require('./executeQueries/executeQueriesCore');
 
-function executeQueries(queries) {
-	var changes = popChanges();
+function executeQueries(context, queries) {
+	var changes = popChanges(context);
 
-	return executeChanges(changes).then(onDoneChanges);
+	return executeChanges(context, changes).then(onDoneChanges);
 
 	function onDoneChanges() {
-		return executeQueriesCore(queries);
+		return executeQueriesCore(context, queries);
 	}
 }
 

package/src/table/getFromDbById.js

@@ -1,6 +1,6 @@
 let tryGetFromDbById = require('./tryGetFromDbById');
 
-function get(table, ...ids) {
+function get(_context, table, ...ids) {
 	return tryGetFromDbById.apply(null, arguments).then((row) => onResult(table, row, ids));
 }
 

package/src/table/getMany.js

@@ -5,18 +5,18 @@ let strategyToSpan = require('./strategyToSpan');
 let emptyInnerJoin = require('./query/newParameterized')();
 let negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 
-function getMany(table,filter,strategy) {
-	return getManyCore(table,filter,strategy);
+function getMany(context,table,filter,strategy) {
+	return getManyCore(context, table,filter,strategy);
 }
 
-async function getManyCore(table,filter,strategy,exclusive) {
+async function getManyCore(context,table,filter,strategy,exclusive) {
 	let alias = table._dbName;
 	let noOrderBy;
-	filter = negotiateRawSqlFilter(filter, table);
+	filter = negotiateRawSqlFilter(context, filter, table);
 	let span = strategyToSpan(table,strategy);
-	let queries = newQuery([],table,filter,span,alias,emptyInnerJoin,noOrderBy,exclusive);
-	let result = await executeQueries(queries);
-	return resultToRows(span,result);
+	let queries = newQuery(context, [],table,filter,span,alias,emptyInnerJoin,noOrderBy,exclusive);
+	let result = await executeQueries(context, queries);
+	return resultToRows(context, span,result);
 }
 
 getMany.exclusive = function(table,filter,strategy) {

package/src/table/getManyDto.js

@@ -1,9 +1,8 @@
-const tryGetSessionContext = require('../table/tryGetSessionContext');
+const getSessionSingleton = require('../table/getSessionSingleton');
 const getManyDtoCore = require('../getManyDto');
 
-
-function getManyDto(_table, _filter, _strategy) {
-	const _getManyDto = tryGetSessionContext().getManyDto || getManyDtoCore;
+function getManyDto(context, _table, _filter, _strategy) {
+	const _getManyDto = getSessionSingleton(context, 'getManyDto') || getManyDtoCore;
 	return _getManyDto.apply(null, arguments);
 }
 

package/src/table/getSessionContext.js

@@ -1,10 +1,10 @@
 let tryGetSessionContext = require('./tryGetSessionContext');
 
-function getSessionContext() {
-	let context = tryGetSessionContext();
-	if (!context)
+function getSessionContext(context) {
+	const rdb = tryGetSessionContext(context);
+	if (!rdb)
 		throw new Error('Rdb transaction is no longer available. Is promise chain broken ?');
-	return context;
+	return rdb;
 }
 
 module.exports = getSessionContext;