orange-orm 4.5.5 → 4.6.0-beta.1

package/src/rollup.config.server.js

@@ -0,0 +1,32 @@
+import json from '@rollup/plugin-json';
+import commonjs from '@rollup/plugin-commonjs';
+import nodeResolve from '@rollup/plugin-node-resolve';
+
+export default {
+	input: './src/index.js',
+	output: {
+		file: './dist/index.mjs',
+		format: 'esm',
+		interop: 'auto'
+	},
+
+	// plugins: [json(), commonjs()],
+	plugins: [json(), nodeResolve({ preferBuiltins: false }), commonjs({
+		transformMixedEsModules: true,
+		esmExternals: true,      // Add this
+		requireReturnsDefault: 'preferred'  // Change this
+	})],
+	external(id) {
+		// If it's in node_modules, mark as external
+		return id.includes('node_modules');
+	},
+	onwarn: (warning, warn) => {
+		if (warning.code === 'CIRCULAR_DEPENDENCY') {
+			// Log the full circular dependency warning message
+			console.warn(`[CIRCULAR DEPENDENCY] ${warning.message}`);
+		} else {
+			// For all other warnings, use Rollup's default handler.
+			warn(warning);
+		}
+	},
+};

package/src/runtimes.js

@@ -0,0 +1,24 @@
+// @ts-ignore
+// eslint-disable-next-line no-undef
+const deno = typeof Deno !== 'undefined' && Deno.version?.deno;
+// @ts-ignore
+// eslint-disable-next-line no-undef
+const bun = typeof Bun !== 'undefined' && Bun.version;
+const node = (typeof process !== 'undefined' && process.versions?.node && !deno && !bun) ? process.versions.node : false;
+
+function parseVersion(version) {
+	if (version) {
+		const versionArray = version.split('.');
+		return {
+			version,
+			major: parseInt(versionArray[0]),
+			minor: parseInt(versionArray[1]),
+			patch: parseInt(versionArray[2])
+		};
+	}
+	else
+		return false;
+}
+
+
+module.exports = { deno: parseVersion(deno), bun: parseVersion(bun), node: parseVersion(node) };

package/src/sap/newTransaction.js

@@ -52,7 +52,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 						return callback(err);
 					}
 					try {
-						wrapQuery(client)(query, (err, res) => {
+						wrapQuery(domain, client)(query, (err, res) => {
 							done();
 							callback(err, res);
 						});
@@ -77,7 +77,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 					onError(err);
 					return;
 				}
-				client.executeQuery = wrapQuery(client);
+				client.executeQuery = wrapQuery(domain, client);
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
 				domain.rdb = rdb;

package/src/sqlite3/encodeBuffer.js

@@ -0,0 +1,7 @@
+//unused because using sql parameters instead
+//Remove ?
+function encodeBuffer(buffer) {
+	return 'E\'\\\\x' + buffer.toString('hex') + '\'';
+}
+
+module.exports = encodeBuffer;

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/{sqlite → sqlite3}/newTransaction.js

@@ -1,12 +1,12 @@
 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');
+const encodeBoolean = require('../sqlite/encodeBoolean');
+const deleteFromSql = require('../sqlite/deleteFromSql');
+const selectForUpdateSql = require('../sqlite/selectForUpdateSql');
+const lastInsertedSql = require('../sqlite/lastInsertedSql');
+const limitAndOffset = require('../sqlite/limitAndOffset');
+const insertSql = require('../sqlite/insertSql');
+const insert = require('../sqlite/insert');
+const quote = require('../sqlite/quote');
 
 function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 	var rdb = {poolFactory: pool};
@@ -41,7 +41,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 						return callback(err);
 					}
 					try {
-						wrapQuery(client)(query, (err, res) => {
+						wrapQuery(domain, client)(query, (err, res) => {
 							done();
 							callback(err, res);
 						});
@@ -65,7 +65,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {})  {
 					onError(err);
 					return;
 				}
-				client.executeQuery = wrapQuery(client);
+				client.executeQuery = wrapQuery(domain, client);
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
 				domain.rdb = rdb;

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/{sqlite → sqlite3}/wrapQuery.js

@@ -1,6 +1,6 @@
 var log = require('../table/log');
 
-function wrapQuery(connection) {
+function wrapQuery(_context, connection) {
 	var runOriginalQuery = connection.all;
 	return runQuery;
 

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

@@ -54,7 +54,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 						return callback(err);
 					}
 					try {
-						wrapQuery(client)(query, (err, res) => {
+						wrapQuery(domain, client)(query, (err, res) => {
 							done();
 							callback(err, res);
 						});
@@ -78,7 +78,7 @@ function newResolveTransaction(domain, pool, { readonly = false } = {}) {
 					onError(err);
 					return;
 				}
-				client.executeQuery = wrapQuery(client);
+				client.executeQuery = wrapQuery(domain, client);
 				rdb.dbClient = client;
 				rdb.dbClientDone = done;
 				domain.rdb = rdb;

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) {
+function wrapQuery(_context, 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();