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

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

@@ -3,20 +3,21 @@ const newQuery = require('./getManyDto/newQuery');
 const negotiateRawSqlFilter = require('./table/column/negotiateRawSqlFilter');
 const strategyToSpan = require('./table/strategyToSpan');
 const executeQueries = require('./table/executeQueries');
+const getSessionSingleton = require('./table/getSessionSingleton');
 
-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;
+		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 +150,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,18 +180,16 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 				}
 			}
 			const column = columns[j];
-			outRow[column.alias] = column.decode(row[keys[j]]);
+			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;
-		// if (parentRows)
-		// 	parentRows[i][parentProp] = outRow;
 		if (updateParent)
 			updateParent(outRow, i);
 		if (shouldCreateMap) {
@@ -208,13 +207,11 @@ 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,70 +237,105 @@ async function decode(strategy, span, rows, keys = rows.length > 0 ? Object.keys
 
 }
 
-async function decodeManyRelations(strategy, span) {
+async function decodeManyRelations(context, strategy, span) {
+	const maxParameters = getSessionSingleton(context, 'maxParameters');
+	const maxRows = maxParameters
+		? maxParameters * span.table._primaryColumns.length
+		: undefined;
+
 	const promises = [];
 	const c = {};
 	c.visitJoin = () => { };
 	c.visitOne = c.visitJoin;
 
+	// Helper function to split an array into chunks
+	function chunk(array, size) {
+		const results = [];
+		for (let i = 0; i < array.length; i += size) {
+			results.push(array.slice(i, i + size));
+		}
+		return results;
+	}
+
 	c.visitMany = function(leg) {
 		const name = leg.name;
 		const table = span.table;
 		const relation = table._relations[name];
 		const rowsMap = span._rowsMap;
 
-		const filter = createOneFilter(relation, span._ids);
 		const extractKey = createExtractKey(leg);
 		const extractFromMap = createExtractFromMap(rowsMap, table._primaryColumns);
 
-		const p = getManyDto(relation.childTable, filter, strategy[name], leg.span, updateParent);
-		// .then(subRows => {
-		// 	for (let i = 0; i < subRows.length; i++) {
-		// 		const key = extractKey(subRows[i]);
-		// 		const parentRow = extractFromMap(key);
-		// 		parentRow[name].push(subRows[i]);
-		// 	}
-		// });
+		// If maxRows is defined, chunk the IDs before calling getManyDto
+		if (maxRows) {
+			const chunkedIds = chunk(span._ids, maxRows);
+			for (const idsChunk of chunkedIds) {
+				const filter = createOneFilter(context, relation, idsChunk);
+				const p = getManyDto(
+					context,
+					relation.childTable,
+					filter,
+					strategy[name],
+					leg.span,
+					updateParent
+				);
+				promises.push(p);
+			}
+		} else {
+			// Otherwise, do the entire set in one go
+			const filter = createOneFilter(context, relation, span._ids);
+			const p = getManyDto(
+				context,
+				relation.childTable,
+				filter,
+				strategy[name],
+				leg.span,
+				updateParent
+			);
+			promises.push(p);
+		}
 
 		function updateParent(subRow) {
 			const key = extractKey(subRow);
 			const parentRow = extractFromMap(key);
 			parentRow[name].push(subRow);
 		}
-
-		promises.push(p);
 	};
 
 	function createExtractKey(leg) {
 		if (leg.columns.length === 1) {
 			const alias = leg.columns[0].alias;
 			return (row) => row[alias];
-		}
-		else {
+		} else {
 			const aliases = leg.columns.map(column => column.alias);
 			return (row) => aliases.map(alias => row[alias]);
 		}
 	}
+
 	function createExtractFromMap(map, primaryColumns) {
-		if (primaryColumns.length === 1)
+		if (primaryColumns.length === 1) {
 			return (key) => map.get(key);
-		else
+		} else {
 			return getFromMap.bind(null, map, primaryColumns);
+		}
 	}
 
+	// Visit all legs
 	span.legs.forEach(onEachLeg);
 
 	function onEachLeg(leg) {
 		leg.accept(c);
 	}
 
+	// Wait until all promises resolve
 	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 +355,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 +370,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.
+