orange-orm 4.5.0-beta.4 → 4.5.1-beta.1

package/src/sqlite3/newDatabase.js

@@ -0,0 +1,116 @@
+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 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
+			return domain.run(run);
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool, options);
+			await new Promise(transaction)
+				.then(begin)
+				.then(() => fn(domain))
+				.then((res) => result = res)
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain, e));
+			return result;
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool, options);
+			p = new Promise(transaction);
+
+			return p.then(begin);
+		}
+
+	};
+
+	c.createTransaction = function(options) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction).then(begin));
+
+		function run(fn) {
+			return p.then(() => fn(domain));
+		}
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
+		return run;
+
+		function begin() {
+			return _begin(domain, options);
+		}
+	};
+
+	c.query = function(query) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool);
+		let p = domain.run(() => new Promise(transaction)
+			.then(() => setSessionSingleton(domain, 'changes', []))
+			.then(() => doQuery(domain, query).then(onResult, onError)));
+		return p;
+
+		function onResult(result) {
+			releaseDbClient(domain);
+			return result;
+		}
+
+		function onError(e) {
+			releaseDbClient(domain);
+			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/sqlite3/newTransaction.js

@@ -0,0 +1,83 @@
+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 quote = require('./quote');
+
+function newResolveTransaction(domain, pool, { readonly = false } = {})  {
+	var rdb = {poolFactory: pool};
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+	rdb.engine = 'sqlite';
+	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;
+	rdb.quote = quote;
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapQuery(client)(query, (err, res) => {
+							done();
+							callback(err, res);
+						});
+					} catch (e) {
+						done();
+						callback(e);
+					}
+				});
+			}
+		};
+		domain.rdb = rdb;
+		return (onSuccess) => onSuccess();
+	}
+
+	return function(onSuccess, onError) {
+		pool.connect(onConnected);
+
+		function onConnected(err, client, done) {
+			try {
+				if (err) {
+					onError(err);
+					return;
+				}
+				client.executeQuery = wrapQuery(client);
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+function decodeJSON(value) {
+	return JSON.parse(value);
+}
+
+module.exports = newResolveTransaction;

package/src/sqlite3/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 → sqlite3}/pool/newGenericPool.js

@@ -2,7 +2,7 @@
 var defaults = require('../../poolDefaults');
 
 var genericPool = require('../../generic-pool');
-var sqlite = require('sqlite3');
+var sqlite;
 
 function newGenericPool(connectionString, poolOptions) {
 	poolOptions = poolOptions || {};
@@ -11,7 +11,15 @@ function newGenericPool(connectionString, poolOptions) {
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log || defaults.poolLog,
-		create: function(cb) {
+		create: async function(cb) {
+			try {
+				if (!sqlite)
+					sqlite = await import('sqlite3');
+				sqlite = sqlite.default || sqlite;
+			}
+			catch (err) {
+				return cb(err, null);
+			}
 			var client = new sqlite.Database(connectionString, onConnected);
 
 			function onConnected(err) {

package/src/sqlite3/quote.js

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

package/src/sqlite3/selectForUpdateSql.js

@@ -0,0 +1,5 @@
+const quote = require('../table/quote');
+
+module.exports = function(alias) {
+	return ' FOR UPDATE OF ' + quote(alias);
+};

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

@@ -1,15 +1,26 @@
 var newDecodeCore = require('../newDecodeCore');
+var getSessionSingleton = require('../../getSessionSingleton');
 
 function _new(column) {
 	var decodeCore = newDecodeCore(column);
 
 	return function(context, value) {
+
+		var toBase64  = getSessionSingleton(context, 'decodeBinary') || toBase64Default;
+
 		value = decodeCore(context, value);
 		if (value === null)
 			return value;
-		else
-			return value.toString('base64');
+		else {
+			const ret = toBase64(value);
+			return ret;
+		}
 	};
 }
 
+function toBase64Default(buffer) {
+	return buffer.toString('base64');
+
+}
+
 module.exports = _new;

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

@@ -1,26 +1,36 @@
 var purify = require('./purify');
 var newParam = require('../../query/newParameterized');
+var getSessionSingleton = require('../../getSessionSingleton');
 
 function _new(_column) {
 
-	function encode(_context, value) {
+	function encode(context, value) {
 		value = purify(value);
 		if (value === null)
 			return newParam('null');
-		return newParam('?', [Buffer.from(value, 'base64')]);
+
+		var encodeCore = getSessionSingleton(context, 'encodeBinary') || encodeDefault;
+		const enc = encodeCore(value);
+		return newParam('?', [enc]);
 	}
-	encode.unsafe = function(_context, value) {
+	encode.unsafe = function(context, value) {
 		value = purify(value);
 		if (value === null)
 			return 'null';
-		return Buffer.from(value, 'base64');
+		var encodeCore = getSessionSingleton(context, 'encodeBinary') || encodeDefault;
+		return encodeCore(value);
 	};
 
-	encode.direct = function(_context, value) {
-		return Buffer.from(value, 'base64');
+	encode.direct = function(context, value) {
+		var encodeCore = getSessionSingleton(context, 'encodeBinary') || encodeDefault;
+		return encodeCore(value);
 	};
 
 	return encode;
 }
 
+function encodeDefault(base64) {
+	return Buffer.from(base64, 'base64');
+}
+
 module.exports = _new;

package/src/table/resultToRows/newDecodeDbRow.js

@@ -207,7 +207,7 @@ function newDecodeDbRow(table, dbRow, filteredAliases, shouldValidate, isInsert)
 		for (let i = 0; i < numberOfColumns; i++) {
 			let index = offset + i;
 			let key = keys[index];
-			if (row[key] !== undefined)
+			if (row[key] !== undefined && !isInsert)
 				row[key] = columns[i].decode(context, row[key]);
 			if (shouldValidate && columns[i].validate)
 				columns[i].validate(row[key], row, isInsert);

package/src/tedious/pool/newGenericPool.js

@@ -3,7 +3,7 @@
 
 var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
-var tedious = require('tedious');
+var tedious;
 var parseConnectionString = require('./parseConnectionString');
 
 function newGenericPool(connectionString, poolOptions) {
@@ -17,7 +17,13 @@ function newGenericPool(connectionString, poolOptions) {
 		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
 		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
 		log: poolOptions.log || defaults.poolLog,
-		create: function(cb) {
+		create: async function(cb) {
+			try {
+				if (!tedious)
+					tedious = await import('tedious');
+			} catch (err) {
+				return cb(err, null);
+			}
 			var client = new tedious.Connection(connectionString);
 			client.on('connect', onConnected);
 			client.connect();

package/src/tedious/wrapQuery.js

@@ -1,12 +1,31 @@
 var log = require('../table/log');
-var { Request, TYPES } = require('tedious');
 
 function wrapQuery(connection) {
+	let CachedRequest = null;
+	let CachedTypes = null;
+
 	return runQuery;
 
 	function runQuery(query, onCompleted) {
+		if (!CachedRequest || !CachedTypes) {
+			import('tedious')
+				.then(({ Request, TYPES }) => {
+					CachedRequest = Request;
+					CachedTypes = TYPES;
+					doQuery(query, onCompleted);
+				})
+				.catch(err => onCompleted(extractError(err), []));
+		}
+		else {
+			doQuery(query, onCompleted);
+		}
+	}
+
+	function doQuery(query, onCompleted) {
 		const result = [];
 		const sql = replaceParamChar(query.sql(), query.parameters);
+
+		// Transaction statements
 		if (sql.length < 18 && query.parameters.length === 0) {
 			if (sql === 'BEGIN TRANSACTION') {
 				log.emitQuery({ sql, parameters: [] });
@@ -30,38 +49,45 @@ function wrapQuery(connection) {
 				return;
 			}
 		}
+
 		let keys;
-		var request = new Request(sql, onInnerCompleted);
-		const params = addParameters(request, query.parameters);
+		// Now we can safely create Request using CachedRequest
+		var request = new CachedRequest(sql, onInnerCompleted);
+		const params = addParameters(request, query.parameters, CachedTypes);
+
 		request.on('row', rows => {
 			const tmp = {};
 			if (!keys) {
 				keys = Object.keys(rows);
 			}
-			keys.forEach((cols) => {
+			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
+			} else {
 				onCompleted(null, result);
+			}
 		}
 	}
+}
 
-	function extractError(e) {
-		if (e && e.errors)
-			return e.errors[0];
-		else
-			return e;
-	}
+// same helpers as before
 
+function extractError(e) {
+	if (e && e.errors) {
+		return e.errors[0];
+	}
+	else {
+		return e;
+	}
 }
 
 function replaceParamChar(sql, params) {
@@ -77,7 +103,7 @@ function replaceParamChar(sql, params) {
 	return sql;
 }
 
-function addParameters(request, params) {
+function addParameters(request, params, TYPES) {
 	const res = [];
 	for (let i = 0; i < params.length; i++) {
 		const p = [`${i}`, toType(params[i]), params[i]];
@@ -93,7 +119,6 @@ function addParameters(request, params) {
 			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))
@@ -104,9 +129,7 @@ function addParameters(request, params) {
 			return TYPES.NVarChar;
 		else
 			throw new Error('Unknown data type');
-
 	}
-
 }
 
-module.exports = wrapQuery;
+module.exports = wrapQuery;

package/src/client/merge.js

@@ -1,9 +0,0 @@
-const fs = require('fs').promises;
-
-async function merge() {
-	let data1 = await fs.readFile('./src/client/self.js', 'utf8');
-	let data2 = await fs.readFile('./src/client/index.mjs', 'utf8');
-	await fs.writeFile('./src/client/index.mjs', data1 + data2);
-}
-
-merge();