orange-orm 3.10.2

package/src/oracle/newInsertCommandCore.js

@@ -0,0 +1,27 @@
+var newParameterized = require('../table/query/newParameterized');
+var insertSql = require('./insertSql');
+var util = require('util');
+
+function newInsertCommandCore(table, row, options = {}) {
+	var parameters = [];
+	var values = [insertSql(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]);
+			if (encoded.parameters.length > 0) {
+				values.push('?');
+				parameters.push(encoded.parameters[0]);
+			} else
+				values.push(encoded.sql());
+		}
+	}
+
+	var sql = util.format.apply(null, values);
+	return newParameterized(sql, parameters);
+}
+
+module.exports = newInsertCommandCore;

package/src/oracle/newPool.js

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

package/src/oracle/newTransaction.js

@@ -0,0 +1,63 @@
+const wrapQuery = require('./wrapQuery');
+const encodeBoolean = require('./encodeBoolean');
+const deleteFromSql = require('./deleteFromSql');
+const selectForUpdateSql = require('./selectForUpdateSql');
+const lastInsertedSql = require('./lastInsertedSql');
+const limitAndOffset = require('./limitAndOffset');
+const insertSql = require('./insertSql');
+const insert = require('./insert');
+const formatDateOut = require('./formatDateOut');
+const formatDateIn = require('./formatDateIn');
+
+function newResolveTransaction(domain, pool) {
+	var rdb = {poolFactory: pool};
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+
+	return function(onSuccess, onError) {
+		pool.connect(onConnected);
+
+		function onConnected(err, client, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				client.executeQuery = wrapQuery(client);
+				rdb.begin = 'SET TRANSACTION ISOLATION LEVEL READ COMMITTED';
+				rdb.engine = 'oracle';
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				rdb.encodeBoolean = encodeBoolean;
+				rdb.decodeJSON = decodeJSON;
+				rdb.encodeJSON = JSON.stringify;
+				rdb.formatDateOut = formatDateOut;
+				rdb.formatDateIn = formatDateIn;
+				rdb.deleteFromSql = deleteFromSql;
+				rdb.selectForUpdateSql = selectForUpdateSql;
+				rdb.lastInsertedSql = lastInsertedSql;
+				rdb.insertSql = insertSql;
+				rdb.insert = insert;
+				rdb.lastInsertedIsSeparate = true;
+				rdb.multipleStatements = false;
+				rdb.limitAndOffset = limitAndOffset;
+				rdb.accept = function(caller) {
+					caller.visitSqlite();
+				};
+				rdb.aggregateCount = 0;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+function decodeJSON(value) {
+	return JSON.parse(value);
+}
+
+module.exports = newResolveTransaction;

package/src/oracle/outputInsertedSql.js

@@ -0,0 +1,5 @@
+function outputInsertedSql(_table) {
+	return '';
+}
+
+module.exports = outputInsertedSql;

package/src/oracle/pool/defaults.js

@@ -0,0 +1,45 @@
+module.exports = {
+	// database host defaults to localhost
+	host: 'localhost',
+
+	//database user's name
+	user: process.platform === 'win32' ? process.env.USERNAME : process.env.USER,
+
+	//name of database to connect
+	database: process.platform === 'win32' ? process.env.USERNAME : process.env.USER,
+
+	//database user's password
+	password: null,
+
+	//database port
+	port: 5432,
+
+	//number of rows to return at a time from a prepared statement's
+	//portal. 0 will return all rows at once
+	rows: 0,
+
+	// binary result mode
+	binary: false,
+
+	//Connection pool options - see https://github.com/coopernurse/node-pool
+	//number of connections to use in connection pool
+	//0 will disable connection pooling
+	poolSize: 0,
+
+	//max milliseconds a client can go unused before it is removed
+	//from the pool and destroyed
+	poolIdleTimeout: 30000,
+
+	//frequeny to check for idle clients within the client pool
+	reapIntervalMillis: 1000,
+
+	//pool log function / boolean
+	poolLog: false,
+
+	client_encoding: '',
+
+	ssl: false,
+
+	application_name : undefined,
+	fallback_application_name: undefined
+};

package/src/oracle/pool/end.js

@@ -0,0 +1,13 @@
+var pools = require('../../pools');
+
+function endPool(genericPool, id, done) {
+	genericPool.drain(onDrained);
+
+	function onDrained() {
+		genericPool.destroyAllNow();
+		delete pools[id];
+		done();
+	}
+}
+
+module.exports = endPool;

package/src/oracle/pool/newGenericPool.js

@@ -0,0 +1,64 @@
+// @ts-nocheck
+/* eslint-disable no-prototype-builtins */
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('./defaults');
+var genericPool = require('../../generic-pool');
+var oracle = require('oracledb');
+
+oracle.outFormat = oracle.OUT_FORMAT_OBJECT;
+oracle.fetchAsBuffer = [ oracle.BLOB ];
+
+function newGenericPool(connectionString, poolOptions) {
+	poolOptions = poolOptions || {};
+	var pool = genericPool.Pool({
+		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
+		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
+		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
+		log: poolOptions.log || defaults.poolLog,
+		create: function(cb) {
+			var client;
+			oracle.getConnection(connectionString, onConnected);
+			function onConnected(err, _client) {
+				client = _client;
+				if (err)
+					return cb(err, null);
+				client.poolCount = 0;
+				return cb(null, client);
+			}
+		},
+
+		destroy: function(client) {
+			client.poolCount = undefined;
+			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) {
+				if (err) {
+					pool.destroy(client);
+				} else {
+					pool.release(client);
+				}
+			});
+		});
+	};
+	return pool;
+}
+
+module.exports = newGenericPool;

package/src/oracle/replaceParamChar.js

@@ -0,0 +1,14 @@
+function replaceParamChar(query, params) {
+	if (params.length === 0)
+		return query.sql();
+	var splitted = query.sql().split('?');
+	var sql = '';
+	var lastIndex = splitted.length - 1;
+	for (var i = 0; i < lastIndex; i++) {
+		sql += splitted[i] + ':p' + (i + 1);
+	}
+	sql += splitted[lastIndex];
+	return sql;
+}
+
+module.exports = replaceParamChar;

package/src/oracle/selectForUpdateSql.js

@@ -0,0 +1,3 @@
+module.exports = function(alias) {
+	return ' FOR UPDATE OF ' + alias;
+};

package/src/oracle/wrapQuery.js

@@ -0,0 +1,38 @@
+var log = require('../table/log');
+var replaceParamChar = require('./replaceParamChar');
+
+function wrapQuery(connection) {
+	var runOriginalQuery = connection.execute;
+	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, {
+			fetchTypeHandler: function(metaData) {
+				// Tells the database to return column names in lowercase
+				metaData.name = metaData.name.toLowerCase();
+			}
+		}, onInnerCompleted);
+
+		function onInnerCompleted(err, rows) {
+			if (err)
+				onCompleted(err);
+			else {
+				if (rows.rows)
+					rows = rows.rows;
+				else
+					rows = [rows];
+				onCompleted(null, rows);
+			}
+		}
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/patchRow.js

@@ -0,0 +1,13 @@
+let patchTable = require('./patchTable');
+
+function patchRow(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);
+}
+
+module.exports = patchRow;

package/src/patchTable.js

@@ -0,0 +1,317 @@
+/* eslint-disable require-atomic-updates */
+let applyPatch = require('./applyPatch');
+let fromCompareObject = require('./fromCompareObject');
+let validateDeleteConflict = require('./validateDeleteConflict');
+let validateDeleteAllowed = require('./validateDeleteAllowed');
+
+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]);
+	return patchTableCore.apply(null, arguments);
+}
+
+async function patchTableCore(table, patches, { strategy = undefined, deduceStrategy = false, ...options } = {}, dryrun) {
+	options = cleanOptions(options);
+	strategy = JSON.parse(JSON.stringify(strategy || {}));
+	let changed = new Set();
+	for (let i = 0; i < patches.length; i++) {
+		let patch = { path: undefined, value: undefined, op: undefined };
+		Object.assign(patch, patches[i]);
+		patch.path = patches[i].path.split('/').slice(1);
+		let result;
+		if (patch.op === 'add' || patch.op === 'replace') {
+			result = await add({ path: patch.path, value: patch.value, op: patch.op, oldValue: patch.oldValue, strategy: deduceStrategy ? strategy : {}, options }, table);
+		}
+		else if (patch.op === 'remove')
+			result = await remove({ path: patch.path, op: patch.op, oldValue: patch.oldValue, options }, table);
+
+		if (result.inserted)
+			changed.add(result.inserted);
+		else if (result.updated)
+			changed.add(result.updated);
+	}
+	if (strategy['insertAndForget'])
+		return {
+			changed: [], strategy
+		};
+	return { changed: await toDtos(changed), strategy };
+
+
+	async function toDtos(set) {
+		set = [...set];
+		return table.getManyDto(set, strategy);
+	}
+
+	function toKey(property) {
+		if (typeof property === 'string' && property.charAt(0) === '[')
+			return JSON.parse(property);
+		else
+			return [property];
+	}
+
+	async function add({ path, value, op, oldValue, strategy, options }, table, row, parentRow, relation) {
+		let property = path[0];
+		path = path.slice(1);
+		if (!row && path.length > 0) {
+			const key = toKey(property);
+			row =  await table.tryGetById.apply(null, toKey(property), strategy);
+			if (!row)
+				throw new Error(`Row ${table._dbName} with id ${key} was not found.`);
+		}
+
+		if (path.length === 0 && value === null) {
+			return remove({ path, op, oldValue, options }, table, row);
+		}
+		if (path.length === 0) {
+			if (dryrun) {
+				return {};
+			}
+			let childInserts = [];
+			for (let name in value) {
+				if (isColumn(name, table))
+					value[name] = fromCompareObject(value[name]);
+				else if (isJoinRelation(name, table)) {
+					strategy[name] = strategy[name] || {};
+					value[name] && updateJoinedColumns(name, value, table, value);
+				}
+				else if (isManyRelation(name, table))
+					value[name] && childInserts.push(insertManyRelation.bind(null, name, value, op, oldValue, table, strategy, options));
+				else if (isOneRelation(name, table) && value)
+					value[name] && childInserts.push(insertOneRelation.bind(null, name, value, op, oldValue, table, strategy, options));
+			}
+			for (let i = 0; i < table._primaryColumns.length; i++) {
+				let pkName = table._primaryColumns[i].alias;
+				let keyValue = value[pkName];
+				if (keyValue && typeof (keyValue) === 'string' && keyValue.indexOf('~') === 0)
+					value[pkName] = undefined;
+			}
+
+			if (relation && relation.joinRelation) {
+				for (let i = 0; i < relation.joinRelation.columns.length; i++) {
+					let column = relation.joinRelation.columns[i];
+					let fkName = column.alias;
+					let parentPk = relation.joinRelation.childTable._primaryColumns[i].alias;
+					if (!value[fkName]) {
+						value[fkName] = parentRow[parentPk];
+					}
+				}
+			}
+			let row = table.insertWithConcurrency.apply(null, [options, value]);
+			row = await row;
+
+			for (let i = 0; i < childInserts.length; i++) {
+				await childInserts[i](row);
+			}
+			return { inserted: row };
+		}
+		property = path[0];
+		if (isColumn(property, table)) {
+			if (dryrun)
+				return { updated: row };
+			let dto = {};
+			dto[property] = row[property];
+			let result = applyPatch({ options }, dto, [{ path: '/' + path.join('/'), op, value, oldValue }], table[property]);
+			row[property] = result[property];
+			return { updated: row };
+		}
+		else if (isOneRelation(property, table)) {
+			let relation = table[property]._relation;
+			let subRow = await row[property];
+			strategy[property] = strategy[property] || {};
+			options[property] = inferOptions(options, property);
+
+			await add({ path, value, op, oldValue, strategy: strategy[property], options: options[property] }, relation.childTable, subRow, row, relation);
+			return { updated: row };
+		}
+		else if (isManyRelation(property, table)) {
+			let relation = table[property]._relation;
+			strategy[property] = strategy[property] || {};
+			options[property] = inferOptions(options, property);
+
+
+			if (path.length === 1) {
+				for (let id in value) {
+					if (id === '__patchType')
+						continue;
+					await add({ path: [id], value: value[id], op, oldValue, strategy: strategy[property], options: options[property] }, relation.childTable, undefined, row, relation);
+				}
+			}
+			else {
+				await add({ path: path.slice(1), value, oldValue, op, strategy: strategy[property], options: options[property] }, relation.childTable, undefined, row, relation);
+			}
+			return { updated: row };
+		}
+		else if (isJoinRelation(property, table) && path.length === 1) {
+			let dto = toJoinedColumns(property, { [property]: value }, table);
+			oldValue = toJoinedColumns(property, { [property]: oldValue }, table);
+			let result;
+			for (let p in dto) {
+				result = await add({ path: ['dummy', p], value: dto[p], oldValue: (oldValue || {})[p], op, strategy: strategy, options: options }, table, row, parentRow, relation) || result;
+			}
+			return result || {};
+		}
+		else if (isJoinRelation(property, table) && path.length === 2) {
+			let dto = toJoinedColumns(property, { [property]: { [path[1]]: value } }, table);
+			oldValue = toJoinedColumns(property, { [property]: { [path[1]]: oldValue } }, table);
+			let result;
+			for (let p in dto) {
+				result = await add({ path: ['dummy', p], value: dto[p], oldValue: (oldValue || {})[p], op, strategy: strategy, options: options }, table, row, parentRow, relation) || result;
+			}
+			return result || {};
+		}
+		return {};
+	}
+
+	async function insertManyRelation(name, value, op, oldValue, table, strategy, options, row) {
+		let relation = table[name]._relation;
+		for (let childKey in value[name]) {
+			if (childKey != '__patchType') {
+				let child = value[name][childKey];
+				strategy[name] = strategy[name] || {};
+				options[name] = inferOptions(options, name);
+
+				await add({ path: [childKey], value: child, op, oldValue, strategy: strategy[name], options: options[name] }, relation.childTable, {}, row, relation);
+			}
+		}
+	}
+
+	async function insertOneRelation(name, value, op, oldValue, table, strategy, options, row) {
+		let relation = table[name]._relation;
+		let child = value[name];
+		strategy[name] = strategy[name] || {};
+		options[name] = inferOptions(options, name);
+
+		await add({ path: [name], value: child, op, oldValue, strategy: strategy[name], options: options[name] }, relation.childTable, {}, row, relation);
+	}
+
+	function updateJoinedColumns(name, value, table, row) {
+		let relation = table[name]._relation;
+		for (let i = 0; i < relation.columns.length; i++) {
+			let parentKey = relation.columns[i].alias;
+			let childKey = relation.childTable._primaryColumns[i].alias;
+			if (childKey in value[name])
+				row[parentKey] = fromCompareObject(value[name][childKey]);
+		}
+	}
+	function toJoinedColumns(name, valueObject, table) {
+		let relation = table[name]._relation;
+		let dto = {};
+		for (let i = 0; i < relation.columns.length; i++) {
+			let parentKey = relation.columns[i].alias;
+			let childKey = relation.childTable._primaryColumns[i].alias;
+			if (valueObject && valueObject[name] && childKey in valueObject[name])
+				dto[parentKey] = fromCompareObject(valueObject[name][childKey]);
+			else
+				dto[parentKey] = null;
+		}
+		return dto;
+	}
+
+	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));
+		if (path.length === 0) {
+			await validateDeleteAllowed({ row, options, table });
+			if (await validateDeleteConflict({ row, oldValue, options, table }))
+				await row.deleteCascade();
+		}
+		property = path[0];
+		if (isColumn(property, table)) {
+			let dto = {};
+			dto[property] = row[property];
+			let result = applyPatch({ options }, dto, [{ path: '/' + path.join('/'), op, oldValue }], table[property]);
+
+			row[property] = result[property];
+			return { updated: row };
+		}
+		else if (isJoinRelation(property, table) && path.length === 1) {
+			oldValue = toJoinedColumns(property, { [property]: oldValue }, table);
+			let relation = table[property]._relation;
+			let result;
+			for (let i = 0; i < relation.columns.length; i++) {
+				let p = relation.columns[i].alias;
+				let dto = {};
+				dto[p] = row[p];
+				result = await remove({ path: ['dummy', p], oldValue: (oldValue || {})[p], op, options: options }, table, row) || result;
+			}
+			return result || {};
+		}
+		else if (isJoinRelation(property, table) && path.length === 2) {
+			let relation = table[property]._relation;
+			oldValue = toJoinedColumns(property, { [property]: { [path[1]]: oldValue } }, table);
+			let result;
+			for (let i = 0; i < relation.columns.length; i++) {
+				let p = relation.columns[i].alias;
+				let childKey = relation.childTable._primaryColumns[i].alias;
+				if (path[1] === childKey) {
+					let dto = {};
+					dto[p] = row[p];
+					result = await remove({ path: ['dummy', p], oldValue: (oldValue || {})[p], op, options: options }, table, row) || result;
+					break;
+				}
+			}
+			return result || {};
+		}
+		else if (isOneRelation(property, table)) {
+			let child = await row[property];
+			if (!child)
+				throw new Error(property + ' does not exist');
+			options[property] = inferOptions(options, property);
+
+			await remove({ path, op, oldValue, options: options[property] }, table[property], child);
+			return { updated: row };
+		}
+		else if (isManyRelation(property, table)) {
+			let relation = table[property]._relation;
+			options[property] = inferOptions(options, property);
+			if (path.length === 1) {
+				let children = (await row[property]).slice(0);
+				for (let i = 0; i < children.length; i++) {
+					let child = children[i];
+					await remove({ path: path.slice(1), op, oldValue, options: options[property] }, table[property], child);
+				}
+			}
+			else {
+				await remove({ path: path.slice(1), op, oldValue, options: options[property] }, relation.childTable);
+			}
+			return { updated: row };
+		}
+		return {};
+	}
+
+	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 isJoinRelation(name, table) {
+		return table[name] && table[name]._relation.columns;
+	}
+
+	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 cleanOptions(options) {
+		const { table, transaction, db, ..._options } = options;
+		return _options;
+	}
+}
+
+module.exports = patchTable;

package/src/pg/deleteFromSql.js

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

package/src/pg/encodeBoolean.js

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

package/src/pg/encodeDate.js

@@ -0,0 +1,7 @@
+function encodeDate(date) {
+	if (date.toISOString)
+		return  '\'' + date.toISOString() + '\'';
+	return '\'' + date + '\'';
+}
+
+module.exports = encodeDate;

package/src/pg/encodeJSON.js

@@ -0,0 +1,15 @@
+function encode(arg) {
+	if (Array.isArray(arg))
+		return new JsonBArrayParam(arg);
+	else
+		return arg;
+}
+
+class JsonBArrayParam {
+	constructor(actualArray) { this.actualArray = actualArray; }
+	toPostgres() {
+		return JSON.stringify(this.actualArray);
+	}
+}
+
+module.exports = encode;

package/src/pg/formatDateOut.js

@@ -0,0 +1,5 @@
+function formatDateOut(column, alias) {
+	return `${alias}.${column._dbName}::text`;
+}
+
+module.exports = formatDateOut;