orange-orm 4.7.17 → 4.8.1

package/src/mssql/wrapCommand.js

@@ -0,0 +1,129 @@
+var log = require('../table/log');
+var getSessionSingleton = require('../table/getSessionSingleton');
+
+function wrapCommand(_context, connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = query.sql();
+		log.emitQuery({ sql, parameters: params });
+
+		const replacements = [];
+		const parametersToRemove = [];
+		const engine = getSessionSingleton(_context, 'engine');
+
+		if (engine === 'sap') {
+			const sap = connection.msnodesqlv8;
+
+			const isStoredProcCall = /EXECUTE\s+/i.test(sql) || /EXEC\s+/i.test(sql);
+			let hexVariables = [];
+
+			for (let i = 0; i < params.length; i++) {
+				const parameter = params[i];
+
+				if (typeof parameter === 'string') {
+					const byteLength = Buffer.from(parameter, 'utf8').length;
+
+					if (hasNonAsciiCharacters(parameter)) {
+						const hexValue = stringToHex(parameter);
+
+						if (isStoredProcCall) {
+							const varName = `@hex_param_${i}`;
+							const convertClause = `CONVERT(VARCHAR(${byteLength}), CONVERT(VARBINARY(${byteLength}), 0x${hexValue}))`;
+
+							hexVariables.push({
+								declaration: `DECLARE ${varName} VARCHAR(${byteLength})`,
+								assignment: `SET ${varName} = ${convertClause}`
+							});
+
+							replacements.push({
+								index: i,
+								replacement: varName
+							});
+						} else {
+							const convertClause = `CONVERT(VARCHAR(${byteLength}), CONVERT(VARBINARY(${byteLength}), 0x${hexValue}))`;
+							replacements.push({
+								index: i,
+								replacement: convertClause
+							});
+						}
+						parametersToRemove.push(i);
+					} else {
+						params[i] = sap.VarChar(parameter, byteLength);
+					}
+				}
+			}
+
+			if (replacements.length > 0) {
+				let questionMarkIndex = 0;
+				sql = sql.replace(/\?/g, (match) => {
+					const replacement = replacements.find(r => r.index === questionMarkIndex);
+					questionMarkIndex++;
+
+					if (replacement) {
+						return replacement.replacement;
+					}
+					return match;
+				});
+
+				if (isStoredProcCall && hexVariables.length > 0) {
+					const lines = sql.split('\n');
+					let insertIndex = 0;
+
+					for (let i = 0; i < lines.length; i++) {
+						if (/^\s*DECLARE\s+/i.test(lines[i])) {
+							insertIndex = i + 1;
+						}
+					}
+
+					const hexDeclarations = hexVariables.map(v => v.declaration);
+					const hexAssignments = hexVariables.map(v => v.assignment);
+
+					lines.splice(insertIndex, 0, ...hexDeclarations, ...hexAssignments);
+					sql = lines.join('\n');
+				}
+			}
+
+			parametersToRemove.reverse().forEach(index => {
+				params.splice(index, 1);
+			});
+		}
+
+		let affectedRows = 0;
+
+		const q = runOriginalQuery.call(connection, sql, params, onInnerCompleted);
+
+		if (q && typeof q.on === 'function') {
+			q.on('rowcount', (count) => {
+				if (typeof count === 'number') {
+					affectedRows += count;
+				}
+			});
+		}
+
+		function onInnerCompleted(err, _rows, hasMore) {
+			if (err) {
+				if (err.code && err.code !== 3604) {
+					onCompleted(err, { rowsAffected: 0 });
+					return;
+				}
+			}
+
+			if (!hasMore) {
+				onCompleted(null, { rowsAffected: affectedRows });
+			}
+		}
+	}
+}
+
+function hasNonAsciiCharacters(str) {
+	return /[\u0080-\uFFFF]/.test(str);
+}
+
+function stringToHex(str) {
+	return Buffer.from(str, 'utf8').toString('hex');
+}
+
+module.exports = wrapCommand;

package/src/mySql/newTransaction.js

@@ -1,4 +1,5 @@
 const wrapQuery = require('./wrapQuery');
+const wrapCommand = require('./wrapCommand');
 const encodeBoolean = require('./encodeBoolean');
 const deleteFromSql = require('./deleteFromSql');
 const selectForUpdateSql = require('./selectForUpdateSql');
@@ -51,6 +52,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;
@@ -67,6 +84,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/mySql/wrapCommand.js

@@ -0,0 +1,22 @@
+var log = require('../table/log');
+
+function wrapCommand(_context, connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = query.sql();
+		log.emitQuery({sql, parameters: params});
+		return runOriginalQuery.call(connection, sql, params, _onCompleted);
+
+		function _onCompleted(e, _result) {
+			const result = {rowsAffected: _result?.affectedRows, ..._result};
+			onCompleted(e, result);
+
+		}
+	}
+
+}
+
+module.exports = wrapCommand;

package/src/nodeSqlite/newTransaction.js

@@ -1,4 +1,5 @@
 const wrapQuery = require('./wrapQuery');
+const wrapCommand = require('./wrapCommand');
 const encodeBoolean = require('../sqlite/encodeBoolean');
 const encodeBinary = require('./encodeBinary');
 const decodeBinary = require('./decodeBinary');
@@ -56,6 +57,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;
@@ -72,6 +89,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/nodeSqlite/wrapCommand.js

@@ -0,0 +1,34 @@
+const log = require('../table/log');
+const connectionCache  = new WeakMap();
+
+function wrapCommand(_context, connection) {
+	let statementCache = connectionCache.get(connection);
+	if (!statementCache) {
+		statementCache = new Map();
+		connectionCache.set(connection, statementCache);
+	}
+
+	return runCommand;
+
+	function runCommand(query, onCompleted) {
+		try {
+			var params = query.parameters;
+			var sql = query.sql();
+			log.emitQuery({ sql, parameters: params });
+
+			let statement = statementCache.get(sql);
+			if (!statement) {
+				statement = connection.prepare(sql);
+				statementCache.set(sql, statement);
+			}
+			const info = statement.run.apply(statement, params);
+			onCompleted(null, { rowsAffected: info.changes, lastInsertRowid: info.lastInsertRowid });
+		}
+		catch (e) {
+			onCompleted(e);
+		}
+	}
+
+}
+
+module.exports = wrapCommand;

package/src/oracle/newTransaction.js

@@ -1,4 +1,5 @@
 const wrapQuery = require('./wrapQuery');
+const wrapCommand = require('./wrapCommand');
 const encodeBoolean = require('./encodeBoolean');
 const deleteFromSql = require('./deleteFromSql');
 const selectForUpdateSql = require('./selectForUpdateSql');
@@ -58,6 +59,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;
@@ -75,6 +92,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/oracle/wrapCommand.js

@@ -0,0 +1,37 @@
+var log = require('../table/log');
+var replaceParamChar = require('./replaceParamChar');
+
+function wrapCommand(_context, connection) {
+	var runOriginalQuery = connection.execute;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		log.emitQuery({ sql: query.sql(), parameters: params });
+
+		var sql = replaceParamChar(query, params);
+
+		runOriginalQuery.call(
+			connection,
+			sql,
+			params,
+			{
+				fetchTypeHandler: function(metaData) {
+					metaData.name = metaData.name.toLowerCase();
+				},
+			},
+			onInnerCompleted
+		);
+
+		function onInnerCompleted(err, result) {
+			if (err) return onCompleted(err);
+
+			var affectedRows =
+        typeof result.rowsAffected === 'number' ? result.rowsAffected : 0;
+
+			return onCompleted(null, { rowsAffected: affectedRows });
+		}
+	}
+}
+
+module.exports = wrapCommand;

package/src/patchTable.js

@@ -1,21 +1,23 @@
 /* eslint-disable require-atomic-updates */
 let applyPatch = require('./applyPatch');
 let fromCompareObject = require('./fromCompareObject');
-let validateDeleteConflict = require('./validateDeleteConflict');
 let validateDeleteAllowed = require('./validateDeleteAllowed');
 let clearCache = require('./table/clearCache');
+const getSessionSingleton = require('./table/getSessionSingleton');
+
 
 async function patchTable() {
 	// const dryrun = true;
 	//traverse all rows you want to update before updatinng or inserting anything.
 	//this is to avoid page locks in ms sql
 	// await patchTableCore.apply(null, [...arguments, dryrun]);
-	const result = await  patchTableCore.apply(null, arguments);
+	const result = await patchTableCore.apply(null, arguments);
 	clearCache(arguments[0]);
 	return result;
 }
 
 async function patchTableCore(context, table, patches, { strategy = undefined, deduceStrategy = false, ...options } = {}, dryrun) {
+	const engine = getSessionSingleton(context, 'engine');
 	options = cleanOptions(options);
 	strategy = JSON.parse(JSON.stringify(strategy || {}));
 	let changed = new Set();
@@ -59,10 +61,11 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 		let property = path[0];
 		path = path.slice(1);
 		if (!row && path.length > 0) {
-			const key = toKey(property);
-			row =  await table.tryGetById.apply(null, [context, ...key, strategy]);
-			if (!row)
-				throw new Error(`Row ${table._dbName} with id ${key} was not found.`);
+			row = await getOrCreateRow({
+				table,
+				strategy,
+				property
+			});
 		}
 
 		if (path.length === 0 && value === null) {
@@ -114,10 +117,22 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 		if (isColumn(property, table)) {
 			if (dryrun)
 				return { updated: row };
+			const column = table[property];
+			const oldColumnValue = row[property];
 			let dto = {};
-			dto[property] = row[property];
-			let result = applyPatch({ options }, dto, [{ path: '/' + path.join('/'), op, value, oldValue }], table[property]);
-			row[property] = result[property];
+			dto[property] = oldColumnValue;
+			const _oldValue = fromCompareObject(oldValue);
+			const _value = fromCompareObject(value);
+			let result = applyPatch({ options, context }, dto, [{ path: '/' + path.join('/'), op, value, oldValue }], table[property]);
+
+			const patchInfo = column.tsType === 'JSONColumn' ? {
+				path,
+				op,
+				value: _value,
+				oldValue : _oldValue,
+				fullOldValue: oldColumnValue
+			} : undefined;
+			await table.updateWithConcurrency(context, options, row, property, result[property], _oldValue, patchInfo);
 			return { updated: row };
 		}
 		else if (isOneRelation(property, table)) {
@@ -216,19 +231,34 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 	async function remove({ path, op, oldValue, options }, table, row) {
 		let property = path[0];
 		path = path.slice(1);
-		row = row || await table.getById.apply(null, [context, ...toKey(property)]);
+		if (!row)
+			row = await getOrCreateRow({ table, strategy: {}, property });
 		if (path.length === 0) {
 			await validateDeleteAllowed({ row, options, table });
-			if (await validateDeleteConflict({ row, oldValue, options, table }))
-				await row.deleteCascade();
+			applyDeleteConcurrencyState(row, oldValue, options, table);
+			await row.deleteCascade();
 		}
 		property = path[0];
 		if (isColumn(property, table)) {
+			const column = table[property];
+			const oldColumnValue = row[property];
 			let dto = {};
-			dto[property] = row[property];
-			let result = applyPatch({ options }, dto, [{ path: '/' + path.join('/'), op, oldValue }], table[property]);
+			dto[property] = oldColumnValue;
+			const _oldValue = fromCompareObject(oldValue);
 
-			row[property] = result[property];
+			let result = applyPatch({ options, context }, dto, [{ path: '/' + path.join('/'), op, oldValue }], table[property]);
+			if (column.tsType === 'JSONColumn') {
+				const patchInfo = {
+					path,
+					op,
+					value: undefined,
+					oldValue: _oldValue,
+					fullOldValue: oldColumnValue
+				};
+				await table.updateWithConcurrency(context, options, row, property, result[property], _oldValue, patchInfo);
+			}
+			else
+				row[property] = result[property];
 			return { updated: row };
 		}
 		else if (isJoinRelation(property, table) && path.length === 1) {
@@ -290,6 +320,40 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 		return table[name] && table[name].equal;
 	}
 
+	function shouldFetchFromDb(table) {
+		return engine === 'sap'
+			&& table._columns.some(x => x.tsType === 'JSONColumn');
+	}
+
+
+	function getOrCreateRow({ table, strategy, property }) {
+		const key = toKey(property);
+
+		if (shouldFetchFromDb(table))
+			return fetchFromDb({context, table, strategy, key});
+		return createRowInCache({ context, table, key });
+	}
+
+	async function fetchFromDb({context, table, strategy, key}) {
+		const row = await table.tryGetById.apply(null, [context, ...key, strategy]);
+		if (!row)
+			throw new Error(`Row ${table._dbName} with id ${key} was not found.`);
+		return row;
+
+	}
+
+
+
+	function createRowInCache({ context, table, key }) {
+		const newRow = getOrCreateRow.cachedNewRow || (getOrCreateRow.cachedNewRow = require('./table/commands/newRow'));
+		const pkDto = {};
+		for (let i = 0; i < key.length && i < table._primaryColumns.length; i++) {
+			pkDto[table._primaryColumns[i].alias] = key[i];
+		}
+		let row = newRow(context, { table, shouldValidate: false }, pkDto);
+		return table._cache.tryAdd(context, row);
+	}
+
 	function isManyRelation(name, table) {
 		return table[name] && table[name]._relation.isMany;
 	}
@@ -303,6 +367,32 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 		return table[name] && table[name]._relation.columns;
 	}
 
+	function applyDeleteConcurrencyState(row, oldValue, options, table) {
+		const state = { columns: {} };
+		if (oldValue && oldValue === Object(oldValue)) {
+			for (let p in oldValue) {
+				if (!isColumn(p, table))
+					continue;
+				const columnOptions = inferOptions(options, p);
+				const concurrency = columnOptions.concurrency || 'optimistic';
+				if (concurrency === 'overwrite')
+					continue;
+				state.columns[p] = { oldValue: fromCompareObject(oldValue[p]), concurrency };
+			}
+		}
+		if (Object.keys(state.columns).length === 0) {
+			const concurrency = options.concurrency || 'optimistic';
+			if (concurrency !== 'overwrite') {
+				for (let i = 0; i < table._primaryColumns.length; i++) {
+					const pkName = table._primaryColumns[i].alias;
+					state.columns[pkName] = { oldValue: row[pkName], concurrency };
+				}
+			}
+		}
+		if (Object.keys(state.columns).length > 0)
+			row._concurrencyState = state;
+	}
+
 	function inferOptions(defaults, property) {
 		const parent = {};
 		if ('readonly' in defaults)
@@ -313,9 +403,9 @@ async function patchTableCore(context, table, patches, { strategy = undefined, d
 	}
 
 	function cleanOptions(options) {
-		const { table, transaction, db, ..._options } = options;
+		const { table, transaction, db, client, ..._options } = options;
 		return _options;
 	}
 }
 
-module.exports = patchTable;
+module.exports = patchTable;

package/src/pg/newTransaction.js

@@ -1,4 +1,5 @@
 var wrapQuery = require('./wrapQuery');
+var wrapCommand = require('./wrapCommand');
 var encodeDate = require('./encodeDate');
 var encodeBoolean = require('./encodeBoolean');
 var deleteFromSql = require('./deleteFromSql');
@@ -53,6 +54,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;
@@ -69,6 +86,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/pg/wrapCommand.js

@@ -0,0 +1,31 @@
+var log = require('../table/log');
+var replaceParamChar = require('./replaceParamChar');
+
+function wrapCommand(_context, connection) {
+	var runOriginalQuery = connection.query;
+	return runCommand;
+
+	function runCommand(query, onCompleted) {
+		var params = query.parameters;
+		log.emitQuery({sql: query.sql(), parameters: params});
+		var sql = replaceParamChar(query, params);
+		query = {
+			text: sql,
+			values: params,
+			types: query.types
+		};
+
+		runOriginalQuery.call(connection, query, onInnerCompleted);
+
+		function onInnerCompleted(err, result) {
+			if (err)
+				onCompleted(err);
+			else
+				onCompleted(null, { rowsAffected: result.rowCount });
+
+		}
+	}
+
+}
+
+module.exports = wrapCommand;

package/src/pglite/newTransaction.js

@@ -1,4 +1,5 @@
 var wrapQuery = require('./wrapQuery');
+var wrapCommand = require('./wrapCommand');
 var encodeDate = require('../pg/encodeDate');
 const encodeBinary = require('../nodeSqlite/encodeBinary');
 const decodeBinary = require('../nodeSqlite/decodeBinary');
@@ -51,6 +52,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;
@@ -67,6 +84,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/pglite/wrapCommand.js

@@ -0,0 +1,30 @@
+var log = require('../table/log');
+var replaceParamChar = require('../pg/replaceParamChar');
+
+function wrapCommand(_context, connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = replaceParamChar(query, params);
+		log.emitQuery({ sql, parameters: params });
+
+		runOriginalQuery
+			.call(connection, sql, params)
+			.then(
+				(result) => onInnerCompleted(null, result),
+				(e) => onInnerCompleted(e)
+			);
+
+		function onInnerCompleted(err, result) {
+			if (err) return onCompleted(err);
+
+			if (Array.isArray(result)) result = result[result.length - 1];
+
+			onCompleted(null, { rowsAffected: result.affectedRows });
+		}
+	}
+}
+
+module.exports = wrapCommand;