orange-orm 4.5.0-beta.0 → 4.5.0-beta.2

package/src/oracle/insert.js

@@ -4,17 +4,17 @@ const setSessionSingleton = require('../table/setSessionSingleton');
 const newGetLastInsertedCommand = require('../table/commands/newGetLastInsertedCommand');
 const executeQueries = require('../table/executeQueries');
 
-function insert(table, row, options) {
+function insert(context, table, row, options) {
 
 	return new Promise((res, rej) => {
-		const cmd = newInsertCommand(newInsertCommandCore, table, row, options);
+		const cmd = newInsertCommand(newInsertCommandCore.bind(null, context), table, row, options);
 		cmd.disallowCompress = true;
-		executeQueries([cmd]).then((result) => result[0]).then(onResult).then(res, rej);
+		executeQueries(context, [cmd]).then((result) => result[0]).then(onResult).then(res, rej);
 
 		function onResult([result]) {
-			setSessionSingleton('lastRowid', result.lastRowid);
-			const selectCmd = newGetLastInsertedCommand(table, row, cmd);
-			return executeQueries([selectCmd]).then((result) => res(result[0]));
+			setSessionSingleton(context, 'lastRowid', result.lastRowid);
+			const selectCmd = newGetLastInsertedCommand(context, table, row, cmd);
+			return executeQueries(context, [selectCmd]).then((result) => res(result[0]));
 		}
 
 	});

package/src/oracle/insertSql.js

@@ -1,12 +1,11 @@
-let outputInsertedSql = require('./outputInsertedSql');
 let mergeSql = require('./mergeSql');
-const getSessionSingleton = require('../table/getSessionSingleton');
+const quote = require('./quote');
 
-function getSqlTemplate(_table, _row, options) {
+function getSqlTemplate(_context, _table, _row, options) {
 	if (hasConcurrency(_table, options) && hasColumns())
-		return mergeSql.apply(null, arguments);
+		return mergeSql.apply(null, [...arguments].slice(1));
 	else
-		return insertSql.apply(null, arguments);
+		return insertSql.apply(null, [...arguments].slice(1));
 
 	function hasColumns() {
 		for(let p in _row) {
@@ -27,7 +26,6 @@ function hasConcurrency(table,options) {
 }
 
 function insertSql(table, row) {
-	const quote = getSessionSingleton('quote');
 	let columnNames = [];
 	let regularColumnNames = [];
 	let values = [];
@@ -35,9 +33,9 @@ function insertSql(table, row) {
 	addDiscriminators();
 	addColumns();
 	if (columnNames.length === 0)
-		sql += `${outputInserted()} (${quote(table._primaryColumns[0]._dbName)}) VALUES(DEFAULT)`;
+		sql += ` (${quote(table._primaryColumns[0]._dbName)}) VALUES(DEFAULT)`;
 	else
-		sql = sql + '('+ columnNames.join(',') + ')' + outputInserted() +  'VALUES (' + values.join(',') + ')';
+		sql = sql + '('+ columnNames.join(',') + ')'  +  ' VALUES (' + values.join(',') + ')';
 	return sql;
 
 	function addDiscriminators() {
@@ -65,12 +63,6 @@ function insertSql(table, row) {
 		}
 	}
 
-
-	function outputInserted() {
-
-		return ' ' + outputInsertedSql(table) + ' ';
-	}
-
 }
 
 module.exports = getSqlTemplate;

package/src/oracle/lastInsertedSql.js

@@ -1,12 +1,12 @@
 let getSessionSingleton = require('../table/getSessionSingleton');
 
-function lastInsertedSql(table, keyValues) {
+function lastInsertedSql(context,table, keyValues) {
 	return keyValues.map((value,i) => {
 		let column = table._primaryColumns[i];
 		if (value === undefined)
-			return `ROWID='${getSessionSingleton('lastRowid')}'`;
+			return `ROWID='${getSessionSingleton(context, 'lastRowid')}'`;
 		else
-			return column.eq(value);
+			return column.eq(context, value);
 	});
 
 }

package/src/oracle/mergeSql.js

@@ -1,8 +1,6 @@
-const outputInsertedSql = require('./outputInsertedSql');
-const getSessionSingleton = require('../table/getSessionSingleton');
+const quote = require('./quote');
 
 function insertSql(table, row, options) {
-	const quote = getSessionSingleton('quote');
 	let columnNames = [];
 	let regularColumnNames = [];
 	let conflictColumnUpdateSql = '';
@@ -13,9 +11,9 @@ function insertSql(table, row, options) {
 	const matched = whenMatched();
 	let sql;
 	if (matched)
-		sql = `MERGE INTO ${quote(table._dbName)} target USING (SELECT ${values.join(',')} FROM DUAL) source ON (${join()}) WHEN MATCHED THEN ${matched} WHEN NOT MATCHED THEN ${whenNotMatched()} ${outputInsertedSql(table)}`;
+		sql = `MERGE INTO ${quote(table._dbName)} target USING (SELECT ${values.join(',')} FROM DUAL) source ON (${join()}) WHEN MATCHED THEN ${matched} WHEN NOT MATCHED THEN ${whenNotMatched()}`;
 	else
-		sql = `MERGE INTO ${quote(table._dbName)} target USING (SELECT ${values.join(',')} FROM DUAL) source ON (${join()}) WHEN NOT MATCHED THEN ${whenNotMatched()} ${outputInsertedSql(table)}`;
+		sql = `MERGE INTO ${quote(table._dbName)} target USING (SELECT ${values.join(',')} FROM DUAL) source ON (${join()}) WHEN NOT MATCHED THEN ${whenNotMatched()}`;
 	return sql;
 
 	function join() {
@@ -72,7 +70,6 @@ function insertSql(table, row, options) {
 			if (concurrency === 'overwrite')
 				conflictColumnUpdates.push(`target.${columnName}=source.${columnName}`);
 			else if (concurrency === 'optimistic')
-				// conflictColumnUpdates.push(`target.${column._dbName} = CASE WHEN target.${column._dbName} <> source.${column._dbName} THEN RAISE_APPLICATION_ERROR(-20001, 'Conflict when updating ${column._dbName}') ELSE target.${column._dbName} END`);
 				conflictColumnUpdates.push(`target.${columnName} = CASE WHEN target.${columnName} <> source.${columnName} THEN 1/0 ELSE target.${columnName} END`);
 
 		}

package/src/oracle/newDatabase.js

@@ -4,10 +4,6 @@ let _begin = require('../table/begin');
 let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
-let useHook = require('../useHook');
-let promise = require('promise/domains');
-let versionArray = process.version.replace('v', '').split('.');
-let major = parseInt(versionArray[0]);
 let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
@@ -34,15 +30,12 @@ function newDatabase(connectionString, poolOptions) {
 
 		if (fn)
 			return domain.run(runInTransaction);
-		else if ((major >= 12) && useHook()) {
-			domain.exitContext = true;
-			return domain.start().then(run);
-		}
 		else
 			return domain.run(run);
 
+
 		function begin() {
-			return _begin(options?.readonly);
+			return _begin(domain, options);
 		}
 
 		async function runInTransaction() {
@@ -50,68 +43,60 @@ function newDatabase(connectionString, poolOptions) {
 			let transaction = newTransaction(domain, pool, options);
 			await new Promise(transaction)
 				.then(begin)
-				.then(fn)
+				.then(() => fn(domain))
 				.then((res) => result = res)
-				.then(c.commit)
-				.then(null, c.rollback);
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain, e));
 			return result;
+
 		}
 
 		function run() {
 			let p;
 			let transaction = newTransaction(domain, pool, options);
-			if (useHook())
-				p = new Promise(transaction);
-			else
-				p = new promise(transaction);
+			p = new Promise(transaction);
 
 			return p.then(begin);
 		}
 
 	};
 
-	c.createTransaction = function() {
+	c.createTransaction = function(options) {
 		let domain = createDomain();
 		let transaction = newTransaction(domain, pool);
-		let p = domain.run(() => new Promise(transaction).then(_begin));
+		let p = domain.run(() => new Promise(transaction).then(begin));
 
 		function run(fn) {
-			return p.then(domain.run.bind(domain, fn));
+			return p.then(() => fn(domain));
 		}
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
 		return run;
-	};
-
-	c.bindTransaction = function() {
-		// @ts-ignore
-		var domain = process.domain;
-		let p = domain.run(() => true);
 
-		function run(fn) {
-			return p.then(domain.run.bind(domain, fn));
+		function begin() {
+			return _begin(domain, options);
 		}
-		return run;
 	};
 
 	c.query = function(query) {
 		let domain = createDomain();
 		let transaction = newTransaction(domain, pool);
 		let p = domain.run(() => new Promise(transaction)
-			.then(() => setSessionSingleton('changes', []))
-			.then(() => doQuery(query).then(onResult, onError)));
+			.then(() => setSessionSingleton(domain, 'changes', []))
+			.then(() => doQuery(domain, query).then(onResult, onError)));
 		return p;
 
 		function onResult(result) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			return result;
 		}
 
 		function onError(e) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			throw e;
 		}
 	};
 
-
 	c.rollback = rollback;
 	c.commit = commit;
 

package/src/oracle/newInsertCommandCore.js

@@ -1,17 +1,17 @@
 var newParameterized = require('../table/query/newParameterized');
 var insertSql = require('./insertSql');
-var util = require('util');
+const formatString = require('../format');
 
-function newInsertCommandCore(table, row, options = {}) {
+function newInsertCommandCore(context,table, row, options = {}) {
 	var parameters = [];
-	var values = [insertSql(table, row, options)];
+	var values = [insertSql(context,table, row, options)];
 
 	var columns = table._columns;
 	for (var i = 0; i < columns.length; i++) {
 		var column = columns[i];
 		var alias = column.alias;
 		if (row['__' + column.alias] !== undefined) {
-			var encoded = column.encode(row[alias]);
+			var encoded = column.encode(context, row[alias]);
 			if (encoded.parameters.length > 0) {
 				values.push('?');
 				parameters.push(encoded.parameters[0]);
@@ -20,7 +20,7 @@ function newInsertCommandCore(table, row, options = {}) {
 		}
 	}
 
-	var sql = util.format.apply(null, values);
+	var sql = formatString.apply(null, values);
 	return newParameterized(sql, parameters);
 }
 

package/src/oracle/newPool.js

@@ -1,17 +1,17 @@
-var pools = require('../pools');
-var promise = require('../table/promise');
-var end = require('./pool/end');
-var newGenericPool = require('./pool/newGenericPool');
-var newId = require('../newId');
+const promisify = require('../promisify');
+const pools = require('../pools');
+const end = require('./pool/end');
+const newGenericPool = require('./pool/newGenericPool');
+const newId = require('../newId');
 
 function newPool(connectionString, poolOptions) {
-	var pool = newGenericPool(connectionString, poolOptions);
-	var id = newId();
-	var boundEnd = end.bind(null, pool, id);
-	var c = {};
+	let pool = newGenericPool(connectionString, poolOptions);
+	let id = newId();
+	let boundEnd = end.bind(null, pool, id);
+	let c = {};
 
 	c.connect = pool.connect;
-	c.end = promise.denodeify(boundEnd);
+	c.end = promisify(boundEnd);
 	pools[id] = c;
 	return c;
 }

package/src/oracle/newTransaction.js

@@ -8,6 +8,7 @@ const insertSql = require('./insertSql');
 const insert = require('./insert');
 const formatDateOut = require('./formatDateOut');
 const formatDateIn = require('./formatDateIn');
+const quote = require('./quote');
 
 function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 	var rdb = {poolFactory: pool};
@@ -35,7 +36,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 		caller.visitSqlite();
 	};
 	rdb.aggregateCount = 0;
-	rdb.quote = (name) => `"${name}"`;
+	rdb.quote = quote;
 
 	if (readonly) {
 		rdb.dbClient = {

package/src/oracle/pool/newGenericPool.js

@@ -1,8 +1,7 @@
 // @ts-nocheck
 /* eslint-disable no-prototype-builtins */
-var EventEmitter = require('events').EventEmitter;
 
-var defaults = require('./defaults');
+var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
 var oracle = require('oracledb');
 
@@ -15,7 +14,7 @@ function newGenericPool(connectionString, poolOptions) {
 		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
-		log: poolOptions.log || defaults.poolLog,
+		log: poolOptions.log,
 		create: function(cb) {
 			var client;
 			oracle.getConnection(connectionString, onConnected);
@@ -33,20 +32,9 @@ function newGenericPool(connectionString, poolOptions) {
 			client.close();
 		}
 	});
-	//mixin EventEmitter to pool
-	EventEmitter.call(pool);
-	for (var key in EventEmitter.prototype) {
-		if (EventEmitter.prototype.hasOwnProperty(key)) {
-			pool[key] = EventEmitter.prototype[key];
-		}
-	}
 	//monkey-patch with connect method
 	pool.connect = function(cb) {
-		var domain = process.domain;
 		pool.acquire(function(err, client) {
-			if (domain) {
-				cb = domain.bind(cb);
-			}
 			if (err) return cb(err, null, function() {/*NOOP*/ });
 			client.poolCount++;
 			cb(null, client, function(err) {

package/src/oracle/quote.js

@@ -0,0 +1 @@
+module.exports = (name) => `"${name}"`;

package/src/oracle/wrapQuery.js

@@ -10,9 +10,6 @@ function wrapQuery(connection) {
 		var sql = replaceParamChar(query, params);
 		log.emitQuery({ sql, parameters: params });
 
-
-
-
 		runOriginalQuery.call(connection, sql, params, {
 			fetchTypeHandler: function(metaData) {
 				// Tells the database to return column names in lowercase

package/src/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "uuid": "^11.0.5"
+  }
+}

package/src/patchRow.js

@@ -1,13 +1,13 @@
 let patchTable = require('./patchTable');
 
-function patchRow(table, row, patches, options) {
+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(table, patches, options);
+	return patchTable(context, table, patches, options);
 }
 
 module.exports = patchRow;

package/src/patchTable.js

@@ -12,7 +12,7 @@ async function patchTable() {
 	return patchTableCore.apply(null, arguments);
 }
 
-async function patchTableCore(table, patches, { strategy = undefined, deduceStrategy = false, ...options } = {}, dryrun) {
+async function patchTableCore(context, table, patches, { strategy = undefined, deduceStrategy = false, ...options } = {}, dryrun) {
 	options = cleanOptions(options);
 	strategy = JSON.parse(JSON.stringify(strategy || {}));
 	let changed = new Set();
@@ -41,7 +41,8 @@ async function patchTableCore(table, patches, { strategy = undefined, deduceStra
 
 	async function toDtos(set) {
 		set = [...set];
-		return table.getManyDto(set, strategy);
+		const result = await table.getManyDto(context, set, strategy);
+		return result;
 	}
 
 	function toKey(property) {
@@ -56,7 +57,7 @@ async function patchTableCore(table, patches, { strategy = undefined, deduceStra
 		path = path.slice(1);
 		if (!row && path.length > 0) {
 			const key = toKey(property);
-			row =  await table.tryGetById.apply(null, toKey(property), strategy);
+			row =  await table.tryGetById.apply(null, [context, ...key, strategy]);
 			if (!row)
 				throw new Error(`Row ${table._dbName} with id ${key} was not found.`);
 		}
@@ -98,7 +99,7 @@ async function patchTableCore(table, patches, { strategy = undefined, deduceStra
 					}
 				}
 			}
-			let row = table.insertWithConcurrency.apply(null, [options, value]);
+			let row = table.insertWithConcurrency.apply(null, [context, options, value]);
 			row = await row;
 
 			for (let i = 0; i < childInserts.length; i++) {
@@ -212,7 +213,7 @@ async function patchTableCore(table, patches, { strategy = undefined, deduceStra
 	async function remove({ path, op, oldValue, options }, table, row) {
 		let property = path[0];
 		path = path.slice(1);
-		row = row || await table.getById.apply(null, toKey(property));
+		row = row || await table.getById.apply(null, [context, ...toKey(property)]);
 		if (path.length === 0) {
 			await validateDeleteAllowed({ row, options, table });
 			if (await validateDeleteConflict({ row, oldValue, options, table }))

package/src/pg/deleteFromSql.js

@@ -1,10 +1,10 @@
-var format = 'delete from %s %s%s';
-var util = require('util');
-const quote = require('../table/quote');
+const format = 'delete from %s %s%s';
+const formatString = require('../format');
+const quote = require('./quote');
 
 function deleteFromSql(table, alias, whereSql) {
-	var name = quote(table._dbName);
+	const name = quote(table._dbName);
 	alias = quote(alias);
-	return util.format(format, name, alias, whereSql);
+	return formatString(format, name, alias, whereSql);
 }
 module.exports = deleteFromSql;

package/src/pg/formatDateOut.js

@@ -1,7 +1,6 @@
-const quote = require('../table/quote');
 
 function formatDateOut(column, alias) {
-	return `${alias}.${quote(column._dbName)}::text`;
+	return `${alias}."${(column._dbName)}"::text`;
 }
 
 module.exports = formatDateOut;

package/src/pg/insert.js

@@ -3,11 +3,11 @@ let newInsertCommandCore = require('../table/commands/newInsertCommandCore');
 let executeQueries = require('../table/executeQueries');
 
 
-function insertDefault(table, row, options) {
-	let insertCmd = newInsertCommand(newInsertCommandCore, table, row, options);
+function insertDefault(context, table, row, options) {
+	let insertCmd = newInsertCommand(newInsertCommandCore.bind(null, context), table, row, options);
 	insertCmd.disallowCompress = true;
 
-	return executeQueries([insertCmd]).then((result) => result[result.length - 1]);
+	return executeQueries(context, [insertCmd]).then((result) => result[result.length - 1]);
 
 }
 

package/src/pg/insertSql.js

@@ -1,9 +1,7 @@
 let lastInsertedSql = require('./lastInsertedSql');
-let getSessionContext = require('../table/getSessionContext');
-const getSessionSingleton = require('../table/getSessionSingleton');
+const quote = require('./quote');
 
-function insertSql(table, row, options) {
-	const quote = getSessionSingleton('quote');
+function insertSql(_context, table, row, options) {
 	let columnNames = [];
 	let regularColumnNames = [];
 	let conflictColumnUpdateSql = '';
@@ -65,9 +63,6 @@ function insertSql(table, row, options) {
 
 
 	function outputInserted() {
-		let context = getSessionContext();
-		if (!context.lastInsertedIsSeparate && context.outputInsertedSql)
-			return context.outputInsertedSql(table) + ' ';
 		return '';
 	}
 }

package/src/pg/lastInsertedSql.js

@@ -1,7 +1,6 @@
-const getSessionSingleton = require('../table/getSessionSingleton');
+const quote = require('./quote');
 
 function lastInsertedSql(table) {
-	const quote = getSessionSingleton('quote');
 	let separator = '';
 	let result = 'RETURNING ';
 	for (let i = 0; i < table._columns.length; i++) {

package/src/pg/newDatabase.js

@@ -6,10 +6,6 @@ let rollback = require('../table/rollback');
 let newPool = require('./newPool');
 let lock = require('../lock');
 let executeSchema = require('./schema');
-let useHook = require('../useHook');
-let promise = require('promise/domains');
-let versionArray = process.version.replace('v', '').split('.');
-let major = parseInt(versionArray[0]);
 let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
@@ -41,39 +37,30 @@ function newDatabase(connectionString, poolOptions) {
 
 		if (fn)
 			return domain.run(runInTransaction);
-		else if ((major >= 12) && useHook()) {
-			domain.exitContext = true;
-			return domain.start().then(run);
-		}
 		else
 			return domain.run(run);
 
-
-
 		async function runInTransaction() {
 			let result;
 			let transaction = newTransaction(domain, pool, options);
 			await new Promise(transaction)
 				.then(begin)
 				.then(negotiateSchema)
-				.then(fn)
+				.then(() => fn(domain))
 				.then((res) => result = res)
-				.then(c.commit)
-				.then(null, c.rollback);
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain,e));
 			return result;
 		}
 
 		function begin() {
-			return _begin(options?.readonly);
+			return _begin(domain, options);
 		}
 
 		function run() {
 			let p;
 			let transaction = newTransaction(domain, pool, options);
-			if (useHook())
-				p = new Promise(transaction);
-			else
-				p = new promise(transaction);
+			p = new Promise(transaction);
 
 			return p.then(begin)
 				.then(negotiateSchema);
@@ -83,37 +70,34 @@ function newDatabase(connectionString, poolOptions) {
 			let schema = options && options.schema;
 			if (!schema)
 				return previous;
-			return executeSchema(schema);
+			return executeSchema(domain, schema);
 		}
 	};
 
 	c.createTransaction = function(options) {
 		let domain = createDomain();
-		let transaction = newTransaction(domain, pool);
-		let p = domain.run(() => new Promise(transaction).then(_begin).then(negotiateSchema));
+		let transaction = newTransaction(domain, pool, options);
+		let p = domain.run(() => new Promise(transaction)
+			.then(begin).then(negotiateSchema));
 
 		function run(fn) {
 			return p.then(domain.run.bind(domain, fn));
 		}
 
+		function begin() {
+			return _begin(domain, options);
+		}
+
 		function negotiateSchema(previous) {
 			let schema = options && options.schema;
 			if (!schema)
 				return previous;
-			return executeSchema(schema);
+			return executeSchema(domain,schema);
 		}
 
-		return run;
-	};
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
 
-	c.bindTransaction = function() {
-		// @ts-ignore
-		var domain = process.domain;
-		let p = domain.run(() => true);
-
-		function run(fn) {
-			return p.then(domain.run.bind(domain, fn));
-		}
 		return run;
 	};
 
@@ -121,22 +105,21 @@ function newDatabase(connectionString, poolOptions) {
 		let domain = createDomain();
 		let transaction = newTransaction(domain, pool);
 		let p = domain.run(() => new Promise(transaction)
-			.then(() => setSessionSingleton('changes', []))
-			.then(() => doQuery(query).then(onResult, onError)));
+			.then(() => setSessionSingleton(domain, 'changes', []))
+			.then(() => doQuery(domain, query).then(onResult, onError)));
 		return p;
 
 		function onResult(result) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			return result;
 		}
 
 		function onError(e) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			throw e;
 		}
 	};
 
-
 	c.rollback = rollback;
 	c.commit = commit;
 	c.lock = lock;