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

package/src/table/relatedTable/relatedColumn.js

@@ -14,24 +14,24 @@ function newRelatedColumn(column, relations, isShallow, depth) {
 			c[propName] = wrapFilter(prop);
 	}
 
-	c.groupSum = aggregateGroup.bind(null, 'sum', column, relations);
-	c.groupAvg = aggregateGroup.bind(null, 'avg', column, relations);
-	c.groupMin = aggregateGroup.bind(null, 'min', column, relations);
-	c.groupMax = aggregateGroup.bind(null, 'max', column, relations);
-	c.groupCount = aggregateGroup.bind(null, 'count', column, relations, false);
-	c.sum = aggregate.bind(null, 'sum', column, relations);
-	c.avg = aggregate.bind(null, 'avg', column, relations);
-	c.min = aggregate.bind(null, 'min', column, relations);
-	c.max = aggregate.bind(null, 'max', column, relations);
-	c.count = aggregate.bind(null, 'count', column, relations, false);
-	c.self = childColumn.bind(null, column, relations);
+	c.groupSum = (context, ...rest) => aggregateGroup.apply(null, [context, 'sum', column, relations, ...rest]);
+	c.groupAvg = (context, ...rest) => aggregateGroup.apply(null, [context, 'avg', column, relations, ...rest]);
+	c.groupMin = (context, ...rest) => aggregateGroup.apply(null, [context, 'min', column, relations, ...rest]);
+	c.groupMax = (context, ...rest) => aggregateGroup.apply(null, [context, 'max', column, relations, ...rest]);
+	c.groupCount = (context, ...rest) => aggregateGroup.apply(null, [context, 'count', column, relations, false, ...rest]);
+	c.sum = (context, ...rest) => aggregate.apply(null, [context, 'sum', column, relations, ...rest]);
+	c.avg = (context, ...rest) => aggregate.apply(null, [context, 'avg', column, relations, ...rest]);
+	c.min = (context, ...rest) => aggregate.apply(null, [context, 'min', column, relations, ...rest]);
+	c.max = (context, ...rest) => aggregate.apply(null, [context, 'max', column, relations, ...rest]);
+	c.count = (context, ...rest) => aggregate.apply(null, [context, 'count', column, relations, false, ...rest]);
+	c.self = (context, ...rest) => childColumn.apply(null, [context, column, relations, ...rest]);
 
 	return c;
 
 	function wrapFilter(filter) {
 		return runFilter;
 
-		function runFilter() {
+		function runFilter(context) {
 			var args = [];
 			for (var i = 0; i < arguments.length; i++) {
 				args.push(arguments[i]);
@@ -40,7 +40,7 @@ function newRelatedColumn(column, relations, isShallow, depth) {
 			var shallowFilter = filter.apply(null, args);
 			if (isShallow)
 				return shallowFilter;
-			return newSubFilter(relations, shallowFilter, depth);
+			return newSubFilter(context, relations, shallowFilter, depth);
 		}
 	}
 

package/src/table/relatedTable/selectSql.js

@@ -2,8 +2,8 @@ var newParameterized = require('../query/newParameterized');
 var newBoolean = require('../column/newBoolean');
 const getSessionSingleton = require('../getSessionSingleton');
 
-function newSelectSql(table, alias) {
-	const quote = getSessionSingleton('quote');
+function newSelectSql(context, table, alias) {
+	const quote = getSessionSingleton(context, 'quote');
 	const quotedAlias  = quote(alias);
 	const colName = quote(table._primaryColumns[0]._dbName);
 	const sql = 'SELECT ' + quotedAlias + '.' + colName + ' FROM ' + quote(table._dbName) + ' ' + quotedAlias;

package/src/table/relatedTable/subFilter.js

@@ -2,13 +2,13 @@ var newSelect = require('./selectSql');
 var newJoin = require('./joinSql');
 var newWhere = require('./whereSql');
 
-function newSubFilter(relations, shallowFilter, depth) {
+function newSubFilter(context, relations, shallowFilter, depth) {
 	var relationCount = relations.length;
 	var alias = 'x' + relationCount;
 	var table = relations[relationCount-1].childTable;
-	var exists = newSelect(table,alias).prepend('EXISTS (');
-	var join = newJoin(relations, depth);
-	var where = newWhere(relations,shallowFilter, depth);
+	var exists = newSelect(context, table,alias).prepend('EXISTS (');
+	var join = newJoin(context, relations, depth);
+	var where = newWhere(context, relations,shallowFilter, depth);
 	return exists.append(join).append(where).append(')');
 
 }

package/src/table/relatedTable/where.js

@@ -1,11 +1,10 @@
-let newRelatedTable = _newRelatedTable;
 const negotiateRawSqlFilter = require('../column/negotiateRawSqlFilter');
 let tryGetSessionContext = require('../tryGetSessionContext');
 
 function newWhere(_relations, _depth) {
 
-	function where(fn) {
-		const includeMany = tryGetSessionContext()?.engine === 'mssql';
+	function where(context, fn) {
+		const includeMany = tryGetSessionContext(context)?.engine === 'mssql';
 		let { relations, alias } = extract(includeMany, _relations);
 		const table = relations[relations.length - 1].childTable;
 		if (!relations[0].isMany || includeMany)
@@ -13,7 +12,7 @@ function newWhere(_relations, _depth) {
 
 		try {
 			let arg = typeof fn === 'function' ? fn(table) : fn;
-			let anyFilter = negotiateRawSqlFilter(arg);
+			let anyFilter = negotiateRawSqlFilter(context, arg);
 			delete table._rootAlias;
 			return anyFilter;
 		}
@@ -42,9 +41,4 @@ function newWhere(_relations, _depth) {
 
 }
 
-function _newRelatedTable() {
-	newRelatedTable = require('../newRelatedTable');
-	return newRelatedTable.apply(null, arguments);
-}
-
 module.exports = newWhere;

package/src/table/relatedTable/whereSql.js

@@ -1,6 +1,6 @@
 var newShallowJoinSql = require('../query/singleQuery/joinSql/newShallowJoinSqlCore');
 
-function newWhereSql(relations, shallowFilter, depth = 0) {
+function newWhereSql(context, relations, shallowFilter, depth = 0) {
 	let relation = relations[depth];
 	var c = {};
 	var sql;
@@ -29,7 +29,7 @@ function newWhereSql(relations, shallowFilter, depth = 0) {
 
 	function where(alias, leftColumns, rightColumns) {
 		var table = relation.childTable;
-		var joinCore = newShallowJoinSql(table, leftColumns, rightColumns, alias, 'x' + (depth + 1));
+		var joinCore = newShallowJoinSql(context, table, leftColumns, rightColumns, alias, 'x' + (depth + 1));
 		if (shallowFilter && shallowFilter.sql()) {
 			sql = joinCore.prepend(' WHERE ').append(' AND ').append(shallowFilter);
 		}

package/src/table/relation/manyCache/synchronizeAdded.js

@@ -1,8 +1,8 @@
 var extractParentKey = require('./extractParentKey');
 
-function synchronizeAdded(action, joinRelation) {
+function synchronizeAdded(context, action, joinRelation) {
 	var cache = joinRelation.parentTable._cache;
-	cache.subscribeAdded(onAdded);
+	cache.subscribeAdded(context, onAdded);
 
 	function onAdded(child) {
 		var parent = extractParentKey(joinRelation, child);

package/src/table/relation/manyCache/synchronizeChanged.js

@@ -1,6 +1,6 @@
 var extractParentKey = require('./extractParentKey');
 
-function synchronizeChanged(manyCache, joinRelation, parent, child) {
+function synchronizeChanged(context, manyCache, joinRelation, parent, child) {
 	var columns = joinRelation.columns;
 	columns.forEach(subscribeColumn);
 	child = null;
@@ -19,9 +19,9 @@ function synchronizeChanged(manyCache, joinRelation, parent, child) {
 
 	function onChanged(child) {
 		unsubscribe(child);
-		manyCache.tryRemove(parent, child);
+		manyCache.tryRemove(context, parent, child);
 		var newParent = extractParentKey(joinRelation, child);
-		manyCache.tryAdd(newParent, child);
+		manyCache.tryAdd(context, newParent, child);
 	}
 
 

package/src/table/relation/manyCache/synchronizeRemoved.js

@@ -1,8 +1,8 @@
 var extractParentKey = require('./extractParentKey');
 
-function synchronizeRemoved(action, joinRelation) {
+function synchronizeRemoved(context, action, joinRelation) {
 	var cache = joinRelation.parentTable._cache;
-	cache.subscribeRemoved(onRemoved);
+	cache.subscribeRemoved(context, onRemoved);
 
 	function onRemoved(child) {
 		var parent = extractParentKey(joinRelation, child);

package/src/table/relation/newForeignKeyFilter.js

@@ -1,4 +1,4 @@
-function newForeignKeyFilter(joinRelation, parentRow) {
+function newForeignKeyFilter(context, joinRelation, parentRow) {
 	var columns = joinRelation.columns;
 	var rightTable = joinRelation.childTable;
 
@@ -12,7 +12,7 @@ function newForeignKeyFilter(joinRelation, parentRow) {
 	function getNextFilterPart(index) {
 		var column = columns[index];
 		var pk = rightTable._primaryColumns[index];
-		return column.eq(parentRow[pk.alias]);
+		return column.eq(context, parentRow[pk.alias]);
 	}
 	return filter;
 }

package/src/table/relation/newManyCache.js

@@ -9,46 +9,54 @@ var setSessionSingleton = require('../setSessionSingleton');
 
 function newManyCache(joinRelation) {
 	var c = {};
-	var key = newId();
+	var key;
 
-	c.tryAdd = function(parent, child) {
-		c.getInnerCache().tryAdd(parent, child);
-		synchronizeChanged(c, joinRelation, parent, child);
+	c.tryAdd = function(context, parent, child) {
+		c.getInnerCache(context).tryAdd(parent, child);
+		synchronizeChanged(context, c, joinRelation, parent, child);
 	};
 
-	c.tryRemove = function(parent, child) {
-		c.getInnerCache().tryRemove(parent, child);
+	c.tryRemove = function(context, parent, child) {
+		c.getInnerCache(context).tryRemove(parent, child);
 	};
 
-	c.tryGet = function(parentRow) {
-		return c.getInnerCache().tryGet(parentRow);
+	c.tryGet = function(context, parentRow) {
+		return c.getInnerCache(context).tryGet(parentRow);
 	};
 
-	c.getInnerCache = function() {
-		var cache = getSessionSingleton(key);
+	c.getInnerCache = function(context) {
+		const theKey = negotiateKey();
+		var cache = getSessionSingleton(context, theKey);
 		if (!cache) {
 			cache = newCacheCore(joinRelation);
-			setSessionSingleton(key, cache);
-			fillCache();
-			synchronizeAdded(c.tryAdd, joinRelation);
-			synchronizeRemoved(c.tryRemove, joinRelation);
+			setSessionSingleton(context, theKey, cache);
+			fillCache(context);
+			synchronizeAdded(context, c.tryAdd.bind(null, context), joinRelation);
+			synchronizeRemoved(context, c.tryRemove.bind(null, context), joinRelation);
 		}
 		return cache;
 	};
 
 
-	function fillCache() {
+	function fillCache(context) {
 		var childTable = joinRelation.parentTable;
 		var childCache = childTable._cache;
-		var children = childCache.getAll();
+		var children = childCache.getAll(context);
 		children.forEach(addToCache);
 
 		function addToCache(child) {
 			var parent = extractParentKey(joinRelation, child);
-			c.tryAdd(parent, child);
+			c.tryAdd(context, parent, child);
 		}
 	}
 
+	function negotiateKey() {
+		if (key)
+			return key;
+		key = newId();
+		return key;
+
+	}
 
 
 	return c;

package/src/table/relation/newOneCache.js

@@ -4,18 +4,18 @@ function newOneCache(joinRelation) {
 	let c = {};
 	let cache = newManyCache(joinRelation);
 
-	c.tryGet = function(parent) {
-		let res = cache.tryGet(parent);
+	c.tryGet = function(context, parent) {
+		let res = cache.tryGet(context, parent);
 		if (res.length === 0)
 			return null;
 		return res[0];
 	};
 
-	c.getInnerCache = function() {
-		let _cache = cache.getInnerCache();
+	c.getInnerCache = function(context) {
+		let _cache = cache.getInnerCache(context);
 		let _c = {};
-		_c.tryGet = function(parent) {
-			let res = _cache.tryGet(parent);
+		_c.tryGet = function(context, parent) {
+			let res = _cache.tryGet(context, parent);
 			if (res.length === 0)
 				return null;
 			return res[0];

package/src/table/releaseDbClient.js

@@ -1,10 +1,10 @@
 var getSessionSingleton = require('./getSessionSingleton');
 var deleteSessionContext = require('./deleteSessionContext');
 
-function release() {
-	var done = getSessionSingleton('dbClientDone');
-	var pool = getSessionSingleton('pool');
-	deleteSessionContext();
+function release(context) {
+	var done = getSessionSingleton(context, 'dbClientDone');
+	var pool = getSessionSingleton(context, 'pool');
+	deleteSessionContext(context);
 	if (done)
 		done();
 	if (pool)

package/src/table/resultToPromise.js

@@ -1,8 +1,6 @@
 
-var deferred = require('deferred');
-
 function resultToPromise(result) {
-	return deferred.resolve(result);
+	return Promise.resolve(result);
 }
 
 module.exports = resultToPromise;

package/src/table/resultToRows/dbRowToRow.js

@@ -1,13 +1,11 @@
 var negotiateQueryContext = require('./negotiateQueryContext');
 var decodeDbRow = require('./decodeDbRow');
-var nextDbRowToRow = _nextDbRowToRow;
 
-
-function dbRowToRow(span, dbRow) {
+function dbRowToRow(context, span, dbRow) {
 	var table = span.table;
-	var row = decodeDbRow(span, table, dbRow);
+	var row = decodeDbRow(context, span, table, dbRow);
 	var cache = table._cache;
-	if (!cache.tryGet(row)) {
+	if (!cache.tryGet(context, row)) {
 		var queryContext = span.queryContext;
 		negotiateQueryContext(queryContext, row);
 		Object.defineProperty(row, 'queryContext', {
@@ -17,17 +15,17 @@ function dbRowToRow(span, dbRow) {
 		});
 		row.queryContext = queryContext;
 	}
-	row = cache.tryAdd(row);
+	row = cache.tryAdd(context, row);
 
 	var c = {};
 
 	c.visitOne = function(leg) {
-		nextDbRowToRow(leg.span, dbRow);
+		dbRowToRow(context, leg.span, dbRow);
 		leg.expand(row);
 	};
 
 	c.visitJoin = function(leg) {
-		nextDbRowToRow(leg.span, dbRow);
+		dbRowToRow(context, leg.span, dbRow);
 		leg.expand(row);
 	};
 
@@ -43,9 +41,4 @@ function dbRowToRow(span, dbRow) {
 	return row;
 }
 
-function _nextDbRowToRow(span, dbRow) {
-	nextDbRowToRow = require('./dbRowToRow');
-	nextDbRowToRow(span, dbRow);
-}
-
 module.exports = dbRowToRow;

package/src/table/resultToRows/dbRowsToRows.js

@@ -1,10 +1,10 @@
 var dbRowToRow = require('./dbRowToRow');
 var newRowArray = require('../rowArray');
 
-function dbRowsToRows(span, dbRows) {
+function dbRowsToRows(context, span, dbRows) {
 	var rows = newRowArray();
 	for (var i = 0; i < dbRows.length; i++) {
-		var row = dbRowToRow(span, dbRows[i]);
+		var row = dbRowToRow(context, span, dbRows[i]);
 		rows.push(row);
 	}
 	return rows;

package/src/table/resultToRows/decodeDbRow.js

@@ -1,6 +1,6 @@
 var newDecodeDbRow = require('./newDecodeDbRow');
 
-function decodeDbRow(span, table, dbRow, shouldValidate, isInsert) {
+function decodeDbRow(context, span, table, dbRow, shouldValidate, isInsert) {
 	var decode = span._decodeDbRow;
 	if (!decode) {
 		let aliases = new Set();
@@ -19,7 +19,7 @@ function decodeDbRow(span, table, dbRow, shouldValidate, isInsert) {
 			},
 		});
 	}
-	return decode(dbRow);
+	return decode(context, dbRow);
 }
 
 module.exports = decodeDbRow;

package/src/table/resultToRows/delete/removeFromCache.js

@@ -1,6 +1,4 @@
-var nextRemoveFromCache = _nextRemoveFromCache;
-
-function removeFromCache(row, strategy, table) {
+function removeFromCache(context, row, strategy, table) {
 	if (Array.isArray(row)) {
 		removeManyRows();
 		return;
@@ -10,7 +8,7 @@ function removeFromCache(row, strategy, table) {
 
 	function removeManyRows() {
 		row.forEach( function(rowToRemove) {
-			nextRemoveFromCache(rowToRemove, strategy, table);
+			removeFromCache(context, rowToRemove, strategy, table);
 		});
 	}
 
@@ -19,15 +17,10 @@ function removeFromCache(row, strategy, table) {
 		for (var relationName in strategy) {
 			var relation = relations[relationName];
 			var rows = relation.getRowsSync(row);
-			nextRemoveFromCache(rows, strategy[relationName], relation.childTable);
+			removeFromCache(context, rows, strategy[relationName], relation.childTable);
 		}
-		table._cache.tryRemove(row);
+		table._cache.tryRemove(context, row);
 	}
 }
 
-function _nextRemoveFromCache(row, strategy, table) {
-	nextRemoveFromCache = require('./removeFromCache');
-	nextRemoveFromCache(row, strategy, table);
-}
-
 module.exports = removeFromCache;

package/src/table/resultToRows/delete.js

@@ -5,25 +5,25 @@ var newPrimaryKeyFilter = require('../newPrimaryKeyFilter');
 var createPatch = require('../../client/createPatch');
 var createDto = require('./toDto/createDto');
 
-function _delete(row, strategy, table) {
+function _delete(context, row, strategy, table) {
 	var relations = [];
-	removeFromCache(row, strategy, table);
+	removeFromCache(context, row, strategy, table);
 
-	var args = [table];
+	var args = [context, table];
 	table._primaryColumns.forEach(function(primary) {
 		args.push(row[primary.alias]);
 	});
 	var filter = newPrimaryKeyFilter.apply(null, args);
-	var cmds = newDeleteCommand([], table, filter, strategy, relations);
+	var cmds = newDeleteCommand(context, [], table, filter, strategy, relations);
 	cmds.forEach(function(cmd) {
-		pushCommand(cmd);
+		pushCommand(context, cmd);
 	});
 	var cmd = cmds[0];
 	if (table._emitChanged.callbacks.length > 0) {
 		cmd.disallowCompress = true;
 		var dto = createDto(table, row);
 		let patch =  createPatch([dto],[]);
-		cmd.emitChanged = table._emitChanged.bind(null, {row: row, patch: patch});
+		cmd.emitChanged = table._emitChanged.bind(null, {row: row, patch: patch}); //todo remove ?
 	}
 
 }

package/src/table/resultToRows/newDecodeDbRow.js

@@ -1,4 +1,3 @@
-let util = require('util');
 let updateField = require('../updateField');
 let newEmitEvent = require('../../emitEvent');
 let extractStrategy = require('./toDto/extractStrategy');
@@ -51,7 +50,7 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 				this._dbRow[key] = value;
 				if (column.validate)
 					column.validate(value, this._dbRow);
-				updateField(table, column, this);
+				updateField(this._context, table, column, this);
 				let emit = this._emitColumnChanged[name];
 				if (emit)
 					emit(this, column, value, oldValue);
@@ -114,8 +113,8 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 		let get = row._related[alias];
 		if (!get) {
 			let relation = table._relations[alias];
-			get = relation.toGetRelated(row);
-			row._relationCacheMap.set(relation, relation.getInnerCache());
+			get = relation.toGetRelated(row._context, row);
+			row._relationCacheMap.set(relation, relation.getInnerCache(row._context));
 			row._related[alias] = get;
 		}
 		return get;
@@ -144,8 +143,8 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 	};
 
 
-	Row.prototype.hydrate = function(dbRow) {
-		const engine = tryGetSessionContext()?.engine;
+	Row.prototype.hydrate = function(context, dbRow) {
+		const engine = tryGetSessionContext(context)?.engine;
 		let i = offset;
 		if (engine === 'sqlite') {
 			const errorSeparator = '12345678-1234-1234-1234-123456789012';
@@ -153,14 +152,14 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 				if (typeof dbRow[p] === 'string' && dbRow[p].indexOf(errorSeparator) === 0)
 					throw new Error(dbRow[p].split(errorSeparator)[1]);
 				let key = keys[i];
-				this._dbRow[key] = columns[i].decode(dbRow[p]);
+				this._dbRow[key] = columns[i].decode(context, dbRow[p]);
 				i++;
 			}
 		}
 		else {
 			for (let p in dbRow) {
 				let key = keys[i];
-				this._dbRow[key] = columns[i].decode(dbRow[p]);
+				this._dbRow[key] = columns[i].decode(context, dbRow[p]);
 				i++;
 			}
 		}
@@ -171,10 +170,10 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 			strategy = extractStrategy(table);
 		}
 		strategy = purifyStrategy(table, strategy);
-		if (!tryGetSessionContext()) {
-			return toDto(strategy, table, this, new Set());
+		if (!tryGetSessionContext(this._context)) {
+			return toDto(this._context, strategy, table, this, new Set());
 		}
-		let p = toDto(strategy, table, this);
+		let p = toDto(this._context, strategy, table, this);
 		return Promise.resolve().then(() => p);
 	};
 
@@ -189,37 +188,31 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 
 	Row.prototype.delete = function(strategy) {
 		strategy = extractDeleteStrategy(strategy);
-		_delete(this, strategy, table);
+		_delete(this._context, this, strategy, table);
 	};
 
 	Row.prototype.cascadeDelete = function() {
 		let strategy = newCascadeDeleteStrategy(newObject(), table);
-		_delete(this, strategy, table);
+		_delete(this._context, this, strategy, table);
 	};
 
 	Row.prototype.deleteCascade = Row.prototype.cascadeDelete;
 
 	Row.prototype.patch = async function(patches, options) {
-		await patchRow(table, this, patches, options);
+		await patchRow(this._context, table, this, patches, options);
 		return this;
 	};
 
-
-	Row.prototype[util.inspect.custom] = function() {
-		let dtos = toDto(undefined, table, this, new Set());
-		return util.inspect(dtos, { compact: false, colors: true });
-	};
-
-	function decodeDbRow(row) {
+	function decodeDbRow(context, row) {
 		for (let i = 0; i < numberOfColumns; i++) {
 			let index = offset + i;
 			let key = keys[index];
 			if (row[key] !== undefined)
-				row[key] = columns[i].decode(row[key]);
+				row[key] = columns[i].decode(context, row[key]);
 			if (shouldValidate && columns[i].validate)
 				columns[i].validate(row[key], row, isInsert);
 		}
-		let target = new Row(row);
+		let target = new Row(context, row);
 		const p = new Proxy(target, {
 			ownKeys: function() {
 				return Array.from(aliases).concat(Object.keys(target._related).filter(alias => {
@@ -245,9 +238,10 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 		return value;
 	}
 
-	function Row(dbRow) {
+	function Row(context, dbRow) {
+		this._context = context;
 		this._relationCacheMap = new Map();
-		this._cache = table._cache.getInnerCache();
+		this._cache = table._cache.getInnerCache(context);
 		this._dbRow = dbRow;
 		this._related = {};
 		this._emitColumnChanged = {};

package/src/table/resultToRows/toDto/extractStrategy.js

@@ -1,5 +1,3 @@
-let extractSubStrategy = _extractSubStrategy;
-
 //either..
 //strategy, table
 //or..
@@ -21,7 +19,7 @@ function extractStrategy(_strategyOrTable, _optinonalTable) {
 	visitor.visitJoin = function() { };
 
 	visitor.visitMany = function(relation) {
-		strategy[relationName] = extractSubStrategy(relation.childTable);
+		strategy[relationName] = extractStrategy(relation.childTable);
 	};
 
 	visitor.visitOne = visitor.visitMany;
@@ -33,9 +31,5 @@ function extractStrategy(_strategyOrTable, _optinonalTable) {
 	return strategy;
 }
 
-function _extractSubStrategy(table) {
-	extractSubStrategy = require('./extractStrategy');
-	return extractSubStrategy(table);
-}
 
 module.exports = extractStrategy;

package/src/table/resultToRows/toDto.js

@@ -1,11 +1,11 @@
 let flags = require('../../flags');
 let tryGetSessionContext = require('../tryGetSessionContext');
 
-function toDto(strategy, table, row, joinRelationSet) {
+function toDto(context, strategy, table, row, joinRelationSet) {
 	let result;
 	flags.useProxy = false;
-	let context = tryGetSessionContext();
-	let ignoreSerializable = context && context.ignoreSerializable;
+	let rdb = tryGetSessionContext(context);
+	let ignoreSerializable = rdb && rdb.ignoreSerializable;
 	if (joinRelationSet) {
 		result = toDtoSync(table, row, joinRelationSet, strategy, ignoreSerializable);
 	}

package/src/table/resultToRows.js

@@ -1,12 +1,12 @@
 var dbRowsToRows = require('./resultToRows/dbRowsToRows');
 
-async function resultToRows(span,result) {
+async function resultToRows(context, span, result) {
 	let rows = await result[0].then(onResult);
 	await expand(spanToStrategy(span), rows);
 	return rows;
 
 	function onResult(result) {
-		return dbRowsToRows(span,result);
+		return dbRowsToRows(context, span, result);
 	}
 }
 
@@ -15,7 +15,7 @@ async function expand(strategy, rows) {
 		return;
 	if (!Array.isArray(rows))
 		rows = [rows];
-	for(let p in strategy) {
+	for (let p in strategy) {
 		if (!(strategy[p] === null || strategy[p]))
 			continue;
 		for (let i = 0; i < rows.length; i++) {