orange-orm 4.5.5 → 4.6.0

package/docs/changelog.md

@@ -1,4 +1,7 @@
 ## Changelog
+__4.6.0__  
+Support for Deno and Bun.  
+Using builtin sqlite for Node22++.    
 __4.5.5__  
 Bugfix:  Parameterized queries are case sensitive on SAP ASE .  See [#123](https://github.com/alfateam/orange-orm/issues/123)  
 __4.5.4__  

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "orange-orm",
-  "version": "4.5.5",
+  "version": "4.6.0",
   "main": "./src/index.js",
-  "browser": "./src/client/index.mjs",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/index.browser.mjs",
+  "exports": {
+    ".": {
+      "require": "./src/index.js",
+      "import": "./dist/index.mjs",
+      "browser": "./dist/index.browser.mjs"
+    }
+  },
   "bin": {
     "orange-orm": "bin/rdb.js"
   },
@@ -43,8 +51,11 @@
     "coverage": "vitest run --coverage.enabled --coverage.reporter='text-summary' --threads=false",
     "testw": "vitest --threads=false update",
     "tscheck": "tsc ./src/index.d.ts --module commonjs --target es2022 --noEmit true --strict true --esModuleInterop true",
-    "concat": "node ./src/client/merge.js",
-    "build": "rollup -c ./src/client/rollup.config.js && npm run concat",
+    "concat-server": "node ./src/merge-server.js",
+    "concat-browser": "node ./src/merge-browser.js",
+    "build": "npm run build-server && npm run build-browser",
+    "build-server": "rollup -c ./src/rollup.config.server.js && npm run concat-server",
+    "build-browser": "rollup -c ./src/rollup.config.browser.js && npm run concat-browser",
     "lint": "eslint ./",
     "fix": "eslint ./ --fix",
     "owasp": "owasp-dependency-check --project \"MY_PROJECT\" --scan \"package-lock.json\" --exclude \"dependency-check-bin\" --out \"owasp\" --format HTML",

package/src/bunPg/newDatabase.js

@@ -0,0 +1,137 @@
+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('../pg/schema');
+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);
+
+		async function runInTransaction() {
+			let result;
+			let transaction = newTransaction(domain, pool, options);
+			await new Promise(transaction)
+				.then(begin)
+				.then(negotiateSchema)
+				.then(() => fn(domain))
+				.then((res) => result = res)
+				.then(() => commit(domain))
+				.then(null, (e) => rollback(domain,e));
+			return result;
+		}
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		function run() {
+			let p;
+			let transaction = newTransaction(domain, pool, options);
+			p = new Promise(transaction);
+
+			return p.then(begin)
+				.then(negotiateSchema);
+		}
+
+		function negotiateSchema(previous) {
+			let schema = options && options.schema;
+			if (!schema)
+				return previous;
+			return executeSchema(domain, schema);
+		}
+	};
+
+	c.createTransaction = function(options) {
+		let domain = createDomain();
+		let transaction = newTransaction(domain, pool, options);
+		let p = domain.run(() => new Promise(transaction)
+			.then(begin).then(negotiateSchema));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		function negotiateSchema(previous) {
+			let schema = options && options.schema;
+			if (!schema)
+				return previous;
+			return executeSchema(domain,schema);
+		}
+
+		run.rollback = rollback.bind(null, domain);
+		run.commit = commit.bind(null, domain);
+
+		return run;
+	};
+
+	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.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/bunPg/newPool.js

@@ -0,0 +1,19 @@
+const promisify = require('../promisify');
+const pools = require('../pools');
+const end = require('./pool/end');
+const newPgPool = require('./pool/newPgPool');
+const newId = require('../newId');
+
+function newPool(connectionString, poolOptions) {
+	let pool = newPgPool(connectionString, poolOptions);
+	let id = newId();
+	let boundEnd = end.bind(null, pool, id);
+	let c = {};
+
+	c.connect = pool.connect;
+	c.end = promisify(boundEnd);
+	pools[id] = c;
+	return c;
+}
+
+module.exports = newPool;

package/src/bunPg/newTransaction.js

@@ -0,0 +1,87 @@
+var wrapQuery = require('./wrapQuery');
+var encodeDate = require('../pg/encodeDate');
+var encodeBoolean = require('../pg/encodeBoolean');
+const encodeBinary = require('../nodeSqlite/encodeBinary');
+const decodeBinary = require('../nodeSqlite/decodeBinary');
+var deleteFromSql = require('../pg/deleteFromSql');
+var selectForUpdateSql = require('../pg/selectForUpdateSql');
+var limitAndOffset = require('../pg/limitAndOffset');
+var formatDateOut = require('../pg/formatDateOut');
+var encodeJSON = require('../pg/encodeJSON');
+var insertSql = require('../pg/insertSql');
+var insert = require('../pg/insert');
+var quote = require('../pg/quote');
+
+function newResolveTransaction(domain, pool, { readonly = false } = {}) {
+	var rdb = { poolFactory: pool };
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+
+	rdb.engine = 'pg';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.encodeDate = encodeDate;
+	rdb.encodeBinary = encodeBinary;
+	rdb.decodeBinary = decodeBinary;
+	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;
+	rdb.quote = quote;
+	rdb.cache = {};
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapQuery(domain, 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(domain, client);
+				rdb.dbClient = client;
+				rdb.dbClientDone = done;
+				domain.rdb = rdb;
+				onSuccess();
+			} catch (e) {
+				onError(e);
+			}
+		}
+	};
+}
+
+module.exports = newResolveTransaction;

package/src/bunPg/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/bunPg/pool/newPgPool.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-prototype-builtins */
+// Simplified pool creator using URL API and handling search_path param
+
+const log = require('../../table/log');
+const defaults = require('../../poolDefaults');
+const genericPool = require('../../generic-pool');
+const { URL } = require('url');
+let SQL;
+
+function newPgPool(connectionString, poolOptions = {}) {
+	let searchPath;
+	let connStr = connectionString;
+
+	try {
+		const url = new URL(connectionString);
+		const paramName = url.searchParams.has('search_path')
+			? 'search_path'
+			: url.searchParams.has('searchPath')
+				? 'searchPath'
+				: null;
+		if (paramName) {
+			searchPath = url.searchParams.get(paramName);
+			url.searchParams.delete(paramName);
+			connStr = url.toString();
+		}
+	} catch {
+		// Non-URL string; leave as-is
+	}
+
+	//@ts-ignore
+	const pool = genericPool.Pool({
+		max: poolOptions.size || poolOptions.poolSize || defaults.poolSize,
+		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
+		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
+		log: poolOptions.log,
+
+		create: async (cb) => {
+			try {
+				if (!SQL) ({ SQL } = await import('bun'));
+				const client = new SQL(connStr);
+				client.poolCount = 0;
+				await applySearchPath(client, searchPath);
+				cb(null, client);
+			} catch (err) {
+				cb(err, null);
+			}
+		},
+
+		destroy: (client) => {
+			client._destroying = true;
+			client.poolCount = undefined;
+			client.end();
+		},
+	});
+
+	pool.connect = (cb) => {
+		pool.acquire((err, client) => {
+			if (err) return cb(err, null, () => {});
+			client.poolCount++;
+			cb(null, client, (releaseErr) => {
+				releaseErr ? pool.destroy(client) : pool.release(client);
+			});
+		});
+	};
+
+	return pool;
+}
+
+async function applySearchPath(client, searchPath) {
+	if (searchPath) {
+		const sql = `SET search_path TO ${searchPath}`;
+		log.emitQuery({ sql, parameters: [] });
+		await client.unsafe(sql);
+	}
+}
+
+module.exports = newPgPool;

package/src/bunPg/wrapQuery.js

@@ -0,0 +1,97 @@
+const log = require('../table/log');
+const replaceParamChar = require('../pg/replaceParamChar');
+const tryGetSessionContext = require('../table/tryGetSessionContext');
+
+function wrapQuery(context, connection) {
+	return runQuery;
+
+	async function runQuery(query, onCompleted) {
+		try {
+
+			const sql = replaceParamChar(query, query.parameters);
+			let rdb = tryGetSessionContext(context);
+			let transactionHandler = rdb.transactionHandler;
+			log.emitQuery({ sql, parameters: query.parameters });
+
+			if (sql.length < 18 && query.parameters.length === 0) {
+				if (sql === 'BEGIN TRANSACTION' || sql === 'BEGIN') {
+					if (transactionHandler)
+						return onCompleted(new Error('Already inside a transaction'), []);
+					beginTransaction(connection).then(_transactionHandler => {
+						rdb.transactionHandler = _transactionHandler;
+						onCompleted(null, []);
+					}, onCompleted);
+					return;
+				}
+				else if (sql === 'COMMIT') {
+					if (!transactionHandler)
+						return onCompleted(new Error('Cannot commit outside transaction'), []);
+					transactionHandler.resolve();
+					transactionHandler.promise.then(() => onCompleted(null, []), err => onCompleted(err, []));
+					return;
+				}
+				else if (sql === 'ROLLBACK') {
+					if (!transactionHandler)
+						return onCompleted(new Error('Cannot rollback outside transaction'), []);
+					transactionHandler.reject(new Error('__rollback__'));
+					transactionHandler.promise.then(null, (err) => {
+						if (err.message === '__rollback__')
+							onCompleted(null, []);
+						else
+							onCompleted(err, []);
+					});
+					return;
+				}
+			}
+
+			let result;
+			const _connection = transactionHandler?.tx || connection;
+			if (query.parameters.length === 0)
+				result = await _connection.unsafe(sql);
+			else
+				result = await _connection.unsafe(sql, query.parameters);
+			onCompleted(null, result);
+		}
+		catch (e) {
+			onCompleted(e);
+		}
+	}
+
+}
+
+function beginTransaction(connection) {
+
+	let beginIsResolved = false;
+	let resolve;
+	let reject;
+	let resolveBegin;
+	let rejectBegin;
+
+	let sqlPromise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	let beginPromise = new Promise((res,rej) => {
+		resolveBegin = res;
+		rejectBegin = rej;
+	});
+	connection.begin(async (tx) => {
+		beginIsResolved = true;
+		resolveBegin({
+			tx,
+			resolve,
+			reject,
+			promise: sqlPromise,
+		});
+		return sqlPromise;
+	}).then(null,
+		e => {
+			if (!beginIsResolved)
+				rejectBegin(e);
+			if (e?.message !== '__rollback__')
+				throw e;
+		});
+	return beginPromise;
+}
+
+module.exports = wrapQuery;

package/src/bunSqlite/newPool.js

@@ -0,0 +1,19 @@
+const promisify = require('../promisify');
+const pools = require('../pools');
+const end = require('../sqlite/pool/end');
+const newGenericPool = require('./pool/newGenericPool');
+const newId = require('../newId');
+
+function newPool(connectionString, poolOptions) {
+	let pool = newGenericPool(connectionString, poolOptions);
+	let id = newId();
+	let boundEnd = end.bind(null, pool, id);
+	let c = {};
+
+	c.connect = pool.connect;
+	c.end = promisify(boundEnd);
+	pools[id] = c;
+	return c;
+}
+
+module.exports = newPool;

package/src/bunSqlite/newTransaction.js

@@ -0,0 +1,88 @@
+const wrapQuery = require('./wrapQuery');
+const encodeBoolean = require('../sqlite/encodeBoolean');
+const encodeBinary = require('../nodeSqlite/encodeBinary');
+const decodeBinary = require('../nodeSqlite/decodeBinary');
+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};
+	if (!pool.connect) {
+		pool = pool();
+		rdb.pool = pool;
+	}
+	rdb.engine = 'sqlite';
+	rdb.encodeBoolean = encodeBoolean;
+	rdb.encodeBinary = encodeBinary;
+	rdb.decodeBinary = decodeBinary;
+	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;
+	rdb.cache = {};
+
+	if (readonly) {
+		rdb.dbClient = {
+			executeQuery: function(query, callback) {
+				pool.connect((err, client, done) => {
+					if (err) {
+						return callback(err);
+					}
+					try {
+						wrapQuery(domain, 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(domain, 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/bunSqlite/pool/newGenericPool.js

@@ -0,0 +1,55 @@
+/* eslint-disable no-prototype-builtins */
+var defaults = require('../../poolDefaults');
+
+var genericPool = require('../../generic-pool');
+var Database;
+
+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: async function(cb) {
+			try {
+				try {
+					if (!Database)
+						({ Database } = await import('bun:Database'));
+				}
+				catch (err) {
+					return cb(err, null);
+				}
+
+				var client = new Database(connectionString);
+				client.poolCount = 0;
+				cb(null, client);
+			}
+			catch(err) {
+				return cb(err, null);
+			}
+		},
+
+		destroy: function(client) {
+			client.poolCount = undefined;
+			client.close();
+		}
+	});
+	//monkey-patch with connect method
+	pool.connect = function(cb) {
+		pool.acquire(function(err, client) {
+			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/bunSqlite/wrapQuery.js

@@ -0,0 +1,23 @@
+var log = require('../table/log');
+
+function wrapQuery(_context, connection) {
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+		try {
+			var params = query.parameters;
+			var sql = query.sql();
+			log.emitQuery({ sql, parameters: params });
+
+			var statement = connection.query(sql);
+			const rows = statement.all.apply(statement, params);
+			onCompleted(null, rows);
+		}
+		catch (e) {
+			onCompleted(e);
+		}
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/d1/newTransaction.js

@@ -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/d1/wrapQuery.js

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