orange-orm 3.10.2

package/src/table/relation/newManyCache.js

@@ -0,0 +1,57 @@
+var synchronizeChanged = require('./manyCache/synchronizeChanged');
+var synchronizeAdded = require('./manyCache/synchronizeAdded');
+var synchronizeRemoved = require('./manyCache/synchronizeRemoved');
+var extractParentKey = require('./manyCache/extractParentKey');
+var newCacheCore = require('./newManyCacheCore');
+var newId = require('../../newId');
+var getSessionSingleton = require('../getSessionSingleton');
+var setSessionSingleton = require('../setSessionSingleton');
+
+function newManyCache(joinRelation) {
+	var c = {};
+	var key = newId();
+
+	c.tryAdd = function(parent, child) {
+		c.getInnerCache().tryAdd(parent, child);
+		synchronizeChanged(c, joinRelation, parent, child);
+	};
+
+	c.tryRemove = function(parent, child) {
+		c.getInnerCache().tryRemove(parent, child);
+	};
+
+	c.tryGet = function(parentRow) {
+		return c.getInnerCache().tryGet(parentRow);
+	};
+
+	c.getInnerCache = function() {
+		var cache = getSessionSingleton(key);
+		if (!cache) {
+			cache = newCacheCore(joinRelation);
+			setSessionSingleton(key, cache);
+			fillCache();
+			synchronizeAdded(c.tryAdd, joinRelation);
+			synchronizeRemoved(c.tryRemove, joinRelation);
+		}
+		return cache;
+	};
+
+
+	function fillCache() {
+		var childTable = joinRelation.parentTable;
+		var childCache = childTable._cache;
+		var children = childCache.getAll();
+		children.forEach(addToCache);
+
+		function addToCache(child) {
+			var parent = extractParentKey(joinRelation, child);
+			c.tryAdd(parent, child);
+		}
+	}
+
+
+
+	return c;
+}
+
+module.exports = newManyCache;

package/src/table/relation/newManyCacheCore.js

@@ -0,0 +1,53 @@
+var newCacheCore = require('../newCache');
+var newRowArray = require('../rowArray');
+
+function newManyCache(joinRelation) {
+	var c = {};
+	var cache = newCacheCore();
+	var primaryColumns = joinRelation.childTable._primaryColumns;
+
+	c.tryGet = function(parentRow) {
+		var key = toKey(parentRow);
+		var rows =  cache.tryGet(key);
+		if (!rows)
+			return newArray();
+		return rows;
+	};
+
+	function tryAdd(parentRow, childRow) {
+		var key = toKey(parentRow);
+		var existing = cache.tryGet(key);
+		if(existing) {
+			existing.push(childRow);
+			return;
+		}
+		var rows = newArray();
+		rows.push(childRow);
+		existing = cache.tryAdd(key, rows);
+	}
+
+	function newArray() {
+		return newRowArray(joinRelation.parentTable);
+	}
+
+	c.tryAdd = tryAdd;
+
+	c.tryRemove = function(parentRow, childRow) {
+		var key = toKey(parentRow);
+		var existing = cache.tryGet(key);
+		var index = existing.indexOf(childRow);
+		existing.splice(index,1);
+	};
+
+	function toKey(row) {
+		return primaryColumns.map(onColumn);
+
+		function onColumn(column) {
+			return row[column.alias];
+		}
+	}
+
+	return c;
+}
+
+module.exports = newManyCache;

package/src/table/relation/newManyLeg.js

@@ -0,0 +1,15 @@
+var newOneLeg = require('./newOneLeg');
+
+function newLeg(relation) {
+	var c = newOneLeg(relation);
+	c.name = relation.joinRelation.rightAlias;
+	c.accept = function(visitor) {
+		visitor.visitMany(c);
+	};
+
+	c.expand = relation.expand;
+
+	return c;
+}
+
+module.exports = newLeg;

package/src/table/relation/newOneCache.js

@@ -0,0 +1,28 @@
+let newManyCache = require('./newManyCache');
+
+function newOneCache(joinRelation) {
+	let c = {};
+	let cache = newManyCache(joinRelation);
+
+	c.tryGet = function(parent) {
+		let res = cache.tryGet(parent);
+		if (res.length === 0)
+			return null;
+		return res[0];
+	};
+
+	c.getInnerCache = function() {
+		let _cache = cache.getInnerCache();
+		let _c = {};
+		_c.tryGet = function(parent) {
+			let res = _cache.tryGet(parent);
+			if (res.length === 0)
+				return null;
+			return res[0];
+		};
+		return _c;
+	};
+	return c;
+}
+
+module.exports = newOneCache;

package/src/table/relation/newOneLeg.js

@@ -0,0 +1,25 @@
+var newCollection = require('../../newCollection');
+var newQueryContext = require('../query/singleQuery/newQueryContext');
+
+function newLeg(relation) {
+
+	var joinRelation = relation.joinRelation;
+	var c = {};
+	c.name = joinRelation.rightAlias;
+	var span = {};
+	span.queryContext = newQueryContext();
+	span.table = joinRelation.parentTable;
+	span.legs = newCollection();
+	c.span = span;
+	c.table = joinRelation.childTable;
+	c.columns = joinRelation.columns;
+	c.expand = relation.expand;
+
+	c.accept = function(visitor) {
+		visitor.visitOne(c);
+	};
+
+	return c;
+}
+
+module.exports = newLeg;

package/src/table/releaseDbClient.js

@@ -0,0 +1,15 @@
+var getSessionSingleton = require('./getSessionSingleton');
+var deleteSessionContext = require('./deleteSessionContext');
+
+function release() {
+	var done = getSessionSingleton('dbClientDone');
+	var pool = getSessionSingleton('pool');
+	deleteSessionContext();
+	if (done)
+		done();
+	if (pool)
+		return pool.end();
+
+}
+
+module.exports = release;

package/src/table/resultToPromise.js

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

package/src/table/resultToRows/dbRowToRow.js

@@ -0,0 +1,51 @@
+var negotiateQueryContext = require('./negotiateQueryContext');
+var decodeDbRow = require('./decodeDbRow');
+var nextDbRowToRow = _nextDbRowToRow;
+
+
+function dbRowToRow(span, dbRow) {
+	var table = span.table;
+	var row = decodeDbRow(span, table, dbRow);
+	var cache = table._cache;
+	if (!cache.tryGet(row)) {
+		var queryContext = span.queryContext;
+		negotiateQueryContext(queryContext, row);
+		Object.defineProperty(row, 'queryContext', {
+			writable: true,
+			configurable: true,
+			enumerable: false
+		});
+		row.queryContext = queryContext;
+	}
+	row = cache.tryAdd(row);
+
+	var c = {};
+
+	c.visitOne = function(leg) {
+		nextDbRowToRow(leg.span, dbRow);
+		leg.expand(row);
+	};
+
+	c.visitJoin = function(leg) {
+		nextDbRowToRow(leg.span, dbRow);
+		leg.expand(row);
+	};
+
+	c.visitMany = function() {
+	};
+
+	span.legs.forEach(onEach);
+
+	function onEach(leg) {
+		leg.accept(c);
+	}
+
+	return row;
+}
+
+function _nextDbRowToRow(span, dbRow) {
+	nextDbRowToRow = require('./dbRowToRow');
+	nextDbRowToRow(span, dbRow);
+}
+
+module.exports = dbRowToRow;

package/src/table/resultToRows/dbRowsToRows.js

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

package/src/table/resultToRows/decodeDbRow.js

@@ -0,0 +1,25 @@
+var newDecodeDbRow = require('./newDecodeDbRow');
+
+function decodeDbRow(span, table, dbRow, shouldValidate, isInsert) {
+	var decode = span._decodeDbRow;
+	if (!decode) {
+		let aliases = new Set();
+		if (span.columns)
+			span.columns.forEach((value, key) => {
+				if (value)
+					aliases.add(key.alias);
+			});
+		if (aliases.size === 0)
+			aliases = undefined;
+		decode = newDecodeDbRow(table, dbRow, aliases, shouldValidate, isInsert);
+		Object.defineProperty(span, '_decodeDbRow', {
+			enumerable: false,
+			get: function() {
+				return decode;
+			},
+		});
+	}
+	return decode(dbRow);
+}
+
+module.exports = decodeDbRow;

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

@@ -0,0 +1,33 @@
+var nextRemoveFromCache = _nextRemoveFromCache;
+
+function removeFromCache(row, strategy, table) {
+	if (Array.isArray(row)) {
+		removeManyRows();
+		return;
+	}
+	if (row)
+		removeSingleRow();
+
+	function removeManyRows() {
+		row.forEach( function(rowToRemove) {
+			nextRemoveFromCache(rowToRemove, strategy, table);
+		});
+	}
+
+	function removeSingleRow() {
+		var relations = table._relations;
+		for (var relationName in strategy) {
+			var relation = relations[relationName];
+			var rows = relation.getRowsSync(row);
+			nextRemoveFromCache(rows, strategy[relationName], relation.childTable);
+		}
+		table._cache.tryRemove(row);
+	}
+}
+
+function _nextRemoveFromCache(row, strategy, table) {
+	nextRemoveFromCache = require('./removeFromCache');
+	nextRemoveFromCache(row, strategy, table);
+}
+
+module.exports = removeFromCache;

package/src/table/resultToRows/delete.js

@@ -0,0 +1,31 @@
+var removeFromCache = require('./delete/removeFromCache');
+var pushCommand = require('../commands/pushCommand');
+var newDeleteCommand = require('../commands/newDeleteCommand');
+var newPrimaryKeyFilter = require('../newPrimaryKeyFilter');
+var createPatch = require('../../client/createPatch');
+var createDto = require('./toDto/createDto');
+
+function _delete(row, strategy, table) {
+	var relations = [];
+	removeFromCache(row, strategy, table);
+
+	var args = [table];
+	table._primaryColumns.forEach(function(primary) {
+		args.push(row[primary.alias]);
+	});
+	var filter = newPrimaryKeyFilter.apply(null, args);
+	var cmds = newDeleteCommand([], table, filter, strategy, relations);
+	cmds.forEach(function(cmd) {
+		pushCommand(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});
+	}
+
+}
+
+module.exports = _delete;

package/src/table/resultToRows/negotiateQueryContext.js

@@ -0,0 +1,6 @@
+function negotiateQueryContext(queryContext, row) {
+	if (queryContext)
+		queryContext.add(row);
+}
+
+module.exports = negotiateQueryContext;

package/src/table/resultToRows/newDecodeDbRow.js

@@ -0,0 +1,262 @@
+let util = require('util');
+let updateField = require('../updateField');
+let newEmitEvent = require('../../emitEvent');
+let extractStrategy = require('./toDto/extractStrategy');
+let extractDeleteStrategy = require('../extractDeleteStrategy');
+let newCascadeDeleteStrategy = require('../newCascadeDeleteStrategy');
+let _delete = require('./delete');
+let newObject = require('../../newObject');
+let toDto = require('./toDto');
+let createDto = require('./toDto/createDto');
+let patchRow = require('../../patchRow');
+let onChange = require('@lroal/on-change');
+let flags = require('../../flags');
+let tryGetSessionContext = require('../tryGetSessionContext');
+let purifyStrategy = require('../purifyStrategy');
+
+
+function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert) {
+	let aliases = filteredAliases || table._aliases;
+	let columns = table._columns;
+	let numberOfColumns = columns.length;
+	if (dbRow.offset === undefined) {
+		dbRow.offset = 0;
+	}
+
+	let offset = dbRow.offset;
+	let keys = Object.keys(dbRow);
+
+	for (let i = 0; i < numberOfColumns; i++) {
+		defineColumnProperty(i);
+	}
+
+	dbRow.offset += numberOfColumns;
+
+	function defineColumnProperty(i) {
+		let column = columns[i];
+		let purify = column.purify;
+		let name = column.alias;
+		let intName = '__' + name;
+		i = offset + i;
+		let key = keys[i];
+
+		Object.defineProperty(Row.prototype, intName, {
+			get: function() {
+				return this._dbRow[key];
+			},
+
+			set: function(value) {
+				let oldValue = this[name];
+				value = purify(value);
+				this._dbRow[key] = value;
+				if (column.validate)
+					column.validate(value, this._dbRow);
+				updateField(table, column, this);
+				let emit = this._emitColumnChanged[name];
+				if (emit)
+					emit(this, column, value, oldValue);
+				this._emitChanged(this, column, value, oldValue);
+			}
+		});
+
+		Object.defineProperty(Row.prototype, name, {
+			enumerable: true,
+			configurable: false,
+
+			get: function() {
+				if (column.onChange && flags.useProxy && (this[intName] !== null && this[intName] !== undefined) && typeof this[intName] === 'object') {
+					if (!(name in this._proxies)) {
+						let value = this[intName];
+						this._proxies[name] = column.onChange(this._dbRow[key], () => {
+							if (this[intName] !== onChange.target(value)) {
+								return;
+							}
+							this[intName] = this._dbRow[key];
+						});
+					}
+					return this._proxies[name];
+				}
+				return negotiateNull(this[intName]);
+			},
+			set: function(value) {
+				if (column.onChange && (this[intName] !== null && this[intName] !== undefined) && typeof value === 'object') {
+					if (this[intName] === onChange.target(value))
+						return;
+					this._proxies[name] = column.onChange(value, () => {
+						if (this[intName] !== onChange.target(value))
+							return;
+						this[intName] = this._dbRow[key];
+					});
+				}
+				this[intName] = value;
+			}
+		});
+	}
+
+	setRelated();
+
+	function setRelated() {
+		let relations = table._relations;
+		for (let relationName in relations) {
+			setSingleRelated(relationName);
+		}
+	}
+
+	function setSingleRelated(name) {
+		Object.defineProperty(Row.prototype, name, {
+			get: function() {
+				return createGetRelated(this, name)();
+			}
+		});
+	}
+
+	function createGetRelated(row, alias) {
+		let get = row._related[alias];
+		if (!get) {
+			let relation = table._relations[alias];
+			get = relation.toGetRelated(row);
+			row._relationCacheMap.set(relation, relation.getInnerCache());
+			row._related[alias] = get;
+		}
+		return get;
+	}
+
+	Row.prototype.subscribeChanged = function(onChanged, name) {
+		let emit;
+		if (name) {
+			emit = this._emitColumnChanged[name] || (this._emitColumnChanged[name] = newEmitEvent());
+			emit.add(onChanged);
+			return;
+		}
+		this._emitChanged.add(onChanged);
+	};
+
+	Row.prototype.unsubscribeChanged = function(onChanged, name) {
+		if (name) {
+			this._emitColumnChanged[name].tryRemove(onChanged);
+			return;
+		}
+		this._emitChanged.tryRemove(onChanged);
+	};
+
+	Row.prototype.toJSON = function() {
+		return toDto(undefined, table, this, new Set());
+	};
+
+
+	Row.prototype.hydrate = function(dbRow) {
+		const engine = tryGetSessionContext()?.engine;
+		let i = offset;
+		if (engine === 'sqlite') {
+			const errorSeparator = '12345678-1234-1234-1234-123456789012';
+			for (let p in dbRow) {
+				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]);
+				i++;
+			}
+		}
+		else {
+			for (let p in dbRow) {
+				let key = keys[i];
+				this._dbRow[key] = columns[i].decode(dbRow[p]);
+				i++;
+			}
+		}
+	};
+
+	Row.prototype.toDto = function(strategy) {
+		if (strategy === undefined) {
+			strategy = extractStrategy(table);
+		}
+		strategy = purifyStrategy(table, strategy);
+		if (!tryGetSessionContext()) {
+			return toDto(strategy, table, this, new Set());
+		}
+		let p = toDto(strategy, table, this);
+		return Promise.resolve().then(() => p);
+	};
+
+	Row.prototype.expand = function(alias) {
+		let get = createGetRelated(this, alias);
+		get.expanded = true;
+	};
+
+	Row.prototype.isExpanded = function(alias) {
+		return this._related[alias] && this._related[alias].expanded;
+	};
+
+	Row.prototype.delete = function(strategy) {
+		strategy = extractDeleteStrategy(strategy);
+		_delete(this, strategy, table);
+	};
+
+	Row.prototype.cascadeDelete = function() {
+		let strategy = newCascadeDeleteStrategy(newObject(), table);
+		_delete(this, strategy, table);
+	};
+
+	Row.prototype.deleteCascade = Row.prototype.cascadeDelete;
+
+	Row.prototype.patch = async function(patches, options) {
+		await patchRow(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) {
+		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]);
+			if (shouldValidate && columns[i].validate)
+				columns[i].validate(row[key], row, isInsert);
+		}
+		let target = new Row(row);
+		const p = new Proxy(target, {
+			ownKeys: function() {
+				return Array.from(aliases).concat(Object.keys(target._related).filter(alias => {
+					return target._related[alias] && target._related[alias].expanded;
+				}));
+			},
+			getOwnPropertyDescriptor(target, prop) {
+				if (table._aliases.has(prop) || (target._related[prop]))
+					return {
+						enumerable: aliases.has(prop) || (target._related[prop] && target._related[prop].expanded),
+						configurable: true,
+						writable: true
+					};
+			}
+		});
+
+		return p;
+	}
+
+	function negotiateNull(value) {
+		if (value === undefined)
+			return null;
+		return value;
+	}
+
+	function Row(dbRow) {
+		this._relationCacheMap = new Map();
+		this._cache = table._cache.getInnerCache();
+		this._dbRow = dbRow;
+		this._related = {};
+		this._emitColumnChanged = {};
+		this._emitChanged = newEmitEvent();
+		this._proxies = {};
+		this._oldValues = JSON.stringify(createDto(table, this));
+	}
+
+	return decodeDbRow;
+}
+
+module.exports = newDecodeDbRow;

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

@@ -0,0 +1,20 @@
+let flags = require('../../../flags');
+
+function _createDto(table, row) {
+	var dto = {};
+	flags.useProxy = false;
+	for (let name in row) {
+		let column = table[name];
+		if (table._aliases.has(name)) {
+			if (column.toDto)
+				dto[name] = column.toDto(row[name]);
+			else
+				dto[name] = row[name];
+		}
+	}
+
+	flags.useProxy = true;
+	return dto;
+}
+
+module.exports = _createDto;

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

@@ -0,0 +1,41 @@
+let extractSubStrategy = _extractSubStrategy;
+
+//either..
+//strategy, table
+//or..
+//table
+function extractStrategy(_strategyOrTable, _optinonalTable) {
+	let table;
+	if (arguments.length === 2 && _strategyOrTable !== undefined)
+		return arguments[0];
+	else if (arguments.length === 2)
+		table = arguments[1];
+	else
+		table = arguments[0];
+
+	let strategy = {};
+	let relations = table._relations;
+	let relationName;
+
+	let visitor = {};
+	visitor.visitJoin = function() { };
+
+	visitor.visitMany = function(relation) {
+		strategy[relationName] = extractSubStrategy(relation.childTable);
+	};
+
+	visitor.visitOne = visitor.visitMany;
+
+	for (relationName in relations) {
+		let relation = relations[relationName];
+		relation.accept(visitor);
+	}
+	return strategy;
+}
+
+function _extractSubStrategy(table) {
+	extractSubStrategy = require('./extractStrategy');
+	return extractSubStrategy(table);
+}
+
+module.exports = extractStrategy;