joist-core 2.3.0 → 2.4.0

package/build/batchloaders/recursiveChildrenBatchLoader.js

@@ -1,77 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recursiveChildrenOperation = void 0;
-exports.recursiveChildrenBatchLoader = recursiveChildrenBatchLoader;
-const configure_1 = require("../configure");
-const EntityManager_1 = require("../EntityManager");
-const index_1 = require("../index");
-const utils_1 = require("../utils");
-exports.recursiveChildrenOperation = "o2m-recursive";
+import "./BatchLoader.js";
+import { isLoadedCollection } from "../relations/Collection.js";
+import "../relations/RecursiveCollection.js";
+import { getField } from "../fields.js";
+import { deTagIds, maybeResolveReferenceToId } from "../keys.js";
+import { kq } from "../queries/sql/keywords.js";
+import { addTablePerClassJoinsAndClassTag } from "../queries/find/QueryParser.js";
+import { isLoadedOneToOneReference } from "../relations/OneToOneReference.js";
+import { abbreviation, groupBy } from "../utils.js";
+import { getMetadataForType } from "../configure.js";
+import "../index.js";
+import { getEmInternalApi } from "../EntityManager.js";
+import "../Entity.js";
+//#region src/batchloaders/recursiveChildrenBatchLoader.ts
+const recursiveChildrenOperation = "o2m-recursive";
 function recursiveChildrenBatchLoader(em, collection) {
-    let { meta, fieldName } = collection;
-    // This could be called from subtypes to get relations defined on the parent. So we need to make sure we are using the
-    // correct meta by walking the inheritance tree until we find the meta that actually has the root o2m field
-    // We intentionally don't use getMetadataForField here because CTI-specialized fields stay on the subtype metadata,
-    // while these raw recursive CTEs need the metadata/table that physically owns the FK column.
-    while (!(collection.o2mFieldName in meta.fields) && meta.baseType)
-        meta = (0, configure_1.getMetadataForType)(meta.baseType);
-    const batchKey = `${meta.tableName}-${fieldName}`;
-    return em.getBatchLoader(exports.recursiveChildrenOperation, batchKey, async (parents) => {
-        const o2m = meta.allFields[collection.o2mFieldName];
-        const m2o = meta.allFields[o2m.otherFieldName];
-        const { columnName } = m2o.serde.columns[0];
-        const alias = (0, utils_1.abbreviation)(meta.tableName);
-        const query = {
-            selects: [`"${alias}".*`],
-            tables: [
-                // We still select directly from our table, and join into the CTE so that we
-                // can use `addTablePerClassJoinsAndClassTag` to get inheritance added for free.
-                { alias, join: "primary", table: meta.tableName },
-                { alias: `${alias}_cte`, join: "inner", table: `${alias}_cte`, col1: `${alias}.id`, col2: `${alias}_cte.id` },
-            ],
-            orderBys: [{ alias, column: "id", order: "ASC" }],
-            ctes: [
-                {
-                    alias: `${alias}_cte`,
-                    query: {
-                        kind: "raw",
-                        // b is our base case, which is the immediate children of the parents, and r is the
-                        // recursive case of finding their children.
-                        sql: `
-             SELECT b.id, b.${columnName} FROM ${(0, index_1.kq)(meta.tableName)} b WHERE b.${columnName} = ANY(?)
+	let { meta, fieldName } = collection;
+	while (!(collection.o2mFieldName in meta.fields) && meta.baseType) meta = getMetadataForType(meta.baseType);
+	const batchKey = `${meta.tableName}-${fieldName}`;
+	return em.getBatchLoader(recursiveChildrenOperation, batchKey, async (parents) => {
+		const o2m = meta.allFields[collection.o2mFieldName];
+		const m2o = meta.allFields[o2m.otherFieldName];
+		const { columnName } = m2o.serde.columns[0];
+		const alias = abbreviation(meta.tableName);
+		const query = {
+			selects: [`"${alias}".*`],
+			tables: [{
+				alias,
+				join: "primary",
+				table: meta.tableName
+			}, {
+				alias: `${alias}_cte`,
+				join: "inner",
+				table: `${alias}_cte`,
+				col1: `${alias}.id`,
+				col2: `${alias}_cte.id`
+			}],
+			orderBys: [{
+				alias,
+				column: "id",
+				order: "ASC"
+			}],
+			ctes: [{
+				alias: `${alias}_cte`,
+				query: {
+					kind: "raw",
+					sql: `
+             SELECT b.id, b.${columnName} FROM ${kq(meta.tableName)} b WHERE b.${columnName} = ANY(?)
              UNION
-             SELECT r.id, r.${columnName} FROM ${(0, index_1.kq)(meta.tableName)} r JOIN ${alias}_cte ON r.${columnName} = ${alias}_cte.id
+             SELECT r.id, r.${columnName} FROM ${kq(meta.tableName)} r JOIN ${alias}_cte ON r.${columnName} = ${alias}_cte.id
             `,
-                        // RecursiveChildrenCollectionImpl won't call `.load` on new entities, so we can assume entities have an id
-                        bindings: [(0, index_1.unsafeDeTagIds)(parents.map((e) => e.idTagged))],
-                    },
-                    recursive: true,
-                },
-            ],
-        };
-        (0, index_1.addTablePerClassJoinsAndClassTag)(query, meta, alias, true);
-        const rows = await em["executeFind"](meta, exports.recursiveChildrenOperation, query, {});
-        const entities = em.hydrate(meta.cstr, rows);
-        // For all the entities we found, group them by their parent (or the root node, which has no parent)
-        const entitiesById = (0, utils_1.groupBy)(entities, (entity) => {
-            const parentId = (0, index_1.maybeResolveReferenceToId)((0, index_1.getField)(entity, m2o.fieldName));
-            return parentId ?? "root";
-        });
-        // For each found parent, use the preloading infra to inject the children into the relation
-        for (const [parentId, children] of entitiesById) {
-            if (parentId !== "root") {
-                (0, EntityManager_1.getEmInternalApi)(em).setPreloadedRelation(parentId, o2m.fieldName, children);
-                // I thought we could delay calling this, but currently `em.populate` calls `preload()` explicitly
-                em.getEntity(parentId)[o2m.fieldName].preload();
-            }
-        }
-        // Any entity[o2m] still not loaded must be a leaf which didn't have any children; go ahead and mark it as loaded
-        for (const entity of [...parents, ...entities]) {
-            if (!(0, index_1.isLoadedCollection)(entity[o2m.fieldName]) && !(0, index_1.isLoadedOneToOneReference)(entity[o2m.fieldName])) {
-                (0, EntityManager_1.getEmInternalApi)(em).setPreloadedRelation(entity.id, o2m.fieldName, []);
-                entity[o2m.fieldName].preload();
-            }
-        }
-    });
+					bindings: [deTagIds(meta, parents.map((e) => e.idTagged))]
+				},
+				recursive: true
+			}]
+		};
+		addTablePerClassJoinsAndClassTag(query, meta, alias, true);
+		const rowData = await em["executeFindRowData"](meta, recursiveChildrenOperation, query, {});
+		const entities = em["hydrateAndFinalize"](meta.cstr, rowData);
+		const entitiesById = groupBy(entities, (entity) => {
+			return maybeResolveReferenceToId(getField(entity, m2o.fieldName)) ?? "root";
+		});
+		for (const [parentId, children] of entitiesById) if (parentId !== "root") {
+			getEmInternalApi(em).setPreloadedRelation(parentId, o2m.fieldName, children);
+			em.getEntity(parentId)[o2m.fieldName].preload();
+		}
+		for (const entity of [...parents, ...entities]) if (!isLoadedCollection(entity[o2m.fieldName]) && !isLoadedOneToOneReference(entity[o2m.fieldName])) {
+			getEmInternalApi(em).setPreloadedRelation(entity.id, o2m.fieldName, []);
+			entity[o2m.fieldName].preload();
+		}
+	});
 }
+//#endregion
+export { recursiveChildrenBatchLoader, recursiveChildrenOperation };
+
 //# sourceMappingURL=recursiveChildrenBatchLoader.js.map

package/build/batchloaders/recursiveChildrenBatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"recursiveChildrenBatchLoader.js","sourceRoot":"","sources":["../../src/batchloaders/recursiveChildrenBatchLoader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recursiveChildrenBatchLoader.js","names":[],"sources":["../../src/batchloaders/recursiveChildrenBatchLoader.ts"],"sourcesContent":["import { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { getMetadataForType } from \"src/configure.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport {\n  type ManyToOneField,\n  type OneToManyField,\n  type OneToOneField,\n  type ParsedFindQuery,\n  addTablePerClassJoinsAndClassTag,\n  deTagIds,\n  getField,\n  isLoadedCollection,\n  isLoadedOneToOneReference,\n  kq,\n  maybeResolveReferenceToId,\n} from \"src/index.ts\";\nimport { type RecursiveChildrenCollectionImpl } from \"src/relations/RecursiveCollection.ts\";\nimport { abbreviation, groupBy } from \"src/utils.ts\";\n\nexport const recursiveChildrenOperation = \"o2m-recursive\";\n\nexport function recursiveChildrenBatchLoader<T extends Entity, U extends Entity>(\n  em: EntityManager,\n  collection: RecursiveChildrenCollectionImpl<T, U>,\n): BatchLoader<Entity> {\n  let { meta, fieldName } = collection;\n  // This could be called from subtypes to get relations defined on the parent. So we need to make sure we are using the\n  // correct meta by walking the inheritance tree until we find the meta that actually has the root o2m field\n  // We intentionally don't use getMetadataForField here because CTI-specialized fields stay on the subtype metadata,\n  // while these raw recursive CTEs need the metadata/table that physically owns the FK column.\n  while (!(collection.o2mFieldName in meta.fields) && meta.baseType) meta = getMetadataForType(meta.baseType);\n  const batchKey = `${meta.tableName}-${fieldName}`;\n  return em.getBatchLoader(recursiveChildrenOperation, batchKey, async (parents) => {\n    const o2m = meta.allFields[collection.o2mFieldName] as OneToManyField | OneToOneField;\n    const m2o = meta.allFields[o2m.otherFieldName] as ManyToOneField;\n    const { columnName } = m2o.serde.columns[0];\n\n    const alias = abbreviation(meta.tableName);\n    const query: ParsedFindQuery = {\n      selects: [`\"${alias}\".*`],\n      tables: [\n        // We still select directly from our table, and join into the CTE so that we\n        // can use `addTablePerClassJoinsAndClassTag` to get inheritance added for free.\n        { alias, join: \"primary\", table: meta.tableName },\n        { alias: `${alias}_cte`, join: \"inner\", table: `${alias}_cte`, col1: `${alias}.id`, col2: `${alias}_cte.id` },\n      ],\n      orderBys: [{ alias, column: \"id\", order: \"ASC\" }],\n      ctes: [\n        {\n          alias: `${alias}_cte`,\n          query: {\n            kind: \"raw\",\n            // b is our base case, which is the immediate children of the parents, and r is the\n            // recursive case of finding their children.\n            sql: `\n             SELECT b.id, b.${columnName} FROM ${kq(meta.tableName)} b WHERE b.${columnName} = ANY(?)\n             UNION\n             SELECT r.id, r.${columnName} FROM ${kq(meta.tableName)} r JOIN ${alias}_cte ON r.${columnName} = ${alias}_cte.id\n            `,\n            // RecursiveChildrenCollectionImpl won't call `.load` on new entities, so we can assume entities have an id\n            bindings: [\n              deTagIds(\n                meta,\n                parents.map((e) => e.idTagged),\n              ),\n            ],\n          },\n          recursive: true,\n        },\n      ],\n    };\n\n    addTablePerClassJoinsAndClassTag(query, meta, alias, true);\n\n    const rowData = await em[\"executeFindRowData\"](meta, recursiveChildrenOperation, query, {});\n    const entities = em[\"hydrateAndFinalize\"](meta.cstr, rowData);\n\n    // For all the entities we found, group them by their parent (or the root node, which has no parent)\n    const entitiesById = groupBy(entities, (entity) => {\n      const parentId = maybeResolveReferenceToId(getField(entity, m2o.fieldName));\n      return parentId ?? \"root\";\n    });\n\n    // For each found parent, use the preloading infra to inject the children into the relation\n    for (const [parentId, children] of entitiesById) {\n      if (parentId !== \"root\") {\n        getEmInternalApi(em).setPreloadedRelation(parentId, o2m.fieldName, children);\n        // I thought we could delay calling this, but currently `em.populate` calls `preload()` explicitly\n        (em.getEntity(parentId) as any)[o2m.fieldName].preload();\n      }\n    }\n\n    // Any entity[o2m] still not loaded must be a leaf which didn't have any children; go ahead and mark it as loaded\n    for (const entity of [...parents, ...entities]) {\n      if (!isLoadedCollection(entity[o2m.fieldName]) && !isLoadedOneToOneReference(entity[o2m.fieldName])) {\n        getEmInternalApi(em).setPreloadedRelation(entity.id, o2m.fieldName, []);\n        entity[o2m.fieldName].preload();\n      }\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,MAAa,6BAA6B;AAE1C,SAAgB,6BACd,IACA,YACqB;CACrB,IAAI,EAAE,MAAM,cAAc;CAK1B,OAAO,EAAE,WAAW,gBAAgB,KAAK,WAAW,KAAK,UAAU,OAAO,mBAAmB,KAAK,QAAQ;CAC1G,MAAM,WAAW,GAAG,KAAK,UAAU,GAAG;CACtC,OAAO,GAAG,eAAe,4BAA4B,UAAU,OAAO,YAAY;EAChF,MAAM,MAAM,KAAK,UAAU,WAAW;EACtC,MAAM,MAAM,KAAK,UAAU,IAAI;EAC/B,MAAM,EAAE,eAAe,IAAI,MAAM,QAAQ;EAEzC,MAAM,QAAQ,aAAa,KAAK,SAAS;EACzC,MAAM,QAAyB;GAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;GACxB,QAAQ,CAGN;IAAE;IAAO,MAAM;IAAW,OAAO,KAAK;GAAU,GAChD;IAAE,OAAO,GAAG,MAAM;IAAO,MAAM;IAAS,OAAO,GAAG,MAAM;IAAO,MAAM,GAAG,MAAM;IAAM,MAAM,GAAG,MAAM;GAAS,CAC9G;GACA,UAAU,CAAC;IAAE;IAAO,QAAQ;IAAM,OAAO;GAAM,CAAC;GAChD,MAAM,CACJ;IACE,OAAO,GAAG,MAAM;IAChB,OAAO;KACL,MAAM;KAGN,KAAK;8BACa,WAAW,QAAQ,GAAG,KAAK,SAAS,EAAE,aAAa,WAAW;;8BAE9D,WAAW,QAAQ,GAAG,KAAK,SAAS,EAAE,UAAU,MAAM,YAAY,WAAW,KAAK,MAAM;;KAG1G,UAAU,CACR,SACE,MACA,QAAQ,KAAK,MAAM,EAAE,QAAQ,CAC/B,CACF;IACF;IACA,WAAW;GACb,CACF;EACF;EAEA,iCAAiC,OAAO,MAAM,OAAO,IAAI;EAEzD,MAAM,UAAU,MAAM,GAAG,qBAAqB,CAAC,MAAM,4BAA4B,OAAO,CAAC,CAAC;EAC1F,MAAM,WAAW,GAAG,qBAAqB,CAAC,KAAK,MAAM,OAAO;EAG5D,MAAM,eAAe,QAAQ,WAAW,WAAW;GAEjD,OADiB,0BAA0B,SAAS,QAAQ,IAAI,SAAS,CAC3D,KAAK;EACrB,CAAC;EAGD,KAAK,MAAM,CAAC,UAAU,aAAa,cACjC,IAAI,aAAa,QAAQ;GACvB,iBAAiB,EAAE,CAAC,CAAC,qBAAqB,UAAU,IAAI,WAAW,QAAQ;GAE3E,GAAI,UAAU,QAAQ,CAAC,CAAS,IAAI,UAAU,CAAC,QAAQ;EACzD;EAIF,KAAK,MAAM,UAAU,CAAC,GAAG,SAAS,GAAG,QAAQ,GAC3C,IAAI,CAAC,mBAAmB,OAAO,IAAI,UAAU,KAAK,CAAC,0BAA0B,OAAO,IAAI,UAAU,GAAG;GACnG,iBAAiB,EAAE,CAAC,CAAC,qBAAqB,OAAO,IAAI,IAAI,WAAW,CAAC,CAAC;GACtE,OAAO,IAAI,UAAU,CAAC,QAAQ;EAChC;CAEJ,CAAC;AACH"}

package/build/batchloaders/recursiveM2mBatchLoader.cjs

@@ -0,0 +1,83 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./BatchLoader.cjs");
+const require_relations_Collection = require("../relations/Collection.cjs");
+require("../relations/RecursiveCollection.cjs");
+const require_keys = require("../keys.cjs");
+const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
+const require_utils = require("../utils.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+require("../index.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+require("../Entity.cjs");
+//#region src/batchloaders/recursiveM2mBatchLoader.ts
+const recursiveM2mOperation = "m2m-recursive";
+function recursiveM2mBatchLoader(em, collection) {
+	let { meta, fieldName } = collection;
+	meta = require_EntityMetadata.getMetadataForField(meta, collection.m2mFieldName);
+	const batchKey = `${meta.tableName}-${fieldName}`;
+	return em.getBatchLoader(recursiveM2mOperation, batchKey, async (entities) => {
+		const m2mField = meta.allFields[collection.m2mFieldName];
+		const { joinTableName, columnNames } = m2mField;
+		const thisColumn = columnNames[0];
+		const otherColumn = columnNames[1];
+		const seedIds = require_keys.deTagIds(meta, entities.map((e) => e.idTagged));
+		const jt = require_utils.abbreviation(joinTableName);
+		const query = {
+			selects: [require_queries_sql_keywords.kqStar(jt)],
+			tables: [{
+				alias: jt,
+				join: "primary",
+				table: "cte"
+			}],
+			orderBys: [{
+				alias: jt,
+				column: "id",
+				order: "ASC"
+			}],
+			ctes: [{
+				alias: "cte",
+				query: {
+					kind: "raw",
+					sql: `
+              SELECT b.* FROM ${require_queries_sql_keywords.kq(joinTableName)} b WHERE ${require_queries_sql_keywords.kqDot("b", thisColumn)} = ANY(?)
+              UNION
+              SELECT r.* FROM ${require_queries_sql_keywords.kq(joinTableName)} r JOIN cte ON ${require_queries_sql_keywords.kqDot("r", thisColumn)} = cte.${require_queries_sql_keywords.kq(otherColumn)}
+            `,
+					bindings: [seedIds]
+				},
+				recursive: true
+			}]
+		};
+		const joinTableRows = await em["executeFind"](meta, recursiveM2mOperation, query, { limit: void 0 });
+		const uniqueIds = new Set(entities.map((e) => e.idTagged));
+		for (const row of joinTableRows) {
+			uniqueIds.add(require_keys.keyToTaggedId(meta, row[thisColumn]));
+			uniqueIds.add(require_keys.keyToTaggedId(meta, row[otherColumn]));
+		}
+		const m2mCollection = entities[0][collection.m2mFieldName];
+		const joinRows = require_EntityManager.getEmInternalApi(em).joinRows(m2mCollection);
+		const tuples = [...uniqueIds].map((id) => [thisColumn, id]);
+		await joinRows.loadRows(tuples, joinTableRows);
+		const api = require_EntityManager.getEmInternalApi(em);
+		for (const id of uniqueIds) {
+			const entity = em.getEntity(id);
+			if (!entity) continue;
+			const others = joinRows.getOthers(thisColumn, entity);
+			api.setPreloadedRelation(entity.idTagged, m2mField.fieldName, others);
+			entity[m2mField.fieldName].preload();
+		}
+		for (const id of uniqueIds) {
+			const entity = em.getEntity(id);
+			if (!entity) continue;
+			if (!require_relations_Collection.isLoadedCollection(entity[m2mField.fieldName])) {
+				api.setPreloadedRelation(entity.idTagged, m2mField.fieldName, []);
+				entity[m2mField.fieldName].preload();
+			}
+		}
+	});
+}
+//#endregion
+exports.recursiveM2mBatchLoader = recursiveM2mBatchLoader;
+exports.recursiveM2mOperation = recursiveM2mOperation;
+
+//# sourceMappingURL=recursiveM2mBatchLoader.cjs.map

package/build/batchloaders/recursiveM2mBatchLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveM2mBatchLoader.cjs","names":["getMetadataForField","deTagIds","abbreviation","kqStar","kq","kqDot","keyToTaggedId","getEmInternalApi","isLoadedCollection"],"sources":["../../src/batchloaders/recursiveM2mBatchLoader.ts"],"sourcesContent":["import { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport {\n  type ManyToManyField,\n  type ParsedFindQuery,\n  deTagIds,\n  getMetadataForField,\n  isLoadedCollection,\n  keyToTaggedId,\n  kq,\n  kqDot,\n  kqStar,\n} from \"src/index.ts\";\nimport { type RecursiveM2mCollectionImpl } from \"src/relations/RecursiveCollection.ts\";\nimport { abbreviation } from \"src/utils.ts\";\n\nexport const recursiveM2mOperation = \"m2m-recursive\";\n\nexport function recursiveM2mBatchLoader<T extends Entity, U extends Entity>(\n  em: EntityManager,\n  collection: RecursiveM2mCollectionImpl<T, U>,\n): BatchLoader<Entity> {\n  let { meta, fieldName } = collection;\n  meta = getMetadataForField(meta, collection.m2mFieldName);\n  const batchKey = `${meta.tableName}-${fieldName}`;\n  return em.getBatchLoader(recursiveM2mOperation, batchKey, async (entities) => {\n    const m2mField = meta.allFields[collection.m2mFieldName] as ManyToManyField;\n    const { joinTableName, columnNames } = m2mField;\n    const thisColumn = columnNames[0];\n    const otherColumn = columnNames[1];\n\n    const seedIds = deTagIds(\n      meta,\n      entities.map((e) => e.idTagged),\n    );\n\n    // Use a recursive CTE to walk the join table and return all join rows for the seed\n    // entities and all transitively-reachable entities. JoinRows.loadRows then calls\n    // em.loadAll internally to hydrate the actual entities on both sides.\n    const jt = abbreviation(joinTableName);\n    const query: ParsedFindQuery = {\n      selects: [kqStar(jt)],\n      tables: [{ alias: jt, join: \"primary\", table: \"cte\" }],\n      orderBys: [{ alias: jt, column: \"id\", order: \"ASC\" }],\n      ctes: [\n        {\n          alias: \"cte\",\n          query: {\n            kind: \"raw\",\n            // Base case returns full join rows for the seed entities; recursive case\n            // follows otherColumn → thisColumn to discover transitively-reachable rows.\n            sql: `\n              SELECT b.* FROM ${kq(joinTableName)} b WHERE ${kqDot(\"b\", thisColumn)} = ANY(?)\n              UNION\n              SELECT r.* FROM ${kq(joinTableName)} r JOIN cte ON ${kqDot(\"r\", thisColumn)} = cte.${kq(otherColumn)}\n            `,\n            bindings: [seedIds],\n          },\n          recursive: true,\n        },\n      ],\n    };\n\n    const joinTableRows = await em[\"executeFind\"](\n      meta,\n      recursiveM2mOperation,\n      query,\n      // No LIMIT needed for join rows\n      { limit: undefined },\n    );\n\n    // Collect all entity IDs from both sides of the join rows. Entities that only appear\n    // on otherColumn (not thisColumn) are leaf nodes with no outgoing connections — since\n    // the CTE transitively discovers everything reachable, we know their m2m is empty and\n    // can mark it loaded here, avoiding a separate load via findUnloadedCollections.\n    const uniqueIds = new Set(entities.map((e) => e.idTagged));\n    for (const row of joinTableRows) {\n      uniqueIds.add(keyToTaggedId(meta, row[thisColumn])!);\n      uniqueIds.add(keyToTaggedId(meta, row[otherColumn])!);\n    }\n\n    const m2mCollection = (entities[0] as any)[collection.m2mFieldName];\n    const joinRows = getEmInternalApi(em).joinRows(m2mCollection);\n\n    // loadRows calls em.loadAll internally to hydrate all referenced entities\n    const tuples: [string, string][] = [...uniqueIds].map((id) => [thisColumn, id]);\n    await joinRows.loadRows(tuples, joinTableRows);\n\n    // Set preloaded relations and call preload() for each entity's m2m collection\n    const api = getEmInternalApi(em);\n    for (const id of uniqueIds) {\n      const entity = em.getEntity(id);\n      if (!entity) continue;\n      const others = joinRows.getOthers(thisColumn, entity);\n      api.setPreloadedRelation(entity.idTagged!, m2mField.fieldName, others);\n      (entity as any)[m2mField.fieldName].preload();\n    }\n\n    // Mark any entity whose m2m is still not loaded as having an empty collection (leaf nodes)\n    for (const id of uniqueIds) {\n      const entity = em.getEntity(id);\n      if (!entity) continue;\n      if (!isLoadedCollection((entity as any)[m2mField.fieldName])) {\n        api.setPreloadedRelation(entity.idTagged!, m2mField.fieldName, []);\n        (entity as any)[m2mField.fieldName].preload();\n      }\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAa,wBAAwB;AAErC,SAAgB,wBACd,IACA,YACqB;CACrB,IAAI,EAAE,MAAM,cAAc;CAC1B,OAAOA,uBAAAA,oBAAoB,MAAM,WAAW,YAAY;CACxD,MAAM,WAAW,GAAG,KAAK,UAAU,GAAG;CACtC,OAAO,GAAG,eAAe,uBAAuB,UAAU,OAAO,aAAa;EAC5E,MAAM,WAAW,KAAK,UAAU,WAAW;EAC3C,MAAM,EAAE,eAAe,gBAAgB;EACvC,MAAM,aAAa,YAAY;EAC/B,MAAM,cAAc,YAAY;EAEhC,MAAM,UAAUC,aAAAA,SACd,MACA,SAAS,KAAK,MAAM,EAAE,QAAQ,CAChC;EAKA,MAAM,KAAKC,cAAAA,aAAa,aAAa;EACrC,MAAM,QAAyB;GAC7B,SAAS,CAACC,6BAAAA,OAAO,EAAE,CAAC;GACpB,QAAQ,CAAC;IAAE,OAAO;IAAI,MAAM;IAAW,OAAO;GAAM,CAAC;GACrD,UAAU,CAAC;IAAE,OAAO;IAAI,QAAQ;IAAM,OAAO;GAAM,CAAC;GACpD,MAAM,CACJ;IACE,OAAO;IACP,OAAO;KACL,MAAM;KAGN,KAAK;gCACeC,6BAAAA,GAAG,aAAa,EAAE,WAAWC,6BAAAA,MAAM,KAAK,UAAU,EAAE;;gCAEpDD,6BAAAA,GAAG,aAAa,EAAE,iBAAiBC,6BAAAA,MAAM,KAAK,UAAU,EAAE,SAASD,6BAAAA,GAAG,WAAW,EAAE;;KAEvG,UAAU,CAAC,OAAO;IACpB;IACA,WAAW;GACb,CACF;EACF;EAEA,MAAM,gBAAgB,MAAM,GAAG,cAAc,CAC3C,MACA,uBACA,OAEA,EAAE,OAAO,KAAA,EAAU,CACrB;EAMA,MAAM,YAAY,IAAI,IAAI,SAAS,KAAK,MAAM,EAAE,QAAQ,CAAC;EACzD,KAAK,MAAM,OAAO,eAAe;GAC/B,UAAU,IAAIE,aAAAA,cAAc,MAAM,IAAI,WAAW,CAAE;GACnD,UAAU,IAAIA,aAAAA,cAAc,MAAM,IAAI,YAAY,CAAE;EACtD;EAEA,MAAM,gBAAiB,SAAS,EAAE,CAAS,WAAW;EACtD,MAAM,WAAWC,sBAAAA,iBAAiB,EAAE,CAAC,CAAC,SAAS,aAAa;EAG5D,MAAM,SAA6B,CAAC,GAAG,SAAS,CAAC,CAAC,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC;EAC9E,MAAM,SAAS,SAAS,QAAQ,aAAa;EAG7C,MAAM,MAAMA,sBAAAA,iBAAiB,EAAE;EAC/B,KAAK,MAAM,MAAM,WAAW;GAC1B,MAAM,SAAS,GAAG,UAAU,EAAE;GAC9B,IAAI,CAAC,QAAQ;GACb,MAAM,SAAS,SAAS,UAAU,YAAY,MAAM;GACpD,IAAI,qBAAqB,OAAO,UAAW,SAAS,WAAW,MAAM;GACrE,OAAgB,SAAS,UAAU,CAAC,QAAQ;EAC9C;EAGA,KAAK,MAAM,MAAM,WAAW;GAC1B,MAAM,SAAS,GAAG,UAAU,EAAE;GAC9B,IAAI,CAAC,QAAQ;GACb,IAAI,CAACC,6BAAAA,mBAAoB,OAAe,SAAS,UAAU,GAAG;IAC5D,IAAI,qBAAqB,OAAO,UAAW,SAAS,WAAW,CAAC,CAAC;IACjE,OAAgB,SAAS,UAAU,CAAC,QAAQ;GAC9C;EACF;CACF,CAAC;AACH"}

package/build/batchloaders/recursiveM2mBatchLoader.d.cts

@@ -0,0 +1,10 @@
+import { BatchLoader } from "./BatchLoader.cjs";
+import { RecursiveM2mCollectionImpl } from "../relations/RecursiveCollection.cjs";
+import { EntityManager } from "../EntityManager.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/batchloaders/recursiveM2mBatchLoader.d.ts
+declare const recursiveM2mOperation = "m2m-recursive";
+declare function recursiveM2mBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveM2mCollectionImpl<T, U>): BatchLoader<Entity>;
+//#endregion
+export { recursiveM2mBatchLoader, recursiveM2mOperation };
+//# sourceMappingURL=recursiveM2mBatchLoader.d.cts.map

package/build/batchloaders/recursiveM2mBatchLoader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveM2mBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/recursiveM2mBatchLoader.ts"],"mappings":";;;;;cAiBa;iBAEG,wBAAwB,UAAU,QAAQ,UAAU,QAClE,IAAI,eACJ,YAAY,2BAA2B,GAAG,KACzC,YAAY"}

package/build/batchloaders/recursiveM2mBatchLoader.d.mts

@@ -0,0 +1,10 @@
+import { BatchLoader } from "./BatchLoader.mjs";
+import { RecursiveM2mCollectionImpl } from "../relations/RecursiveCollection.mjs";
+import { EntityManager } from "../EntityManager.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/batchloaders/recursiveM2mBatchLoader.d.ts
+declare const recursiveM2mOperation = "m2m-recursive";
+declare function recursiveM2mBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveM2mCollectionImpl<T, U>): BatchLoader<Entity>;
+//#endregion
+export { recursiveM2mBatchLoader, recursiveM2mOperation };
+//# sourceMappingURL=recursiveM2mBatchLoader.d.mts.map

package/build/batchloaders/recursiveM2mBatchLoader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveM2mBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/recursiveM2mBatchLoader.ts"],"mappings":";;;;;cAiBa;iBAEG,wBAAwB,UAAU,QAAQ,UAAU,QAClE,IAAI,eACJ,YAAY,2BAA2B,GAAG,KACzC,YAAY"}

package/build/batchloaders/recursiveM2mBatchLoader.js

@@ -1,84 +1,81 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recursiveM2mOperation = void 0;
-exports.recursiveM2mBatchLoader = recursiveM2mBatchLoader;
-const EntityManager_1 = require("../EntityManager");
-const index_1 = require("../index");
-const utils_1 = require("../utils");
-exports.recursiveM2mOperation = "m2m-recursive";
+import "./BatchLoader.js";
+import { isLoadedCollection } from "../relations/Collection.js";
+import "../relations/RecursiveCollection.js";
+import { deTagIds, keyToTaggedId } from "../keys.js";
+import { kq, kqDot, kqStar } from "../queries/sql/keywords.js";
+import { abbreviation } from "../utils.js";
+import { getMetadataForField } from "../EntityMetadata.js";
+import "../index.js";
+import { getEmInternalApi } from "../EntityManager.js";
+import "../Entity.js";
+//#region src/batchloaders/recursiveM2mBatchLoader.ts
+const recursiveM2mOperation = "m2m-recursive";
 function recursiveM2mBatchLoader(em, collection) {
-    let { meta, fieldName } = collection;
-    meta = (0, index_1.getMetadataForField)(meta, collection.m2mFieldName);
-    const batchKey = `${meta.tableName}-${fieldName}`;
-    return em.getBatchLoader(exports.recursiveM2mOperation, batchKey, async (entities) => {
-        const m2mField = meta.allFields[collection.m2mFieldName];
-        const { joinTableName, columnNames } = m2mField;
-        const thisColumn = columnNames[0];
-        const otherColumn = columnNames[1];
-        const seedIds = (0, index_1.unsafeDeTagIds)(entities.map((e) => e.idTagged));
-        // Use a recursive CTE to walk the join table and return all join rows for the seed
-        // entities and all transitively-reachable entities. JoinRows.loadRows then calls
-        // em.loadAll internally to hydrate the actual entities on both sides.
-        const jt = (0, utils_1.abbreviation)(joinTableName);
-        const query = {
-            selects: [(0, index_1.kqStar)(jt)],
-            tables: [{ alias: jt, join: "primary", table: "cte" }],
-            orderBys: [{ alias: jt, column: "id", order: "ASC" }],
-            ctes: [
-                {
-                    alias: "cte",
-                    query: {
-                        kind: "raw",
-                        // Base case returns full join rows for the seed entities; recursive case
-                        // follows otherColumn → thisColumn to discover transitively-reachable rows.
-                        sql: `
-              SELECT b.* FROM ${(0, index_1.kq)(joinTableName)} b WHERE ${(0, index_1.kqDot)("b", thisColumn)} = ANY(?)
+	let { meta, fieldName } = collection;
+	meta = getMetadataForField(meta, collection.m2mFieldName);
+	const batchKey = `${meta.tableName}-${fieldName}`;
+	return em.getBatchLoader(recursiveM2mOperation, batchKey, async (entities) => {
+		const m2mField = meta.allFields[collection.m2mFieldName];
+		const { joinTableName, columnNames } = m2mField;
+		const thisColumn = columnNames[0];
+		const otherColumn = columnNames[1];
+		const seedIds = deTagIds(meta, entities.map((e) => e.idTagged));
+		const jt = abbreviation(joinTableName);
+		const query = {
+			selects: [kqStar(jt)],
+			tables: [{
+				alias: jt,
+				join: "primary",
+				table: "cte"
+			}],
+			orderBys: [{
+				alias: jt,
+				column: "id",
+				order: "ASC"
+			}],
+			ctes: [{
+				alias: "cte",
+				query: {
+					kind: "raw",
+					sql: `
+              SELECT b.* FROM ${kq(joinTableName)} b WHERE ${kqDot("b", thisColumn)} = ANY(?)
               UNION
-              SELECT r.* FROM ${(0, index_1.kq)(joinTableName)} r JOIN cte ON ${(0, index_1.kqDot)("r", thisColumn)} = cte.${(0, index_1.kq)(otherColumn)}
+              SELECT r.* FROM ${kq(joinTableName)} r JOIN cte ON ${kqDot("r", thisColumn)} = cte.${kq(otherColumn)}
             `,
-                        bindings: [seedIds],
-                    },
-                    recursive: true,
-                },
-            ],
-        };
-        const joinTableRows = await em["executeFind"](meta, exports.recursiveM2mOperation, query, 
-        // No LIMIT needed for join rows
-        { limit: undefined });
-        // Collect all entity IDs from both sides of the join rows. Entities that only appear
-        // on otherColumn (not thisColumn) are leaf nodes with no outgoing connections — since
-        // the CTE transitively discovers everything reachable, we know their m2m is empty and
-        // can mark it loaded here, avoiding a separate load via findUnloadedCollections.
-        const uniqueIds = new Set(entities.map((e) => e.idTagged));
-        for (const row of joinTableRows) {
-            uniqueIds.add((0, index_1.keyToTaggedId)(meta, row[thisColumn]));
-            uniqueIds.add((0, index_1.keyToTaggedId)(meta, row[otherColumn]));
-        }
-        const m2mCollection = entities[0][collection.m2mFieldName];
-        const joinRows = (0, EntityManager_1.getEmInternalApi)(em).joinRows(m2mCollection);
-        // loadRows calls em.loadAll internally to hydrate all referenced entities
-        const tuples = [...uniqueIds].map((id) => [thisColumn, id]);
-        await joinRows.loadRows(tuples, joinTableRows);
-        // Set preloaded relations and call preload() for each entity's m2m collection
-        const api = (0, EntityManager_1.getEmInternalApi)(em);
-        for (const id of uniqueIds) {
-            const entity = em.getEntity(id);
-            if (!entity)
-                continue;
-            const others = joinRows.getOthers(thisColumn, entity);
-            api.setPreloadedRelation(entity.idTagged, m2mField.fieldName, others);
-            entity[m2mField.fieldName].preload();
-        }
-        // Mark any entity whose m2m is still not loaded as having an empty collection (leaf nodes)
-        for (const id of uniqueIds) {
-            const entity = em.getEntity(id);
-            if (!entity)
-                continue;
-            if (!(0, index_1.isLoadedCollection)(entity[m2mField.fieldName])) {
-                api.setPreloadedRelation(entity.idTagged, m2mField.fieldName, []);
-                entity[m2mField.fieldName].preload();
-            }
-        }
-    });
+					bindings: [seedIds]
+				},
+				recursive: true
+			}]
+		};
+		const joinTableRows = await em["executeFind"](meta, recursiveM2mOperation, query, { limit: void 0 });
+		const uniqueIds = new Set(entities.map((e) => e.idTagged));
+		for (const row of joinTableRows) {
+			uniqueIds.add(keyToTaggedId(meta, row[thisColumn]));
+			uniqueIds.add(keyToTaggedId(meta, row[otherColumn]));
+		}
+		const m2mCollection = entities[0][collection.m2mFieldName];
+		const joinRows = getEmInternalApi(em).joinRows(m2mCollection);
+		const tuples = [...uniqueIds].map((id) => [thisColumn, id]);
+		await joinRows.loadRows(tuples, joinTableRows);
+		const api = getEmInternalApi(em);
+		for (const id of uniqueIds) {
+			const entity = em.getEntity(id);
+			if (!entity) continue;
+			const others = joinRows.getOthers(thisColumn, entity);
+			api.setPreloadedRelation(entity.idTagged, m2mField.fieldName, others);
+			entity[m2mField.fieldName].preload();
+		}
+		for (const id of uniqueIds) {
+			const entity = em.getEntity(id);
+			if (!entity) continue;
+			if (!isLoadedCollection(entity[m2mField.fieldName])) {
+				api.setPreloadedRelation(entity.idTagged, m2mField.fieldName, []);
+				entity[m2mField.fieldName].preload();
+			}
+		}
+	});
 }
+//#endregion
+export { recursiveM2mBatchLoader, recursiveM2mOperation };
+
 //# sourceMappingURL=recursiveM2mBatchLoader.js.map

package/build/batchloaders/recursiveM2mBatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"recursiveM2mBatchLoader.js","sourceRoot":"","sources":["../../src/batchloaders/recursiveM2mBatchLoader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"recursiveM2mBatchLoader.js","names":[],"sources":["../../src/batchloaders/recursiveM2mBatchLoader.ts"],"sourcesContent":["import { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport {\n  type ManyToManyField,\n  type ParsedFindQuery,\n  deTagIds,\n  getMetadataForField,\n  isLoadedCollection,\n  keyToTaggedId,\n  kq,\n  kqDot,\n  kqStar,\n} from \"src/index.ts\";\nimport { type RecursiveM2mCollectionImpl } from \"src/relations/RecursiveCollection.ts\";\nimport { abbreviation } from \"src/utils.ts\";\n\nexport const recursiveM2mOperation = \"m2m-recursive\";\n\nexport function recursiveM2mBatchLoader<T extends Entity, U extends Entity>(\n  em: EntityManager,\n  collection: RecursiveM2mCollectionImpl<T, U>,\n): BatchLoader<Entity> {\n  let { meta, fieldName } = collection;\n  meta = getMetadataForField(meta, collection.m2mFieldName);\n  const batchKey = `${meta.tableName}-${fieldName}`;\n  return em.getBatchLoader(recursiveM2mOperation, batchKey, async (entities) => {\n    const m2mField = meta.allFields[collection.m2mFieldName] as ManyToManyField;\n    const { joinTableName, columnNames } = m2mField;\n    const thisColumn = columnNames[0];\n    const otherColumn = columnNames[1];\n\n    const seedIds = deTagIds(\n      meta,\n      entities.map((e) => e.idTagged),\n    );\n\n    // Use a recursive CTE to walk the join table and return all join rows for the seed\n    // entities and all transitively-reachable entities. JoinRows.loadRows then calls\n    // em.loadAll internally to hydrate the actual entities on both sides.\n    const jt = abbreviation(joinTableName);\n    const query: ParsedFindQuery = {\n      selects: [kqStar(jt)],\n      tables: [{ alias: jt, join: \"primary\", table: \"cte\" }],\n      orderBys: [{ alias: jt, column: \"id\", order: \"ASC\" }],\n      ctes: [\n        {\n          alias: \"cte\",\n          query: {\n            kind: \"raw\",\n            // Base case returns full join rows for the seed entities; recursive case\n            // follows otherColumn → thisColumn to discover transitively-reachable rows.\n            sql: `\n              SELECT b.* FROM ${kq(joinTableName)} b WHERE ${kqDot(\"b\", thisColumn)} = ANY(?)\n              UNION\n              SELECT r.* FROM ${kq(joinTableName)} r JOIN cte ON ${kqDot(\"r\", thisColumn)} = cte.${kq(otherColumn)}\n            `,\n            bindings: [seedIds],\n          },\n          recursive: true,\n        },\n      ],\n    };\n\n    const joinTableRows = await em[\"executeFind\"](\n      meta,\n      recursiveM2mOperation,\n      query,\n      // No LIMIT needed for join rows\n      { limit: undefined },\n    );\n\n    // Collect all entity IDs from both sides of the join rows. Entities that only appear\n    // on otherColumn (not thisColumn) are leaf nodes with no outgoing connections — since\n    // the CTE transitively discovers everything reachable, we know their m2m is empty and\n    // can mark it loaded here, avoiding a separate load via findUnloadedCollections.\n    const uniqueIds = new Set(entities.map((e) => e.idTagged));\n    for (const row of joinTableRows) {\n      uniqueIds.add(keyToTaggedId(meta, row[thisColumn])!);\n      uniqueIds.add(keyToTaggedId(meta, row[otherColumn])!);\n    }\n\n    const m2mCollection = (entities[0] as any)[collection.m2mFieldName];\n    const joinRows = getEmInternalApi(em).joinRows(m2mCollection);\n\n    // loadRows calls em.loadAll internally to hydrate all referenced entities\n    const tuples: [string, string][] = [...uniqueIds].map((id) => [thisColumn, id]);\n    await joinRows.loadRows(tuples, joinTableRows);\n\n    // Set preloaded relations and call preload() for each entity's m2m collection\n    const api = getEmInternalApi(em);\n    for (const id of uniqueIds) {\n      const entity = em.getEntity(id);\n      if (!entity) continue;\n      const others = joinRows.getOthers(thisColumn, entity);\n      api.setPreloadedRelation(entity.idTagged!, m2mField.fieldName, others);\n      (entity as any)[m2mField.fieldName].preload();\n    }\n\n    // Mark any entity whose m2m is still not loaded as having an empty collection (leaf nodes)\n    for (const id of uniqueIds) {\n      const entity = em.getEntity(id);\n      if (!entity) continue;\n      if (!isLoadedCollection((entity as any)[m2mField.fieldName])) {\n        api.setPreloadedRelation(entity.idTagged!, m2mField.fieldName, []);\n        (entity as any)[m2mField.fieldName].preload();\n      }\n    }\n  });\n}\n"],"mappings":";;;;;;;;;;;AAiBA,MAAa,wBAAwB;AAErC,SAAgB,wBACd,IACA,YACqB;CACrB,IAAI,EAAE,MAAM,cAAc;CAC1B,OAAO,oBAAoB,MAAM,WAAW,YAAY;CACxD,MAAM,WAAW,GAAG,KAAK,UAAU,GAAG;CACtC,OAAO,GAAG,eAAe,uBAAuB,UAAU,OAAO,aAAa;EAC5E,MAAM,WAAW,KAAK,UAAU,WAAW;EAC3C,MAAM,EAAE,eAAe,gBAAgB;EACvC,MAAM,aAAa,YAAY;EAC/B,MAAM,cAAc,YAAY;EAEhC,MAAM,UAAU,SACd,MACA,SAAS,KAAK,MAAM,EAAE,QAAQ,CAChC;EAKA,MAAM,KAAK,aAAa,aAAa;EACrC,MAAM,QAAyB;GAC7B,SAAS,CAAC,OAAO,EAAE,CAAC;GACpB,QAAQ,CAAC;IAAE,OAAO;IAAI,MAAM;IAAW,OAAO;GAAM,CAAC;GACrD,UAAU,CAAC;IAAE,OAAO;IAAI,QAAQ;IAAM,OAAO;GAAM,CAAC;GACpD,MAAM,CACJ;IACE,OAAO;IACP,OAAO;KACL,MAAM;KAGN,KAAK;gCACe,GAAG,aAAa,EAAE,WAAW,MAAM,KAAK,UAAU,EAAE;;gCAEpD,GAAG,aAAa,EAAE,iBAAiB,MAAM,KAAK,UAAU,EAAE,SAAS,GAAG,WAAW,EAAE;;KAEvG,UAAU,CAAC,OAAO;IACpB;IACA,WAAW;GACb,CACF;EACF;EAEA,MAAM,gBAAgB,MAAM,GAAG,cAAc,CAC3C,MACA,uBACA,OAEA,EAAE,OAAO,KAAA,EAAU,CACrB;EAMA,MAAM,YAAY,IAAI,IAAI,SAAS,KAAK,MAAM,EAAE,QAAQ,CAAC;EACzD,KAAK,MAAM,OAAO,eAAe;GAC/B,UAAU,IAAI,cAAc,MAAM,IAAI,WAAW,CAAE;GACnD,UAAU,IAAI,cAAc,MAAM,IAAI,YAAY,CAAE;EACtD;EAEA,MAAM,gBAAiB,SAAS,EAAE,CAAS,WAAW;EACtD,MAAM,WAAW,iBAAiB,EAAE,CAAC,CAAC,SAAS,aAAa;EAG5D,MAAM,SAA6B,CAAC,GAAG,SAAS,CAAC,CAAC,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC;EAC9E,MAAM,SAAS,SAAS,QAAQ,aAAa;EAG7C,MAAM,MAAM,iBAAiB,EAAE;EAC/B,KAAK,MAAM,MAAM,WAAW;GAC1B,MAAM,SAAS,GAAG,UAAU,EAAE;GAC9B,IAAI,CAAC,QAAQ;GACb,MAAM,SAAS,SAAS,UAAU,YAAY,MAAM;GACpD,IAAI,qBAAqB,OAAO,UAAW,SAAS,WAAW,MAAM;GACrE,OAAgB,SAAS,UAAU,CAAC,QAAQ;EAC9C;EAGA,KAAK,MAAM,MAAM,WAAW;GAC1B,MAAM,SAAS,GAAG,UAAU,EAAE;GAC9B,IAAI,CAAC,QAAQ;GACb,IAAI,CAAC,mBAAoB,OAAe,SAAS,UAAU,GAAG;IAC5D,IAAI,qBAAqB,OAAO,UAAW,SAAS,WAAW,CAAC,CAAC;IACjE,OAAgB,SAAS,UAAU,CAAC,QAAQ;GAC9C;EACF;CACF,CAAC;AACH"}

package/build/batchloaders/recursiveParentsBatchLoader.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./BatchLoader.cjs");
+require("../relations/RecursiveCollection.cjs");
+const require_fields = require("../fields.cjs");
+const require_keys = require("../keys.cjs");
+const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
+const require_queries_find_QueryParser = require("../queries/find/QueryParser.cjs");
+const require_utils = require("../utils.cjs");
+const require_configure = require("../configure.cjs");
+require("../index.cjs");
+require("../EntityManager.cjs");
+require("../Entity.cjs");
+//#region src/batchloaders/recursiveParentsBatchLoader.ts
+const recursiveParentsOperation = "m2o-recursive";
+function recursiveParentsBatchLoader(em, collection) {
+	let { meta, fieldName } = collection;
+	while (!(collection.m2oFieldName in meta.fields) && meta.baseType) meta = require_configure.getMetadataForType(meta.baseType);
+	const batchKey = `${meta.tableName}-${fieldName}`;
+	return em.getBatchLoader(recursiveParentsOperation, batchKey, async (children) => {
+		const m2o = meta.allFields[collection.m2oFieldName];
+		const immediateParentIds = children.map((c) => require_fields.getField(c, m2o.fieldName)).filter((id) => id !== void 0);
+		const { columnName } = m2o.serde.columns[0];
+		const alias = require_utils.abbreviation(meta.tableName);
+		const query = {
+			selects: [`"${alias}".*`],
+			tables: [{
+				alias,
+				join: "primary",
+				table: meta.tableName
+			}, {
+				alias: `${alias}_cte`,
+				join: "inner",
+				table: `${alias}_cte`,
+				col1: `${alias}.id`,
+				col2: `${alias}_cte.id`
+			}],
+			orderBys: [{
+				alias,
+				column: "id",
+				order: "ASC"
+			}],
+			ctes: [{
+				alias: `${alias}_cte`,
+				query: {
+					kind: "raw",
+					sql: `
+              SELECT b.id, b.${columnName} FROM ${require_queries_sql_keywords.kq(meta.tableName)} b WHERE b.id = ANY(?)
+              UNION
+              SELECT r.id, r.${columnName} FROM ${require_queries_sql_keywords.kq(meta.tableName)} r JOIN ${alias}_cte ON r.id = ${alias}_cte.${columnName}
+            `,
+					bindings: [require_keys.deTagIds(meta, immediateParentIds)]
+				},
+				recursive: true
+			}]
+		};
+		require_queries_find_QueryParser.addTablePerClassJoinsAndClassTag(query, meta, alias, true);
+		const rowData = await em["executeFindRowData"](meta, recursiveParentsOperation, query, {});
+		em["hydrateAndFinalize"](meta.cstr, rowData);
+	});
+}
+//#endregion
+exports.recursiveParentsBatchLoader = recursiveParentsBatchLoader;
+exports.recursiveParentsOperation = recursiveParentsOperation;
+
+//# sourceMappingURL=recursiveParentsBatchLoader.cjs.map

package/build/batchloaders/recursiveParentsBatchLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursiveParentsBatchLoader.cjs","names":["getMetadataForType","getField","abbreviation","kq","deTagIds"],"sources":["../../src/batchloaders/recursiveParentsBatchLoader.ts"],"sourcesContent":["import { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { getMetadataForType } from \"src/configure.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager } from \"src/EntityManager.ts\";\nimport {\n  type ManyToOneField,\n  type ParsedFindQuery,\n  addTablePerClassJoinsAndClassTag,\n  deTagIds,\n  getField,\n  kq,\n} from \"src/index.ts\";\nimport { type RecursiveParentsCollectionImpl } from \"src/relations/RecursiveCollection.ts\";\nimport { abbreviation } from \"src/utils.ts\";\n\nexport const recursiveParentsOperation = \"m2o-recursive\";\n\nexport function recursiveParentsBatchLoader<T extends Entity, U extends Entity>(\n  em: EntityManager,\n  collection: RecursiveParentsCollectionImpl<T, U>,\n): BatchLoader<Entity> {\n  let { meta, fieldName } = collection;\n  // This could be called from subtypes to get relations defined on the parent. So we need to make sure we are using the\n  // correct meta by walking the inheritance tree until we find the meta that actually has the root m2o field\n  // We intentionally don't use getMetadataForField here because CTI-specialized fields stay on the subtype metadata,\n  // while these raw recursive CTEs need the metadata/table that physically owns the FK column.\n  while (!(collection.m2oFieldName in meta.fields) && meta.baseType) meta = getMetadataForType(meta.baseType);\n  const batchKey = `${meta.tableName}-${fieldName}`;\n  return em.getBatchLoader(recursiveParentsOperation, batchKey, async (children) => {\n    const m2o = meta.allFields[collection.m2oFieldName] as ManyToOneField;\n    // ...can `getField` return a new entity? In theory, we shouldn't see new entities because\n    // RecursiveParentsCollectionImpl.load/isLoaded will see the `ManyToOneReferenceImpl` as loaded.\n    const immediateParentIds = children.map((c) => getField(c, m2o.fieldName)).filter((id: any) => id !== undefined);\n    const { columnName } = m2o.serde.columns[0];\n\n    const alias = abbreviation(meta.tableName);\n    const query: ParsedFindQuery = {\n      selects: [`\"${alias}\".*`],\n      tables: [\n        // We still select directly from our table, and join into the CTE so that we\n        // can use `addTablePerClassJoinsAndClassTag` to get inheritance added for free.\n        { alias, join: \"primary\", table: meta.tableName },\n        { alias: `${alias}_cte`, join: \"inner\", table: `${alias}_cte`, col1: `${alias}.id`, col2: `${alias}_cte.id` },\n      ],\n      orderBys: [{ alias, column: \"id\", order: \"ASC\" }],\n      ctes: [\n        {\n          alias: `${alias}_cte`,\n          query: {\n            kind: \"raw\",\n            // b is our base case, which is the immediate parents of the children we're loading,\n            // and r is the recursive case of finding their parents.\n            sql: `\n              SELECT b.id, b.${columnName} FROM ${kq(meta.tableName)} b WHERE b.id = ANY(?)\n              UNION\n              SELECT r.id, r.${columnName} FROM ${kq(meta.tableName)} r JOIN ${alias}_cte ON r.id = ${alias}_cte.${columnName}\n            `,\n            bindings: [deTagIds(meta, immediateParentIds)],\n          },\n          recursive: true,\n        },\n      ],\n    };\n\n    addTablePerClassJoinsAndClassTag(query, meta, alias, true);\n\n    const rowData = await em[\"executeFindRowData\"](meta, recursiveParentsOperation, query, {});\n\n    // Since we're preloading m2os up the tree, merely having the entities in the EM is enough\n    // for the ManyToOneReferenceImpl to find them, so we don't need to map them back to the\n    // keys, or push them into the preloader cache.\n    em[\"hydrateAndFinalize\"](meta.cstr, rowData);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,MAAa,4BAA4B;AAEzC,SAAgB,4BACd,IACA,YACqB;CACrB,IAAI,EAAE,MAAM,cAAc;CAK1B,OAAO,EAAE,WAAW,gBAAgB,KAAK,WAAW,KAAK,UAAU,OAAOA,kBAAAA,mBAAmB,KAAK,QAAQ;CAC1G,MAAM,WAAW,GAAG,KAAK,UAAU,GAAG;CACtC,OAAO,GAAG,eAAe,2BAA2B,UAAU,OAAO,aAAa;EAChF,MAAM,MAAM,KAAK,UAAU,WAAW;EAGtC,MAAM,qBAAqB,SAAS,KAAK,MAAMC,eAAAA,SAAS,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,QAAQ,OAAY,OAAO,KAAA,CAAS;EAC/G,MAAM,EAAE,eAAe,IAAI,MAAM,QAAQ;EAEzC,MAAM,QAAQC,cAAAA,aAAa,KAAK,SAAS;EACzC,MAAM,QAAyB;GAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;GACxB,QAAQ,CAGN;IAAE;IAAO,MAAM;IAAW,OAAO,KAAK;GAAU,GAChD;IAAE,OAAO,GAAG,MAAM;IAAO,MAAM;IAAS,OAAO,GAAG,MAAM;IAAO,MAAM,GAAG,MAAM;IAAM,MAAM,GAAG,MAAM;GAAS,CAC9G;GACA,UAAU,CAAC;IAAE;IAAO,QAAQ;IAAM,OAAO;GAAM,CAAC;GAChD,MAAM,CACJ;IACE,OAAO,GAAG,MAAM;IAChB,OAAO;KACL,MAAM;KAGN,KAAK;+BACc,WAAW,QAAQC,6BAAAA,GAAG,KAAK,SAAS,EAAE;;+BAEtC,WAAW,QAAQA,6BAAAA,GAAG,KAAK,SAAS,EAAE,UAAU,MAAM,iBAAiB,MAAM,OAAO,WAAW;;KAElH,UAAU,CAACC,aAAAA,SAAS,MAAM,kBAAkB,CAAC;IAC/C;IACA,WAAW;GACb,CACF;EACF;EAEA,iCAAA,iCAAiC,OAAO,MAAM,OAAO,IAAI;EAEzD,MAAM,UAAU,MAAM,GAAG,qBAAqB,CAAC,MAAM,2BAA2B,OAAO,CAAC,CAAC;EAKzF,GAAG,qBAAqB,CAAC,KAAK,MAAM,OAAO;CAC7C,CAAC;AACH"}

package/build/batchloaders/recursiveParentsBatchLoader.d.cts

@@ -0,0 +1,10 @@
+import { BatchLoader } from "./BatchLoader.cjs";
+import { RecursiveParentsCollectionImpl } from "../relations/RecursiveCollection.cjs";
+import { EntityManager } from "../EntityManager.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/batchloaders/recursiveParentsBatchLoader.d.ts
+declare const recursiveParentsOperation = "m2o-recursive";
+declare function recursiveParentsBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveParentsCollectionImpl<T, U>): BatchLoader<Entity>;
+//#endregion
+export { recursiveParentsBatchLoader, recursiveParentsOperation };
+//# sourceMappingURL=recursiveParentsBatchLoader.d.cts.map