orange-orm 3.10.2

package/src/table/negotiateAddStrategy.js

@@ -0,0 +1,20 @@
+var emptyStrategy = require('./emptyStrategy');
+
+function negotiate(table) {
+	var argsCount = arguments.length;
+	var args = [];
+	for (var i = 0; i < arguments.length; i++) {
+		args.push(arguments[i]);
+	}
+	if (noStrategy())
+		args.push(emptyStrategy);
+	return args;
+
+	function noStrategy() {
+		var columnCount = table._primaryColumns.length;
+		return (columnCount+2 !== argsCount);
+
+	}
+}
+
+module.exports = negotiate;

package/src/table/negotiateExpandInverse.js

@@ -0,0 +1,13 @@
+function negotiateExpandInverse(parent, relation, children) {
+	var joinRelation = relation.joinRelation;
+	if (!joinRelation || !joinRelation.leftAlias)
+		return;
+	var firstChild = children.find(function(child) {
+		return child.queryContext;
+	});
+
+	if (firstChild)
+		firstChild.queryContext.expand(joinRelation);
+}
+
+module.exports = negotiateExpandInverse;

package/src/table/newCache.js

@@ -0,0 +1,96 @@
+var newEmitEvent = require('../emitEvent');
+
+function cacheCore() {
+	var emitAdded = newEmitEvent();
+	var emitRemoved = newEmitEvent();
+	var c = {};
+	var cache = {};
+	var keyLength;
+
+	c.tryGet = function(key) {
+		var index = 0;
+		var keyLength = key.length;
+
+		return tryGetCore(cache, index);
+
+		function tryGetCore(cache, index) {
+			var keyValue = key[index];
+			var cacheValue = cache[keyValue];
+			if (typeof cacheValue === 'undefined')
+				return null;
+			if (keyLength - 1 === index)
+				return cacheValue;
+			return tryGetCore(cache[keyValue], ++index);
+		}
+
+	};
+
+	c.tryAdd = function(key, result) {
+		var index = 0;
+		keyLength = key.length;
+
+		return  addCore(cache, index);
+
+		function addCore(cache, index) {
+			var keyValue = key[index];
+
+			if (keyLength - 1 === index) {
+				if (keyValue in cache)
+					return cache[keyValue];
+
+				cache[keyValue] = result;
+				emitAdded(result);
+				return result;
+			}
+			if (! (keyValue in cache))
+				cache[keyValue] = {};
+			return addCore(cache[keyValue], ++index);
+		}
+	};
+
+	c.tryRemove = function(key) {
+		var index = 0;
+		var keyLength = key.length;
+
+		return tryRemoveCore(cache, index);
+
+		function tryRemoveCore(cache, index) {
+			var keyValue = key[index];
+			if (!(keyValue in cache))
+				return null;
+			var cacheValue = cache[keyValue];
+			if (keyLength - 1 === index) {
+				delete cache[keyValue];
+				emitRemoved(cacheValue);
+				return cacheValue;
+			}
+
+			return tryRemoveCore(cache[keyValue], ++index);
+		}
+
+	};
+
+	c.getAll = function() {
+		var index = 0;
+		var result = [];
+		getAllCore(cache, index);
+
+		function getAllCore(cache, index) {
+			for (var name in cache) {
+				var value = cache[name];
+				if (index === keyLength - 1)
+					result.push(value);
+				else
+					getAllCore(value, index+1);
+			}
+		}
+		return result;
+	};
+
+	c.subscribeAdded = emitAdded.add;
+	c.subscribeRemoved = emitRemoved.add;
+
+	return c;
+}
+
+module.exports = cacheCore;

package/src/table/newCascadeDeleteStrategy.js

@@ -0,0 +1,30 @@
+var addSubStrategies = _addSubStrategies;
+var newObject = require('../newObject');
+
+function newCascadeDeleteStrategy(strategy, table) {
+	var relations = table._relations;
+	var relationName;
+
+	var c = {};
+	c.visitJoin = function(){};
+	c.visitOne = function(relation) {
+		var subStrategy = newObject();
+		strategy[relationName] = subStrategy;
+		addSubStrategies(subStrategy, relation.childTable);
+	};
+
+	c.visitMany = c.visitOne;
+
+	for(relationName in relations) {
+		var relation = relations[relationName];
+		relation.accept(c);
+	}
+	return strategy;
+}
+
+function _addSubStrategies(strategy, table) {
+	addSubStrategies = require('./newCascadeDeleteStrategy');
+	addSubStrategies(strategy, table);
+}
+
+module.exports = newCascadeDeleteStrategy;

package/src/table/newGetRelated.js

@@ -0,0 +1,21 @@
+function newGetRelated(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);
+
+		function onFromDb(rows) {
+			getRelated.expanded = true;
+			return rows;
+		}
+
+		function onRelatives() {
+			return relation.getFromCache(parent);
+		}
+	}
+	return getRelated;
+}
+
+module.exports = newGetRelated;

package/src/table/newJoinRelation.js

@@ -0,0 +1,117 @@
+var newLeg = require('./relation/newJoinLeg'),
+	getById = require('./getById'),
+	nullPromise = require('./nullPromise'),
+	newGetRelated = require('./newGetRelated'),
+	getRelatives = require('./joinRelation/getRelatives'),
+	fuzzyPromise = require('./fuzzyPromise');
+function _newJoin(parentTable, childTable, columnNames) {
+	var c = {};
+
+	c.parentTable = parentTable;
+	c.childTable = childTable;
+	c.columns = [];
+	var columns = parentTable._columns;
+	addColumns();
+
+	c.accept = function(visitor) {
+		visitor.visitJoin(c);
+	};
+
+	c.toLeg = function() {
+		return newLeg(c);
+	};
+
+	c.getFromDb = function(parent) {
+		var key = parentToArrayKey(parent);
+		if (key.length === 0) {
+			return nullPromise;
+		}
+		var args = [childTable].concat(key);
+		return getById.apply(null, args);
+	};
+
+	c.getFromCache = function(parent) {
+		var result = c.getRowsSync(parent);
+		return fuzzyPromise(result);
+	};
+
+	c.toGetRelated = function(parent) {
+		return newGetRelated(parent, c);
+	};
+
+	c.getRelatives = function(parent) {
+		return getRelatives(parent, c);
+	};
+
+	c.expand = function(parent) {
+		parent.expand(c.leftAlias);
+	};
+
+	c.getRowsSync = function(parent) {
+		var key = parentToKey(parent);
+		let cache = parent._relationCacheMap.get(c);
+		return cache.tryGet(key);
+	};
+
+	c.getInnerCache = function() {
+		return childTable._cache.getInnerCache();
+	};
+
+	c.notNullExceptInsert = function() {
+		return c;
+	};
+
+	c.notNull = function() {
+		return c;
+	};
+
+
+	return c;
+
+	function addColumns() {
+		var numberOfColumns = columnNames.length;
+		for (var i = 0; i < columns.length; i++) {
+			var curColumn = columns[i];
+			tryAdd(curColumn);
+			if (numberOfColumns === c.columns.length)
+				return;
+		}
+	}
+
+	function tryAdd(column) {
+		for (var i = 0; i < columnNames.length; i++) {
+			var name = columnNames[i];
+			if (column._dbName === name) {
+				column.default = undefined;
+				// delete column.lazyDefault;
+				c.columns.push(column);
+				return;
+			}
+		}
+	}
+
+	function parentToKey(parent) {
+		let key = {};
+		for (let i = 0; i < c.columns.length; i++) {
+			let value = parent[c.columns[i].alias];
+			if (value === null || value === undefined)
+				return {};
+			key[childTable._primaryColumns[i].alias] = value;
+		}
+		return key;
+	}
+
+	function parentToArrayKey(parent) {
+		let key = [];
+		for (let i = 0; i < c.columns.length; i++) {
+			let value = parent[c.columns[i].alias];
+			if (value === null || value === undefined)
+				return [];
+			key.push(value);
+		}
+		return key;
+	}
+}
+
+
+module.exports = _newJoin;

package/src/table/newManyRelation.js

@@ -0,0 +1,61 @@
+var newLeg = require('./relation/newManyLeg');
+var newManyCache = require('./relation/newManyCache');
+var newForeignKeyFilter = require('./relation/newForeignKeyFilter');
+var getRelatives = require('./oneRelation/getRelatives');
+var fuzzyPromise = require('./fuzzyPromise');
+var newGetRelated = require('./newGetRelated');
+
+function newManyRelation(joinRelation) {
+	var c = {};
+	var manyCache = newManyCache(joinRelation);
+
+	c.joinRelation = joinRelation;
+	c.childTable = joinRelation.parentTable;
+	c.parentTable = joinRelation.childTable;
+	c.isMany = true;
+
+	c.accept = function(visitor) {
+		visitor.visitMany(c);
+	};
+
+	c.getFromCache = function(parent) {
+		var result = c.getRowsSync(parent);
+		return fuzzyPromise(result);
+	};
+
+	c.getFromDb = function(parent) {
+		var filter = newForeignKeyFilter(joinRelation, parent);
+		return c.childTable.getMany(filter, null);
+	};
+
+	c.getRelatives = function(parent) {
+		return getRelatives(parent, c);
+	};
+
+	c.toGetRelated = function(parent) {
+		return newGetRelated(parent, c);
+	};
+
+	c.expand = function(parent) {
+		return parent.expand(joinRelation.rightAlias);
+	};
+
+	c.getRowsSync = function(parent) {
+		let cache = parent._relationCacheMap.get(c);
+		if (!cache)
+			return [];
+		return cache.tryGet(parent);
+	};
+
+	c.toLeg = function() {
+		return newLeg(c);
+	};
+
+	c.getInnerCache = function() {
+		return manyCache.getInnerCache();
+	};
+
+	return c;
+}
+
+module.exports = newManyRelation;

package/src/table/newOneRelation.js

@@ -0,0 +1,61 @@
+var newLeg = require('./relation/newOneLeg');
+var newOneCache = require('./relation/newOneCache');
+var newForeignKeyFilter = require('./relation/newForeignKeyFilter');
+var getRelatives = require('./oneRelation/getRelatives');
+var fuzzyPromise = require('./fuzzyPromise');
+var newGetRelated = require('./newGetRelated');
+
+function newOneRelation(joinRelation) {
+	var c = {};
+	var oneCache = newOneCache(joinRelation);
+
+	c.joinRelation = joinRelation;
+	c.childTable = joinRelation.parentTable;
+	c.parentTable = joinRelation.childTable;
+	c.isOne = true;
+
+	c.accept = function(visitor) {
+		visitor.visitOne(c);
+	};
+
+	c.getFromCache = function(parent) {
+		let row = c.getRowsSync(parent);
+		return fuzzyPromise(row);
+	};
+
+	c.getFromDb = function(parent) {
+		var filter = newForeignKeyFilter(joinRelation, parent);
+		return c.childTable.tryGetFirst(filter, null);
+	};
+
+	c.getRelatives = function(parent) {
+		return getRelatives(parent, c);
+	};
+
+	c.toGetRelated = function(parent) {
+		return newGetRelated(parent, c);
+	};
+
+	c.expand = function(parent) {
+		return parent.expand(joinRelation.rightAlias);
+	};
+
+	c.getRowsSync = function(parent) {
+		let cache = parent._relationCacheMap.get(c);
+		if (!cache)
+			return null;
+		return cache.tryGet(parent);
+	};
+
+	c.toLeg = function() {
+		return newLeg(c);
+	};
+
+	c.getInnerCache = function() {
+		return oneCache.getInnerCache();
+	};
+
+	return c;
+}
+
+module.exports = newOneRelation;

package/src/table/newPrimaryKeyFilter.js

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

package/src/table/newQuery.js

@@ -0,0 +1,18 @@
+var newSingleQuery = require('./query/newSingleQuery');
+var extractFilter = require('./query/extractFilter');
+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) {
+	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);
+	queries.push(singleQuery);
+
+	return queries;
+}
+
+module.exports = newQuery;

package/src/table/newRelatedTable.js

@@ -0,0 +1,100 @@
+var newRelatedColumn = require('./relatedTable/relatedColumn');
+var nextRelatedTable = _nextRelatedTable;
+var subFilter = require('./relatedTable/subFilter');
+var any = require('./relatedTable/any');
+var all = require('./relatedTable/all');
+var where = require('./relatedTable/where');
+var aggregate = require('./relatedTable/aggregate');
+var none = require('./relatedTable/none');
+
+function newRelatedTable(relations, isShallow, depth = 0) {
+	var table = relations[relations.length - 1].childTable;
+	var columns = table._columns;
+
+	let c;
+	// if (isShallow)
+	// 	c = any(relations.slice(-1), depth);
+	// else
+	c = any(relations, depth);
+	// @ts-ignore
+	c.all = all(relations, depth);
+	// @ts-ignore
+	c.any = c;
+
+	// @ts-ignore
+	c.none = none(relations, depth);
+
+	// @ts-ignore
+	c.where =  where(relations, depth);
+
+	//todo
+	// @ts-ignore
+	c._aggregate = aggregate(relations);
+
+	Object.defineProperty(c, '_relation', {
+		value: relations[relations.length - 1],
+		writable: false
+	});
+
+	for (var i = 0; i < columns.length; i++) {
+		var col = columns[i];
+		if (col.alias === 'name')
+			c._name = newRelatedColumn(col, relations, isShallow, depth);
+		else
+			c[col.alias] = newRelatedColumn(col, relations, isShallow, depth);
+	}
+	defineChildren();
+
+	function defineChildren() {
+		var childRelations = table._relations;
+		for (var alias in childRelations) {
+			defineChild(alias);
+		}
+	}
+
+	function defineChild(alias) {
+		var relation = table._relations[alias];
+		var children = relations.slice(0);
+		children.push(relation);
+
+		Object.defineProperty(c, alias, {
+			get: function() {
+				return nextRelatedTable(children, false, depth);
+			}
+		});
+	}
+
+
+	// @ts-ignore
+	c.exists = function() {
+		if (isShallow)
+			return '';
+		return subFilter(relations, false, depth);
+	};
+
+	let cProxy = new Proxy(c, {
+		get: function(target, prop) {
+			if (prop === 'name') {
+				return target._name !== undefined ? target._name : target.name;
+			}
+			return target[prop];
+		},
+		set: function(target, prop, value) {
+			if (prop === 'name') {
+				target._name = value;
+			} else {
+				target[prop] = value;
+			}
+			return true;
+		}
+	});
+
+	return cProxy;
+}
+
+function _nextRelatedTable(relations, isShallow, depth) {
+	nextRelatedTable = require('./newRelatedTable');
+	return nextRelatedTable(relations, isShallow, depth);
+}
+
+module.exports = newRelatedTable;

package/src/table/newRowCache.js

@@ -0,0 +1,106 @@
+let newCache = require('./newCache');
+let getSessionSingleton = require('./getSessionSingleton');
+let setSessionSingleton = require('./setSessionSingleton');
+
+function newRowCache(table) {
+	let id = Symbol();
+	let c = {};
+
+	c.tryGet = function(row) {
+		return getCache(table, id).tryGet(row);
+	};
+
+	c.tryAdd = function(row) {
+		return getCache(table, id).tryAdd(row);
+	};
+
+	c.tryRemove = function(row) {
+		return getCache(table, id).tryRemove(row);
+	};
+
+	c.subscribeAdded = function() {
+		return getCache(table, id).subscribeAdded.apply(null, arguments);
+	};
+
+	c.subscribeRemoved = function() {
+		return getCache(table, id).subscribeRemoved.apply(null, arguments);
+	};
+
+	c.getAll = function() {
+		return getCache(table, id).getAll.apply(null, arguments);
+	};
+
+	c.getInnerCache = function() {
+		return getCache(table, id);
+	};
+	return c;
+}
+
+
+function getCache(table, id) {
+	let cache = getSessionSingleton(id);
+	if (cache)
+		return cache;
+	cache = _newRowCache(table);
+	setSessionSingleton(id, cache);
+	return cache;
+}
+
+
+function _newRowCache(table) {
+	let c = {};
+	let cache = newCache();
+	let pkNames;
+	let rowToKey = firstRowToKey;
+
+	function getPkNames() {
+		let names = {};
+		let primaryColumns = table._primaryColumns;
+		let keyLength = primaryColumns.length;
+		for (let i = 0; i < keyLength; i++) {
+			let column = primaryColumns[i];
+			names[column.alias] = null;
+		}
+		return names;
+	}
+
+	c.tryGet = function(row) {
+		let key = rowToKey(row);
+		return cache.tryGet(key);
+
+	};
+
+	function firstRowToKey(row) {
+		pkNames = getPkNames();
+		rowToKey = nextRowToKey;
+		table = null;
+		return rowToKey(row);
+	}
+
+	function nextRowToKey(row) {
+		let key = [];
+		for(let pkName in pkNames) {
+			key.push(row[pkName]);
+		}
+		return key;
+	}
+
+	c.tryAdd = function(row) {
+		let key = rowToKey(row);
+		return cache.tryAdd(key, row);
+	};
+
+	c.tryRemove = function(row) {
+		let key = rowToKey(row);
+		return cache.tryRemove(key);
+	};
+
+	c.subscribeAdded = cache.subscribeAdded;
+	c.subscribeRemoved = cache.subscribeRemoved;
+
+	c.getAll = cache.getAll;
+
+	return c;
+}
+
+module.exports = newRowCache;

package/src/table/newThrow.js

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

package/src/table/nullPromise.js

@@ -0,0 +1 @@
+module.exports = require('./promise')(null);

package/src/table/objectToCallback.js

@@ -0,0 +1,7 @@
+module.exports = function(object) {
+	return invoke;
+
+	function invoke(resolve) {
+		resolve(object);
+	}
+};