orange-orm 3.10.2

package/src/table/resultToRows/toDto.js

@@ -0,0 +1,92 @@
+let flags = require('../../flags');
+let tryGetSessionContext = require('../tryGetSessionContext');
+
+function toDto(strategy, table, row, joinRelationSet) {
+	let result;
+	flags.useProxy = false;
+	let context = tryGetSessionContext();
+	let ignoreSerializable = context && context.ignoreSerializable;
+	if (joinRelationSet) {
+		result = toDtoSync(table, row, joinRelationSet, strategy, ignoreSerializable);
+	}
+	else
+		result =  _toDto(table, row, strategy, ignoreSerializable);
+	flags.useProxy = true;
+	return result;
+}
+
+async function _toDto(table, row, strategy, ignoreSerializable) {
+	let dto = {};
+	if (!row)
+		return;
+	for (let name in strategy) {
+		if (!strategy[name])
+			continue;
+		let column = table[name];
+		// eslint-disable-next-line no-prototype-builtins
+		if (table._aliases.has(name) && (ignoreSerializable || !('serializable' in column && !column.serializable) && row.propertyIsEnumerable(name))) {
+			if (column.toDto)
+				dto[name] = column.toDto(row[name]);
+			else
+				dto[name] = row[name];
+		}
+		else if (table._relations[name] && strategy[name]) {
+			let child;
+			let relation = table._relations[name];
+			if ((strategy && !(strategy[name] || strategy[name] === null)))
+				continue;
+			else if (!row.isExpanded(name))
+				child = await row[name];
+			else
+				child = relation.getRowsSync(row);
+			if (!child)
+				dto[name] = child;
+			else if (Array.isArray(child)) {
+				dto[name] = [];
+				for (let i = 0; i < child.length; i++) {
+					dto[name].push(await _toDto(relation.childTable, child[i], strategy && strategy[name], ignoreSerializable));
+				}
+			}
+			else
+				dto[name] = await _toDto(relation.childTable, child, strategy && strategy[name], ignoreSerializable);
+		}
+	}
+	return dto;
+}
+
+
+function toDtoSync(table, row, joinRelationSet, strategy, ignoreSerializable) {
+	let dto = {};
+	if (!row)
+		return;
+	for (let name in row) {
+		let column = table[name];
+		if (table._aliases.has(name) && (ignoreSerializable || !('serializable' in column && !column.serializable))) {
+			if (column.toDto)
+				dto[name] = column.toDto(row[name]);
+			else
+				dto[name] = row[name];
+		}
+		else if (table._relations[name]) {
+			let relation = table._relations[name];
+			let join = relation.joinRelation || relation;
+			if (!row.isExpanded(name) || joinRelationSet.has(join) || (strategy && !(strategy[name] || strategy[name] === null)))
+				continue;
+			let child = relation.getRowsSync(row);
+			if (!child)
+				dto[name] = child;
+			else if (Array.isArray(child)) {
+				dto[name] = [];
+				for (let i = 0; i < child.length; i++) {
+					dto[name].push(toDtoSync(relation.childTable, child[i], new Set([...joinRelationSet, join]), strategy && strategy[name], ignoreSerializable));
+				}
+			}
+			else
+				dto[name] = toDtoSync(relation.childTable, child, new Set([...joinRelationSet, join]), strategy && strategy[name], ignoreSerializable);
+
+		}
+	}
+	return dto;
+}
+
+module.exports = toDto;

package/src/table/resultToRows.js

@@ -0,0 +1,37 @@
+var dbRowsToRows = require('./resultToRows/dbRowsToRows');
+
+async function resultToRows(span,result) {
+	let rows = await result[0].then(onResult);
+	await expand(spanToStrategy(span), rows);
+	return rows;
+
+	function onResult(result) {
+		return dbRowsToRows(span,result);
+	}
+}
+
+async function expand(strategy, rows) {
+	if (!rows)
+		return;
+	if (!Array.isArray(rows))
+		rows = [rows];
+	for(let p in strategy) {
+		if (!(strategy[p] === null || strategy[p]))
+			continue;
+		for (let i = 0; i < rows.length; i++) {
+			await expand(strategy[p], await rows[i][p]);
+		}
+	}
+}
+
+function spanToStrategy(span) {
+	let strategy = {};
+
+	span.legs.forEach((leg) => {
+		strategy[leg.name] = spanToStrategy(leg.span);
+	});
+	return strategy;
+
+}
+
+module.exports = resultToRows;

package/src/table/rollback.js

@@ -0,0 +1,31 @@
+const rollbackCommand = require('./commands/rollbackCommand');
+const executeQuery = require('./executeQueries/executeQuery');
+const releaseDbClient = require('./releaseDbClient');
+const popChanges = require('./popChanges');
+const newThrow = require('./newThrow');
+const resultToPromise = require('./resultToPromise');
+const conflictId = '12345678-1234-1234-1234-123456789012';
+
+function rollback(e) {
+	var executeRollback = executeQuery.bind(null, rollbackCommand);
+	var chain = resultToPromise()
+		.then(popChanges)
+		.then(executeRollback)
+		.then(releaseDbClient);
+
+	if (e) {
+		if (e.message.indexOf('ORA-01476: divisor is equal to zero') > -1)
+			return newThrow(new Error('Conflict when updating a column'), chain);
+		let errors = e.message && e.message.split(conflictId) || [];
+		if (errors.length > 1) {
+			return newThrow(new Error(errors[1]), chain);
+		}
+		else
+			return newThrow(e, chain);
+	}
+	return chain;
+}
+
+module.exports = function(e) {
+	return Promise.resolve().then(() => rollback(e));
+};

package/src/table/rowArray/negotiateNextTick.js

@@ -0,0 +1,11 @@
+var promise = require('promise/domains');
+
+function negotiateNextTick(i) {
+	if (i === 0)
+		return;
+	if (i % 1000 === 0)
+		return promise.resolve();
+	return;
+}
+
+module.exports = negotiateNextTick;

package/src/table/rowArray/orderBy.js

@@ -0,0 +1,51 @@
+function orderBy(strategy, rows) {
+	if (strategy && strategy.orderBy) {
+		var comparer = createComparer(strategy.orderBy);
+		return rows.sort(comparer);
+	}
+	return rows;
+}
+
+function createComparer(orderBy) {
+	var comparers = [];
+	if (typeof orderBy === 'string')
+		orderBy = [orderBy];
+	orderBy.forEach(function(order) {
+		var elements = order.split(' ');
+		var name = elements[0];
+		var direction = elements[1] || 'asc';
+
+		if (direction === 'asc')
+			comparers.push(compareAscending);
+		else
+			comparers.push(compareDescending);
+
+		function compareAscending(a, b) {
+			a = a[name];
+			b = b[name];
+			if (a === b)
+				return 0;
+			if (a < b)
+				return -1;
+			return 1;
+		}
+
+		function compareDescending(a, b) {
+			return compareAscending(b, a);
+		}
+
+	});
+
+	function compareComposite(a, b) {
+		for (var i = 0; i < comparers.length; i++) {
+			var result = comparers[i](a, b);
+			if (result !== 0)
+				return result;
+		}
+		return 0;
+	}
+
+	return compareComposite;
+}
+
+module.exports = orderBy;

package/src/table/rowArray.js

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-this-alias */
+var resultToPromise = require('./resultToPromise');
+var orderBy = require('./rowArray/orderBy');
+var negotiateNextTick = require('./rowArray/negotiateNextTick');
+
+function newRowArray() {
+	var c = [];
+
+	Object.defineProperty(c, 'toDto', {
+		enumerable: false,
+		writable: true,
+		value: toDtoNativePromise
+	});
+
+	Object.defineProperty(c, '__toDto', {
+		enumerable: false,
+		writable: true,
+		value: toDto
+	});
+
+	async function toDtoNativePromise() {
+		let result = [];
+		for (let i = 0; i < c.length; i++) {
+			result.push(await c[i].toDto.apply(c[i], arguments));
+		}
+		return result;
+	}
+
+	return c;
+}
+
+function toDto(optionalStrategy) {
+	var args = arguments;
+	var result = [];
+	var length = this.length;
+	var rows = this;
+	var i = -1;
+
+	return resultToPromise().then(toDtoAtIndex);
+
+	function toDtoAtIndex() {
+		i++;
+		if (i === length) {
+			return orderBy(optionalStrategy, result);
+		}
+		var row = rows[i];
+		return getDto()
+			.then(onDto)
+			.then(toDtoAtIndex);
+
+		function getDto() {
+			return row.__toDto.apply(row,args);
+		}
+
+		function onDto(dto) {
+			result.push(dto);
+			return negotiateNextTick(i);
+		}
+	}
+}
+
+module.exports = newRowArray;

package/src/table/setSessionSingleton.js

@@ -0,0 +1,5 @@
+var getSessionContext = require('./getSessionContext');
+
+module.exports = function(name, value) {
+	getSessionContext()[name] = value;
+};

package/src/table/strategyToSpan.js

@@ -0,0 +1,49 @@
+var newCollection = require('../newCollection');
+var newQueryContext = require('./query/singleQuery/newQueryContext');
+var purifyStrategy = require('./purifyStrategy');
+
+function toSpan(table, strategy) {
+	var span = {};
+	span.aggregates = {};
+	span.legs = newCollection();
+	span.table = table;
+	strategy = purifyStrategy(table, strategy);
+	applyStrategy(table,span,strategy);
+	span.queryContext = newQueryContext();
+	span.queryContext.strategy = strategy;
+	return span;
+
+	function applyStrategy(table,span,strategy) {
+		let columns = new Map();
+		var legs = span.legs;
+		if(!strategy)
+			return;
+		for (var name in strategy) {
+			if (table._relations[name] && !strategy[name])
+				continue;
+			if (table._relations[name])
+				addLeg(legs,table,strategy,name);
+			else if (strategy[name]?.expression && (strategy[name]?.joins || strategy[name]?.join || strategy[name]?.column))
+				span.aggregates[name] = strategy[name];
+			else if (table[name] && table[name].eq)
+				columns.set(table[name], strategy[name]);
+			else
+				span[name] = strategy[name];
+		}
+		span.columns = columns;
+	}
+
+	function addLeg(legs,table,strategy,name) {
+		var relation = table._relations[name];
+		var leg = relation.toLeg();
+		leg.span.queryContext.strategy = strategy;
+		leg.span.where = strategy[name].where;
+		leg.span.aggregates = {};
+		legs.add(leg);
+		var subStrategy = strategy[name];
+		var childTable = relation.childTable;
+		applyStrategy(childTable,leg.span,subStrategy);
+	}
+}
+
+module.exports = toSpan;

package/src/table/tryGetById.js

@@ -0,0 +1,13 @@
+var tryGetFromCacheById = require('./tryGetFromCacheById');
+var tryGetFromDbById = require('./tryGetFromDbById');
+var resultToPromise = require('./resultToPromise');
+
+function get() {
+	var cached =  tryGetFromCacheById.apply(null,arguments);
+	if (cached)
+		return resultToPromise(cached);
+	return tryGetFromDbById.apply(null,arguments);
+}
+get.exclusive = tryGetFromDbById.exclusive;
+
+module.exports = get;

package/src/table/tryGetFirstFromDb.js

@@ -0,0 +1,23 @@
+var getMany = require('./getMany');
+
+function tryGet(table, filter, strategy) {
+	strategy = setLimit(strategy);
+	return getMany(table, filter, strategy).then(filterRows);
+}
+
+function filterRows(rows) {
+	if (rows.length > 0)
+		return rows[0];
+	return null;
+}
+
+tryGet.exclusive = function(table, filter, strategy) {
+	strategy = setLimit(strategy);
+	return getMany.exclusive(table, filter, strategy).then(filterRows);
+};
+
+function setLimit(strategy) {
+	return {...strategy, ...{limit: 1}};
+}
+
+module.exports = tryGet;

package/src/table/tryGetFromCacheById.js

@@ -0,0 +1,12 @@
+function tryGet(table) {
+	var fakeRow = {};
+	var args = arguments;
+	table._primaryColumns.forEach(addPkValue);
+
+	function addPkValue(pkColumn, index){
+		fakeRow[pkColumn.alias] = args[index + 1];
+	}
+
+	return table._cache.tryGet(fakeRow);
+}
+module.exports = tryGet;

package/src/table/tryGetFromDbById/extractStrategy.js

@@ -0,0 +1,9 @@
+
+function extract(table) {
+	var lengthWithStrategy = table._primaryColumns.length  + 2;
+	if (arguments.length === lengthWithStrategy)
+		return arguments[lengthWithStrategy-1];
+	return;
+}
+
+module.exports = extract;

package/src/table/tryGetFromDbById.js

@@ -0,0 +1,19 @@
+var newPrimaryKeyFilter = require('./newPrimaryKeyFilter');
+var tryGetFirstFromDb = require('./tryGetFirstFromDb');
+var extractStrategy = require('./tryGetFromDbById/extractStrategy');
+
+function tryGet() {
+	var filter = newPrimaryKeyFilter.apply(null, arguments);
+	var table = arguments[0];
+	var strategy = extractStrategy.apply(null, arguments);
+	return tryGetFirstFromDb(table, filter, strategy);
+}
+
+tryGet.exclusive = function tryGet() {
+	var filter = newPrimaryKeyFilter.apply(null, arguments);
+	var table = arguments[0];
+	var strategy = extractStrategy.apply(null, arguments);
+	return tryGetFirstFromDb.exclusive(table, filter, strategy);
+};
+
+module.exports = tryGet;

package/src/table/tryGetSessionContext.js

@@ -0,0 +1,16 @@
+let useHook = require('../useHook');
+let cls;
+
+
+function tryGetSessionContext() {
+	if (useHook()) {
+		if (!cls)
+			cls = require('node-cls');
+		let context = cls.getContext('rdb');
+		return context && context.rdb;
+	}
+	else
+		return process.domain && process.domain.rdb;
+}
+
+module.exports = tryGetSessionContext;

package/src/table/tryReleaseDbClient.js

@@ -0,0 +1,14 @@
+var release = require('./releaseDbClient');
+
+function tryReleaseDbClient() {
+	try {
+		release();
+	}
+	// eslint-disable-next-line no-empty
+	catch (e) {
+
+	}
+
+}
+
+module.exports = tryReleaseDbClient;

package/src/table/updateField.js

@@ -0,0 +1,12 @@
+var newUpdateCommand = require('./commands/newUpdateCommand');
+var pushCommand = require('./commands/pushCommand');
+var lastCommandMatches = require('./commands/lastCommandMatches');
+
+function updateField(table, column, row, oldValue) {
+	if (lastCommandMatches(row))
+		return;
+	var command = newUpdateCommand(table, column, row, oldValue);
+	pushCommand(command);
+}
+
+module.exports = updateField;

package/src/table/where.js

@@ -0,0 +1,12 @@
+const negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
+
+function newWhere(table) {
+
+	function where(fn) {
+		let arg = typeof fn === 'function' ? fn(table) : fn;
+		return negotiateRawSqlFilter(arg);
+	}
+	return where;
+}
+
+module.exports = newWhere;

package/src/table.js

@@ -0,0 +1,174 @@
+const newColumn = require('./table/column/newColumn');
+const column = require('./table/column');
+const join = require('./table/join');
+const hasMany = require('./table/hasMany');
+const hasOne = require('./table/hasOne');
+const getMany = require('./table/getMany');
+const count = require('./table/count');
+const getManyDto = require('./table/getManyDto');
+const getById = require('./table/getById');
+const tryGetById = require('./table/tryGetById');
+const tryGetFirst = require('./table/tryGetFirstFromDb');
+const newCache = require('./table/newRowCache');
+const newContext = require('./newObject');
+const insert = require('./table/insert');
+const _delete = require('./table/delete');
+const cascadeDelete = require('./table/cascadeDelete');
+const createReadStream = require('./table/createReadStream');
+const createJSONReadStream = require('./table/createJSONReadStream');
+const getIdArgs = require('./table/getIdArgs');
+const patchTable = require('./patchTable');
+const newEmitEvent = require('./emitEvent');
+const hostLocal = require('./hostLocal');
+const getTSDefinition = require('./getTSDefinition');
+const where = require('./table/where');
+const aggregate = require('./table/aggregate');
+const groupBy = require('./table/groupBy');
+
+
+function _new(tableName) {
+	var table = newContext();
+	table._dbName = tableName;
+	table._primaryColumns = [];
+	table._aliases = new Set();
+	table._columns = [];
+	table._columnDiscriminators = [];
+	table._formulaDiscriminators = [];
+	table._relations = {};
+	table._cache = newCache(table);
+	table._emitChanged = newEmitEvent();
+
+	table.primaryColumn = function(columnName) {
+		var columnDef = newColumn(table, columnName);
+		columnDef.isPrimary = true;
+		table._primaryColumns.push(columnDef);
+		return column(columnDef, table);
+	};
+
+	table.column = function(columnName) {
+		var columnDef = newColumn(table, columnName);
+		return column(columnDef, table);
+	};
+
+	table.join = function(relatedTable) {
+		return join(table, relatedTable);
+	};
+
+	table.hasMany = function(joinRelation) {
+		return hasMany(joinRelation);
+	};
+
+	table.hasOne = function(joinRelation) {
+		return hasOne(joinRelation);
+	};
+
+	table.count = function(filter) {
+		return Promise.resolve().then(() => count(table, filter));
+	};
+
+	table.getMany = function(filter, strategy) {
+		return Promise.resolve().then(() => getMany(table, filter, strategy));
+	};
+	table.getManyDto = function(filter, strategy) {
+		return Promise.resolve().then(() => getManyDto(table, filter, strategy));
+	};
+
+	table.aggregate = function(filter, strategy) {
+		return groupBy(table, filter, strategy);
+	};
+
+	table.getMany.exclusive = function(filter, strategy) {
+		return Promise.resolve().then(() => getMany.exclusive(table, filter, strategy));
+	};
+
+	table.tryGetFirst = function(filter, strategy) {
+		return Promise.resolve().then(() => tryGetFirst(table, filter, strategy));
+	};
+	table.tryGetFirst.exclusive = function(filter, strategy) {
+		return Promise.resolve().then(() => tryGetFirst.exclusive(table, filter, strategy));
+	};
+	table.getOne = table.tryGetFirst;
+	table.getOne.exclusive = table.tryGetFirst.exclusive;
+
+	function callAsync(func, args) {
+		return Promise.resolve().then(() => call(func, args));
+	}
+
+	function call(func, args) {
+		var mergedArgs = [table];
+		for (var i = 0; i < args.length; i++) {
+			mergedArgs.push(args[i]);
+		}
+		return func.apply(null, mergedArgs);
+	}
+
+	table.getById = function() {
+		return callAsync(getById, getIdArgs(table, arguments));
+	};
+
+	table.getById.exclusive = function() {
+
+		return callAsync(getById.exclusive, getIdArgs(table, arguments));
+	};
+
+	table.tryGetById = function() {
+		return callAsync(tryGetById, getIdArgs(table, arguments));
+	};
+
+	table.tryGetById.exclusive = function() {
+		return callAsync(tryGetById.exclusive, getIdArgs(table, arguments));
+	};
+
+	table.columnDiscriminators = function() {
+		for (var i = 0; i < arguments.length; i++) {
+			table._columnDiscriminators.push(arguments[i]);
+		}
+		return table;
+	};
+
+	table.formulaDiscriminators = function() {
+		for (var i = 0; i < arguments.length; i++) {
+			table._formulaDiscriminators.push(arguments[i]);
+		}
+		return table;
+	};
+
+	table.insert = function() {
+		const concurrency = undefined;
+		let args = [{table, concurrency}].concat([].slice.call(arguments));
+		return insert.apply(null, args);
+	};
+
+	table.insertWithConcurrency = function(options, ...rows) {
+		let args = [{table, options}].concat([].slice.call(rows));
+		return insert.apply(null, args);
+	};
+
+	table.delete = _delete.bind(null, table);
+	table.cascadeDelete = cascadeDelete.bind(null, table);
+	table.deleteCascade = cascadeDelete.bind(null, table);
+	table.createReadStream = createReadStream.bind(null, table);
+	table.createJSONReadStream = createJSONReadStream.bind(null, table);
+	table.exclusive = function() {
+		table._exclusive = true;
+		return table;
+	};
+	table.patch = patchTable.bind(null, table);
+	table.subscribeChanged = table._emitChanged.add;
+	table.unsubscribeChanged = table._emitChanged.remove;
+
+	table.hostLocal = function(options) {
+		return hostLocal({table, ...options});
+	};
+
+	table.ts = function(name) {
+		return getTSDefinition(table, {name});
+	};
+
+	table.where = where(table);
+	table._aggregate = aggregate(table);
+
+	return table;
+}
+
+module.exports = _new;

package/src/tedious/deleteFromSql.js

@@ -0,0 +1,8 @@
+var format = 'delete %s from %s as %s%s';
+var util = require('util');
+
+function deleteFromSql(table, alias, whereSql) {
+	var name = table._dbName;
+	return util.format(format, alias, name, alias, whereSql);
+}
+module.exports = deleteFromSql;

package/src/tedious/encodeBoolean.js

@@ -0,0 +1,7 @@
+function encodeBoolean(bool) {
+	if (bool)
+		return 1;
+	return 0;
+}
+
+module.exports = encodeBoolean;

package/src/tedious/encodeBuffer.js

@@ -0,0 +1,7 @@
+//unused because using sql parameters instead
+//Remove ?
+function encodeBuffer(buffer) {
+	return 'E\'\\\\x' + buffer.toString('hex') + '\'';
+}
+
+module.exports = encodeBuffer;