orange-orm 4.8.0 → 4.8.2

package/src/table/executeQueries/resolveExecuteQuery.js

@@ -1,4 +1,5 @@
 const getSessionSingleton = require('../getSessionSingleton');
+const negotiateNullParams = require('./negotiateNullParams');
 
 function resolveExecuteQuery(context, query) {
 	return resolve;
@@ -22,29 +23,6 @@ function resolveExecuteQuery(context, query) {
 
 }
 
-function negotiateNullParams(query) {
-	if (query && query.parameters && query.parameters.length > 0 && (query.parameters.filter(x => x === null || x === undefined).length > 0)) {
-		var splitted = query.sql().split('?');
-		var sql = '';
-		var parameters = [];
-		var lastIndex = splitted.length - 1;
-		for (var i = 0; i < lastIndex; i++) {
-			if (query.parameters[i] === null || query.parameters[i] === undefined)
-				sql += splitted[i] + 'null';
-			else {
-				sql += splitted[i] + '?';
-				parameters.push(query.parameters[i]);
-			}
-		}
-		sql += splitted[lastIndex];
-		return {
-			sql: () => sql,
-			parameters
-		};
 
-	}
-	else
-		return query;
-}
 
 module.exports = resolveExecuteQuery;

package/src/table/isJsonUpdateSupported.js

@@ -0,0 +1,5 @@
+function isJsonUpdateSupported(engine) {
+	return engine === 'pg' || engine === 'mysql' || engine === 'sqlite' || engine === 'mssql' || engine === 'mssqlNative' || engine === 'oracle';
+}
+
+module.exports = isJsonUpdateSupported;

package/src/table/resultToRows/decodeDbRow.js

@@ -1,7 +1,18 @@
 var newDecodeDbRow = require('./newDecodeDbRow');
 
 function decodeDbRow(context, span, table, dbRow, shouldValidate, isInsert) {
-	var decode = span._decodeDbRow;
+	var decodeCache = span._decodeDbRowCache;
+	if (!decodeCache) {
+		decodeCache = {};
+		Object.defineProperty(span, '_decodeDbRowCache', {
+			enumerable: false,
+			get: function() {
+				return decodeCache;
+			},
+		});
+	}
+	var cacheKey = (shouldValidate ? 'v' : 'nv') + (isInsert ? ':i' : ':u');
+	var decode = decodeCache[cacheKey];
 	if (!decode) {
 		let aliases = new Set();
 		if (span.columns)
@@ -12,12 +23,7 @@ function decodeDbRow(context, span, table, dbRow, shouldValidate, isInsert) {
 		if (aliases.size === 0)
 			aliases = undefined;
 		decode = newDecodeDbRow(table, dbRow, aliases, shouldValidate, isInsert);
-		Object.defineProperty(span, '_decodeDbRow', {
-			enumerable: false,
-			get: function() {
-				return decode;
-			},
-		});
+		decodeCache[cacheKey] = decode;
 	}
 	return decode(context, dbRow);
 }

package/src/table/resultToRows/delete.js

@@ -14,11 +14,25 @@ function _delete(context, row, strategy, table) {
 		args.push(row[primary.alias]);
 	});
 	var filter = newPrimaryKeyFilter.apply(null, args);
-	var cmds = newDeleteCommand(context, [], table, filter, strategy, relations);
+	var concurrencyState = row._concurrencyState;
+	delete row._concurrencyState;
+	var cmds = newDeleteCommand(context, [], table, filter, strategy, relations, concurrencyState);
 	cmds.forEach(function(cmd) {
 		pushCommand(context, cmd);
 	});
 	var cmd = cmds[0];
+	var concurrencySummary = summarizeConcurrency(concurrencyState);
+	if (concurrencySummary.hasConcurrency) {
+		var deleteCmd = cmds[cmds.length - 1];
+		deleteCmd.onResult = function(result) {
+			var rowCount = extractRowCount(result);
+			if (rowCount === undefined)
+				return;
+			if (rowCount === 0 && concurrencySummary.hasOptimistic) {
+				throw new Error('The row was changed by another user.');
+			}
+		};
+	}
 	if (table._emitChanged.callbacks.length > 0) {
 		cmd.disallowCompress = true;
 		var dto = createDto(table, row);
@@ -28,4 +42,31 @@ function _delete(context, row, strategy, table) {
 
 }
 
-module.exports = _delete;
+function summarizeConcurrency(concurrencyState) {
+	const summary = { hasConcurrency: false, hasOptimistic: false };
+	if (!concurrencyState || !concurrencyState.columns)
+		return summary;
+	for (let name in concurrencyState.columns) {
+		const state = concurrencyState.columns[name];
+		if (!state)
+			continue;
+		const strategy = state.concurrency || 'optimistic';
+		if (strategy === 'overwrite')
+			continue;
+		summary.hasConcurrency = true;
+		if (strategy === 'optimistic')
+			summary.hasOptimistic = true;
+	}
+	return summary;
+}
+
+function extractRowCount(result) {
+	if (Array.isArray(result) && typeof result[0].rowsAffected === 'number')
+		return result[0].rowsAffected;
+	if (!result || typeof result !== 'object')
+		return;
+	if (typeof result.rowsAffected === 'number')
+		return result.rowsAffected;
+}
+
+module.exports = _delete;

package/src/table/resultToRows/newDecodeDbRow.js

@@ -7,7 +7,6 @@ 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');
@@ -78,7 +77,7 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 				return negotiateNull(this[intName]);
 			},
 			set: function(value) {
-				if (column.onChange && (this[intName] !== null && this[intName] !== undefined) && typeof value === 'object') {
+				if (column.onChange && (this[intName] !== null && this[intName] !== undefined) && value && typeof value === 'object') {
 					if (this[intName] === onChange.target(value))
 						return;
 					this._proxies[name] = column.onChange(value, () => {
@@ -198,11 +197,6 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 
 	Row.prototype.deleteCascade = Row.prototype.cascadeDelete;
 
-	Row.prototype.patch = async function(patches, options) {
-		await patchRow(this._context, table, this, patches, options);
-		return this;
-	};
-
 	function decodeDbRow(context, row) {
 		for (let i = 0; i < numberOfColumns; i++) {
 			let index = offset + i;

package/src/table.js

@@ -17,6 +17,8 @@ const cascadeDelete = require('./table/cascadeDelete');
 const patchTable = require('./patchTable');
 const newEmitEvent = require('./emitEvent');
 const hostLocal = require('./hostLocal');
+const getSessionSingleton = require('./table/getSessionSingleton');
+const isJsonUpdateSupported = require('./table/isJsonUpdateSupported');
 // const getTSDefinition = require('./getTSDefinition'); //todo: unused ?
 const where = require('./table/where');
 const aggregate = require('./table/aggregate');
@@ -141,6 +143,55 @@ function _new(tableName) {
 		return insert.apply(null, args);
 	};
 
+	table.updateWithConcurrency = function(context, options, row, property, value, oldValue, patchInfo) {
+		options = options || {};
+		const columnOptions = inferColumnOptions(options, property);
+		const concurrency = columnOptions.concurrency || 'optimistic';
+		const column = table[property];
+
+		if (patchInfo && column && column.tsType === 'JSONColumn' && Array.isArray(patchInfo.path) && patchInfo.path.length > 1) {
+			const engine = getSessionSingleton(context, 'engine');
+			if (isJsonUpdateSupported(engine)) {
+				const jsonPath = patchInfo.path.slice(1);
+				const jsonUpdateState = row._jsonUpdateState || {};
+				const columnState = jsonUpdateState[property] || { patches: [] };
+				columnState.patches.push({
+					path: jsonPath,
+					op: patchInfo.op,
+					value: patchInfo.value,
+					oldValue: patchInfo.oldValue
+				});
+				jsonUpdateState[property] = columnState;
+				row._jsonUpdateState = jsonUpdateState;
+				if (concurrency !== 'overwrite') {
+					const state = row._concurrencyState || { columns: {} };
+					const columnConcurrency = state.columns[property] || {};
+					columnConcurrency.concurrency = concurrency;
+					columnConcurrency.paths = columnConcurrency.paths || [];
+					columnConcurrency.paths.push({
+						path: jsonPath,
+						oldValue: patchInfo.oldValue
+					});
+					delete columnConcurrency.oldValue;
+					state.columns[property] = columnConcurrency;
+					row._concurrencyState = state;
+				}
+			}
+			else if (concurrency !== 'overwrite') {
+				const state = row._concurrencyState || { columns: {} };
+				const fullOldValue = Object.prototype.hasOwnProperty.call(patchInfo, 'fullOldValue') ? patchInfo.fullOldValue : oldValue;
+				state.columns[property] = { oldValue: fullOldValue, concurrency };
+				row._concurrencyState = state;
+			}
+		}
+		else if (concurrency !== 'overwrite') {
+			const state = row._concurrencyState || { columns: {} };
+			state.columns[property] = { oldValue, concurrency };
+			row._concurrencyState = state;
+		}
+		row[property] = value;
+	};
+
 	table.delete = _delete.bind(null, table);
 	table.cascadeDelete = function(context, ...rest) {
 		const args = [context, table, ...rest];
@@ -174,4 +225,15 @@ function _new(tableName) {
 	return table;
 }
 
+function inferColumnOptions(defaults, property) {
+	const parent = {};
+	if (!defaults)
+		return parent;
+	if ('readonly' in defaults)
+		parent.readonly = defaults.readonly;
+	if ('concurrency' in defaults)
+		parent.concurrency = defaults.concurrency;
+	return { ...parent, ...(defaults[property] || {}) };
+}
+
 module.exports = _new;

package/src/tedious/newTransaction.js

@@ -1,4 +1,5 @@
 var wrapQuery = require('./wrapQuery');
+var wrapCommand = require('./wrapCommand');
 var encodeBoolean = require('./encodeBoolean');
 var deleteFromSql = require('./deleteFromSql');
 var selectForUpdateSql = require('./selectForUpdateSql');
@@ -65,6 +66,22 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 						callback(e);
 					}
 				});
+			},
+			executeCommand: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapCommand(domain, client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
 			}
 		};
 		domain.rdb = rdb;
@@ -81,6 +98,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 					return;
 				}
 				client.executeQuery = wrapQuery(domain, client);
+				client.executeCommand = wrapCommand(domain, client);
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
 				domain.rdb = rdb;

package/src/tedious/wrapCommand.js

@@ -0,0 +1,121 @@
+var log = require('../table/log');
+
+function wrapCommand(_context, connection) {
+	let CachedRequest = null;
+	let CachedTypes = null;
+
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		if (!CachedRequest || !CachedTypes) {
+			import('tedious')
+				.then(({ Request, TYPES }) => {
+					CachedRequest = Request;
+					CachedTypes = TYPES;
+					doQuery(query, onCompleted);
+				})
+				.catch((err) => onCompleted(extractError(err), { rowsAffected: 0 }));
+		} else {
+			doQuery(query, onCompleted);
+		}
+	}
+
+	function doQuery(query, onCompleted) {
+		log.emitQuery({ sql: query.sql(), parameters: query.parameters });
+		const sql = replaceParamChar(query.sql(), query.parameters);
+
+		if (sql.length < 18 && query.parameters.length === 0) {
+			if (sql === 'BEGIN TRANSACTION') {
+				connection.beginTransaction((err) => {
+					if (err) return onCompleted(extractError(err), { rowsAffected: 0 });
+					return onCompleted(null, { rowsAffected: 0 });
+				});
+				return;
+			} else if (sql === 'COMMIT') {
+				connection.commitTransaction((err) => {
+					if (err) return onCompleted(extractError(err), { rowsAffected: 0 });
+					return onCompleted(null, { rowsAffected: 0 });
+				});
+				return;
+			} else if (sql === 'ROLLBACK') {
+				connection.rollbackTransaction((err) => {
+					if (err) return onCompleted(extractError(err), { rowsAffected: 0 });
+					return onCompleted(null, { rowsAffected: 0 });
+				});
+				return;
+			}
+		}
+
+		let affectedRows = 0;
+
+		var request = new CachedRequest(sql, onInnerCompleted);
+		addParameters(request, query.parameters, CachedTypes);
+
+		request.on('doneInProc', (rowCount) => {
+			if (typeof rowCount === 'number') affectedRows += rowCount;
+		});
+
+		request.on('doneProc', (rowCount) => {
+			if (typeof rowCount === 'number') affectedRows += rowCount;
+		});
+
+		request.on('done', (rowCount) => {
+			if (typeof rowCount === 'number') affectedRows += rowCount;
+		});
+
+		connection.execSql(request);
+
+		function onInnerCompleted(err) {
+			if (err) return onCompleted(extractError(err), { rowsAffected: 0 });
+			return onCompleted(null, { rowsAffected: affectedRows });
+		}
+	}
+}
+
+function extractError(e) {
+	if (e && e.errors) {
+		return e.errors[0];
+	} else {
+		return e;
+	}
+}
+
+function replaceParamChar(sql, params) {
+	if (params.length === 0) return sql;
+	var splitted = sql.split('?');
+	sql = '';
+	var lastIndex = splitted.length - 1;
+	for (var i = 0; i < lastIndex; i++) {
+		sql += splitted[i] + '@' + i;
+	}
+	sql += splitted[lastIndex];
+	return sql;
+}
+
+function addParameters(request, params, TYPES) {
+	const res = [];
+	for (let i = 0; i < params.length; i++) {
+		const p = [`${i}`, toType(params[i]), params[i]];
+		request.addParameter.apply(request, p);
+		res.push(p);
+	}
+	return res;
+
+	function toType(p) {
+		if (typeof p === 'string') return TYPES.VarChar;
+		else if (Number.isInteger(p)) {
+			if (p >= -2147483648 && p <= 2147483647) {
+				return TYPES.Int;
+			} else {
+				return TYPES.BigInt;
+			}
+		} else if (typeof p === 'number') return TYPES.Money;
+		else if (p instanceof Date && !isNaN(p)) return TYPES.Date;
+		else if (Array.isArray(p)) return TYPES.NVarChar;
+		else if (Buffer.isBuffer(p)) return TYPES.VarBinary;
+		else if (typeof p === 'object' && p instanceof Object) return TYPES.NVarChar;
+		else throw new Error('Unknown data type');
+	}
+}
+
+module.exports = wrapCommand;

package/src/validateDeleteAllowed.js

@@ -5,12 +5,14 @@ async function validateDeleteAllowed({ row, options, table }) {
 		e.status = 405;
 		throw e;
 	}
-	for (let p in options)
-		if (isColumn(p, table))
-			return;
-		else if (isManyRelation(p, table)) {
+	if (!hasReadonlyTrue(options))
+		return;
+	for (let p in options) {
+		if (isManyRelation(p, table)) {
 			const childTable = table[p]._relation.childTable;
 			const childOptions = inferOptions(options, p);
+			if (!hasReadonlyTrue(childOptions))
+				continue;
 			const children = await row[p];
 			for (let i = 0; i < children.length; i++) {
 				const childRow = children[i];
@@ -19,22 +21,22 @@ async function validateDeleteAllowed({ row, options, table }) {
 		}
 		else if (isOneRelation(p, table)) {
 			const childOptions = inferOptions(options, p);
+			if (!hasReadonlyTrue(childOptions))
+				continue;
 			const childTable = table[p]._relation.childTable;
 			let childRow = await row[p];
 			await validateDeleteAllowed({ row: childRow, options: childOptions, table: childTable });
 		}
+	}
 }
 
-function isColumn(name, table) {
-	return table[name] && table[name].equal;
-}
 
 function isManyRelation(name, table) {
-	return table[name] && table[name]._relation.isMany;
+	return table[name] && table[name]._relation && table[name]._relation.isMany;
 }
 
 function isOneRelation(name, table) {
-	return table[name] && table[name]._relation.isOne;
+	return table[name] && table[name]._relation && table[name]._relation.isOne;
 }
 
 function inferOptions(defaults, property) {
@@ -46,4 +48,19 @@ function inferOptions(defaults, property) {
 	return {...parent,  ...(defaults[property] || {})};
 }
 
-module.exports = validateDeleteAllowed;
+function hasReadonlyTrue(options) {
+	if (!options || options !== Object(options))
+		return false;
+	if (options.readonly === true)
+		return true;
+	for (let p in options) {
+		const value = options[p];
+		if (!value || value !== Object(value))
+			continue;
+		if (hasReadonlyTrue(value))
+			return true;
+	}
+	return false;
+}
+
+module.exports = validateDeleteAllowed;

package/src/patchRow.js

@@ -1,13 +0,0 @@
-let patchTable = require('./patchTable');
-
-function patchRow(context, table, row, patches, options) {
-	patches = JSON.parse(JSON.stringify(patches));
-	let pkName = table._primaryColumns[0].alias;
-	let id = row[pkName];
-	for (let i = 0; i < patches.length; i++) {
-		patches[i].path = '/' + id + patches[i].path;
-	}
-	return patchTable(context, table, patches, options);
-}
-
-module.exports = patchRow;

package/src/table/insertDefault.js

@@ -1,88 +0,0 @@
-let getSessionContext = require('./getSessionContext');
-let executeQueries = require('./executeQueries');
-let newRow = require('./commands/newRow');
-let newInsertCommand = require('./commands/newInsertCommand');
-let newInsertCommandCore = require('./commands/newInsertCommandCore');
-let newGetLastInsertedCommand = require('./commands/newGetLastInsertedCommand');
-let pushCommand = require('./commands/pushCommand');
-
-function insert({table, options}, arg) {
-	if (Array.isArray(arg)) {
-		let all = [];
-		for (let i = 0; i < arg.length; i++) {
-			all.push(insert(table, arg[i]));
-		}
-		return Promise.all(all);
-	}
-	let args = [table].slice.call(arguments);
-	let row = newRow.apply(null, args);
-	let hasPrimary = getHasPrimary(table, row);
-	if (hasPrimary)
-		row = table._cache.tryAdd(row);
-	let cmd = newInsertCommand(newInsertCommandCore, table, row, options);
-
-	pushCommand(cmd);
-	expand(table, row);
-	Object.defineProperty(row, 'then', {
-		value: then,
-		writable: true,
-		enumerable: false,
-		configurable: true
-	});
-
-	let selectCmd;
-	if (getSessionContext().lastInsertedIsSeparate) {
-		selectCmd = newGetLastInsertedCommand(table, row, cmd);
-		pushCommand(selectCmd);
-		selectCmd.onResult = onResult;
-	}
-	else {
-		cmd.onResult = onResult;
-		cmd.disallowCompress = true;
-	}
-
-	return row;
-	function then(fn,efn) {
-		delete row.then;
-		return executeQueries([]).then(() => fn(row), efn);
-	}
-
-	function onResult([result]) {
-		row.hydrate(result);
-		if (!hasPrimary)
-			row = table._cache.tryAdd(row);
-		table._cache.tryAdd(row);
-	}
-}
-
-function expand(table, row) {
-	let relationName;
-	let visitor = {};
-	visitor.visitJoin = function() { };
-
-	visitor.visitMany = function() {
-		row.expand(relationName);
-	};
-
-	visitor.visitOne = function() {
-		row.expand(relationName);
-	};
-
-	for (relationName in table._relations) {
-		let relation = table._relations[relationName];
-		relation.accept(visitor);
-	}
-
-}
-
-function getHasPrimary(table, row) {
-	for (let i = 0; i < table._primaryColumns.length; i++) {
-		let column = table._primaryColumns[i];
-		if (row[column.alias] === null)
-			return;
-	}
-	return true;
-
-}
-
-module.exports = insert;

package/src/validateDeleteConflict.js

@@ -1,98 +0,0 @@
-// @ts-nocheck
-/* eslint-disable */
-const toCompareObject = require('./toCompareObject');
-
-async function validateDeleteConflict({ row, oldValue, options, table }) {
-	for (let p in oldValue) {
-		if (isColumn(p, table)) {
-			const option = inferOptions(options, p);
-			let strategy = option.concurrency || 'optimistic';
-			if ((strategy === 'optimistic')) {
-				try {
-					const column = table[p];
-					if (column?.tsType === 'DateColumn') {
-						assertDatesEqual(oldValue[p], toCompareObject(row[p]));
-					}
-					else
-						assertDeepEqual(oldValue[p], toCompareObject(row[p]));						
-				}
-				catch (e) {
-					throw new Error(`The field ${p} was changed by another user. Expected ${inspect(oldValue[p])}, but was ${inspect(row[p])}.`);
-				}
-			}
-		}
-		else if (isManyRelation(p, table)) {
-			const childTable = table[p]._relation.childTable;
-			for (let name in oldValue[p]) {
-				if (name === '__patchType')
-					continue;
-				let childRow = await childTable.tryGetById.apply(null, JSON.parse(name));
-				if (!childRow)
-					throw new Error(`${p} with id ${name} was deleted by another user`);
-				if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p][name], options: inferOptions(options, p), table: childTable }))
-					return false;
-			}
-		}
-		else if (isOneRelation(p, table)) {
-			const childTable = table[p]._relation.childTable;
-			let childRow = await row[p];
-			if (!childRow)
-				throw new Error(`${p} was deleted by another user`);
-			if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p], options: inferOptions(options, p), table: childTable }))
-				return false;
-		}
-
-	}
-	return true;
-}
-
-function isColumn(name, table) {
-	return table[name] && table[name].equal;
-}
-
-function isManyRelation(name, table) {
-	return table[name] && table[name]._relation.isMany;
-}
-
-function isOneRelation(name, table) {
-	return table[name] && table[name]._relation.isOne;
-
-}
-
-function inferOptions(defaults, property) {
-	const parent = {};
-	if ('readonly' in defaults)
-		parent.readonly = defaults.readonly;
-	if ('concurrency' in defaults)
-		parent.concurrency = defaults.concurrency;
-	return {...parent,  ...(defaults[property] || {})};
-}
-
-function assertDatesEqual(date1, date2) {
-	if (date1 && date2) {
-		const parts1 = date1.split('T');
-		const time1parts = (parts1[1] || '').split(/[-+.]/);
-		const parts2 = date2.split('T');
-		const time2parts = (parts2[1] || '').split(/[-+.]/);
-		while (time1parts.length !== time2parts.length) {
-			if (time1parts.length > time2parts.length)
-				time1parts.pop();
-			else if (time1parts.length < time2parts.length)
-				time2parts.pop();
-		}
-		date1 = `${parts1[0]}T${time1parts[0]}`;
-		date2 = `${parts2[0]}T${time2parts[0]}`;
-	}
-	assertDeepEqual(date1, date2);
-}
-
-function assertDeepEqual(a, b) {
-	if (JSON.stringify(a) !== JSON.stringify(b))
-		throw new Error('A, b are not equal');
-}
-
-function inspect(obj) {
-	return JSON.stringify(obj, null, 2);
-}
-
-module.exports = validateDeleteConflict;