orange-orm 4.5.0-beta.0 → 4.5.0-beta.1

package/src/d1/newDatabase.js

@@ -4,10 +4,6 @@ let _begin = require('../table/begin');
 let commit = require('../table/commit');
 let rollback = require('../table/rollback');
 let newPool = require('./newPool');
-let useHook = require('../useHook');
-let promise = require('promise/domains');
-let versionArray = process.version.replace('v', '').split('.');
-let major = parseInt(versionArray[0]);
 let express = require('../hostExpress');
 let hostLocal = require('../hostLocal');
 let doQuery = require('../query');
@@ -34,85 +30,75 @@ function newDatabase(d1Database, poolOptions) {
 
 		if (fn)
 			return domain.run(runInTransaction);
-		else if ((major >= 12) && useHook()) {
-			domain.exitContext = true;
-			return domain.start().then(run);
-		}
 		else
 			return domain.run(run);
 
-		function begin() {
-			const transactionLess = true;
-			return _begin(transactionLess);
-		}
-
 		async function runInTransaction() {
 			let result;
 			let transaction = newTransaction(domain, pool, options);
 			await new Promise(transaction)
 				.then(begin)
-				.then(fn)
+				.then(() => fn(domain))
 				.then((res) => result = res)
-				.then(c.commit)
-				.then(null, c.rollback);
+				.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);
-			if (useHook())
-				p = new Promise(transaction);
-			else
-				p = new promise(transaction);
+			p = new Promise(transaction);
 
 			return p.then(begin);
 		}
 
 	};
 
-	c.createTransaction = function() {
+	c.createTransaction = function(options) {
 		let domain = createDomain();
-		let transaction = newTransaction(domain, pool);
-		let p = domain.run(() => new Promise(transaction).then(_begin));
+		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));
 		}
-		return run;
-	};
-
-	c.bindTransaction = function() {
-		// @ts-ignore
-		var domain = process.domain;
-		let p = domain.run(() => true);
 
-		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('changes', []))
-			.then(() => doQuery(query).then(onResult, onError)));
+			.then(() => setSessionSingleton(domain, 'changes', []))
+			.then(() => doQuery(domain, query).then(onResult, onError)));
 		return p;
 
 		function onResult(result) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			return result;
 		}
 
 		function onError(e) {
-			releaseDbClient();
+			releaseDbClient(domain);
 			throw e;
 		}
 	};
 
-
 	c.rollback = rollback;
 	c.commit = commit;
 

package/src/d1/newPool.js

@@ -1,8 +1,8 @@
-var pools = require('../pools');
-var promise = require('../table/promise');
-var end = require('./pool/end');
-var newGenericPool = require('./pool/newGenericPool');
-var newId = require('../newId');
+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);
@@ -11,7 +11,7 @@ function newPool(d1Database, poolOptions) {
 	var c = {};
 
 	c.connect = pool.connect;
-	c.end = promise.denodeify(boundEnd);
+	c.end = promisify(boundEnd);
 	pools[id] = c;
 	return c;
 }

package/src/d1/pool/newGenericPool.js

@@ -1,8 +1,9 @@
 /* eslint-disable no-prototype-builtins */
 var EventEmitter = require('events').EventEmitter;
 
-var defaults = require('./defaults');
+var defaults = require('../../poolDefaults');
 var genericPool = require('../../generic-pool');
+var process = require('node:process');
 
 function newGenericPool(d1Database, poolOptions) {
 	poolOptions = poolOptions || {};

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;
 

package/src/getManyDto/newQuery.js

@@ -5,13 +5,13 @@ var extractLimit = require('../table/query/extractLimit');
 var newParameterized = require('../table/query/newParameterized');
 var extractOffset = require('../table/query/extractOffset');
 
-function newQuery(table,filter,span,alias) {
+function newQuery(context,table,filter,span,alias) {
 	filter = extractFilter(filter);
-	var orderBy = extractOrderBy(table,alias,span.orderBy);
-	var limit = extractLimit(span);
-	var offset = extractOffset(span);
+	var orderBy = extractOrderBy(context,table,alias,span.orderBy);
+	var limit = extractLimit(context, span);
+	var offset = extractOffset(context, span);
 
-	var query = newSingleQuery(table,filter,span,alias,orderBy,limit,offset);
+	var query = newSingleQuery(context,table,filter,span,alias,orderBy,limit,offset);
 	return newParameterized(query.sql(), query.parameters);
 }
 

package/src/getManyDto/query/newSingleQuery.js

@@ -4,12 +4,12 @@ var newJoinSql = require('../../table/query/singleQuery/newJoinSql');
 var newParameterized = require('../../table/query/newParameterized');
 var getSessionSingleton = require('../../table/getSessionSingleton');
 
-function _new(table,filter,span, alias,orderBy,limit,offset) {
-	var quote = getSessionSingleton('quote');
+function _new(context,table,filter,span, alias,orderBy,limit,offset) {
+	var quote = getSessionSingleton(context, 'quote');
 	var name = quote(table._dbName);
-	var columnSql = newColumnSql(table,span,alias,true);
-	var joinSql = newJoinSql(span, alias);
-	var whereSql = newWhereSql(table,filter,alias);
+	var columnSql = newColumnSql(context,table,span,alias,true);
+	var joinSql = newJoinSql(context, span, alias);
+	var whereSql = newWhereSql(context,table,filter,alias);
 	if (limit)
 		limit = limit + ' ';
 

package/src/getManyDto.js

@@ -4,19 +4,19 @@ const negotiateRawSqlFilter = require('./table/column/negotiateRawSqlFilter');
 const strategyToSpan = require('./table/strategyToSpan');
 const executeQueries = require('./table/executeQueries');
 
-async function getManyDto(table, filter, strategy, spanFromParent, updateParent) {
-	filter = negotiateRawSqlFilter(filter, table);
+async function getManyDto(context, table, filter, strategy, spanFromParent, updateParent) {
+	filter = negotiateRawSqlFilter(context, filter, table);
 	if (strategy && strategy.where) {
-		let arg = typeof strategy.where === 'function' ? strategy.where(table) : strategy.where;
-		filter = filter.and(arg);
+		let arg = typeof strategy.where === 'function' ? strategy.where(context, table) : strategy.where;//todo
+		filter = filter.and(context, arg);
 	}
 
 	let span = spanFromParent || strategyToSpan(table, strategy);
 	let alias = table._dbName;
 
-	const query = newQuery(table, filter, span, alias);
-	const res = await executeQueries([query]);
-	return decode(strategy, span, await res[0], undefined, updateParent);
+	const query = newQuery(context, table, filter, span, alias);
+	const res = await executeQueries(context, [query]);
+	return decode(context, strategy, span, await res[0], undefined, updateParent);
 }
 
 function newCreateRow(span) {
@@ -149,7 +149,7 @@ function hasManyRelations(span) {
 	}
 }
 
-async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : [], updateParent) {
+async function decode(context, strategy, span, rows, keys = rows.length > 0 ? Object.keys(rows[0]) : [], updateParent) {
 	const table = span.table;
 	let columnsMap = span.columns;
 	const columns = table._columns.filter(column => !columnsMap || columnsMap.get(column));
@@ -179,13 +179,14 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 				}
 			}
 			const column = columns[j];
-			outRow[column.alias] = column.decode(row[keys[j]]);
+			//todo
+			outRow[column.alias] = column.decode(context, row[keys[j]]);
 		}
 
 		for (let j = 0; j < aggregateKeys.length; j++) {
 			const key = aggregateKeys[j];
-			const parse = span.aggregates[key].column?.decode || Number.parseFloat;
-			outRow[key] = parse(row[keys[j + columnsLength]]);
+			const parse = span.aggregates[key].column?.decode || ((context, arg) => Number.parseFloat(arg));
+			outRow[key] = parse(context, row[keys[j + columnsLength]]);
 		}
 
 		outRows[i] = outRow;
@@ -208,13 +209,13 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 	const all = [];
 
 	if (shouldCreateMap) {
-		all.push(decodeManyRelations(strategy, span));
-		all.push(decodeRelations2(strategy, span, rows, outRows, keys));
+		all.push(decodeManyRelations(context, strategy, span));
+		all.push(decodeRelations2(context, strategy, span, rows, outRows, keys));
 	}
 	// decodeRelations2(strategy, span, rows, outRows, keys);
 	// }
 	else
-		all.push(decodeRelations2(strategy, span, rows, outRows, keys));
+		all.push(decodeRelations2(context, strategy, span, rows, outRows, keys));
 
 	await Promise.all(all);
 
@@ -240,7 +241,7 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 
 }
 
-async function decodeManyRelations(strategy, span) {
+async function decodeManyRelations(context, strategy, span) {
 	const promises = [];
 	const c = {};
 	c.visitJoin = () => { };
@@ -252,11 +253,11 @@ async function decodeManyRelations(strategy, span) {
 		const relation = table._relations[name];
 		const rowsMap = span._rowsMap;
 
-		const filter = createOneFilter(relation, span._ids);
+		const filter = createOneFilter(context, relation, span._ids);
 		const extractKey = createExtractKey(leg);
 		const extractFromMap = createExtractFromMap(rowsMap, table._primaryColumns);
 
-		const p = getManyDto(relation.childTable, filter, strategy[name], leg.span, updateParent);
+		const p = getManyDto(context, relation.childTable, filter, strategy[name], leg.span, updateParent);
 		// .then(subRows => {
 		// 	for (let i = 0; i < subRows.length; i++) {
 		// 		const key = extractKey(subRows[i]);
@@ -299,11 +300,11 @@ async function decodeManyRelations(strategy, span) {
 
 	await Promise.all(promises);
 }
-async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
+async function decodeRelations2(context, strategy, span, rawRows, resultRows, keys) {
 	const c = {};
 	c.visitJoin = function(leg) {
 		const name = leg.name;
-		return decode(strategy[name], leg.span, rawRows, keys, updateParent);
+		return decode(context, strategy[name], leg.span, rawRows, keys, updateParent);
 
 		function updateParent(subRow, i) {
 			resultRows[i][name] = subRow;
@@ -323,11 +324,11 @@ async function decodeRelations2(strategy, span, rawRows, resultRows, keys) {
 	await processLegsSequentially(span.legs);
 }
 
-function createOneFilter(relation, ids) {
+function createOneFilter(context, relation, ids) {
 	const columns = relation.joinRelation.columns;
 
 	if (columns.length === 1)
-		return columns[0].in(ids);
+		return columns[0].in(context, ids);
 
 	else
 		return createCompositeFilter();
@@ -338,11 +339,11 @@ function createOneFilter(relation, ids) {
 			let nextFilter;
 			for (let i = 0; i < columns.length; i++) {
 				if (nextFilter)
-					nextFilter = nextFilter.and(columns[i].eq(id[i]));
+					nextFilter = nextFilter.and(context, columns[i].eq(context, id[i]));
 				else
-					nextFilter = columns[i].eq(id[i]);
+					nextFilter = columns[i].eq(context, id[i]);
 			}
-			filter = filter.or(nextFilter);
+			filter = filter.or(context, nextFilter);
 		}
 		return filter;
 	}

package/src/hostExpress/cycle.ts

@@ -0,0 +1,211 @@
+// Utility to decrement recursion depth
+type DecrementDepth<D extends any[]> = D extends [any, ...infer Rest] ? Rest : never;
+
+// Define the structure of each node's definition within NodeTypeMap
+// NodeKey is a string (or a type union of strings) that identifies a node.
+type NodeDefinition = {
+  base: {}; // Base type of the node
+  children?: Record<string, string>; // childPropName -> childNodeKey
+  parent?: { prop: string; node: string }; // parentPropName, parentNodeKey
+};
+
+// A map of node keys to their definitions
+type NodeTypeMap = {
+  [NodeKey: string]: NodeDefinition;
+};
+
+// The RecursiveNode type:
+// D: depth array
+// M: the NodeTypeMap
+// K: the NodeKey for the current node
+//
+// If D is empty, we return just the base type.
+// If not empty, we return the base type plus recursively expanded children and parent.
+type RecursiveNode<
+  D extends any[],
+  M extends Record<string, NodeDefinition>,
+  K extends keyof M
+> = D extends []
+  ? // At zero depth, just return the base type of this node
+    M[K]['base']
+  : // Non-zero depth:
+    // Start with the base type
+    M[K]['base']
+    // Add recursively expanded children, if any
+    & (M[K]['children'] extends Record<string, string>
+       ? { [ChildProp in keyof M[K]['children']]:
+            RecursiveNode<DecrementDepth<D>, M, M[K]['children'][ChildProp]> }
+       : {})
+    // Add recursively expanded parent, if defined
+    & (M[K]['parent'] extends { prop: string; node: string }
+       ? { [P in M[K]['parent']['prop']]:
+            RecursiveNode<DecrementDepth<D>, M, M[K]['parent']['node']> }
+       : {});
+
+// ================== EXAMPLE USAGE ==================
+
+// Define your base types (clean, no recursion)
+type ABase = { name: string; foo: number };
+type BBase = { title: string; bar: number };
+type CBase = { label: string; baz: boolean };
+type DBase = { tag: string; qux: string };
+
+// Now define a NodeTypeMap describing the structure:
+// Let's say we have a graph like before, but arbitrary children.
+// A has three children: bChild -> B, cChild -> C, dChild -> D
+// B, C, D each have a parent going back to A
+// D also has a cLink -> C
+
+type MyNodeTypeMap = {
+  A: {
+    base: ABase;
+    children: {
+      bChild: 'B';
+      cChild: 'C';
+      dChild: 'D';
+    };
+    // No parent defined for A (root)
+  };
+  B: {
+    base: BBase;    
+    children: {
+        fooLink: 'C'; // D links to C as well
+      };
+    parent: { prop: 'aParent'; node: 'A' };
+  };
+  C: {
+    base: CBase;
+    // C has no children defined here
+    parent: { prop: 'aParent'; node: 'A' };
+  };
+  D: {
+    base: DBase;
+    children: {
+      cLink: 'C'; // D links to C as well
+    };
+    parent: { prop: 'aParent'; node: 'A' };
+  };
+};
+
+// Limit recursion to depth 2
+type Depth2 = [unknown, unknown, unknown, unknown];
+
+// Now we can create a type for each node expanded to Depth2:
+type MyA = RecursiveNode<Depth2, MyNodeTypeMap, 'A'>;
+type MyB = RecursiveNode<Depth2, MyNodeTypeMap, 'B'>;
+type MyC = RecursiveNode<Depth2, MyNodeTypeMap, 'C'>;
+type MyD = RecursiveNode<Depth2, MyNodeTypeMap, 'D'>;
+
+// Create an instance of MyA:
+const aInstance: MyA = {
+  name: "Root A",
+  foo: 1,
+  bChild: {
+    title: "B Node",
+    bar: 100,
+    aParent: {
+      name: "A Level 2",
+      foo: 2,
+      bChild: { title: "B2", bar: 200, aParent: { name: "A Terminal", foo: 3 } },
+      cChild: { label: "C2", baz: true, aParent: { name: "A Terminal", foo: 4 } },
+      dChild: {
+        tag: "D2",
+        qux: "XYZ",
+        aParent: { name: "A Terminal", foo: 5 },
+        cLink: { label: "C-Terminal", baz: false }
+      }
+    }
+  },
+  cChild: {
+    label: "C Node",
+    baz: true,
+    aParent: {
+      name: "A Level 2C",
+      foo: 10,
+      bChild: { title: "B3", bar: 300, aParent: { name: "A Terminal", foo: 6 } },
+      cChild: { label: "C3", baz: false, aParent: { name: "A Terminal", foo: 7 } },
+      dChild: {
+        tag: "D3",
+        qux: "ABC",
+        aParent: { name: "A Terminal", foo: 8 },
+        cLink: { label: "C-Terminal2", baz: true }
+      }
+    }
+  },
+  dChild: {
+    tag: "D Node",
+    qux: "QWE",
+    aParent: {
+      name: "A Level 2D",
+      foo: 20,
+      bChild: { title: "B4", bar: 400, aParent: { name: "A Terminal", foo: 9 } },
+      cChild: { label: "C4", baz: true, aParent: { name: "A Terminal", foo: 11 } },
+      dChild: {
+        tag: "D4",
+        qux: "DEF",
+        aParent: { name: "A Terminal", foo: 12 },
+        cLink: { label: "C-Terminal3", baz: false }
+      }
+    },
+    cLink: {
+      label: "C Link Node",
+      baz: false
+    }
+  }
+};
+
+console.log(aInstance.name);            // "Root A"
+console.log(aInstance.bChild.title);    // "B Node"
+console.log(aInstance.bChild.aParent.cChild.label); // "C2"
+console.log(aInstance.dChild.aParent.dChild.cLink.baz); // true
+
+// interface HasChild<C> {
+//     child: C;
+//   }
+  
+//   interface HasParent<P> {
+//     parent: P;
+//   }
+  
+//   interface AType<C> extends HasChild<C> {
+//     name: string;
+//   }
+  
+//   interface BType<P> extends HasParent<P> {
+//     title: string;
+//   }
+  
+//   // Here is the key part: By using a circular type definition, we create a 
+//   // specific pair (CyclicA, CyclicB) that point to each other generically. 
+//   // 'CyclicA' extends 'AType' and expects a child of type 'CyclicB'.
+//   // 'CyclicB' extends 'BType' and expects a parent of type 'CyclicA'.
+  
+//   // Note: TypeScript allows this pattern as long as the interfaces are defined first.
+//   // The cycle is established by the subsequent type definitions.
+  
+//   type CyclicA = AType<CyclicB>;
+//   type CyclicB = BType<CyclicA>;
+  
+//   // Now 'CyclicA' and 'CyclicB' are fully defined, with a cyclical reference:
+//   // CyclicA -> child: CyclicB
+//   // CyclicB -> parent: CyclicA
+  
+//   // Example usage:
+//   const aInstance: CyclicA ;
+  
+
+//   // Establish the cycle at runtime.
+
+  
+//   // We can now traverse back and forth:
+//   console.log(aInstance.name);              // "Node A"
+//   console.log(aInstance.child.title);       // "Node B"
+//   console.log(aInstance.child.parent.name); // "Node A" (cycle complete)
+  
+//   // This pattern is generic. If you want another pair of cyclical types, 
+//   // say X and Y, you can do:
+  
+//   type CyclicX = XType<CyclicY>; // define similarly using HasChild/HasParent
+//   type CyclicY = YType<CyclicX>;
+//   // ...and so forth, using the same building blocks.
+