orange-orm 3.10.2

package/src/sqlite/newDatabase.js

@@ -0,0 +1,128 @@
+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 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');
+
+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(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);
+		}
+
+	};
+
+	c.createTransaction = function() {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(begin));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+		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.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitSqlite();
+	};
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/sqlite/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/sqlite/newTransaction.js

@@ -0,0 +1,58 @@
+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');
+
+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.engine = 'sqlite';
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				rdb.encodeBoolean = encodeBoolean;
+				rdb.decodeJSON = decodeJSON;
+				rdb.encodeJSON = JSON.stringify;
+				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/sqlite/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/sqlite/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/sqlite/pool/newGenericPool.js

@@ -0,0 +1,59 @@
+/* eslint-disable no-prototype-builtins */
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('./defaults');
+var genericPool = require('../../generic-pool');
+var sqlite = require('sqlite3');
+
+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 = new sqlite.Database(connectionString, onConnected);
+
+			function onConnected(err) {
+				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/sqlite/selectForUpdateSql.js

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

package/src/sqlite/wrapQuery.js

@@ -0,0 +1,24 @@
+var log = require('../table/log');
+
+function wrapQuery(connection) {
+	var runOriginalQuery = connection.all;
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		var params = query.parameters;
+		var sql = query.sql();
+		log.emitQuery({sql, parameters: params});
+
+		runOriginalQuery.call(connection, sql, params, onInnerCompleted);
+
+		function onInnerCompleted(err, rows) {
+			if (err)
+				onCompleted(err);
+			else
+				onCompleted(null, rows);
+		}
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/table/aggregate.js

@@ -0,0 +1,9 @@
+function newAggregate(table) {
+
+	function aggregate(fn) {
+		return fn(table);
+	}
+	return aggregate;
+}
+
+module.exports = newAggregate;

package/src/table/begin.js

@@ -0,0 +1,10 @@
+let beginCommand = require('./commands/beginCommand');
+let executeQuery = require('./executeQueries/executeQuery');
+let setSessionSingleton = require('./setSessionSingleton');
+
+function begin() {
+	setSessionSingleton('changes', []);
+	return executeQuery(beginCommand());
+}
+
+module.exports = begin;

package/src/table/cascadeDelete.js

@@ -0,0 +1,11 @@
+var _delete = require('./delete');
+var newObject = require('../newObject');
+var newCascadeDeleteStrategy = require('./newCascadeDeleteStrategy');
+
+function cascadeDelete(table, filter) {
+	var empty = newObject();
+	var strategy = newCascadeDeleteStrategy(empty, table);
+	return _delete(table, filter, strategy);
+}
+
+module.exports = cascadeDelete;

package/src/table/cloneStrategy.js

@@ -0,0 +1,18 @@
+function cloneStrategy(strategy, target) {
+	target = target || {};
+	for (var name in strategy) {
+		target[name] = mapChild(strategy[name]);
+	}
+	return target;
+}
+
+function mapChild(strategy) {
+	if (strategy instanceof Array)
+		return cloneStrategy(strategy, []);
+	if (strategy instanceof Object) {
+		return cloneStrategy(strategy, {});
+	}
+	return strategy;
+}
+
+module.exports = cloneStrategy;

package/src/table/column/binary/newDecode.js

@@ -0,0 +1,15 @@
+var newDecodeCore = require('../newDecodeCore');
+
+function _new(column) {
+	var decodeCore = newDecodeCore(column);
+
+	return function(value) {
+		value = decodeCore(value);
+		if (value === null)
+			return value;
+		else
+			return value.toString('base64');
+	};
+}
+
+module.exports = _new;

package/src/table/column/binary/newEncode.js

@@ -0,0 +1,23 @@
+var purify = require('./purify');
+var newParam = require('../../query/newParameterized');
+
+function _new(_column) {
+
+
+	function encode(value) {
+		value = purify(value);
+		if (value === null)
+			return newParam('null');
+		return newParam('?', [Buffer.from(value, 'base64')]);
+	}
+	encode.unsafe = function(value) {
+		value = purify(value);
+		if (value === null)
+			return 'null';
+		return Buffer.from(value, 'base64');
+	};
+
+	return encode;
+}
+
+module.exports = _new;

package/src/table/column/binary/purify.js

@@ -0,0 +1,12 @@
+function purify(value) {
+	if(value == null)
+		return null;
+	if (Buffer.isBuffer(value))
+		return value.toString('base64');
+	else if (typeof value === 'string')
+		return value;
+	else
+		throw new Error('\'' + value + '\'' + ' is not a base64');
+}
+
+module.exports = purify;

package/src/table/column/binary.js

@@ -0,0 +1,12 @@
+var newEncode = require('./binary/newEncode');
+var newDecode = require('./binary/newDecode');
+var purify = require('./binary/purify');
+
+function _new(column) {
+	column.tsType = 'BinaryColumn';
+	column.purify = purify;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+}
+
+module.exports = _new;

package/src/table/column/boolean/newDecode.js

@@ -0,0 +1,12 @@
+var purify = require('./purify');
+
+function _new(column) {
+
+	return function(value) {
+		if (value == column.dbNull)
+			return null;
+		return purify(value);
+	};
+}
+
+module.exports = _new;

package/src/table/column/boolean/newEncode.js

@@ -0,0 +1,36 @@
+var purify = require('./purify');
+var newParam = require('../../query/newParameterized');
+var getSessionSingleton = require('../../getSessionSingleton');
+
+function _new(column) {
+
+	function encode(value) {
+		value = purify(value);
+		if (value === null) {
+			if (column.dbNull === null)
+				return newParam('null');
+			return newParam('\'' + column.dbNull + '\'');
+		}
+		var encodeCore = getSessionSingleton('encodeBoolean');
+
+
+		return newParam('?', [encodeCore(value)]);
+	}
+
+	encode.unsafe = function(value) {
+		value = purify(value);
+		if (value === null) {
+			if (column.dbNull === null)
+				return 'null';
+			return '\'' + column.dbNull + '\'';
+		}
+		var encodeCore = getSessionSingleton('encodeBoolean');
+
+
+		return encodeCore(value);
+	};
+
+	return encode;
+}
+
+module.exports = _new;

package/src/table/column/boolean/purify.js

@@ -0,0 +1,7 @@
+function purify(value) {
+	if (value === null || typeof (value) === 'undefined')
+		return null;
+	return Boolean(value);
+}
+
+module.exports = purify;

package/src/table/column/boolean.js

@@ -0,0 +1,14 @@
+var newEncode = require('./boolean/newEncode');
+var newDecode = require('./boolean/newDecode');
+var purify = require('./boolean/purify');
+
+function _new(column) {
+	column.tsType = 'BooleanColumn';
+	column.purify = purify;
+	// column.default = false;
+	column.lazyDefault = false;
+	column.encode = newEncode(column);
+	column.decode = newDecode(column);
+}
+
+module.exports = _new;

package/src/table/column/date/formatOut.js

@@ -0,0 +1,11 @@
+var getSessionSingleton = require('../../getSessionSingleton');
+
+function formatOut(column, alias) {
+	var formatColumn = getSessionSingleton('formatDateOut');
+	if (formatColumn)
+		return formatColumn(column, alias);
+	else
+		return `${alias}.${column._dbName}`;
+}
+
+module.exports = formatOut;

package/src/table/column/date/newDecode.js

@@ -0,0 +1,17 @@
+var newDecodeCore = require('../newDecodeCore');
+var dateToISOString = require('../../../dateToISOString');
+
+function _new(column) {
+	var decodeCore = newDecodeCore(column);
+
+	return function(value) {
+		value = decodeCore(value);
+		if (value === null)
+			return value;
+		else if (typeof value === 'string')
+			return value.replace(' ', 'T').replace(' ', '');
+		return dateToISOString(value);
+	};
+}
+
+module.exports = _new;

package/src/table/column/date/newEncode.js

@@ -0,0 +1,47 @@
+var newPara = require('../../query/newParameterized');
+var purify = require('./purify');
+var getSessionContext = require('../../getSessionContext');
+var getSessionSingleton = require('../../getSessionSingleton');
+
+function _new(column) {
+	var encode = function(value) {
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				return newPara('null');
+			return newPara('\'' + column.dbNull + '\'');
+		}
+		var context = getSessionContext();
+		var encodeCore = context.encodeDate || encodeDate;
+		var formatIn = context.formatDateIn;
+		return newPara(formatIn ? formatIn('?') : '?', [encodeCore(value)]);
+	};
+
+	encode.unsafe = function(value) {
+		value = purify(value);
+		if (value == null) {
+			if (column.dbNull === null)
+				return newPara('null');
+			return newPara('\'' + column.dbNull + '\'');
+		}
+		var encodeCore = getSessionSingleton('encodeDate') || encodeDate;
+		return encodeCore(value);
+	};
+
+	return encode;
+
+
+}
+function encodeDate(date) {
+	date = date.toISOString ? removeTimezone(date.toISOString(date)) : removeTimezone(date);
+	return date;
+}
+
+function removeTimezone(isoString) {
+	let dateTimePattern = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?/;
+	let match = isoString.match(dateTimePattern);
+	return match ? match[0] : isoString;
+}
+
+
+module.exports = _new;

package/src/table/column/date/purify.js

@@ -0,0 +1,17 @@
+var tryParseISO = require('./tryParseISO');
+var dateToISOString = require('../../../dateToISOString');
+
+function purify(value) {
+	if(value == null)
+		return null;
+	if (value.toISOString)
+		return dateToISOString(value);
+	if (value.indexOf('Z') > -1)
+		return 	dateToISOString(new Date(value));
+	var iso = tryParseISO(value);
+	if (iso)
+		return iso;
+	return value;
+}
+
+module.exports = purify;

package/src/table/column/date/toISOString.js

@@ -0,0 +1,25 @@
+function dateToIsoString(date) {
+	let tzo = -date.getTimezoneOffset();
+	let dif = tzo >= 0 ? '+' : '-';
+
+	function pad(num) {
+		let norm = Math.floor(Math.abs(num));
+		return (norm < 10 ? '0' : '') + norm;
+	}
+
+	function padMilli(d) {
+		return (d.getMilliseconds() + '').padStart(3, '0');
+	}
+
+	return date.getFullYear() +
+		'-' + pad(date.getMonth() + 1) +
+		'-' + pad(date.getDate()) +
+		'T' + pad(date.getHours()) +
+		':' + pad(date.getMinutes()) +
+		':' + pad(date.getSeconds()) +
+		'.' + padMilli(date) +
+		dif + pad(tzo / 60) +
+		':' + pad(tzo % 60);
+}
+
+module.exports = dateToIsoString;