joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/batchloaders/enumCollectionBatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"enumCollectionBatchLoader.js","sourceRoot":"","sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"enumCollectionBatchLoader.js","names":[],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"sourcesContent":["import { type EntityManager, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"../index.ts\";\nimport { abbreviation } from \"../utils.ts\";\nimport { type BatchLoader } from \"./BatchLoader.ts\";\n\nexport const enumCollectionLoadOperation = \"enum-collection-load\";\n\n/** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */\nexport function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string> {\n  return em.getBatchLoader(enumCollectionLoadOperation, collection.joinTableName, (keys) =>\n    loadBatch(em, collection, keys),\n  );\n}\n\nasync function loadBatch(em: EntityManager, collection: ManyToManyLike, keys: string[]): Promise<void> {\n  const { meta, columnName, otherColumnName, joinTableName, hasJoinTableId, otherEnum, fieldName } = collection;\n  const joinRows = getEmInternalApi(em).joinRows(collection);\n\n  const alias = abbreviation(joinTableName);\n  const query: ParsedFindQuery = {\n    selects: [`\"${alias}\".*`],\n    tables: [{ alias, join: \"primary\", table: joinTableName }],\n    condition: {\n      kind: \"exp\",\n      op: \"and\",\n      conditions: [\n        {\n          kind: \"column\",\n          alias,\n          column: columnName,\n          dbType: meta.idDbType,\n          cond: { kind: \"in\", value: keys.map((id) => keyToNumber(meta, id)!) },\n        },\n      ],\n    },\n    // Id-less join tables have no surrogate id to order by, so order by the FK columns instead.\n    orderBys: hasJoinTableId\n      ? [{ alias, column: \"id\", order: \"ASC\" }]\n      : [\n          { alias, column: columnName, order: \"ASC\" },\n          { alias, column: otherColumnName, order: \"ASC\" },\n        ],\n  };\n\n  const rows = await em[\"executeFind\"](meta, enumCollectionLoadOperation, query, { limit: undefined });\n  await joinRows.loadRows(\n    keys.map((id) => [columnName, id]),\n    rows,\n  );\n\n  const api = getEmInternalApi(em);\n  for (const id of keys) {\n    const entity = em.getEntity(id);\n    if (!entity) continue;\n    const codes = (joinRows.getOthers(columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((enumId) => otherEnum!.findById(enumId)!.code);\n    api.setPreloadedRelation(entity.idTagged!, fieldName, codes);\n  }\n}\n"],"mappings":";;;;;;AAKA,MAAa,8BAA8B;;AAG3C,SAAgB,0BAA0B,IAAmB,YAAiD;CAC5G,OAAO,GAAG,eAAe,6BAA6B,WAAW,gBAAgB,SAC/E,UAAU,IAAI,YAAY,IAAI,CAChC;AACF;AAEA,eAAe,UAAU,IAAmB,YAA4B,MAA+B;CACrG,MAAM,EAAE,MAAM,YAAY,iBAAiB,eAAe,gBAAgB,WAAW,cAAc;CACnG,MAAM,WAAW,iBAAiB,EAAE,CAAC,CAAC,SAAS,UAAU;CAEzD,MAAM,QAAQ,aAAa,aAAa;CACxC,MAAM,QAAyB;EAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;EACxB,QAAQ,CAAC;GAAE;GAAO,MAAM;GAAW,OAAO;EAAc,CAAC;EACzD,WAAW;GACT,MAAM;GACN,IAAI;GACJ,YAAY,CACV;IACE,MAAM;IACN;IACA,QAAQ;IACR,QAAQ,KAAK;IACb,MAAM;KAAE,MAAM;KAAM,OAAO,KAAK,KAAK,OAAO,YAAY,MAAM,EAAE,CAAE;IAAE;GACtE,CACF;EACF;EAEA,UAAU,iBACN,CAAC;GAAE;GAAO,QAAQ;GAAM,OAAO;EAAM,CAAC,IACtC,CACE;GAAE;GAAO,QAAQ;GAAY,OAAO;EAAM,GAC1C;GAAE;GAAO,QAAQ;GAAiB,OAAO;EAAM,CACjD;CACN;CAEA,MAAM,OAAO,MAAM,GAAG,cAAc,CAAC,MAAM,6BAA6B,OAAO,EAAE,OAAO,KAAA,EAAU,CAAC;CACnG,MAAM,SAAS,SACb,KAAK,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,GACjC,IACF;CAEA,MAAM,MAAM,iBAAiB,EAAE;CAC/B,KAAK,MAAM,MAAM,MAAM;EACrB,MAAM,SAAS,GAAG,UAAU,EAAE;EAC9B,IAAI,CAAC,QAAQ;EACb,MAAM,QAAS,SAAS,UAAU,YAAY,MAAM,CAAC,CAClD,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,CACrB,KAAK,WAAW,UAAW,SAAS,MAAM,CAAC,CAAE,IAAI;EACpD,IAAI,qBAAqB,OAAO,UAAW,WAAW,KAAK;CAC7D;AACF"}

package/build/batchloaders/loadBatchLoader.cjs

@@ -0,0 +1,78 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./BatchLoader.cjs");
+const require_keys = require("../keys.cjs");
+require("../EntityMetadata.cjs");
+require("../loadHints.cjs");
+const require_utils = require("../utils.cjs");
+const require_HintTree = require("../HintTree.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+const require_BaseEntity = require("../BaseEntity.cjs");
+const require_QueryParser = require("../QueryParser.cjs");
+//#region src/batchloaders/loadBatchLoader.ts
+const loadOperation = "load";
+/**
+* Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
+* After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
+*
+* Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
+* preloading into the same SELECT that fetches the entities.
+*/
+function loadBatchLoader(em, meta, overwriteExisting = false) {
+	return em.getBatchLoader(loadOperation, `${meta.type}-${overwriteExisting}`, async (loads) => {
+		const keys = loads.map((l) => require_keys.keyToNumber(meta, l.taggedId));
+		const alias = require_utils.abbreviation(meta.tableName);
+		const query = {
+			selects: meta.hasLazyColumns ? require_QueryParser.lazyExcludedSelects(meta, alias) : [`"${alias}".*`],
+			tables: [{
+				alias,
+				join: "primary",
+				table: meta.tableName
+			}],
+			condition: {
+				kind: "exp",
+				op: "and",
+				conditions: [{
+					kind: "column",
+					alias,
+					column: "id",
+					dbType: meta.idDbType,
+					cond: {
+						kind: "in",
+						value: keys
+					}
+				}]
+			},
+			orderBys: [{
+				alias,
+				column: "id",
+				order: "ASC"
+			}]
+		};
+		require_QueryParser.addTablePerClassJoinsAndClassTag(query, meta, alias, true);
+		const { preloader } = require_EntityManager.getEmInternalApi(em);
+		const preloadHydrator = preloader && preloader.addPreloading(meta, require_HintTree.buildHintTree(loads.map((l) => ({
+			entity: l.taggedId,
+			hint: l.hint
+		}))), query);
+		const rowData = await em["executeFindRowData"](meta, loadOperation, query, {});
+		em["hydrateAndFinalize"](meta.cstr, rowData, {
+			overwriteExisting,
+			sidecars: (entities) => {
+				preloadHydrator && preloadHydrator(rowData, entities);
+				if (rowData.rowCount !== loads.length) {
+					const foundIds = /* @__PURE__ */ new Set();
+					for (let i = 0; i < rowData.rowCount; i++) foundIds.add(require_keys.tagId(meta, rowData.get(i, "id")));
+					for (const load of loads) if (!foundIds.has(load.taggedId)) {
+						const existingEntity = em.findExistingInstance(load.taggedId);
+						if (existingEntity) require_BaseEntity.getInstanceData(existingEntity).markDeletedBecauseNotFound();
+					}
+				}
+			}
+		});
+	});
+}
+//#endregion
+exports.loadBatchLoader = loadBatchLoader;
+exports.loadOperation = loadOperation;
+
+//# sourceMappingURL=loadBatchLoader.cjs.map

package/build/batchloaders/loadBatchLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadBatchLoader.cjs","names":["keyToNumber","abbreviation","lazyExcludedSelects","getEmInternalApi","buildHintTree","tagId"],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"sourcesContent":["import { getInstanceData } from \"../BaseEntity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type EntityMetadata } from \"../EntityMetadata.ts\";\nimport { buildHintTree } from \"../HintTree.ts\";\nimport { keyToNumber, tagId } from \"../keys.ts\";\nimport { type LoadHint } from \"../loadHints.ts\";\nimport { type ParsedFindQuery, addTablePerClassJoinsAndClassTag, lazyExcludedSelects } from \"../QueryParser.ts\";\nimport { abbreviation } from \"../utils.ts\";\nimport { type BatchLoader } from \"./BatchLoader.ts\";\n\nexport const loadOperation = \"load\";\n\n/**\n * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.\n * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.\n *\n * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based\n * preloading into the same SELECT that fetches the entities.\n */\nexport function loadBatchLoader(\n  em: EntityManager,\n  meta: EntityMetadata,\n  overwriteExisting: boolean = false,\n): BatchLoader<{ taggedId: string; hint: LoadHint<any> | undefined }> {\n  return em.getBatchLoader(loadOperation, `${meta.type}-${overwriteExisting}`, async (loads) => {\n    const keys = loads.map((l) => keyToNumber(meta, l.taggedId));\n    const alias = abbreviation(meta.tableName);\n    const query = {\n      selects: meta.hasLazyColumns ? lazyExcludedSelects(meta, alias) : [`\"${alias}\".*`],\n      tables: [{ alias, join: \"primary\", table: meta.tableName }],\n      condition: {\n        kind: \"exp\",\n        op: \"and\",\n        conditions: [{ kind: \"column\", alias, column: \"id\", dbType: meta.idDbType, cond: { kind: \"in\", value: keys } }],\n      },\n      orderBys: [{ alias, column: \"id\", order: \"ASC\" }],\n    } satisfies ParsedFindQuery;\n    addTablePerClassJoinsAndClassTag(query, meta, alias, true);\n    // Inject preloading joins into the query if enabled\n    const { preloader } = getEmInternalApi(em);\n    const preloadHydrator =\n      preloader &&\n      preloader.addPreloading(meta, buildHintTree(loads.map((l) => ({ entity: l.taggedId, hint: l.hint }))), query);\n    const rowData = await em[\"executeFindRowData\"](meta, loadOperation, query, {});\n    em[\"hydrateAndFinalize\"](meta.cstr, rowData, {\n      overwriteExisting,\n      sidecars: (entities) => {\n        preloadHydrator && preloadHydrator(rowData, entities);\n        // If we're missing any requested rows, mark any requested-but-not-found entities as deleted\n        if (rowData.rowCount !== loads.length) {\n          const foundIds = new Set<string>();\n          for (let i = 0; i < rowData.rowCount; i++) foundIds.add(tagId(meta, rowData.get(i, \"id\")));\n          for (const load of loads) {\n            if (!foundIds.has(load.taggedId)) {\n              const existingEntity = em.findExistingInstance(load.taggedId);\n              if (existingEntity) {\n                getInstanceData(existingEntity).markDeletedBecauseNotFound();\n              }\n            }\n          }\n        }\n      },\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,gBAAgB;;;;;;;;AAS7B,SAAgB,gBACd,IACA,MACA,oBAA6B,OACuC;CACpE,OAAO,GAAG,eAAe,eAAe,GAAG,KAAK,KAAK,GAAG,qBAAqB,OAAO,UAAU;EAC5F,MAAM,OAAO,MAAM,KAAK,MAAMA,aAAAA,YAAY,MAAM,EAAE,QAAQ,CAAC;EAC3D,MAAM,QAAQC,cAAAA,aAAa,KAAK,SAAS;EACzC,MAAM,QAAQ;GACZ,SAAS,KAAK,iBAAiBC,oBAAAA,oBAAoB,MAAM,KAAK,IAAI,CAAC,IAAI,MAAM,IAAI;GACjF,QAAQ,CAAC;IAAE;IAAO,MAAM;IAAW,OAAO,KAAK;GAAU,CAAC;GAC1D,WAAW;IACT,MAAM;IACN,IAAI;IACJ,YAAY,CAAC;KAAE,MAAM;KAAU;KAAO,QAAQ;KAAM,QAAQ,KAAK;KAAU,MAAM;MAAE,MAAM;MAAM,OAAO;KAAK;IAAE,CAAC;GAChH;GACA,UAAU,CAAC;IAAE;IAAO,QAAQ;IAAM,OAAO;GAAM,CAAC;EAClD;EACA,oBAAA,iCAAiC,OAAO,MAAM,OAAO,IAAI;EAEzD,MAAM,EAAE,cAAcC,sBAAAA,iBAAiB,EAAE;EACzC,MAAM,kBACJ,aACA,UAAU,cAAc,MAAMC,iBAAAA,cAAc,MAAM,KAAK,OAAO;GAAE,QAAQ,EAAE;GAAU,MAAM,EAAE;EAAK,EAAE,CAAC,GAAG,KAAK;EAC9G,MAAM,UAAU,MAAM,GAAG,qBAAqB,CAAC,MAAM,eAAe,OAAO,CAAC,CAAC;EAC7E,GAAG,qBAAqB,CAAC,KAAK,MAAM,SAAS;GAC3C;GACA,WAAW,aAAa;IACtB,mBAAmB,gBAAgB,SAAS,QAAQ;IAEpD,IAAI,QAAQ,aAAa,MAAM,QAAQ;KACrC,MAAM,2BAAW,IAAI,IAAY;KACjC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,UAAU,KAAK,SAAS,IAAIC,aAAAA,MAAM,MAAM,QAAQ,IAAI,GAAG,IAAI,CAAC,CAAC;KACzF,KAAK,MAAM,QAAQ,OACjB,IAAI,CAAC,SAAS,IAAI,KAAK,QAAQ,GAAG;MAChC,MAAM,iBAAiB,GAAG,qBAAqB,KAAK,QAAQ;MAC5D,IAAI,gBACF,mBAAA,gBAAgB,cAAc,CAAC,CAAC,2BAA2B;KAE/D;IAEJ;GACF;EACF,CAAC;CACH,CAAC;AACH"}

package/build/batchloaders/loadBatchLoader.d.cts

@@ -0,0 +1,20 @@
+import { BatchLoader } from "./BatchLoader.cjs";
+import { LoadHint } from "../loadHints.cjs";
+import { EntityMetadata } from "../EntityMetadata.cjs";
+import { EntityManager } from "../EntityManager.cjs";
+//#region src/batchloaders/loadBatchLoader.d.ts
+declare const loadOperation = "load";
+/**
+ * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
+ * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
+ *
+ * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
+ * preloading into the same SELECT that fetches the entities.
+ */
+declare function loadBatchLoader(em: EntityManager, meta: EntityMetadata, overwriteExisting?: boolean): BatchLoader<{
+  taggedId: string;
+  hint: LoadHint<any> | undefined;
+}>;
+//#endregion
+export { loadBatchLoader, loadOperation };
+//# sourceMappingURL=loadBatchLoader.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"mappings":";;;;;cAUa;;;;;;;;iBASG,gBACd,IAAI,eACJ,MAAM,gBACN,8BACC;EAAc;EAAkB,MAAM"}

package/build/batchloaders/loadBatchLoader.d.mts

@@ -0,0 +1,20 @@
+import { BatchLoader } from "./BatchLoader.mjs";
+import { LoadHint } from "../loadHints.mjs";
+import { EntityMetadata } from "../EntityMetadata.mjs";
+import { EntityManager } from "../EntityManager.mjs";
+//#region src/batchloaders/loadBatchLoader.d.ts
+declare const loadOperation = "load";
+/**
+ * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
+ * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
+ *
+ * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
+ * preloading into the same SELECT that fetches the entities.
+ */
+declare function loadBatchLoader(em: EntityManager, meta: EntityMetadata, overwriteExisting?: boolean): BatchLoader<{
+  taggedId: string;
+  hint: LoadHint<any> | undefined;
+}>;
+//#endregion
+export { loadBatchLoader, loadOperation };
+//# sourceMappingURL=loadBatchLoader.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loadBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"mappings":";;;;;cAUa;;;;;;;;iBASG,gBACd,IAAI,eACJ,MAAM,gBACN,8BACC;EAAc;EAAkB,MAAM"}

package/build/batchloaders/loadBatchLoader.js

@@ -1,55 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadOperation = void 0;
-exports.loadBatchLoader = loadBatchLoader;
-const BaseEntity_1 = require("../BaseEntity");
-const EntityManager_1 = require("../EntityManager");
-const HintTree_1 = require("../HintTree");
-const QueryParser_1 = require("../QueryParser");
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-exports.loadOperation = "load";
+import "./BatchLoader.js";
+import { keyToNumber, tagId } from "../keys.js";
+import "../EntityMetadata.js";
+import "../loadHints.js";
+import { abbreviation } from "../utils.js";
+import { buildHintTree } from "../HintTree.js";
+import { getEmInternalApi } from "../EntityManager.js";
+import { getInstanceData } from "../BaseEntity.js";
+import { addTablePerClassJoinsAndClassTag, lazyExcludedSelects } from "../QueryParser.js";
+//#region src/batchloaders/loadBatchLoader.ts
+const loadOperation = "load";
 /**
- * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
- * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
- *
- * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
- * preloading into the same SELECT that fetches the entities.
- */
+* Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
+* After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
+*
+* Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
+* preloading into the same SELECT that fetches the entities.
+*/
 function loadBatchLoader(em, meta, overwriteExisting = false) {
-    return em.getBatchLoader(exports.loadOperation, `${meta.type}-${overwriteExisting}`, async (loads) => {
-        const keys = loads.map((l) => (0, keys_1.keyToNumber)(meta, l.taggedId));
-        const alias = (0, utils_1.abbreviation)(meta.tableName);
-        const query = {
-            selects: [`"${alias}".*`],
-            tables: [{ alias, join: "primary", table: meta.tableName }],
-            condition: {
-                kind: "exp",
-                op: "and",
-                conditions: [{ kind: "column", alias, column: "id", dbType: meta.idDbType, cond: { kind: "in", value: keys } }],
-            },
-            orderBys: [{ alias, column: "id", order: "ASC" }],
-        };
-        (0, QueryParser_1.addTablePerClassJoinsAndClassTag)(query, meta, alias, true);
-        // Inject preloading joins into the query if enabled
-        const { preloader } = (0, EntityManager_1.getEmInternalApi)(em);
-        const preloadHydrator = preloader &&
-            preloader.addPreloading(meta, (0, HintTree_1.buildHintTree)(loads.map((l) => ({ entity: l.taggedId, hint: l.hint }))), query);
-        const rows = await em["executeFind"](meta, exports.loadOperation, query, {});
-        const entities = em.hydrate(meta.cstr, rows, { overwriteExisting });
-        preloadHydrator && preloadHydrator(rows, entities);
-        // If we're missing any requested rows, mark any requested-but-not-found entities as deleted
-        if (rows.length !== loads.length) {
-            const foundIds = new Set(rows.map((r) => (0, keys_1.tagId)(meta, r.id)));
-            for (const load of loads) {
-                if (!foundIds.has(load.taggedId)) {
-                    const existingEntity = em.findExistingInstance(load.taggedId);
-                    if (existingEntity) {
-                        (0, BaseEntity_1.getInstanceData)(existingEntity).markDeletedBecauseNotFound();
-                    }
-                }
-            }
-        }
-    });
+	return em.getBatchLoader(loadOperation, `${meta.type}-${overwriteExisting}`, async (loads) => {
+		const keys = loads.map((l) => keyToNumber(meta, l.taggedId));
+		const alias = abbreviation(meta.tableName);
+		const query = {
+			selects: meta.hasLazyColumns ? lazyExcludedSelects(meta, alias) : [`"${alias}".*`],
+			tables: [{
+				alias,
+				join: "primary",
+				table: meta.tableName
+			}],
+			condition: {
+				kind: "exp",
+				op: "and",
+				conditions: [{
+					kind: "column",
+					alias,
+					column: "id",
+					dbType: meta.idDbType,
+					cond: {
+						kind: "in",
+						value: keys
+					}
+				}]
+			},
+			orderBys: [{
+				alias,
+				column: "id",
+				order: "ASC"
+			}]
+		};
+		addTablePerClassJoinsAndClassTag(query, meta, alias, true);
+		const { preloader } = getEmInternalApi(em);
+		const preloadHydrator = preloader && preloader.addPreloading(meta, buildHintTree(loads.map((l) => ({
+			entity: l.taggedId,
+			hint: l.hint
+		}))), query);
+		const rowData = await em["executeFindRowData"](meta, loadOperation, query, {});
+		em["hydrateAndFinalize"](meta.cstr, rowData, {
+			overwriteExisting,
+			sidecars: (entities) => {
+				preloadHydrator && preloadHydrator(rowData, entities);
+				if (rowData.rowCount !== loads.length) {
+					const foundIds = /* @__PURE__ */ new Set();
+					for (let i = 0; i < rowData.rowCount; i++) foundIds.add(tagId(meta, rowData.get(i, "id")));
+					for (const load of loads) if (!foundIds.has(load.taggedId)) {
+						const existingEntity = em.findExistingInstance(load.taggedId);
+						if (existingEntity) getInstanceData(existingEntity).markDeletedBecauseNotFound();
+					}
+				}
+			}
+		});
+	});
 }
+//#endregion
+export { loadBatchLoader, loadOperation };
+
 //# sourceMappingURL=loadBatchLoader.js.map

package/build/batchloaders/loadBatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"loadBatchLoader.js","sourceRoot":"","sources":["../../src/batchloaders/loadBatchLoader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"loadBatchLoader.js","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"sourcesContent":["import { getInstanceData } from \"../BaseEntity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type EntityMetadata } from \"../EntityMetadata.ts\";\nimport { buildHintTree } from \"../HintTree.ts\";\nimport { keyToNumber, tagId } from \"../keys.ts\";\nimport { type LoadHint } from \"../loadHints.ts\";\nimport { type ParsedFindQuery, addTablePerClassJoinsAndClassTag, lazyExcludedSelects } from \"../QueryParser.ts\";\nimport { abbreviation } from \"../utils.ts\";\nimport { type BatchLoader } from \"./BatchLoader.ts\";\n\nexport const loadOperation = \"load\";\n\n/**\n * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.\n * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.\n *\n * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based\n * preloading into the same SELECT that fetches the entities.\n */\nexport function loadBatchLoader(\n  em: EntityManager,\n  meta: EntityMetadata,\n  overwriteExisting: boolean = false,\n): BatchLoader<{ taggedId: string; hint: LoadHint<any> | undefined }> {\n  return em.getBatchLoader(loadOperation, `${meta.type}-${overwriteExisting}`, async (loads) => {\n    const keys = loads.map((l) => keyToNumber(meta, l.taggedId));\n    const alias = abbreviation(meta.tableName);\n    const query = {\n      selects: meta.hasLazyColumns ? lazyExcludedSelects(meta, alias) : [`\"${alias}\".*`],\n      tables: [{ alias, join: \"primary\", table: meta.tableName }],\n      condition: {\n        kind: \"exp\",\n        op: \"and\",\n        conditions: [{ kind: \"column\", alias, column: \"id\", dbType: meta.idDbType, cond: { kind: \"in\", value: keys } }],\n      },\n      orderBys: [{ alias, column: \"id\", order: \"ASC\" }],\n    } satisfies ParsedFindQuery;\n    addTablePerClassJoinsAndClassTag(query, meta, alias, true);\n    // Inject preloading joins into the query if enabled\n    const { preloader } = getEmInternalApi(em);\n    const preloadHydrator =\n      preloader &&\n      preloader.addPreloading(meta, buildHintTree(loads.map((l) => ({ entity: l.taggedId, hint: l.hint }))), query);\n    const rowData = await em[\"executeFindRowData\"](meta, loadOperation, query, {});\n    em[\"hydrateAndFinalize\"](meta.cstr, rowData, {\n      overwriteExisting,\n      sidecars: (entities) => {\n        preloadHydrator && preloadHydrator(rowData, entities);\n        // If we're missing any requested rows, mark any requested-but-not-found entities as deleted\n        if (rowData.rowCount !== loads.length) {\n          const foundIds = new Set<string>();\n          for (let i = 0; i < rowData.rowCount; i++) foundIds.add(tagId(meta, rowData.get(i, \"id\")));\n          for (const load of loads) {\n            if (!foundIds.has(load.taggedId)) {\n              const existingEntity = em.findExistingInstance(load.taggedId);\n              if (existingEntity) {\n                getInstanceData(existingEntity).markDeletedBecauseNotFound();\n              }\n            }\n          }\n        }\n      },\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;AAUA,MAAa,gBAAgB;;;;;;;;AAS7B,SAAgB,gBACd,IACA,MACA,oBAA6B,OACuC;CACpE,OAAO,GAAG,eAAe,eAAe,GAAG,KAAK,KAAK,GAAG,qBAAqB,OAAO,UAAU;EAC5F,MAAM,OAAO,MAAM,KAAK,MAAM,YAAY,MAAM,EAAE,QAAQ,CAAC;EAC3D,MAAM,QAAQ,aAAa,KAAK,SAAS;EACzC,MAAM,QAAQ;GACZ,SAAS,KAAK,iBAAiB,oBAAoB,MAAM,KAAK,IAAI,CAAC,IAAI,MAAM,IAAI;GACjF,QAAQ,CAAC;IAAE;IAAO,MAAM;IAAW,OAAO,KAAK;GAAU,CAAC;GAC1D,WAAW;IACT,MAAM;IACN,IAAI;IACJ,YAAY,CAAC;KAAE,MAAM;KAAU;KAAO,QAAQ;KAAM,QAAQ,KAAK;KAAU,MAAM;MAAE,MAAM;MAAM,OAAO;KAAK;IAAE,CAAC;GAChH;GACA,UAAU,CAAC;IAAE;IAAO,QAAQ;IAAM,OAAO;GAAM,CAAC;EAClD;EACA,iCAAiC,OAAO,MAAM,OAAO,IAAI;EAEzD,MAAM,EAAE,cAAc,iBAAiB,EAAE;EACzC,MAAM,kBACJ,aACA,UAAU,cAAc,MAAM,cAAc,MAAM,KAAK,OAAO;GAAE,QAAQ,EAAE;GAAU,MAAM,EAAE;EAAK,EAAE,CAAC,GAAG,KAAK;EAC9G,MAAM,UAAU,MAAM,GAAG,qBAAqB,CAAC,MAAM,eAAe,OAAO,CAAC,CAAC;EAC7E,GAAG,qBAAqB,CAAC,KAAK,MAAM,SAAS;GAC3C;GACA,WAAW,aAAa;IACtB,mBAAmB,gBAAgB,SAAS,QAAQ;IAEpD,IAAI,QAAQ,aAAa,MAAM,QAAQ;KACrC,MAAM,2BAAW,IAAI,IAAY;KACjC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,UAAU,KAAK,SAAS,IAAI,MAAM,MAAM,QAAQ,IAAI,GAAG,IAAI,CAAC,CAAC;KACzF,KAAK,MAAM,QAAQ,OACjB,IAAI,CAAC,SAAS,IAAI,KAAK,QAAQ,GAAG;MAChC,MAAM,iBAAiB,GAAG,qBAAqB,KAAK,QAAQ;MAC5D,IAAI,gBACF,gBAAgB,cAAc,CAAC,CAAC,2BAA2B;KAE/D;IAEJ;GACF;EACF,CAAC;CACH,CAAC;AACH"}

package/build/batchloaders/manyToManyBatchLoader.cjs

@@ -0,0 +1,78 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./BatchLoader.cjs");
+const require_keys = require("../keys.cjs");
+const require_utils = require("../utils.cjs");
+require("../index.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+require("../Entity.cjs");
+//#region src/batchloaders/manyToManyBatchLoader.ts
+const manyToManyLoadOperation = "m2m-load";
+/** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */
+function manyToManyBatchLoader(em, collection) {
+	return em.getBatchLoader(manyToManyLoadOperation, collection.joinTableName, (keys) => loadBatch(collection, keys));
+}
+async function loadBatch(collection, keys) {
+	const { em } = collection.entity;
+	const joinRows = require_EntityManager.getEmInternalApi(em).joinRows(collection);
+	const columns = {};
+	const tuples = [];
+	keys.forEach((key) => {
+		const [columnId, id] = key.split("=");
+		require_utils.getOrSet(columns, columnId, []).push(id);
+		tuples.push([columnId, id]);
+	});
+	const alias = require_utils.abbreviation(collection.joinTableName);
+	const query = {
+		selects: [`"${alias}".*`],
+		tables: [{
+			alias,
+			join: "primary",
+			table: collection.joinTableName
+		}],
+		condition: {
+			kind: "exp",
+			op: "or",
+			conditions: Object.entries(columns).map(([columnId, values]) => {
+				const meta = collection.columnName == columnId ? collection.meta : collection.otherMeta;
+				return {
+					kind: "column",
+					alias,
+					column: columnId,
+					dbType: meta.idDbType,
+					cond: {
+						kind: "in",
+						value: values.map((id) => require_keys.keyToNumber(meta, id))
+					}
+				};
+			})
+		},
+		orderBys: collection.hasJoinTableId ? [{
+			alias,
+			column: "id",
+			order: "ASC"
+		}] : [{
+			alias,
+			column: collection.columnName,
+			order: "ASC"
+		}, {
+			alias,
+			column: collection.otherColumnName,
+			order: "ASC"
+		}]
+	};
+	const rows = await em["executeFind"](collection.otherMeta, manyToManyLoadOperation, query, { limit: void 0 });
+	await joinRows.loadRows(tuples, rows);
+	const api = require_EntityManager.getEmInternalApi(em);
+	for (const [column, id] of tuples) {
+		const entity = em.getEntity(id);
+		if (!entity) continue;
+		const others = joinRows.getOthers(column, entity);
+		const fieldName = column === collection.columnName ? collection.fieldName : collection.otherFieldName;
+		api.setPreloadedRelation(entity.idTagged, fieldName, others);
+	}
+}
+//#endregion
+exports.manyToManyBatchLoader = manyToManyBatchLoader;
+exports.manyToManyLoadOperation = manyToManyLoadOperation;
+
+//# sourceMappingURL=manyToManyBatchLoader.cjs.map

package/build/batchloaders/manyToManyBatchLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"manyToManyBatchLoader.cjs","names":["getEmInternalApi","abbreviation","keyToNumber"],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"../index.ts\";\nimport { abbreviation, getOrSet } from \"../utils.ts\";\nimport { type BatchLoader } from \"./BatchLoader.ts\";\n\nexport const manyToManyLoadOperation = \"m2m-load\";\n\n/** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */\nexport function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string> {\n  return em.getBatchLoader(manyToManyLoadOperation, collection.joinTableName, (keys) => loadBatch(collection, keys));\n}\n\nasync function loadBatch<U extends Entity>(collection: ManyToManyLike, keys: string[]): Promise<void> {\n  const { em } = collection.entity;\n\n  const joinRows = getEmInternalApi(em).joinRows(collection);\n\n  // Break out `column_id=string` keys\n  const columns: Record<string, string[]> = {};\n  const tuples: [string, string][] = [];\n  keys.forEach((key) => {\n    const [columnId, id] = key.split(\"=\");\n    getOrSet(columns, columnId, []).push(id);\n    tuples.push([columnId, id]);\n  });\n\n  const alias = abbreviation(collection.joinTableName);\n  const query: ParsedFindQuery = {\n    selects: [`\"${alias}\".*`],\n    tables: [{ alias, join: \"primary\", table: collection.joinTableName }],\n    condition: {\n      kind: \"exp\",\n      op: \"or\",\n      conditions: Object.entries(columns).map(([columnId, values]) => {\n        // `otherMeta` is only optional because of enum m2ms (EnumCollections), which use their own\n        // batch loader, so here it's always an entity-to-entity m2m and `otherMeta` is defined.\n        const meta = collection.columnName == columnId ? collection.meta : collection.otherMeta!;\n        return {\n          kind: \"column\",\n          alias,\n          column: columnId,\n          dbType: meta.idDbType,\n          cond: { kind: \"in\", value: values.map((id) => keyToNumber(meta, id)!) },\n        };\n      }),\n    },\n    // Id-less join tables have no surrogate id to order by, so order by the FK columns instead.\n    orderBys: collection.hasJoinTableId\n      ? [{ alias, column: \"id\", order: \"ASC\" }]\n      : [\n          { alias, column: collection.columnName, order: \"ASC\" },\n          { alias, column: collection.otherColumnName, order: \"ASC\" },\n        ],\n  };\n\n  const rows = await em[\"executeFind\"](\n    collection.otherMeta!,\n    manyToManyLoadOperation,\n    query,\n    // No LIMIT needed for join rows\n    { limit: undefined },\n  );\n  await joinRows.loadRows(tuples, rows);\n\n  const api = getEmInternalApi(em);\n  for (const [column, id] of tuples) {\n    const entity = em.getEntity(id);\n    if (!entity) continue;\n    const others = joinRows.getOthers(column, entity) as U[];\n    // Determine the field name from the column\n    const fieldName = column === collection.columnName ? collection.fieldName : collection.otherFieldName!;\n    api.setPreloadedRelation(entity.idTagged!, fieldName, others);\n  }\n}\n"],"mappings":";;;;;;;;AAMA,MAAa,0BAA0B;;AAGvC,SAAgB,sBAAsB,IAAmB,YAAiD;CACxG,OAAO,GAAG,eAAe,yBAAyB,WAAW,gBAAgB,SAAS,UAAU,YAAY,IAAI,CAAC;AACnH;AAEA,eAAe,UAA4B,YAA4B,MAA+B;CACpG,MAAM,EAAE,OAAO,WAAW;CAE1B,MAAM,WAAWA,sBAAAA,iBAAiB,EAAE,CAAC,CAAC,SAAS,UAAU;CAGzD,MAAM,UAAoC,CAAC;CAC3C,MAAM,SAA6B,CAAC;CACpC,KAAK,SAAS,QAAQ;EACpB,MAAM,CAAC,UAAU,MAAM,IAAI,MAAM,GAAG;EACpC,cAAA,SAAS,SAAS,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE;EACvC,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC;CAC5B,CAAC;CAED,MAAM,QAAQC,cAAAA,aAAa,WAAW,aAAa;CACnD,MAAM,QAAyB;EAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;EACxB,QAAQ,CAAC;GAAE;GAAO,MAAM;GAAW,OAAO,WAAW;EAAc,CAAC;EACpE,WAAW;GACT,MAAM;GACN,IAAI;GACJ,YAAY,OAAO,QAAQ,OAAO,CAAC,CAAC,KAAK,CAAC,UAAU,YAAY;IAG9D,MAAM,OAAO,WAAW,cAAc,WAAW,WAAW,OAAO,WAAW;IAC9E,OAAO;KACL,MAAM;KACN;KACA,QAAQ;KACR,QAAQ,KAAK;KACb,MAAM;MAAE,MAAM;MAAM,OAAO,OAAO,KAAK,OAAOC,aAAAA,YAAY,MAAM,EAAE,CAAE;KAAE;IACxE;GACF,CAAC;EACH;EAEA,UAAU,WAAW,iBACjB,CAAC;GAAE;GAAO,QAAQ;GAAM,OAAO;EAAM,CAAC,IACtC,CACE;GAAE;GAAO,QAAQ,WAAW;GAAY,OAAO;EAAM,GACrD;GAAE;GAAO,QAAQ,WAAW;GAAiB,OAAO;EAAM,CAC5D;CACN;CAEA,MAAM,OAAO,MAAM,GAAG,cAAc,CAClC,WAAW,WACX,yBACA,OAEA,EAAE,OAAO,KAAA,EAAU,CACrB;CACA,MAAM,SAAS,SAAS,QAAQ,IAAI;CAEpC,MAAM,MAAMF,sBAAAA,iBAAiB,EAAE;CAC/B,KAAK,MAAM,CAAC,QAAQ,OAAO,QAAQ;EACjC,MAAM,SAAS,GAAG,UAAU,EAAE;EAC9B,IAAI,CAAC,QAAQ;EACb,MAAM,SAAS,SAAS,UAAU,QAAQ,MAAM;EAEhD,MAAM,YAAY,WAAW,WAAW,aAAa,WAAW,YAAY,WAAW;EACvF,IAAI,qBAAqB,OAAO,UAAW,WAAW,MAAM;CAC9D;AACF"}

package/build/batchloaders/manyToManyBatchLoader.d.cts

@@ -0,0 +1,11 @@
+import { BatchLoader } from "./BatchLoader.cjs";
+import { ManyToManyLike } from "../JoinRows.cjs";
+import "../index.cjs";
+import { EntityManager } from "../EntityManager.cjs";
+//#region src/batchloaders/manyToManyBatchLoader.d.ts
+declare const manyToManyLoadOperation = "m2m-load";
+/** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */
+declare function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+//#endregion
+export { manyToManyBatchLoader, manyToManyLoadOperation };
+//# sourceMappingURL=manyToManyBatchLoader.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manyToManyBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"mappings":";;;;;cAMa;;iBAGG,sBAAsB,IAAI,eAAe,YAAY,iBAAiB"}

package/build/batchloaders/manyToManyBatchLoader.d.mts

@@ -0,0 +1,11 @@
+import { BatchLoader } from "./BatchLoader.mjs";
+import { ManyToManyLike } from "../JoinRows.mjs";
+import "../index.mjs";
+import { EntityManager } from "../EntityManager.mjs";
+//#region src/batchloaders/manyToManyBatchLoader.d.ts
+declare const manyToManyLoadOperation = "m2m-load";
+/** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */
+declare function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+//#endregion
+export { manyToManyBatchLoader, manyToManyLoadOperation };
+//# sourceMappingURL=manyToManyBatchLoader.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manyToManyBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"mappings":";;;;;cAMa;;iBAGG,sBAAsB,IAAI,eAAe,YAAY,iBAAiB"}

package/build/batchloaders/manyToManyBatchLoader.js

@@ -1,67 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.manyToManyLoadOperation = void 0;
-exports.manyToManyBatchLoader = manyToManyBatchLoader;
-const EntityManager_1 = require("../EntityManager");
-const index_1 = require("../index");
-const utils_1 = require("../utils");
-exports.manyToManyLoadOperation = "m2m-load";
+import "./BatchLoader.js";
+import { keyToNumber } from "../keys.js";
+import { abbreviation, getOrSet } from "../utils.js";
+import "../index.js";
+import { getEmInternalApi } from "../EntityManager.js";
+import "../Entity.js";
+//#region src/batchloaders/manyToManyBatchLoader.ts
+const manyToManyLoadOperation = "m2m-load";
 /** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */
 function manyToManyBatchLoader(em, collection) {
-    return em.getBatchLoader(exports.manyToManyLoadOperation, collection.joinTableName, (keys) => loadBatch(collection, keys));
+	return em.getBatchLoader(manyToManyLoadOperation, collection.joinTableName, (keys) => loadBatch(collection, keys));
 }
 async function loadBatch(collection, keys) {
-    const { em } = collection.entity;
-    const joinRows = (0, EntityManager_1.getEmInternalApi)(em).joinRows(collection);
-    // Break out `column_id=string` keys
-    const columns = {};
-    const tuples = [];
-    keys.forEach((key) => {
-        const [columnId, id] = key.split("=");
-        (0, utils_1.getOrSet)(columns, columnId, []).push(id);
-        tuples.push([columnId, id]);
-    });
-    const alias = (0, utils_1.abbreviation)(collection.joinTableName);
-    const query = {
-        selects: [`"${alias}".*`],
-        tables: [{ alias, join: "primary", table: collection.joinTableName }],
-        condition: {
-            kind: "exp",
-            op: "or",
-            conditions: Object.entries(columns).map(([columnId, values]) => {
-                // `otherMeta` is only optional because of enum m2ms (EnumCollections), which use their own
-                // batch loader, so here it's always an entity-to-entity m2m and `otherMeta` is defined.
-                const meta = collection.columnName == columnId ? collection.meta : collection.otherMeta;
-                return {
-                    kind: "column",
-                    alias,
-                    column: columnId,
-                    dbType: meta.idDbType,
-                    cond: { kind: "in", value: values.map((id) => (0, index_1.keyToNumber)(meta, id)) },
-                };
-            }),
-        },
-        // Id-less join tables have no surrogate id to order by, so order by the FK columns instead.
-        orderBys: collection.hasJoinTableId
-            ? [{ alias, column: "id", order: "ASC" }]
-            : [
-                { alias, column: collection.columnName, order: "ASC" },
-                { alias, column: collection.otherColumnName, order: "ASC" },
-            ],
-    };
-    const rows = await em["executeFind"](collection.otherMeta, exports.manyToManyLoadOperation, query, 
-    // No LIMIT needed for join rows
-    { limit: undefined });
-    await joinRows.loadRows(tuples, rows);
-    const api = (0, EntityManager_1.getEmInternalApi)(em);
-    for (const [column, id] of tuples) {
-        const entity = em.getEntity(id);
-        if (!entity)
-            continue;
-        const others = joinRows.getOthers(column, entity);
-        // Determine the field name from the column
-        const fieldName = column === collection.columnName ? collection.fieldName : collection.otherFieldName;
-        api.setPreloadedRelation(entity.idTagged, fieldName, others);
-    }
+	const { em } = collection.entity;
+	const joinRows = getEmInternalApi(em).joinRows(collection);
+	const columns = {};
+	const tuples = [];
+	keys.forEach((key) => {
+		const [columnId, id] = key.split("=");
+		getOrSet(columns, columnId, []).push(id);
+		tuples.push([columnId, id]);
+	});
+	const alias = abbreviation(collection.joinTableName);
+	const query = {
+		selects: [`"${alias}".*`],
+		tables: [{
+			alias,
+			join: "primary",
+			table: collection.joinTableName
+		}],
+		condition: {
+			kind: "exp",
+			op: "or",
+			conditions: Object.entries(columns).map(([columnId, values]) => {
+				const meta = collection.columnName == columnId ? collection.meta : collection.otherMeta;
+				return {
+					kind: "column",
+					alias,
+					column: columnId,
+					dbType: meta.idDbType,
+					cond: {
+						kind: "in",
+						value: values.map((id) => keyToNumber(meta, id))
+					}
+				};
+			})
+		},
+		orderBys: collection.hasJoinTableId ? [{
+			alias,
+			column: "id",
+			order: "ASC"
+		}] : [{
+			alias,
+			column: collection.columnName,
+			order: "ASC"
+		}, {
+			alias,
+			column: collection.otherColumnName,
+			order: "ASC"
+		}]
+	};
+	const rows = await em["executeFind"](collection.otherMeta, manyToManyLoadOperation, query, { limit: void 0 });
+	await joinRows.loadRows(tuples, rows);
+	const api = getEmInternalApi(em);
+	for (const [column, id] of tuples) {
+		const entity = em.getEntity(id);
+		if (!entity) continue;
+		const others = joinRows.getOthers(column, entity);
+		const fieldName = column === collection.columnName ? collection.fieldName : collection.otherFieldName;
+		api.setPreloadedRelation(entity.idTagged, fieldName, others);
+	}
 }
+//#endregion
+export { manyToManyBatchLoader, manyToManyLoadOperation };
+
 //# sourceMappingURL=manyToManyBatchLoader.js.map

package/build/batchloaders/manyToManyBatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"manyToManyBatchLoader.js","sourceRoot":"","sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"names":[],"mappings":";;;AASA,sDAEC;AAVD,oDAAmE;AACnE,oCAAwE;AACxE,oCAAkD;AAGrC,QAAA,uBAAuB,GAAG,UAAU,CAAC;AAElD,+FAA+F;AAC/F,SAAgB,qBAAqB,CAAC,EAAiB,EAAE,UAA0B;IACjF,OAAO,EAAE,CAAC,cAAc,CAAC,+BAAuB,EAAE,UAAU,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;AACrH,CAAC;AAED,KAAK,UAAU,SAAS,CAAmB,UAA0B,EAAE,IAAc;IACnF,MAAM,EAAE,EAAE,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC;IAEjC,MAAM,QAAQ,GAAG,IAAA,gCAAgB,EAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAE3D,oCAAoC;IACpC,MAAM,OAAO,GAA6B,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAuB,EAAE,CAAC;IACtC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;QACnB,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,IAAA,gBAAQ,EAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACzC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,IAAA,oBAAY,EAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IACrD,MAAM,KAAK,GAAoB;QAC7B,OAAO,EAAE,CAAC,IAAI,KAAK,KAAK,CAAC;QACzB,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,UAAU,CAAC,aAAa,EAAE,CAAC;QACrE,SAAS,EAAE;YACT,IAAI,EAAE,KAAK;YACX,EAAE,EAAE,IAAI;YACR,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE;gBAC7D,2FAA2F;gBAC3F,wFAAwF;gBACxF,MAAM,IAAI,GAAG,UAAU,CAAC,UAAU,IAAI,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,SAAU,CAAC;gBACzF,OAAO;oBACL,IAAI,EAAE,QAAQ;oBACd,KAAK;oBACL,MAAM,EAAE,QAAQ;oBAChB,MAAM,EAAE,IAAI,CAAC,QAAQ;oBACrB,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAA,mBAAW,EAAC,IAAI,EAAE,EAAE,CAAE,CAAC,EAAE;iBACxE,CAAC;YACJ,CAAC,CAAC;SACH;QACD,4FAA4F;QAC5F,QAAQ,EAAE,UAAU,CAAC,cAAc;YACjC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;YACzC,CAAC,CAAC;gBACE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE;gBACtD,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE;aAC5D;KACN,CAAC;IAEF,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,aAAa,CAAC,CAClC,UAAU,CAAC,SAAU,EACrB,+BAAuB,EACvB,KAAK;IACL,gCAAgC;IAChC,EAAE,KAAK,EAAE,SAAS,EAAE,CACrB,CAAC;IACF,MAAM,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAEtC,MAAM,GAAG,GAAG,IAAA,gCAAgB,EAAC,EAAE,CAAC,CAAC;IACjC,KAAK,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,MAAM,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM;YAAE,SAAS;QACtB,MAAM,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAQ,CAAC;QACzD,2CAA2C;QAC3C,MAAM,SAAS,GAAG,MAAM,KAAK,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,cAAe,CAAC;QACvG,GAAG,CAAC,oBAAoB,CAAC,MAAM,CAAC,QAAS,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC;AACH,CAAC"}
+{"version":3,"file":"manyToManyBatchLoader.js","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type EntityManager, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"../index.ts\";\nimport { abbreviation, getOrSet } from \"../utils.ts\";\nimport { type BatchLoader } from \"./BatchLoader.ts\";\n\nexport const manyToManyLoadOperation = \"m2m-load\";\n\n/** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */\nexport function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string> {\n  return em.getBatchLoader(manyToManyLoadOperation, collection.joinTableName, (keys) => loadBatch(collection, keys));\n}\n\nasync function loadBatch<U extends Entity>(collection: ManyToManyLike, keys: string[]): Promise<void> {\n  const { em } = collection.entity;\n\n  const joinRows = getEmInternalApi(em).joinRows(collection);\n\n  // Break out `column_id=string` keys\n  const columns: Record<string, string[]> = {};\n  const tuples: [string, string][] = [];\n  keys.forEach((key) => {\n    const [columnId, id] = key.split(\"=\");\n    getOrSet(columns, columnId, []).push(id);\n    tuples.push([columnId, id]);\n  });\n\n  const alias = abbreviation(collection.joinTableName);\n  const query: ParsedFindQuery = {\n    selects: [`\"${alias}\".*`],\n    tables: [{ alias, join: \"primary\", table: collection.joinTableName }],\n    condition: {\n      kind: \"exp\",\n      op: \"or\",\n      conditions: Object.entries(columns).map(([columnId, values]) => {\n        // `otherMeta` is only optional because of enum m2ms (EnumCollections), which use their own\n        // batch loader, so here it's always an entity-to-entity m2m and `otherMeta` is defined.\n        const meta = collection.columnName == columnId ? collection.meta : collection.otherMeta!;\n        return {\n          kind: \"column\",\n          alias,\n          column: columnId,\n          dbType: meta.idDbType,\n          cond: { kind: \"in\", value: values.map((id) => keyToNumber(meta, id)!) },\n        };\n      }),\n    },\n    // Id-less join tables have no surrogate id to order by, so order by the FK columns instead.\n    orderBys: collection.hasJoinTableId\n      ? [{ alias, column: \"id\", order: \"ASC\" }]\n      : [\n          { alias, column: collection.columnName, order: \"ASC\" },\n          { alias, column: collection.otherColumnName, order: \"ASC\" },\n        ],\n  };\n\n  const rows = await em[\"executeFind\"](\n    collection.otherMeta!,\n    manyToManyLoadOperation,\n    query,\n    // No LIMIT needed for join rows\n    { limit: undefined },\n  );\n  await joinRows.loadRows(tuples, rows);\n\n  const api = getEmInternalApi(em);\n  for (const [column, id] of tuples) {\n    const entity = em.getEntity(id);\n    if (!entity) continue;\n    const others = joinRows.getOthers(column, entity) as U[];\n    // Determine the field name from the column\n    const fieldName = column === collection.columnName ? collection.fieldName : collection.otherFieldName!;\n    api.setPreloadedRelation(entity.idTagged!, fieldName, others);\n  }\n}\n"],"mappings":";;;;;;;AAMA,MAAa,0BAA0B;;AAGvC,SAAgB,sBAAsB,IAAmB,YAAiD;CACxG,OAAO,GAAG,eAAe,yBAAyB,WAAW,gBAAgB,SAAS,UAAU,YAAY,IAAI,CAAC;AACnH;AAEA,eAAe,UAA4B,YAA4B,MAA+B;CACpG,MAAM,EAAE,OAAO,WAAW;CAE1B,MAAM,WAAW,iBAAiB,EAAE,CAAC,CAAC,SAAS,UAAU;CAGzD,MAAM,UAAoC,CAAC;CAC3C,MAAM,SAA6B,CAAC;CACpC,KAAK,SAAS,QAAQ;EACpB,MAAM,CAAC,UAAU,MAAM,IAAI,MAAM,GAAG;EACpC,SAAS,SAAS,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE;EACvC,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC;CAC5B,CAAC;CAED,MAAM,QAAQ,aAAa,WAAW,aAAa;CACnD,MAAM,QAAyB;EAC7B,SAAS,CAAC,IAAI,MAAM,IAAI;EACxB,QAAQ,CAAC;GAAE;GAAO,MAAM;GAAW,OAAO,WAAW;EAAc,CAAC;EACpE,WAAW;GACT,MAAM;GACN,IAAI;GACJ,YAAY,OAAO,QAAQ,OAAO,CAAC,CAAC,KAAK,CAAC,UAAU,YAAY;IAG9D,MAAM,OAAO,WAAW,cAAc,WAAW,WAAW,OAAO,WAAW;IAC9E,OAAO;KACL,MAAM;KACN;KACA,QAAQ;KACR,QAAQ,KAAK;KACb,MAAM;MAAE,MAAM;MAAM,OAAO,OAAO,KAAK,OAAO,YAAY,MAAM,EAAE,CAAE;KAAE;IACxE;GACF,CAAC;EACH;EAEA,UAAU,WAAW,iBACjB,CAAC;GAAE;GAAO,QAAQ;GAAM,OAAO;EAAM,CAAC,IACtC,CACE;GAAE;GAAO,QAAQ,WAAW;GAAY,OAAO;EAAM,GACrD;GAAE;GAAO,QAAQ,WAAW;GAAiB,OAAO;EAAM,CAC5D;CACN;CAEA,MAAM,OAAO,MAAM,GAAG,cAAc,CAClC,WAAW,WACX,yBACA,OAEA,EAAE,OAAO,KAAA,EAAU,CACrB;CACA,MAAM,SAAS,SAAS,QAAQ,IAAI;CAEpC,MAAM,MAAM,iBAAiB,EAAE;CAC/B,KAAK,MAAM,CAAC,QAAQ,OAAO,QAAQ;EACjC,MAAM,SAAS,GAAG,UAAU,EAAE;EAC9B,IAAI,CAAC,QAAQ;EACb,MAAM,SAAS,SAAS,UAAU,QAAQ,MAAM;EAEhD,MAAM,YAAY,WAAW,WAAW,aAAa,WAAW,YAAY,WAAW;EACvF,IAAI,qBAAqB,OAAO,UAAW,WAAW,MAAM;CAC9D;AACF"}