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

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/newCascadeDeleteStrategy.js

@@ -1,4 +1,3 @@
-var addSubStrategies = _addSubStrategies;
 var newObject = require('../newObject');
 
 function newCascadeDeleteStrategy(strategy, table) {
@@ -10,7 +9,7 @@ function newCascadeDeleteStrategy(strategy, table) {
 	c.visitOne = function(relation) {
 		var subStrategy = newObject();
 		strategy[relationName] = subStrategy;
-		addSubStrategies(subStrategy, relation.childTable);
+		newCascadeDeleteStrategy(subStrategy, relation.childTable);
 	};
 
 	c.visitMany = c.visitOne;
@@ -22,9 +21,4 @@ function newCascadeDeleteStrategy(strategy, table) {
 	return strategy;
 }
 
-function _addSubStrategies(strategy, table) {
-	addSubStrategies = require('./newCascadeDeleteStrategy');
-	addSubStrategies(strategy, table);
-}
-
 module.exports = newCascadeDeleteStrategy;

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

@@ -1,5 +1,4 @@
 var newRelatedColumn = require('./relatedTable/relatedColumn');
-var nextRelatedTable = _nextRelatedTable;
 var subFilter = require('./relatedTable/subFilter');
 var any = require('./relatedTable/any');
 var all = require('./relatedTable/all');
@@ -15,14 +14,14 @@ function newRelatedTable(relations, isShallow, depth = 0) {
 	// if (isShallow)
 	// 	c = any(relations.slice(-1), depth);
 	// else
-	c = any(relations, depth);
+	c = any(newRelatedTable, relations, depth);
 	// @ts-ignore
-	c.all = all(relations, depth);
+	c.all = all(newRelatedTable, relations, depth);
 	// @ts-ignore
 	c.any = c;
 
 	// @ts-ignore
-	c.none = none(relations, depth);
+	c.none = none(newRelatedTable, relations, depth);
 
 	// @ts-ignore
 	c.where =  where(relations, depth);
@@ -58,17 +57,17 @@ function newRelatedTable(relations, isShallow, depth = 0) {
 
 		Object.defineProperty(c, alias, {
 			get: function() {
-				return nextRelatedTable(children, false, depth);
+				return newRelatedTable(children, false, depth);
 			}
 		});
 	}
 
 
 	// @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, {
@@ -91,9 +90,4 @@ function newRelatedTable(relations, isShallow, depth = 0) {
 	return cProxy;
 }
 
-function _nextRelatedTable(relations, isShallow, depth) {
-	nextRelatedTable = require('./newRelatedTable');
-	return nextRelatedTable(relations, isShallow, depth);
-}
-
 module.exports = newRelatedTable;

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;

package/src/table/query/extractLimit.js

@@ -1,7 +1,7 @@
 var getSessionContext = require('../getSessionContext');
 
-function extractLimit(span) {
-	let limit = getSessionContext().limit;
+function extractLimit(context, span) {
+	let limit = getSessionContext(context).limit;
 	if (limit)
 		return limit(span);
 	else

package/src/table/query/extractOffset.js

@@ -1,7 +1,7 @@
 var getSessionContext = require('../getSessionContext');
 
-function extractOffset(span) {
-	let {limitAndOffset} = getSessionContext();
+function extractOffset(context, span) {
+	let {limitAndOffset} = getSessionContext(context);
 	if (limitAndOffset)
 		return limitAndOffset(span);
 	else

package/src/table/query/extractOrderBy.js

@@ -1,7 +1,7 @@
 const getSessionSingleton = require('../getSessionSingleton');
 
-function extractOrderBy(table, alias, orderBy, originalOrderBy) {
-	const quote = getSessionSingleton('quote');
+function extractOrderBy(context, table, alias, orderBy, originalOrderBy) {
+	const quote = getSessionSingleton(context, 'quote');
 	alias = quote(alias);
 	var dbNames = [];
 	var i;

package/src/table/query/newParameterized.js

@@ -1,11 +1,6 @@
 var extractSql = require('./extractSql');
 var extractParameters = require('./parameterized/extractParameters');
 
-var nextParameterized = function(text, params) {
-	nextParameterized = require('../query/newParameterized');
-	return nextParameterized(text, params);
-};
-
 function Parameterized(text, parameters) {
 	this._text = text;
 	this.parameters = parameters;
@@ -18,21 +13,23 @@ Parameterized.prototype.sql = function() {
 Parameterized.prototype.prepend = function(other) {
 	if (other.sql) {
 		var params = other.parameters.concat(this.parameters);
-		return nextParameterized(other.sql() + this._text, params);
+		return newParameterized(other.sql() + this._text, params);
 	} else
-		return nextParameterized(other + this._text, this.parameters);
+		return newParameterized(other + this._text, this.parameters);
 };
 
 Parameterized.prototype.append = function(other) {
 	if (other.sql) {
 		var params = this.parameters.concat(other.parameters);
-		return nextParameterized(this._text + other.sql(), params);
+		return newParameterized(this._text + other.sql(), params);
 	} else
-		return nextParameterized(this._text + other, this.parameters);
+		return newParameterized(this._text + other, this.parameters);
 };
 
-module.exports = function(text, parameters) {
+function newParameterized(text, parameters) {
 	text = extractSql(text);
 	parameters = extractParameters(parameters);
 	return new Parameterized(text, parameters);
-};
+}
+
+module.exports = newParameterized;

package/src/table/query/newSingleQuery.js

@@ -6,15 +6,15 @@ var negotiateExclusive = require('./singleQuery/negotiateExclusive');
 var newParameterized = require('../../table/query/newParameterized');
 var quote = require('../quote');
 
-function _new(table,filter,span,alias,innerJoin,orderBy,limit,offset,exclusive) {
+function _new(context, table, filter, span, alias, innerJoin, orderBy, limit, offset, exclusive) {
 
-	var name = quote(table._dbName);
-	var columnSql = newColumnSql(table,span,alias);
-	var joinSql = newJoinSql(span,alias);
-	var whereSql = newWhereSql(table,filter,alias);
+	var name = quote(context, table._dbName);
+	var columnSql = newColumnSql(context, table, span, alias);
+	var joinSql = newJoinSql(context, span, alias);
+	var whereSql = newWhereSql(context, table, filter, alias);
 	var safeLimit = negotiateLimit(limit);
-	var exclusiveClause = negotiateExclusive(table,alias,exclusive);
-	return newParameterized('select' + safeLimit + ' ' + columnSql + ' from ' + name + ' ' + quote(alias))
+	var exclusiveClause = negotiateExclusive(table, alias, exclusive);
+	return newParameterized('select' + safeLimit + ' ' + columnSql + ' from ' + name + ' ' + quote(context, alias))
 		.append(innerJoin)
 		.append(joinSql)
 		.append(whereSql)

package/src/table/query/singleQuery/columnSql/joinLegToColumnSql.js

@@ -1,16 +1,3 @@
-var newShallowColumnSql = require('./newShallowColumnSql');
-var newJoinedColumnSql = _initJoinedColumnSql;
+const { joinLegToColumnSql} = require('./sharedJoinUtils');
 
-function sql(leg,alias,ignoreNull) {
-	var span = leg.span;
-	var shallowColumnSql = newShallowColumnSql(span.table,alias, span, ignoreNull);
-	var joinedColumnSql = newJoinedColumnSql(span,alias,ignoreNull);
-	return ',' + shallowColumnSql + joinedColumnSql;
-}
-
-function _initJoinedColumnSql(span,alias,ignoreNull) {
-	newJoinedColumnSql = require('./newJoinedColumnSql');
-	return newJoinedColumnSql(span,alias,ignoreNull);
-}
-
-module.exports = sql;
+module.exports = joinLegToColumnSql;