orange-orm 4.4.2 → 4.5.0-beta.1

package/README.md

@@ -1867,7 +1867,7 @@ Supported functions include:
 - avg  
 
 __On each row__  
-In this example, we are counting the number of lines calculating total amount for each order.  This is represented as the property <i>numberOfLines</i>. You can call these aggregated properties whatever you want.  
+In this example, we are counting the number of lines on each order.  This is represented as the property <i>numberOfLines</i>. You can name these aggregated properties whatever you want.  
 You can also elevate associated data to the a parent level for easier access. In the example below, <i>balance</i> of the customer is elevated to the root level.
 
 ```javascript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orange-orm",
-  "version": "4.4.2",
+  "version": "4.5.0-beta.1",
   "main": "./src/index.js",
   "browser": "./src/client/index.mjs",
   "bin": {
@@ -19,6 +19,7 @@
     "mssql",
     "Microsoft Sql Server",
     "PostgreSql",
+    "Cloudflare D1",
     "Postgres",
     "pg",
     "sap",
@@ -48,7 +49,7 @@
     "lint": "eslint ./",
     "fix": "eslint ./ --fix",
     "owasp": "owasp-dependency-check --project \"MY_PROJECT\" --scan \"package-lock.json\" --exclude \"dependency-check-bin\" --out \"owasp\" --format HTML",
-    "beta": "publish --tag beta"
+    "beta": "npm publish --tag beta"
   },
   "dependencies": {
     "@lroal/on-change": "^4.0.2",
@@ -58,15 +59,14 @@
     "@types/tedious": "^4.0.14",
     "ajv": "^6.10.2",
     "axios": "^1.6.2",
-    "deferred": "^0.7.5",
     "fast-json-patch": "^3.1.1",
     "findup-sync": "^5.0.0",
     "glob": "^10.3.4",
     "module-definition": "^4.0.0",
     "node-cls": "^1.0.5",
-    "promise": "^8.0.3",
     "rfdc": "^1.2.0",
-    "uuid": "^8.3.2"
+    "uuid": "^8.3.2",
+    "wrangler": "^3.107.2"
   },
   "peerDependencies": {
     "msnodesqlv8": "^4.1.0",
@@ -99,9 +99,14 @@
     },
     "tedious": {
       "optional": true
+    },
+    "oracledb": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@cloudflare/workers-types": "^4.20241106.0",
+    "@miniflare/d1": "^2.14.4",
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.0.0",
     "@typescript-eslint/eslint-plugin": "^6.x",
@@ -111,6 +116,7 @@
     "eslint": "^8.57.0",
     "eslint-plugin-jest": "^27.1.7",
     "express": "^4.18.2",
+    "miniflare": "^3.20250129.0",
     "msnodesqlv8": "^4.1.0",
     "mysql2": "^3.9.4",
     "oracledb": "^6.3.0",
@@ -121,7 +127,7 @@
     "sqlite3": "^5.0.2",
     "tedious": "^18.2.0",
     "typescript": "^5.4.5",
-    "vitest": "^0.34.1"
+    "vitest": "^0.34.6"
   },
   "engines": {
     "node": ">= 8.0.0"

package/src/client/clientMap.js

@@ -39,6 +39,7 @@ function map(index, _fn) {
 	dbMap.sap = throwDb;
 	dbMap.oracle = throwDb;
 	dbMap.sqlite = throwDb;
+	dbMap.d1 = throwDb;
 
 	function throwDb() {
 		throw new Error('Cannot create pool for database outside node');
@@ -65,6 +66,7 @@ function map(index, _fn) {
 	onFinal.sap = () => index({ db: throwDb, providers: dbMap });
 	onFinal.oracle = () => index({ db: throwDb, providers: dbMap });
 	onFinal.sqlite = () => index({ db: throwDb, providers: dbMap });
+	onFinal.d1 = () => index({ db: throwDb, providers: dbMap });
 
 	return new Proxy(onFinal, handler);
 }

package/src/client/createProviders.js

@@ -48,6 +48,11 @@ function createProviders(index) {
 			return createPool.bind(null, 'sqlite');
 		}
 	});
+	Object.defineProperty(dbMap, 'd1', {
+		get:  function() {
+			return createPool.bind(null, 'd1');
+		}
+	});
 	Object.defineProperty(dbMap, 'http', {
 		get:  function() {
 			return createPool.bind(null, 'http');
@@ -97,12 +102,19 @@ function negotiateCachedPool(fn, providers) {
 		get sqlite() {
 			return createPool.bind(null, 'sqlite');
 		},
+		get d1() {
+			return createPool.bind(null, 'd1');
+		},
 		get http() {
 			return createPool.bind(null, 'http');
 		}
 	};
 
 	function createPool(providerName, ...args) {
+		//todo
+		if (providerName === 'd1') {
+			return providers[providerName].apply(null, args);
+		}
 		const key = JSON.stringify(args);
 		if (!cache[providerName])
 			cache[providerName] = {};

package/src/client/index.js

@@ -57,6 +57,7 @@ function rdbClient(options = {}) {
 	client.mssqlNative = onProvider.bind(null, 'mssqlNative');
 	client.pg = onProvider.bind(null, 'pg');
 	client.postgres = onProvider.bind(null, 'postgres');
+	client.d1 = onProvider.bind(null, 'd1');
 	client.sqlite = onProvider.bind(null, 'sqlite');
 	client.sap = onProvider.bind(null, 'sap');
 	client.oracle = onProvider.bind(null, 'oracle');
@@ -128,7 +129,8 @@ function rdbClient(options = {}) {
 	}
 
 	async function query() {
-		return netAdapter(baseUrl, undefined, { tableOptions: { db: baseUrl, transaction } }).query.apply(null, arguments);
+		const adapter = netAdapter(baseUrl, undefined, { tableOptions: { db: baseUrl, transaction } });
+		return adapter.query.apply(null, arguments);
 	}
 
 	function express(arg) {
@@ -168,13 +170,14 @@ function rdbClient(options = {}) {
 		if (!db.createTransaction)
 			throw new Error('Transaction not supported through http');
 		const transaction = db.createTransaction(_options);
+
 		try {
 			const nextClient = client({ transaction });
 			await fn(nextClient);
-			await transaction(db.commit);
+			await transaction(transaction.commit);
 		}
 		catch (e) {
-			await transaction(db.rollback.bind(null, e));
+			await transaction(transaction.rollback.bind(null, e));
 		}
 	}
 

package/src/client/index.mjs

@@ -5594,6 +5594,7 @@ function map$1(index, _fn) {
 	dbMap.sap = throwDb;
 	dbMap.oracle = throwDb;
 	dbMap.sqlite = throwDb;
+	dbMap.d1 = throwDb;
 
 	function throwDb() {
 		throw new Error('Cannot create pool for database outside node');
@@ -5620,6 +5621,7 @@ function map$1(index, _fn) {
 	onFinal.sap = () => index({ db: throwDb, providers: dbMap });
 	onFinal.oracle = () => index({ db: throwDb, providers: dbMap });
 	onFinal.sqlite = () => index({ db: throwDb, providers: dbMap });
+	onFinal.d1 = () => index({ db: throwDb, providers: dbMap });
 
 	return new Proxy(onFinal, handler);
 }
@@ -5930,6 +5932,7 @@ function rdbClient(options = {}) {
 	client.mssqlNative = onProvider.bind(null, 'mssqlNative');
 	client.pg = onProvider.bind(null, 'pg');
 	client.postgres = onProvider.bind(null, 'postgres');
+	client.d1 = onProvider.bind(null, 'd1');
 	client.sqlite = onProvider.bind(null, 'sqlite');
 	client.sap = onProvider.bind(null, 'sap');
 	client.oracle = onProvider.bind(null, 'oracle');
@@ -6001,7 +6004,8 @@ function rdbClient(options = {}) {
 	}
 
 	async function query() {
-		return netAdapter(baseUrl, undefined, { tableOptions: { db: baseUrl, transaction } }).query.apply(null, arguments);
+		const adapter = netAdapter(baseUrl, undefined, { tableOptions: { db: baseUrl, transaction } });
+		return adapter.query.apply(null, arguments);
 	}
 
 	function express(arg) {
@@ -6041,13 +6045,14 @@ function rdbClient(options = {}) {
 		if (!db.createTransaction)
 			throw new Error('Transaction not supported through http');
 		const transaction = db.createTransaction(_options);
+
 		try {
 			const nextClient = client({ transaction });
 			await fn(nextClient);
-			await transaction(db.commit);
+			await transaction(transaction.commit);
 		}
 		catch (e) {
-			await transaction(db.rollback.bind(null, e));
+			await transaction(transaction.rollback.bind(null, e));
 		}
 	}
 

package/src/client/map.js

@@ -48,6 +48,7 @@ function map(index, context, providers, fn) {
 	context.sap = connect.bind(null, 'sap');
 	context.oracle = connect.bind(null, 'oracle');
 	context.sqlite = connect.bind(null, 'sqlite');
+	context.d1 = connect.bind(null, 'd1');
 	context.http = function(url) {
 		return index({ db: url, providers});
 	};

package/src/createDomain.js

@@ -1,9 +1,7 @@
-let useHook = require('./useHook');
-let cls;
-var Domain = require('domain');
+var Domain = require('node:domain');
 var negotiateForwardProperty = require('./createDomain/negotiateForwardProperty');
 
-function createDomain() {
+function createNodeDomain() {
 	var oldDomain = Domain.active || {};
 	var domain = Domain.create();
 	var ownProperties = Object.getOwnPropertyNames(oldDomain);
@@ -13,19 +11,16 @@ function createDomain() {
 	return domain;
 }
 
-function createOnContext() {
-	if (!cls)
-		cls = require('node-cls');
-	return cls.create('rdb');
-}
-
-
-function _createDomain() {
-	if (useHook())
-		return createOnContext();
-	else
-		return createDomain();
 
+function _createDomain(useNodeDomain) {
+	if (useNodeDomain)
+		return createNodeDomain();
+	let c = {};
+	function run(fn) {
+		return fn(c);
+	}
+	c.run = run;
+	return c;
 }
 
 module.exports = _createDomain;

package/src/d1/newDatabase.js

@@ -0,0 +1,119 @@
+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(d1Database, poolOptions) {
+	if (!d1Database)
+		throw new Error('Missing d1Database');
+	var pool;
+	if (!poolOptions)
+		pool = newPool.bind(null,d1Database, poolOptions);
+	else
+		pool = newPool(d1Database, 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(() => fn(domain))
+				.then((res) => result = res)
+				.then(() => c.commit(domain))
+				.then(null, (e) =>  c.rollback(domain,e));
+			return result;
+		}
+
+		function begin() {
+			const transactionLess = true;
+			return _begin(domain, transactionLess);
+		}
+
+		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, options);
+		let p = domain.run(() => new Promise(transaction).then(begin));
+
+		function run(fn) {
+			return p.then(domain.run.bind(domain, fn));
+		}
+
+		function begin() {
+			return _begin(domain, options);
+		}
+
+		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.end = function() {
+		if (poolOptions)
+			return pool.end();
+		else
+			return Promise.resolve();
+	};
+
+	c.accept = function(caller) {
+		caller.visitSqlite();
+	};
+
+	return c;
+}
+
+module.exports = newDatabase;

package/src/d1/newPool.js

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

package/src/d1/newTransaction.js

@@ -0,0 +1,82 @@
+const wrapQuery = require('./wrapQuery');
+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');
+
+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 = (name) => `"${name}"`;
+
+	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/d1/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/d1/pool/newGenericPool.js

@@ -0,0 +1,53 @@
+/* eslint-disable no-prototype-builtins */
+var EventEmitter = require('events').EventEmitter;
+
+var defaults = require('../../poolDefaults');
+var genericPool = require('../../generic-pool');
+var process = require('node:process');
+
+function newGenericPool(d1Database, poolOptions) {
+	poolOptions = poolOptions || {};
+	// @ts-ignore
+	var pool = genericPool.Pool({
+		max: 1,
+		idleTimeoutMillis: poolOptions.idleTimeout || defaults.poolIdleTimeout,
+		reapIntervalMillis: poolOptions.reapIntervalMillis || defaults.reapIntervalMillis,
+		log: poolOptions.log || defaults.poolLog,
+		create: function(cb) {
+			var client = {d1: d1Database, poolCount: 0};
+
+			return cb(null, client);
+		},
+
+		destroy: function() {
+		}
+	});
+	//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/d1/wrapQuery.js

@@ -0,0 +1,22 @@
+var log = require('../table/log');
+
+function wrapQuery(client) {
+
+	return runQuery;
+
+	function runQuery(query, onCompleted) {
+
+		var params = query.parameters;
+		var sql = query.sql();
+		log.emitQuery({sql, parameters: params});
+		client.d1.prepare(sql, params).bind(...params).all().then(onInnerCompleted, onCompleted);
+
+		function onInnerCompleted(response) {
+			onCompleted(null, response.results);
+		}
+
+	}
+
+}
+
+module.exports = wrapQuery;

package/src/d1test.js

@@ -0,0 +1,35 @@
+import { connect } from '@cloudflare/d1';
+
+const databaseId = process.env.D1_DATABASE_ID;
+const accountId = process.env.D1_ACCOUNT_ID;
+const apiToken = process.env.D1_API_TOKEN;
+
+export class Database {
+	constructor() {
+		this.db = connect({
+			databaseId,
+			accountId,
+			apiToken,
+		});
+	}
+
+	async createUser(name, email) {
+		return await this.db
+			.prepare('INSERT INTO users (name, email) VALUES (?, ?)')
+			.bind(name, email)
+			.run();
+	}
+
+	async getUsers() {
+		return await this.db
+			.prepare('SELECT * FROM users')
+			.all();
+	}
+
+	async getUserById(id) {
+		return await this.db
+			.prepare('SELECT * FROM users WHERE id = ?')
+			.bind(id)
+			.first();
+	}
+}

package/src/emitEvent.js

@@ -6,12 +6,14 @@ function emitEvent() {
 		var result = [];
 		for (var i = 0; i < copy.length; i++) {
 			var callback = copy[i];
-			result.push(callback.apply(null,arguments));
+			result.push(callback.apply(null, arguments));
 		}
 		return result;
 	};
 
 	emit.add = function(callback) {
+		if (!callback)
+			throw new Error('missing callback');
 		callbacks.push(callback);
 	};
 
@@ -22,15 +24,15 @@ function emitEvent() {
 
 	emit.remove = function(callback) {
 		for (var i = 0; i < callbacks.length; i++) {
-			if(callbacks[i] === callback){
-				callbacks.splice(i,1);
+			if (callbacks[i] === callback) {
+				callbacks.splice(i, 1);
 				return;
 			}
 		}
 	};
 
 	emit.tryRemove = function(callback) {
-		if(callback)
+		if (callback)
 			emit.remove(callback);
 	};
 

package/src/emptyFilter.js

@@ -7,26 +7,26 @@ function emptyFilter() {
 emptyFilter.sql = parameterized.sql;
 emptyFilter.parameters = parameterized.parameters;
 
-emptyFilter.and = function(other) {
-	other = negotiateRawSqlFilter(other);
-	for (var i = 1; i < arguments.length; i++) {
-		other = other.and(arguments[i]);
+emptyFilter.and = function(context, other) {
+	other = negotiateRawSqlFilter(context, other);
+	for (var i = 2; i < arguments.length; i++) {
+		other = other.and(context, arguments[i]);
 	}
 	return other;
 };
 
-emptyFilter.or = function(other) {
-	other = negotiateRawSqlFilter(other);
-	for (var i = 1; i < arguments.length; i++) {
-		other = other.or(arguments[i]);
+emptyFilter.or = function(context, other) {
+	other = negotiateRawSqlFilter(context, other);
+	for (var i = 2; i < arguments.length; i++) {
+		other = other.or(context, arguments[i]);
 	}
 	return other;
 };
 
-emptyFilter.not = function(other) {
-	other = negotiateRawSqlFilter(other).not();
-	for (var i = 1; i < arguments.length; i++) {
-		other = other.and(arguments[i]);
+emptyFilter.not = function(context, other) {
+	other = negotiateRawSqlFilter(context, other).not(context);
+	for (var i = 2; i < arguments.length; i++) {
+		other = other.and(context, arguments[i]);
 	}
 	return other;