orange-orm 4.4.2 → 4.5.0-beta.1

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,8 @@
-let useHook = require('../useHook');
-let cls;
+const process = require('node:process');
 
-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) {
+	context = context || process.domain;
+	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,6 +1,7 @@
-var getSessionSingleton = require('../getSessionSingleton');
+const getSessionSingleton = require('../getSessionSingleton');
+const process = require('node:process');
 
-function resolveExecuteQuery(query) {
+function resolveExecuteQuery(context, query) {
 	return resolve;
 
 	function resolve(success, failed) {
@@ -11,8 +12,7 @@ function resolveExecuteQuery(query) {
 				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;

package/src/table/getSessionSingleton.js

@@ -1,5 +1,6 @@
 var getSessionContext = require('./getSessionContext');
 
-module.exports = function(name) {
-	return getSessionContext()[name];
+module.exports = function(context, name) {
+	const rdb = getSessionContext(context);
+	return rdb[name];
 };

package/src/table/groupBy/newQuery.js

@@ -4,13 +4,13 @@ var extractLimit = require('../query/extractLimit');
 var newParameterized = require('../query/newParameterized');
 var extractOffset = require('../query/extractOffset');
 
-function newQuery(table,filter,span,alias) {
+function newQuery(context, table,filter,span,alias) {
 	filter = extractFilter(filter);
 	var orderBy = '';
-	var limit = extractLimit(span);
-	var offset = extractOffset(span);
+	var limit = extractLimit(context, span);
+	var offset = extractOffset(context, span);
 
-	var query = newSingleQuery(table,filter,span,alias,orderBy,limit,offset);
+	var query = newSingleQuery(context, table,filter,span,alias,orderBy,limit,offset);
 	const groupClause = groupBy(span);
 	return newParameterized(query.sql(), query.parameters).append(groupClause);
 }

package/src/table/groupBy.js

@@ -3,11 +3,11 @@ const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 const strategyToSpan = require('./strategyToSpan');
 const executeQueries = require('./executeQueries');
 
-async function groupBy(table, filter, strategy) {
-	filter = negotiateRawSqlFilter(filter, table);
+async function groupBy(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);
@@ -15,9 +15,9 @@ async function groupBy(table, filter, strategy) {
 
 	let alias = table._dbName;
 
-	const query = newQuery(table, filter, span, alias);
-	const res = await executeQueries([query]);
-	return decode(span, await res[0]);
+	const query = newQuery(context, table, filter, span, alias);
+	const res = await executeQueries(context, [query]);
+	return decode(context, span, await res[0]);
 }
 
 function newCreateRow(span) {
@@ -40,7 +40,7 @@ function createProto(span) {
 }
 
 
-async function decode(span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
+async function decode(context, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : []) {
 	const rowsLength = rows.length;
 	const aggregateKeys = Object.keys(span.aggregates);
 
@@ -52,8 +52,8 @@ async function decode(span, rows, keys = rows.length > 0 ? Object.keys(rows[0])
 
 		for (let j = 0; j < aggregateKeys.length; j++) {
 			const key = aggregateKeys[j];
-			const parse = span.aggregates[key].column?.decode || Number.parseFloat;
-			outRow[key] =  parse(row[keys[j]]);
+			const parse = span.aggregates[key].column?.decode || ((_context, arg) => Number.parseFloat(arg));
+			outRow[key] =  parse(context, row[keys[j]]);
 		}
 
 		outRows[i] = outRow;

package/src/table/insert.js

@@ -1,21 +1,18 @@
 let getSessionContext = require('./getSessionContext');
 let newRow = require('./commands/newRow');
-let insertDefault = require('./insertDefault');
 
-function insert({ table, options }, arg) {
-	// return insertDefault.apply(null, arguments);
+function insert(context, { table, options }, arg) {
 	if (Array.isArray(arg)) {
 		let all = [];
 		for (let i = 0; i < arg.length; i++) {
-			all.push(insert(table, arg[i]));
+			all.push(insert(context, table, arg[i]));
 		}
 		return Promise.all(all);
 	}
-	let args = [table].slice.call(arguments);
-	let row = newRow.apply(null, args);
+	let row = newRow.apply(null, [...arguments]);
 	let hasPrimary = getHasPrimary(table, row);
 	if (hasPrimary) {
-		row = table._cache.tryAdd(row);
+		row = table._cache.tryAdd(context, row);
 	}
 	expand(table, row);
 	Object.defineProperty(row, 'then', {
@@ -24,8 +21,8 @@ function insert({ table, options }, arg) {
 		enumerable: false,
 		configurable: true
 	});
-	const context = getSessionContext();
-	const insertP = (context.insert || insertDefault)(table, row, options).then(onResult);
+	const rdb = getSessionContext(context);
+	const insertP = rdb.insert(context, table, row, options).then(onResult);
 
 
 	// }
@@ -51,10 +48,10 @@ function insert({ table, options }, arg) {
 	return row;
 
 	function onResult([result]) {
-		row.hydrate(result);
-		if (!hasPrimary)
-			row = table._cache.tryAdd(row);
-		table._cache.tryAdd(row);
+		row.hydrate(context, result);
+		// if (!hasPrimary)
+		// 	row = table._cache.tryAdd(context, row);
+		row = table._cache.tryAdd(context, row);
 		return row;
 	}
 }

package/src/table/joinRelation/getRelatives.js

@@ -2,7 +2,7 @@ var newPrimaryKeyFilter = require('../newPrimaryKeyFilter');
 var emptyFilter = require('../../emptyFilter');
 var negotiateExpandInverse = require('../negotiateExpandInverse');
 
-function getRelatives(parent, relation) {
+function getRelatives(context, parent, relation) {
 	var queryContext = parent.queryContext;
 	let strategy = queryContext && queryContext.strategy[relation.leftAlias];
 	var filter = emptyFilter;
@@ -24,15 +24,15 @@ function getRelatives(parent, relation) {
 		}
 
 		if (ids.length > 0)
-			filter = relation.childTable._primaryColumns[0].in(ids);
+			filter = relation.childTable._primaryColumns[0].in(context, ids);
 	}
 
 	function createCompositeFilter() {
 		var keyFilter;
 		for (var i = 0; i < queryContext.rows.length; i++) {
-			keyFilter = rowToPrimaryKeyFilter(queryContext.rows[i], relation);
+			keyFilter = rowToPrimaryKeyFilter(context, queryContext.rows[i], relation);
 			if (keyFilter)
-				filter = filter.or(keyFilter);
+				filter = filter.or(context, keyFilter);
 		}
 	}
 
@@ -46,14 +46,14 @@ function getRelatives(parent, relation) {
 
 }
 
-function rowToPrimaryKeyFilter(row, relation) {
+function rowToPrimaryKeyFilter(context, row, relation) {
 	var key = relation.columns.map( function(column) {
 		return row[column.alias];
 	});
 	if (key.some(isNullOrUndefined)) {
 		return;
 	}
-	var args = [relation.childTable].concat(key);
+	var args = [context, relation.childTable].concat(key);
 	return newPrimaryKeyFilter.apply(null, args);
 }
 

package/src/table/newGetRelated.js

@@ -1,10 +1,10 @@
-function newGetRelated(parent, relation) {
+function newGetRelated(context, parent, relation) {
 	function getRelated() {
 		if (getRelated.expanded)
 			return relation.getFromCache(parent);
 		if (parent.queryContext)
-			return relation.getRelatives(parent).then(onRelatives);
-		return relation.getFromDb(parent).then(onFromDb);
+			return relation.getRelatives(context, parent).then(onRelatives);
+		return relation.getFromDb(context, parent).then(onFromDb);
 
 		function onFromDb(rows) {
 			getRelated.expanded = true;

package/src/table/newManyRelation.js

@@ -23,17 +23,17 @@ function newManyRelation(joinRelation) {
 		return fuzzyPromise(result);
 	};
 
-	c.getFromDb = function(parent) {
-		var filter = newForeignKeyFilter(joinRelation, parent);
-		return c.childTable.getMany(filter, null);
+	c.getFromDb = function(context, parent) {
+		var filter = newForeignKeyFilter(context, joinRelation, parent);
+		return c.childTable.getMany(context, filter, null);
 	};
 
-	c.getRelatives = function(parent) {
-		return getRelatives(parent, c);
+	c.getRelatives = function(context, parent) {
+		return getRelatives(context, parent, c);
 	};
 
-	c.toGetRelated = function(parent) {
-		return newGetRelated(parent, c);
+	c.toGetRelated = function(context, parent) {
+		return newGetRelated(context, parent, c);
 	};
 
 	c.expand = function(parent) {
@@ -51,8 +51,8 @@ function newManyRelation(joinRelation) {
 		return newLeg(c);
 	};
 
-	c.getInnerCache = function() {
-		return manyCache.getInnerCache();
+	c.getInnerCache = function(context) {
+		return manyCache.getInnerCache(context);
 	};
 
 	return c;

package/src/table/newOneRelation.js

@@ -23,17 +23,17 @@ function newOneRelation(joinRelation) {
 		return fuzzyPromise(row);
 	};
 
-	c.getFromDb = function(parent) {
-		var filter = newForeignKeyFilter(joinRelation, parent);
-		return c.childTable.tryGetFirst(filter, null);
+	c.getFromDb = function(context, parent) {
+		var filter = newForeignKeyFilter(context, joinRelation, parent);
+		return c.childTable.tryGetFirst(context, filter, null);
 	};
 
-	c.getRelatives = function(parent) {
-		return getRelatives(parent, c);
+	c.getRelatives = function(context, parent) {
+		return getRelatives(context, parent, c);
 	};
 
-	c.toGetRelated = function(parent) {
-		return newGetRelated(parent, c);
+	c.toGetRelated = function(context, parent) {
+		return newGetRelated(context, parent, c);
 	};
 
 	c.expand = function(parent) {
@@ -51,8 +51,8 @@ function newOneRelation(joinRelation) {
 		return newLeg(c);
 	};
 
-	c.getInnerCache = function() {
-		return oneCache.getInnerCache();
+	c.getInnerCache = function(context) {
+		return oneCache.getInnerCache(context);
 	};
 
 	return c;

package/src/table/newPrimaryKeyFilter.js

@@ -1,11 +1,11 @@
-function primaryKeyFilter(table) {
+function primaryKeyFilter(context, table) {
 	var primaryColumns = table._primaryColumns;
-	var key = arguments[1];
-	var filter = primaryColumns[0].equal(key);
-	for (var i = 1; i < primaryColumns.length; i++) {
+	var key = arguments[2];
+	var filter = primaryColumns[0].equal(context, key);
+	for (var i = 2; i < primaryColumns.length; i++) {
 		key = arguments[i+1];
-		var colFilter = primaryColumns[i].equal(key);
-		filter = filter.and(colFilter);
+		var colFilter = primaryColumns[i].equal(context, key);
+		filter = filter.and(context, colFilter);
 	}
 	return filter;
 }

package/src/table/newQuery.js

@@ -4,12 +4,12 @@ var extractOrderBy = require('./query/extractOrderBy');
 var extractLimit = require('./query/extractLimit');
 var extractOffset = require('./query/extractOffset');
 
-function newQuery(queries,table,filter,span,alias,innerJoin,orderBy,exclusive) {
+function newQuery(context, queries,table,filter,span,alias,innerJoin,orderBy,exclusive) {
 	filter = extractFilter(filter);
-	orderBy = extractOrderBy(table,alias,span.orderBy,orderBy);
-	var limit = extractLimit(span);
-	var offset = extractOffset(span);
-	var singleQuery = newSingleQuery(table,filter,span,alias,innerJoin,orderBy,limit,offset,exclusive);
+	orderBy = extractOrderBy(context, table,alias,span.orderBy,orderBy);
+	var limit = extractLimit(context, span);
+	var offset = extractOffset(context, span);
+	var singleQuery = newSingleQuery(context, table,filter,span,alias,innerJoin,orderBy,limit,offset,exclusive);
 	queries.push(singleQuery);
 
 	return queries;

package/src/table/newRelatedTable.js

@@ -65,10 +65,10 @@ function newRelatedTable(relations, isShallow, depth = 0) {
 
 
 	// @ts-ignore
-	c.exists = function() {
+	c.exists = function(context) {
 		if (isShallow)
 			return '';
-		return subFilter(relations, false, depth);
+		return subFilter(context, relations, false, depth);
 	};
 
 	let cProxy = new Proxy(c, {

package/src/table/newRowCache.js

@@ -6,43 +6,43 @@ function newRowCache(table) {
 	let id = Symbol();
 	let c = {};
 
-	c.tryGet = function(row) {
-		return getCache(table, id).tryGet(row);
+	c.tryGet = function(context, row) {
+		return getCache(context, table, id).tryGet(row);
 	};
 
-	c.tryAdd = function(row) {
-		return getCache(table, id).tryAdd(row);
+	c.tryAdd = function(context, row) {
+		return getCache(context, table, id).tryAdd(row);
 	};
 
-	c.tryRemove = function(row) {
-		return getCache(table, id).tryRemove(row);
+	c.tryRemove = function(context, row) {
+		return getCache(context, table, id).tryRemove(row);
 	};
 
-	c.subscribeAdded = function() {
-		return getCache(table, id).subscribeAdded.apply(null, arguments);
+	c.subscribeAdded = function(context, ...rest) {
+		return getCache(context, table, id).subscribeAdded.apply(null, rest);
 	};
 
-	c.subscribeRemoved = function() {
-		return getCache(table, id).subscribeRemoved.apply(null, arguments);
+	c.subscribeRemoved = function(context, ...rest) {
+		return getCache(context, table, id).subscribeRemoved.apply(null, rest);
 	};
 
-	c.getAll = function() {
-		return getCache(table, id).getAll.apply(null, arguments);
+	c.getAll = function(context) {
+		return getCache(context, table, id).getAll.apply(null, arguments);
 	};
 
-	c.getInnerCache = function() {
-		return getCache(table, id);
+	c.getInnerCache = function(context) {
+		return getCache(context, table, id);
 	};
 	return c;
 }
 
 
-function getCache(table, id) {
-	let cache = getSessionSingleton(id);
+function getCache(context, table, id) {
+	let cache = getSessionSingleton(context, id);
 	if (cache)
 		return cache;
 	cache = _newRowCache(table);
-	setSessionSingleton(id, cache);
+	setSessionSingleton(context, id, cache);
 	return cache;
 }
 

package/src/table/newThrow.js

@@ -1,9 +1,9 @@
 var tryReleaseDbClient = require('./tryReleaseDbClient');
 
-function newThrow(e, previousPromise) {
+function newThrow(context, e, previousPromise) {
 	return previousPromise.then(throwError, throwError);
 	function throwError() {
-		tryReleaseDbClient();
+		tryReleaseDbClient(context);
 		throw e;
 	}
 }

package/src/table/oneRelation/getRelatives.js

@@ -2,7 +2,7 @@ let emptyFilter = require('../../emptyFilter');
 let newForeignKeyFilter = require('../relation/newForeignKeyFilter');
 let negotiateExpandInverse = require('../negotiateExpandInverse');
 
-function getRelatives(parent, relation) {
+function getRelatives(context, parent, relation) {
 	let queryContext = parent.queryContext;
 	let strategy = queryContext && queryContext.strategy[relation.joinRelation.rightAlias];
 
@@ -22,17 +22,17 @@ function getRelatives(parent, relation) {
 			return row[parentAlias];
 		});
 		let column = relation.joinRelation.columns[0];
-		return column.in(ids);
+		return column.in(context, ids);
 	}
 
 	function createCompositeFilter() {
 		let filters = queryContext.rows.map(function(row) {
-			return newForeignKeyFilter(relation.joinRelation, row);
+			return newForeignKeyFilter(context, relation.joinRelation, row);
 		});
-		return emptyFilter.or.apply(emptyFilter, filters);
+		return emptyFilter.or.apply(emptyFilter, [context, ...filters]);
 	}
 
-	return relation.childTable.getMany(filter, strategy).then(onRows);
+	return relation.childTable.getMany(context, filter, strategy).then(onRows);
 
 	function onRows(rows) {
 		queryContext.expand(relation);

package/src/table/popChanges.js

@@ -1,14 +1,14 @@
 var getChangeSet = require('./commands/getChangeSet');
 var compressChanges = require('./commands/compressChanges');
 
-function popChanges() {
-	var changeSet = getChangeSet();
+function popChanges(context) {
+	var changeSet = getChangeSet(context);
 	var length = changeSet.length;
 	if (length > 0) {
 		var lastCmd = changeSet[length-1];
 		if (lastCmd.endEdit)
 			lastCmd.endEdit();
-		var compressed = compressChanges(changeSet);
+		var compressed = compressChanges(context, changeSet);
 		changeSet.length = 0;
 		return compressed;
 	}

package/src/table/promise.js

@@ -1,14 +1,8 @@
-var promise = require('promise/domains');
-var deferred = require('deferred');
-let promisify = require('util').promisify;
-
-
 function newPromise(func) {
 	if (!func)
-		return deferred.resolve.apply(deferred, arguments);
-	return new promise(func);
+		return Promise.resolve.apply(Promise, arguments);
+	return new Promise(func);
 }
 
 newPromise.all = Promise.all;
-newPromise.denodeify = promisify || promise.denodeify;
 module.exports = newPromise;