orange-orm 3.10.2

package/src/tedious/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/tedious/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/tedious/pool/newGenericPool.js

@@ -0,0 +1,71 @@
+// @ts-nocheck
+/* eslint-disable no-prototype-builtins */
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('./defaults');
+var genericPool = require('../../generic-pool');
+var tedious = require('tedious');
+var parseConnectionString = require('./parseConnectionString');
+
+function newGenericPool(connectionString, poolOptions) {
+	if (typeof connectionString === 'string')
+		connectionString = parseConnectionString(connectionString);
+	if (typeof connectionString === 'object')
+		connectionString.options = { ...connectionString.options, ...{ useColumnNames: true } };
+	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 tedious.Connection(connectionString);
+			client.on('connect', onConnected);
+			client.connect();
+
+			function onConnected(err) {
+				if (err) {
+					if (err.errors)
+						return cb(err.errors[0], null);
+					else
+						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/tedious/pool/parseConnectionString.js

@@ -0,0 +1,40 @@
+var { parseConnectionString } = require('@tediousjs/connection-string');
+
+function parse(connectionString) {
+	const config = { options: {useUTC: false}, authentication: { type: 'default', options: {} } };
+	const elements = parseConnectionString(connectionString);
+	for (const key in elements) {
+		const value = elements[key];
+		switch (key) {
+		case 'uid':
+			config.authentication.options.userName = value;
+			break;
+		case 'pwd':
+			config.authentication.options.password = value;
+			break;
+		case 'server':
+			config.server = value.split(',')[0];
+			if (value.split(',')[1] !== undefined)
+				config.options.port = Number.parseInt(value.split(',')[1]);
+			break;
+		case 'database':
+			config.options.database = value;
+			break;
+		case 'trustservercertificate':
+			config.options.trustServerCertificate = value.toLowerCase() === 'yes';
+			break;
+		case 'app':
+			config.options.appName = value;
+			break;
+		case 'appname':
+			config.options.appName = value;
+			break;
+
+		default:
+			break;
+		}
+	}
+	return config;
+}
+
+module.exports = parse;

package/src/tedious/selectForUpdateSql.js

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

package/src/tedious/wrapQuery.js

@@ -0,0 +1,112 @@
+var log = require('../table/log');
+var { Request, TYPES } = require('tedious');
+
+function wrapQuery(connection) {
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		const result = [];
+		const sql = replaceParamChar(query.sql(), query.parameters);
+		if (sql.length < 18 && query.parameters.length === 0) {
+			if (sql === 'BEGIN TRANSACTION') {
+				log.emitQuery({ sql, parameters: [] });
+				connection.beginTransaction((err) => {
+					onCompleted(extractError(err), []);
+				});
+				return;
+			}
+			else if (sql === 'COMMIT') {
+				log.emitQuery({ sql, parameters: [] });
+				connection.commitTransaction((err) => {
+					onCompleted(extractError(err), []);
+				});
+				return;
+			}
+			else if (sql === 'ROLLBACK') {
+				log.emitQuery({ sql, parameters: [] });
+				connection.rollbackTransaction((err) => {
+					onCompleted(extractError(err), []);
+				});
+				return;
+			}
+		}
+		let keys;
+		var request = new Request(sql, onInnerCompleted);
+		const params = addParameters(request, query.parameters);
+		request.on('row', rows => {
+			const tmp = {};
+			if (!keys) {
+				keys = Object.keys(rows);
+			}
+			keys.forEach((cols) => {
+				tmp[cols] = rows[cols].value;
+			});
+			result.push(tmp);
+		});
+		log.emitQuery({ sql, parameters: params });
+		connection.execSql(request);
+
+		function onInnerCompleted(err) {
+			if (err) {
+				onCompleted(extractError(err));
+			}
+			else
+				onCompleted(null, result);
+		}
+	}
+
+	function extractError(e) {
+		if (e && e.errors)
+			return e.errors[0];
+		else
+			return e;
+	}
+
+}
+
+function replaceParamChar(sql, params) {
+	if (params.length === 0)
+		return sql;
+	var splitted = sql.split('?');
+	sql = '';
+	var lastIndex = splitted.length - 1;
+	for (var i = 0; i < lastIndex; i++) {
+		sql += splitted[i] + '@' + i;
+	}
+	sql += splitted[lastIndex];
+	return sql;
+}
+
+function addParameters(request, params) {
+	const res = [];
+	for (let i = 0; i < params.length; i++) {
+		const p = [`${i}`, toType(params[i]), params[i]];
+		request.addParameter.apply(request, p);
+		res.push(p);
+	}
+	return res;
+
+	function toType(p) {
+		if (typeof p === 'string')
+			return TYPES.VarChar;
+		else if (Number.isInteger(p))
+			return TYPES.Int;
+		else if (typeof p === 'number')
+			return TYPES.Money;
+		// @ts-ignore
+		else if (p instanceof Date && !isNaN(p))
+			return TYPES.Date;
+		else if (Array.isArray(p))
+			return TYPES.NVarChar;
+		else if (Buffer.isBuffer(p))
+			return TYPES.VarBinary;
+		else if (typeof p === 'object' && p instanceof Object)
+			return TYPES.NVarChar;
+		else
+			throw new Error('Unknown data type');
+
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/toCompareObject.js

@@ -0,0 +1,41 @@
+const dateToISOString = require('./dateToISOString');
+const isNode = (typeof window === 'undefined');
+
+function toCompareObject(object) {
+	if (Array.isArray(object)) {
+		let copy = {};
+		Object.defineProperty(copy, '__patchType', {
+			value: 'Array',
+			writable: true,
+			enumerable: true
+		});
+
+		for (var i = 0; i < object.length; i++) {
+			let element = toCompareObject(object[i]);
+			if (element === Object(element) && 'id' in element)
+				copy[element.id] = element;
+			else
+				copy[i] = element;
+		}
+		return copy;
+	}
+	if (isNode && isNodeBuffer(object))
+		return object.toString('base64');
+	// @ts-ignore
+	else if (object instanceof Date && !isNaN(object))
+		return dateToISOString(object);
+	else if (object === Object(object)) {
+		let copy = {};
+		for (let name in object) {
+			copy[name] = toCompareObject(object[name]);
+		}
+		return copy;
+	}
+	return object;
+}
+
+function isNodeBuffer(object) {
+	return Buffer.isBuffer(object);
+}
+
+module.exports = toCompareObject;

package/src/useHook.js

@@ -0,0 +1,9 @@
+let flags = require('./flags');
+let versionArray = process.version.replace('v', '').split('.');
+let major = parseInt(versionArray[0]);
+
+function useHook() {
+	return flags.useHook && major > 7;
+}
+
+module.exports = useHook;

package/src/validateDeleteAllowed.js

@@ -0,0 +1,49 @@
+async function validateDeleteAllowed({ row, options, table }) {
+	if (options.readonly) {
+		const e = new Error(`Cannot delete ${table._dbName} because it is readonly`);
+		// @ts-ignore
+		e.status = 405;
+		throw e;
+	}
+	for (let p in options)
+		if (isColumn(p, table))
+			return;
+		else if (isManyRelation(p, table)) {
+			const childTable = table[p]._relation.childTable;
+			const childOptions = inferOptions(options, p);
+			const children = await row[p];
+			for (let i = 0; i < children.length; i++) {
+				const childRow = children[i];
+				await validateDeleteAllowed({ row: childRow, options: childOptions, table: childTable });
+			}
+		}
+		else if (isOneRelation(p, table)) {
+			const childOptions = inferOptions(options, p);
+			const childTable = table[p]._relation.childTable;
+			let childRow = await row[p];
+			await validateDeleteAllowed({ row: childRow, options: childOptions, table: childTable });
+		}
+}
+
+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 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] || {})};
+}
+
+module.exports = validateDeleteAllowed;

package/src/validateDeleteConflict.js

@@ -0,0 +1,92 @@
+// @ts-nocheck
+/* eslint-disable */
+let { inspect } = require('util');
+let assert = require('assert');
+const toCompareObject = require('./toCompareObject');
+
+async function validateDeleteConflict({ row, oldValue, options, table }) {
+	for (let p in oldValue) {
+		if (isColumn(p, table)) {
+			const option = inferOptions(options, p);
+			let strategy = option.concurrency || 'optimistic';
+			if ((strategy === 'optimistic')) {
+				try {
+					const column = table[p];
+					if (column?.tsType === 'DateColumn') {
+						assertDatesEqual(oldValue[p], toCompareObject(row[p]));
+					}
+					else
+						assert.deepEqual(oldValue[p], toCompareObject(row[p]));						
+				}
+				catch (e) {
+					throw new Error(`The field ${p} was changed by another user. Expected ${inspect(oldValue[p], false, 10)}, but was ${inspect(row[p], false, 10)}.`);
+				}
+			}
+		}
+		else if (isManyRelation(p, table)) {
+			const childTable = table[p]._relation.childTable;
+			for (let name in oldValue[p]) {
+				if (name === '__patchType')
+					continue;
+				let childRow = await childTable.tryGetById.apply(null, JSON.parse(name));
+				if (!childRow)
+					throw new Error(`${p} with id ${name} was deleted by another user`);
+				if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p][name], defaultConcurrency, concurrency: concurrency[p], table: childTable }))
+					return false;
+			}
+		}
+		else if (isOneRelation(p, table)) {
+			const childTable = table[p]._relation.childTable;
+			let childRow = await row[p];
+			if (!childRow)
+				throw new Error(`${p} was deleted by another user`);
+			if (! await validateDeleteConflict({ row: childRow, oldValue: oldValue[p], defaultConcurrency, concurrency: concurrency[p], table: childTable }))
+				return false;
+		}
+
+	}
+	return true;
+}
+
+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 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 assertDatesEqual(date1, date2) {
+	if (date1 && date2) {
+		const parts1 = date1.split('T');
+		const time1parts = (parts1[1] || '').split(/[-+.]/);
+		const parts2 = date2.split('T');
+		const time2parts = (parts2[1] || '').split(/[-+.]/);
+		while (time1parts.length !== time2parts.length) {
+			if (time1parts.length > time2parts.length)
+				time1parts.pop();
+			else if (time1parts.length < time2parts.length)
+				time2parts.pop();
+		}
+		date1 = `${parts1[0]}T${time1parts[0]}`;
+		date2 = `${parts2[0]}T${time2parts[0]}`;
+	}
+	assert.deepEqual(date1, date2);
+}
+
+
+module.exports = validateDeleteConflict;