orange-orm 3.10.2

package/src/pg/insert.js

@@ -0,0 +1,14 @@
+let newInsertCommand = require('../table/commands/newInsertCommand');
+let newInsertCommandCore = require('../table/commands/newInsertCommandCore');
+let executeQueries = require('../table/executeQueries');
+
+
+function insertDefault(table, row, options) {
+	let insertCmd = newInsertCommand(newInsertCommandCore, table, row, options);
+	insertCmd.disallowCompress = true;
+
+	return executeQueries([insertCmd]).then((result) => result[result.length - 1]);
+
+}
+
+module.exports = insertDefault;

package/src/pg/insertSql.js

@@ -0,0 +1,70 @@
+let lastInsertedSql = require('./lastInsertedSql');
+let getSessionContext = require('../table/getSessionContext');
+
+function insertSql(table, row, options) {
+	let columnNames = [];
+	let regularColumnNames = [];
+	let conflictColumnUpdateSql = '';
+	let values = [];
+	let sql = 'INSERT INTO ' + table._dbName + ' ';
+	addDiscriminators();
+	addColumns();
+	if (columnNames.length === 0)
+		sql += `${outputInserted()}DEFAULT VALUES ${lastInsertedSql(table)}`;
+	else
+		sql = sql + '(' + columnNames.join(',') + ') ' + outputInserted() + 'VALUES (' + values.join(',') + ')' + onConflict() + lastInsertedSql(table);
+	return sql;
+
+	function onConflict() {
+		if (options.concurrency === 'skipOnConflict' || options.concurrency === 'overwrite') {
+			const primaryKeys = table._primaryColumns.map(x => x._dbName).join(',');
+			return ` ON CONFLICT(${primaryKeys}) ${conflictColumnUpdateSql} `;
+		}
+		else return '';
+	}
+
+	function addDiscriminators() {
+		let discriminators = table._columnDiscriminators;
+		for (let i = 0; i < discriminators.length; i++) {
+			let parts = discriminators[i].split('=');
+			columnNames.push(parts[0]);
+			values.push(parts[1]);
+		}
+	}
+
+	function addColumns() {
+		let conflictColumnUpdates = [];
+		let columns = table._columns;
+		for (let i = 0; i < columns.length; i++) {
+			let column = columns[i];
+			regularColumnNames.push(column._dbName);
+			if (row['__' + column.alias] !== undefined) {
+				columnNames.push(column._dbName);
+				values.push('%s');
+				addConflictUpdate(column);
+			}
+		}
+		if (conflictColumnUpdates.length === 0)
+			conflictColumnUpdateSql = 'DO NOTHING';
+		else
+			conflictColumnUpdateSql = 'DO UPDATE SET ' + conflictColumnUpdates.join(',');
+
+		function addConflictUpdate(column) {
+			let concurrency = options[column.alias]?.concurrency || options.concurrency;
+			if (concurrency === 'overwrite')
+				conflictColumnUpdates.push(`${column._dbName}=EXCLUDED.${column._dbName}`);
+			else if (concurrency === 'optimistic')
+				conflictColumnUpdates.push(`${column._dbName} = CASE WHEN ${table._dbName}.${column._dbName} <> EXCLUDED.${column._dbName} THEN CAST(random()::int || '12345678-1234-1234-1234-123456789012Conflict when updating ${column._dbName}12345678-1234-1234-1234-123456789012' AS INTEGER) ELSE ${table._dbName}.${column._dbName} END`);
+		}
+	}
+
+
+	function outputInserted() {
+		let context = getSessionContext();
+		if (!context.lastInsertedIsSeparate && context.outputInsertedSql)
+			return context.outputInsertedSql(table) + ' ';
+		return '';
+	}
+}
+
+module.exports = insertSql;

package/src/pg/lastInsertedSql.js

@@ -0,0 +1,11 @@
+function lastInsertedSql(table) {
+	let separator = '';
+	let result = 'RETURNING ';
+	for (let i = 0; i < table._columns.length; i++) {
+		result += separator + table._columns[i]._dbName;
+		separator = ',';
+	}
+	return result;
+}
+
+module.exports = lastInsertedSql;

package/src/pg/limitAndOffset.js

@@ -0,0 +1,18 @@
+function limitAndOffset(span) {
+	if (span.offset)
+		return ` limit ${limit()} offset ${span.offset}`;
+	else if (span.limit || span.limit === 0)
+		return ` limit ${span.limit}`;
+	else
+		return '';
+
+	function limit() {
+		if (span.limit || span.limit === 0)
+			return span.limit;
+		else
+			return 'all';
+	}
+
+}
+
+module.exports = limitAndOffset;

package/src/pg/newDatabase.js

@@ -0,0 +1,153 @@
+let createDomain = require('../createDomain');
+let newTransaction = require('./newTransaction');
+let begin = require('../table/begin');
+let commit = require('../table/commit');
+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');
+let releaseDbClient = require('../table/releaseDbClient');
+let setSessionSingleton = require('../table/setSessionSingleton');
+let types = require('pg').types;
+
+types.setTypeParser(1700, function(val) {
+	return parseFloat(val);
+});
+
+function newDatabase(connectionString, poolOptions) {
+	if (!connectionString)
+		throw new Error('Connection string cannot be empty');
+	var pool;
+	if (!poolOptions)
+		pool = newPool.bind(null, connectionString, poolOptions);
+	else
+		pool = newPool(connectionString, poolOptions);
+
+	let c = { poolFactory: pool, hostLocal, express };
+
+	c.transaction = function(options, fn) {
+		if ((arguments.length === 1) && (typeof options === 'function')) {
+			fn = options;
+			options = undefined;
+		}
+		let domain = createDomain();
+
+		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);
+			await new Promise(transaction)
+				.then(begin)
+				.then(negotiateSchema)
+				.then(fn)
+				.then((res) => result = res)
+				.then(c.commit)
+				.then(null, c.rollback);
+			return result;
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool);
+			if (useHook())
+				p = new Promise(transaction);
+			else
+				p = new promise(transaction);
+
+			return p.then(begin)
+				.then(negotiateSchema);
+		}
+
+		function negotiateSchema(previous) {
+			let schema = options && options.schema;
+			if (!schema)
+				return previous;
+			return executeSchema(schema);
+		}
+	};
+
+	c.createTransaction = function(options) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(begin).then(negotiateSchema));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+
+		function negotiateSchema(previous) {
+			let schema = options && options.schema;
+			if (!schema)
+				return previous;
+			return executeSchema(schema);
+		}
+
+		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));
+		}
+		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)));
+		return p;
+
+		function onResult(result) {
+			releaseDbClient();
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient();
+			throw e;
+		}
+	};
+
+
+	c.rollback = rollback;
+	c.commit = commit;
+	c.lock = lock;
+	c.schema = executeSchema;
+
+	c.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitPg();
+	};
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/pg/newPool.js

@@ -0,0 +1,19 @@
+var pools = require('../pools');
+var promise = require('../table/promise');
+var end = require('./pool/end');
+var newPgPool = require('./pool/newPgPool');
+var newId = require('../newId');
+
+function newPool(connectionString, poolOptions) {
+	var pool = newPgPool(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/pg/newStreamableQuery.js

@@ -0,0 +1,7 @@
+var QueryStream;
+
+module.exports = function(sql, params) {
+	if (!QueryStream)
+		QueryStream = require('pg-query-stream');
+	return new QueryStream(sql, params);
+};

package/src/pg/newTransaction.js

@@ -0,0 +1,58 @@
+var wrapQuery = require('./wrapQuery');
+var wrapQueryStream = require('./wrapQueryStream');
+var encodeDate = require('./encodeDate');
+var encodeBoolean = require('./encodeBoolean');
+var deleteFromSql = require('./deleteFromSql');
+var selectForUpdateSql = require('./selectForUpdateSql');
+var limitAndOffset = require('./limitAndOffset');
+var formatDateOut = require('./formatDateOut');
+var encodeJSON = require('./encodeJSON');
+var insertSql = require('./insertSql');
+var insert = require('./insert');
+
+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);
+				client.streamQuery = wrapQueryStream(client);
+				rdb.engine = 'pg';
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				rdb.encodeBoolean = encodeBoolean;
+				rdb.encodeDate = encodeDate;
+				rdb.encodeJSON = encodeJSON;
+				rdb.formatDateOut = formatDateOut;
+				rdb.deleteFromSql = deleteFromSql;
+				rdb.selectForUpdateSql = selectForUpdateSql;
+				rdb.lastInsertedIsSeparate = false;
+				rdb.insertSql = insertSql;
+				rdb.insert = insert;
+				rdb.multipleStatements = true;
+				rdb.limitAndOffset = limitAndOffset;
+				rdb.accept = function(caller) {
+					caller.visitPg();
+				};
+				rdb.aggregateCount = 0;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+module.exports = newResolveTransaction;

package/src/pg/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/pg/pool/end.js

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

package/src/pg/pool/newPgPool.js

@@ -0,0 +1,82 @@
+/* eslint-disable no-prototype-builtins */
+//slightly modified code from github.com/brianc/node-postgres
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('./defaults');
+var genericPool = require('../../generic-pool');
+var _pg = require('pg');
+
+function newPgPool(connectionString, poolOptions) {
+	poolOptions = poolOptions || {};
+	let pg = poolOptions.native ? _pg.native : _pg;
+	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 = new pg.Client(connectionString);
+			client.connect(function(err) {
+				if (err) return cb(err, null);
+
+				//handle connected client background errors by emitting event
+				//via the pg object and then removing errored client from the pool
+				client.on('error', function(e) {
+					pool.emit('error', e, client);
+
+					// If the client is already being destroyed, the error
+					// occurred during stream ending. Do not attempt to destroy
+					// the client again.
+					if (!client._destroying) {
+						pool.destroy(client);
+					}
+				});
+
+				// Remove connection from pool on disconnect
+				client.on('end', function(_e) {
+					// Do not enter infinite loop between pool.destroy
+					// and client 'end' event...
+					if (!client._destroying) {
+						pool.destroy(client);
+					}
+				});
+				client.poolCount = 0;
+				return cb(null, client);
+			});
+		},
+		destroy: function(client) {
+			client._destroying = true;
+			client.poolCount = undefined;
+			client.end();
+		}
+	});
+	//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 = newPgPool;

package/src/pg/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] + '$' + (i + 1);
+	}
+	sql += splitted[lastIndex];
+	return sql;
+}
+
+module.exports = replaceParamChar;

package/src/pg/schema.js

@@ -0,0 +1,11 @@
+var query = require('../query');
+
+function executeSchema(schema) {
+	if (!schema)
+		throw new Error('Missing schema');
+	if (!Array.isArray(schema))
+		schema = [schema];
+	return query('SET LOCAL search_path TO ' + schema.join(','));
+}
+
+module.exports = executeSchema;

package/src/pg/selectForUpdateSql.js

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

package/src/pg/wrapQuery.js

@@ -0,0 +1,33 @@
+var log = require('../table/log');
+var replaceParamChar = require('./replaceParamChar');
+
+function wrapQuery(connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = replaceParamChar(query, params);
+		query = {
+			text: sql,
+			values: params,
+			types: query.types
+		};
+		log.emitQuery({sql, parameters: params});
+
+		runOriginalQuery.call(connection, query, onInnerCompleted);
+
+		function onInnerCompleted(err, result) {
+			if (err)
+				onCompleted(err);
+			else {
+				if (Array.isArray(result))
+					result = result[result.length-1];
+				onCompleted(null, result.rows);
+			}
+		}
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/pg/wrapQueryStream.js

@@ -0,0 +1,20 @@
+var log = require('../table/log');
+var replaceParamChar = require('./replaceParamChar');
+var newStreamableQuery = require('./newStreamableQuery');
+
+function wrapQueryStream(connection) {
+	var runOriginalQuery = connection.query;
+	return runQuery;
+
+	function runQuery(query, options) {
+		var params = query.parameters;
+		var sql = replaceParamChar(query, params);
+		log.emitQuery({sql, parameters: params});
+		query = newStreamableQuery(sql, params, options);
+
+		return runOriginalQuery.call(connection, query);
+	}
+
+}
+
+module.exports = wrapQueryStream;

package/src/pools.js

@@ -0,0 +1,17 @@
+var pools = require('./newObject')();
+
+Object.defineProperty(pools, 'end', {
+	enumerable: false,
+	value: end
+});
+
+function end() {
+	var all = [];
+	for (var poolId in pools) {
+		var endPool = pools[poolId].end();
+		all.push(endPool);
+	}
+	return Promise.all(all);
+}
+
+module.exports = pools;

package/src/query/negotiateParameters.js

@@ -0,0 +1,10 @@
+function negotiateParameters(parameters) {
+	if(parameters === undefined)
+		return [];
+	else if(parameters.length !== undefined)
+		return parameters;
+	else
+		throw new Error('Query has invalid parameters property. Must be undefined or array');
+}
+
+module.exports = negotiateParameters;

package/src/query/negotiateSql.js

@@ -0,0 +1,14 @@
+function negotiateSql(query) {
+	if(typeof(query) === 'string')
+		return function() { return query; };
+
+	var sql = query.sql;
+	if(typeof(sql) === 'function')
+		return sql;
+	else if(typeof(sql) === 'string')
+		return function() { return sql; };
+	else
+		throw new Error('Query lacks sql property string or function');
+}
+
+module.exports = negotiateSql;

package/src/query/wrapQuery.js

@@ -0,0 +1,17 @@
+var negotiateSql = require('./negotiateSql');
+var negotiateParameters = require('./negotiateParameters');
+
+function wrapQuery(query) {
+	var safeSql = negotiateSql(query);
+	var safeParameters = negotiateParameters(query.parameters);
+	let obj =  {
+		sql: safeSql,
+		parameters: safeParameters
+	};
+	if (query.types)
+		obj.types = query.types;
+	return obj;
+}
+
+
+module.exports = wrapQuery;

package/src/query.js

@@ -0,0 +1,13 @@
+var executeQueries = require('./table/executeQueries');
+var wrapQuery = require('./query/wrapQuery');
+
+function doQuery(query) {
+	var wrappedQuery = wrapQuery(query);
+	return executeQueries([wrappedQuery]).then(unwrapResult);
+}
+
+function unwrapResult(results) {
+	return results[0];
+}
+
+module.exports = doQuery;

package/src/sap/deleteFromSql.js

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

package/src/sap/encodeBoolean.js

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