joist-core 2.3.0 → 2.4.0-next.10

package/build/RowData.js

@@ -0,0 +1,35 @@
+//#region src/RowData.ts
+/** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */
+var PojoRowData = class {
+	rows;
+	constructor(rows) {
+		this.rows = rows;
+	}
+	get rowCount() {
+		return this.rows.length;
+	}
+	get(rowIndex, columnName) {
+		return this.rows[rowIndex][columnName];
+	}
+	toRow(rowIndex) {
+		return this.rows[rowIndex];
+	}
+	toRows() {
+		return this.rows;
+	}
+};
+/** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */
+const emptyRowData = {
+	rowCount: 0,
+	get() {},
+	toRow() {
+		return {};
+	},
+	toRows() {
+		return [];
+	}
+};
+//#endregion
+export { PojoRowData, emptyRowData };
+
+//# sourceMappingURL=RowData.js.map

package/build/RowData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RowData.js","names":[],"sources":["../src/RowData.ts"],"sourcesContent":["/**\n * A read-only view of one query's result rows; each entity references its as-loaded row as a\n * `(rowData, rowIndex)` pair on its `InstanceData`.\n *\n * Each query result gets its own individual `RowData` — results are never combined or appended\n * across queries. An entity keeps pointing at the `RowData` of whichever query first loaded it\n * (or, for `em.refresh`, the query that most recently refreshed it), and the `RowData` is never\n * written to: mutations go into the entity's `data`/`originalData` bags as usual, so a `RowData`\n * stays a snapshot of \"what the database returned for this query\".\n *\n * This is the seam that lets rows be backed by different representations:\n *\n * - `PojoRowData` wraps the classic node-pg POJO rows, i.e. for the public\n *   `em.hydrate(type, rows)` API and drivers that return materialized rows, and\n * - lazy/columnar results (`WireRowData` in joist-orm, see `JS-ROW-STORE-DESIGN.md`) keep raw\n *   wire bytes in off-heap arenas and only decode a `row × column` cell when a field is read.\n *\n * Values returned from `get` are \"driver-level\" values, i.e. whatever the pg type\n * parsers produce (numbers for `int4`, parsed objects for `jsonb`, strings for\n * deferred temporals); the field serdes then convert them to domain values.\n */\nexport interface RowData {\n  /** The number of rows in this query result. */\n  readonly rowCount: number;\n  /** Returns the driver-level column value for a row, i.e. `rowData.get(0, \"first_name\")`. */\n  get(rowIndex: number, columnName: string): any;\n  /** Materializes one row as a classic POJO, i.e. for debugging and differential tests. */\n  toRow(rowIndex: number): any;\n  /** Materializes classic POJO rows, i.e. for `afterFind` observation or debugging. */\n  toRows(): any[];\n  /** Optionally marks `rowIndex` as retained by a hydrated entity; see `finalize`. */\n  retain?(rowIndex: number): void;\n  /**\n   * Optionally trims/compacts the result after hydration + sidecar reads are complete, i.e. so\n   * lazy results only retain bytes for rows whose entities were actually kept.\n   */\n  finalize?(): void;\n}\n\n/** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */\nexport class PojoRowData implements RowData {\n  constructor(private rows: readonly any[]) {}\n\n  get rowCount(): number {\n    return this.rows.length;\n  }\n\n  get(rowIndex: number, columnName: string): any {\n    return this.rows[rowIndex][columnName];\n  }\n\n  toRow(rowIndex: number): any {\n    return this.rows[rowIndex];\n  }\n\n  toRows(): any[] {\n    return this.rows as any[];\n  }\n}\n\n/** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */\nexport const emptyRowData: RowData = {\n  rowCount: 0,\n  get() {\n    return undefined;\n  },\n  toRow() {\n    return {};\n  },\n  toRows() {\n    return [];\n  },\n};\n"],"mappings":";;AAwCA,IAAa,cAAb,MAA4C;CACtB;CAApB,YAAY,MAA8B;EAAtB,KAAA,OAAA;CAAuB;CAE3C,IAAI,WAAmB;EACrB,OAAO,KAAK,KAAK;CACnB;CAEA,IAAI,UAAkB,YAAyB;EAC7C,OAAO,KAAK,KAAK,SAAS,CAAC;CAC7B;CAEA,MAAM,UAAuB;EAC3B,OAAO,KAAK,KAAK;CACnB;CAEA,SAAgB;EACd,OAAO,KAAK;CACd;AACF;;AAGA,MAAa,eAAwB;CACnC,UAAU;CACV,MAAM,CAEN;CACA,QAAQ;EACN,OAAO,CAAC;CACV;CACA,SAAS;EACP,OAAO,CAAC;CACV;AACF"}

package/build/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/build/batchloaders/BatchLoader.cjs

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/batchloaders/BatchLoader.ts
+/**
+* Like DataLoader, but all callers in the same tick share a single Promise<void>.
+*
+* The batch function writes results into a side channel (e.g. setPreloadedRelation
+* or em.hydrate), so there's no per-key return value — just one shared promise
+* that signals "the batch is done".
+*/
+var BatchLoader = class {
+	#batchFn;
+	#pending;
+	#batchPromise;
+	constructor(batchFn) {
+		this.#batchFn = batchFn;
+	}
+	load(key) {
+		this.#ensureBatch();
+		this.#pending.push(key);
+		return this.#batchPromise;
+	}
+	loadAll(keys) {
+		this.#ensureBatch();
+		const pending = this.#pending;
+		const start = pending.length;
+		pending.length += keys.length;
+		for (let i = 0; i < keys.length; i++) pending[start + i] = keys[i];
+		return this.#batchPromise;
+	}
+	#ensureBatch() {
+		if (!this.#pending) {
+			this.#pending = [];
+			this.#batchPromise = new Promise((resolve, reject) => {
+				enqueuePostPromiseJob(() => {
+					const keys = this.#pending;
+					this.#pending = void 0;
+					this.#batchPromise = void 0;
+					this.#batchFn(keys).then(resolve, reject);
+				});
+			});
+		}
+	}
+};
+const resolvedPromise = Promise.resolve();
+const enqueuePostPromiseJob = typeof process === "object" && typeof process.nextTick === "function" ? (fn) => resolvedPromise.then(() => process.nextTick(fn)) : (fn) => setTimeout(fn);
+//#endregion
+exports.BatchLoader = BatchLoader;
+
+//# sourceMappingURL=BatchLoader.cjs.map

package/build/batchloaders/BatchLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchLoader.cjs","names":["#batchFn","#ensureBatch","#pending","#batchPromise"],"sources":["../../src/batchloaders/BatchLoader.ts"],"sourcesContent":["/**\n * Like DataLoader, but all callers in the same tick share a single Promise<void>.\n *\n * The batch function writes results into a side channel (e.g. setPreloadedRelation\n * or em.hydrate), so there's no per-key return value — just one shared promise\n * that signals \"the batch is done\".\n */\nexport class BatchLoader<K> {\n  #batchFn: (keys: K[]) => Promise<void>;\n  #pending: K[] | undefined;\n  #batchPromise: Promise<void> | undefined;\n\n  constructor(batchFn: (keys: K[]) => Promise<void>) {\n    this.#batchFn = batchFn;\n  }\n\n  load(key: K): Promise<void> {\n    this.#ensureBatch();\n    this.#pending!.push(key);\n    return this.#batchPromise!;\n  }\n\n  loadAll(keys: K[]): Promise<void> {\n    this.#ensureBatch();\n    // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the\n    // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack\n    // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).\n    const pending = this.#pending!;\n    const start = pending.length;\n    pending.length += keys.length;\n    for (let i = 0; i < keys.length; i++) {\n      pending[start + i] = keys[i];\n    }\n    return this.#batchPromise!;\n  }\n\n  #ensureBatch(): void {\n    if (!this.#pending) {\n      this.#pending = [];\n      this.#batchPromise = new Promise<void>((resolve, reject) => {\n        enqueuePostPromiseJob(() => {\n          const keys = this.#pending!;\n          this.#pending = undefined;\n          this.#batchPromise = undefined;\n          this.#batchFn(keys).then(resolve, reject);\n        });\n      });\n    }\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\n\n// Matches DataLoader's enqueuePostPromiseJob scheduling:\n// https://github.com/graphql/dataloader/blob/main/src/index.js#L214\nconst enqueuePostPromiseJob =\n  typeof process === \"object\" && typeof process.nextTick === \"function\"\n    ? (fn: () => void) => resolvedPromise.then(() => process.nextTick(fn))\n    : (fn: () => void) => setTimeout(fn);\n"],"mappings":";;;;;;;;;AAOA,IAAa,cAAb,MAA4B;CAC1B;CACA;CACA;CAEA,YAAY,SAAuC;EACjD,KAAKA,WAAW;CAClB;CAEA,KAAK,KAAuB;EAC1B,KAAKC,aAAa;EAClB,KAAKC,SAAU,KAAK,GAAG;EACvB,OAAO,KAAKC;CACd;CAEA,QAAQ,MAA0B;EAChC,KAAKF,aAAa;EAIlB,MAAM,UAAU,KAAKC;EACrB,MAAM,QAAQ,QAAQ;EACtB,QAAQ,UAAU,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,QAAQ,QAAQ,KAAK,KAAK;EAE5B,OAAO,KAAKC;CACd;CAEA,eAAqB;EACnB,IAAI,CAAC,KAAKD,UAAU;GAClB,KAAKA,WAAW,CAAC;GACjB,KAAKC,gBAAgB,IAAI,SAAe,SAAS,WAAW;IAC1D,4BAA4B;KAC1B,MAAM,OAAO,KAAKD;KAClB,KAAKA,WAAW,KAAA;KAChB,KAAKC,gBAAgB,KAAA;KACrB,KAAKH,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS,MAAM;IAC1C,CAAC;GACH,CAAC;EACH;CACF;AACF;AAEA,MAAM,kBAAkB,QAAQ,QAAQ;AAIxC,MAAM,wBACJ,OAAO,YAAY,YAAY,OAAO,QAAQ,aAAa,cACtD,OAAmB,gBAAgB,WAAW,QAAQ,SAAS,EAAE,CAAC,KAClE,OAAmB,WAAW,EAAE"}

package/build/batchloaders/BatchLoader.d.cts

@@ -0,0 +1,17 @@
+//#region src/batchloaders/BatchLoader.d.ts
+/**
+ * Like DataLoader, but all callers in the same tick share a single Promise<void>.
+ *
+ * The batch function writes results into a side channel (e.g. setPreloadedRelation
+ * or em.hydrate), so there's no per-key return value — just one shared promise
+ * that signals "the batch is done".
+ */
+declare class BatchLoader<K> {
+  #private;
+  constructor(batchFn: (keys: K[]) => Promise<void>);
+  load(key: K): Promise<void>;
+  loadAll(keys: K[]): Promise<void>;
+}
+//#endregion
+export { BatchLoader };
+//# sourceMappingURL=BatchLoader.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"mappings":";;;;;;;;cAOa,YAAY;;EAKvB,YAAY,UAAU,MAAM,QAAQ;EAIpC,KAAK,KAAK,IAAI;EAMd,QAAQ,MAAM,MAAM"}

package/build/batchloaders/BatchLoader.d.mts

@@ -0,0 +1,17 @@
+//#region src/batchloaders/BatchLoader.d.ts
+/**
+ * Like DataLoader, but all callers in the same tick share a single Promise<void>.
+ *
+ * The batch function writes results into a side channel (e.g. setPreloadedRelation
+ * or em.hydrate), so there's no per-key return value — just one shared promise
+ * that signals "the batch is done".
+ */
+declare class BatchLoader<K> {
+  #private;
+  constructor(batchFn: (keys: K[]) => Promise<void>);
+  load(key: K): Promise<void>;
+  loadAll(keys: K[]): Promise<void>;
+}
+//#endregion
+export { BatchLoader };
+//# sourceMappingURL=BatchLoader.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"mappings":";;;;;;;;cAOa,YAAY;;EAKvB,YAAY,UAAU,MAAM,QAAQ;EAIpC,KAAK,KAAK,IAAI;EAMd,QAAQ,MAAM,MAAM"}

package/build/batchloaders/BatchLoader.js

@@ -1,57 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchLoader = void 0;
+//#region src/batchloaders/BatchLoader.ts
 /**
- * Like DataLoader, but all callers in the same tick share a single Promise<void>.
- *
- * The batch function writes results into a side channel (e.g. setPreloadedRelation
- * or em.hydrate), so there's no per-key return value — just one shared promise
- * that signals "the batch is done".
- */
-class BatchLoader {
-    #batchFn;
-    #pending;
-    #batchPromise;
-    constructor(batchFn) {
-        this.#batchFn = batchFn;
-    }
-    load(key) {
-        this.#ensureBatch();
-        this.#pending.push(key);
-        return this.#batchPromise;
-    }
-    loadAll(keys) {
-        this.#ensureBatch();
-        // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the
-        // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack
-        // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).
-        const pending = this.#pending;
-        const start = pending.length;
-        pending.length += keys.length;
-        for (let i = 0; i < keys.length; i++) {
-            pending[start + i] = keys[i];
-        }
-        return this.#batchPromise;
-    }
-    #ensureBatch() {
-        if (!this.#pending) {
-            this.#pending = [];
-            this.#batchPromise = new Promise((resolve, reject) => {
-                enqueuePostPromiseJob(() => {
-                    const keys = this.#pending;
-                    this.#pending = undefined;
-                    this.#batchPromise = undefined;
-                    this.#batchFn(keys).then(resolve, reject);
-                });
-            });
-        }
-    }
-}
-exports.BatchLoader = BatchLoader;
+* Like DataLoader, but all callers in the same tick share a single Promise<void>.
+*
+* The batch function writes results into a side channel (e.g. setPreloadedRelation
+* or em.hydrate), so there's no per-key return value — just one shared promise
+* that signals "the batch is done".
+*/
+var BatchLoader = class {
+	#batchFn;
+	#pending;
+	#batchPromise;
+	constructor(batchFn) {
+		this.#batchFn = batchFn;
+	}
+	load(key) {
+		this.#ensureBatch();
+		this.#pending.push(key);
+		return this.#batchPromise;
+	}
+	loadAll(keys) {
+		this.#ensureBatch();
+		const pending = this.#pending;
+		const start = pending.length;
+		pending.length += keys.length;
+		for (let i = 0; i < keys.length; i++) pending[start + i] = keys[i];
+		return this.#batchPromise;
+	}
+	#ensureBatch() {
+		if (!this.#pending) {
+			this.#pending = [];
+			this.#batchPromise = new Promise((resolve, reject) => {
+				enqueuePostPromiseJob(() => {
+					const keys = this.#pending;
+					this.#pending = void 0;
+					this.#batchPromise = void 0;
+					this.#batchFn(keys).then(resolve, reject);
+				});
+			});
+		}
+	}
+};
 const resolvedPromise = Promise.resolve();
-// Matches DataLoader's enqueuePostPromiseJob scheduling:
-// https://github.com/graphql/dataloader/blob/main/src/index.js#L214
-const enqueuePostPromiseJob = typeof process === "object" && typeof process.nextTick === "function"
-    ? (fn) => resolvedPromise.then(() => process.nextTick(fn))
-    : (fn) => setTimeout(fn);
+const enqueuePostPromiseJob = typeof process === "object" && typeof process.nextTick === "function" ? (fn) => resolvedPromise.then(() => process.nextTick(fn)) : (fn) => setTimeout(fn);
+//#endregion
+export { BatchLoader };
+
 //# sourceMappingURL=BatchLoader.js.map

package/build/batchloaders/BatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"BatchLoader.js","sourceRoot":"","sources":["../../src/batchloaders/BatchLoader.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,MAAa,WAAW;IACtB,QAAQ,CAA+B;IACvC,QAAQ,CAAkB;IAC1B,aAAa,CAA4B;IAEzC,YAAY,OAAqC;QAC/C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED,IAAI,CAAC,GAAM;QACT,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,QAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC,aAAc,CAAC;IAC7B,CAAC;IAED,OAAO,CAAC,IAAS;QACf,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,+FAA+F;QAC/F,gGAAgG;QAChG,2EAA2E;QAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,QAAS,CAAC;QAC/B,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;QAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,IAAI,CAAC,aAAc,CAAC;IAC7B,CAAC;IAED,YAAY;QACV,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;YACnB,IAAI,CAAC,aAAa,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACzD,qBAAqB,CAAC,GAAG,EAAE;oBACzB,MAAM,IAAI,GAAG,IAAI,CAAC,QAAS,CAAC;oBAC5B,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;oBAC1B,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;oBAC/B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBAC5C,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF;AA1CD,kCA0CC;AAED,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;AAE1C,yDAAyD;AACzD,oEAAoE;AACpE,MAAM,qBAAqB,GACzB,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU;IACnE,CAAC,CAAC,CAAC,EAAc,EAAE,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC,EAAc,EAAE,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC"}
+{"version":3,"file":"BatchLoader.js","names":["#batchFn","#ensureBatch","#pending","#batchPromise"],"sources":["../../src/batchloaders/BatchLoader.ts"],"sourcesContent":["/**\n * Like DataLoader, but all callers in the same tick share a single Promise<void>.\n *\n * The batch function writes results into a side channel (e.g. setPreloadedRelation\n * or em.hydrate), so there's no per-key return value — just one shared promise\n * that signals \"the batch is done\".\n */\nexport class BatchLoader<K> {\n  #batchFn: (keys: K[]) => Promise<void>;\n  #pending: K[] | undefined;\n  #batchPromise: Promise<void> | undefined;\n\n  constructor(batchFn: (keys: K[]) => Promise<void>) {\n    this.#batchFn = batchFn;\n  }\n\n  load(key: K): Promise<void> {\n    this.#ensureBatch();\n    this.#pending!.push(key);\n    return this.#batchPromise!;\n  }\n\n  loadAll(keys: K[]): Promise<void> {\n    this.#ensureBatch();\n    // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the\n    // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack\n    // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).\n    const pending = this.#pending!;\n    const start = pending.length;\n    pending.length += keys.length;\n    for (let i = 0; i < keys.length; i++) {\n      pending[start + i] = keys[i];\n    }\n    return this.#batchPromise!;\n  }\n\n  #ensureBatch(): void {\n    if (!this.#pending) {\n      this.#pending = [];\n      this.#batchPromise = new Promise<void>((resolve, reject) => {\n        enqueuePostPromiseJob(() => {\n          const keys = this.#pending!;\n          this.#pending = undefined;\n          this.#batchPromise = undefined;\n          this.#batchFn(keys).then(resolve, reject);\n        });\n      });\n    }\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\n\n// Matches DataLoader's enqueuePostPromiseJob scheduling:\n// https://github.com/graphql/dataloader/blob/main/src/index.js#L214\nconst enqueuePostPromiseJob =\n  typeof process === \"object\" && typeof process.nextTick === \"function\"\n    ? (fn: () => void) => resolvedPromise.then(() => process.nextTick(fn))\n    : (fn: () => void) => setTimeout(fn);\n"],"mappings":";;;;;;;;AAOA,IAAa,cAAb,MAA4B;CAC1B;CACA;CACA;CAEA,YAAY,SAAuC;EACjD,KAAKA,WAAW;CAClB;CAEA,KAAK,KAAuB;EAC1B,KAAKC,aAAa;EAClB,KAAKC,SAAU,KAAK,GAAG;EACvB,OAAO,KAAKC;CACd;CAEA,QAAQ,MAA0B;EAChC,KAAKF,aAAa;EAIlB,MAAM,UAAU,KAAKC;EACrB,MAAM,QAAQ,QAAQ;EACtB,QAAQ,UAAU,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,QAAQ,QAAQ,KAAK,KAAK;EAE5B,OAAO,KAAKC;CACd;CAEA,eAAqB;EACnB,IAAI,CAAC,KAAKD,UAAU;GAClB,KAAKA,WAAW,CAAC;GACjB,KAAKC,gBAAgB,IAAI,SAAe,SAAS,WAAW;IAC1D,4BAA4B;KAC1B,MAAM,OAAO,KAAKD;KAClB,KAAKA,WAAW,KAAA;KAChB,KAAKC,gBAAgB,KAAA;KACrB,KAAKH,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS,MAAM;IAC1C,CAAC;GACH,CAAC;EACH;CACF;AACF;AAEA,MAAM,kBAAkB,QAAQ,QAAQ;AAIxC,MAAM,wBACJ,OAAO,YAAY,YAAY,OAAO,QAAQ,aAAa,cACtD,OAAmB,gBAAgB,WAAW,QAAQ,SAAS,EAAE,CAAC,KAClE,OAAmB,WAAW,EAAE"}

package/build/batchloaders/enumCollectionBatchLoader.cjs

@@ -0,0 +1,66 @@
+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");
+//#region src/batchloaders/enumCollectionBatchLoader.ts
+const enumCollectionLoadOperation = "enum-collection-load";
+/** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */
+function enumCollectionBatchLoader(em, collection) {
+	return em.getBatchLoader(enumCollectionLoadOperation, collection.joinTableName, (keys) => loadBatch(em, collection, keys));
+}
+async function loadBatch(em, collection, keys) {
+	const { meta, columnName, otherColumnName, joinTableName, hasJoinTableId, otherEnum, fieldName } = collection;
+	const joinRows = require_EntityManager.getEmInternalApi(em).joinRows(collection);
+	const alias = require_utils.abbreviation(joinTableName);
+	const query = {
+		selects: [`"${alias}".*`],
+		tables: [{
+			alias,
+			join: "primary",
+			table: joinTableName
+		}],
+		condition: {
+			kind: "exp",
+			op: "and",
+			conditions: [{
+				kind: "column",
+				alias,
+				column: columnName,
+				dbType: meta.idDbType,
+				cond: {
+					kind: "in",
+					value: keys.map((id) => require_keys.keyToNumber(meta, id))
+				}
+			}]
+		},
+		orderBys: hasJoinTableId ? [{
+			alias,
+			column: "id",
+			order: "ASC"
+		}] : [{
+			alias,
+			column: columnName,
+			order: "ASC"
+		}, {
+			alias,
+			column: otherColumnName,
+			order: "ASC"
+		}]
+	};
+	const rows = await em["executeFind"](meta, enumCollectionLoadOperation, query, { limit: void 0 });
+	await joinRows.loadRows(keys.map((id) => [columnName, id]), rows);
+	const api = require_EntityManager.getEmInternalApi(em);
+	for (const id of keys) {
+		const entity = em.getEntity(id);
+		if (!entity) continue;
+		const codes = joinRows.getOthers(columnName, entity).sort((a, b) => a - b).map((enumId) => otherEnum.findById(enumId).code);
+		api.setPreloadedRelation(entity.idTagged, fieldName, codes);
+	}
+}
+//#endregion
+exports.enumCollectionBatchLoader = enumCollectionBatchLoader;
+exports.enumCollectionLoadOperation = enumCollectionLoadOperation;
+
+//# sourceMappingURL=enumCollectionBatchLoader.cjs.map

package/build/batchloaders/enumCollectionBatchLoader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumCollectionBatchLoader.cjs","names":["getEmInternalApi","abbreviation","keyToNumber"],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"sourcesContent":["import { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"src/index.ts\";\nimport { abbreviation } from \"src/utils.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,WAAWA,sBAAAA,iBAAiB,EAAE,CAAC,CAAC,SAAS,UAAU;CAEzD,MAAM,QAAQC,cAAAA,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,OAAOC,aAAAA,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,MAAMF,sBAAAA,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/enumCollectionBatchLoader.d.cts

@@ -0,0 +1,11 @@
+import { BatchLoader } from "./BatchLoader.cjs";
+import { ManyToManyLike } from "../flush/JoinRows.cjs";
+import "../index.cjs";
+import { EntityManager } from "../EntityManager.cjs";
+//#region src/batchloaders/enumCollectionBatchLoader.d.ts
+declare const enumCollectionLoadOperation = "enum-collection-load";
+/** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */
+declare function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+//#endregion
+export { enumCollectionBatchLoader, enumCollectionLoadOperation };
+//# sourceMappingURL=enumCollectionBatchLoader.d.cts.map

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

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

package/build/batchloaders/enumCollectionBatchLoader.d.mts

@@ -0,0 +1,11 @@
+import { BatchLoader } from "./BatchLoader.mjs";
+import { ManyToManyLike } from "../flush/JoinRows.mjs";
+import "../index.mjs";
+import { EntityManager } from "../EntityManager.mjs";
+//#region src/batchloaders/enumCollectionBatchLoader.d.ts
+declare const enumCollectionLoadOperation = "enum-collection-load";
+/** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */
+declare function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+//#endregion
+export { enumCollectionBatchLoader, enumCollectionLoadOperation };
+//# sourceMappingURL=enumCollectionBatchLoader.d.mts.map

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

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

package/build/batchloaders/enumCollectionBatchLoader.js

@@ -1,54 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.enumCollectionLoadOperation = void 0;
-exports.enumCollectionBatchLoader = enumCollectionBatchLoader;
-const EntityManager_1 = require("../EntityManager");
-const index_1 = require("../index");
-const utils_1 = require("../utils");
-exports.enumCollectionLoadOperation = "enum-collection-load";
+import "./BatchLoader.js";
+import { keyToNumber } from "../keys.js";
+import { abbreviation } from "../utils.js";
+import "../index.js";
+import { getEmInternalApi } from "../EntityManager.js";
+//#region src/batchloaders/enumCollectionBatchLoader.ts
+const enumCollectionLoadOperation = "enum-collection-load";
 /** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */
 function enumCollectionBatchLoader(em, collection) {
-    return em.getBatchLoader(exports.enumCollectionLoadOperation, collection.joinTableName, (keys) => loadBatch(em, collection, keys));
+	return em.getBatchLoader(enumCollectionLoadOperation, collection.joinTableName, (keys) => loadBatch(em, collection, keys));
 }
 async function loadBatch(em, collection, keys) {
-    const { meta, columnName, otherColumnName, joinTableName, hasJoinTableId, otherEnum, fieldName } = collection;
-    const joinRows = (0, EntityManager_1.getEmInternalApi)(em).joinRows(collection);
-    const alias = (0, utils_1.abbreviation)(joinTableName);
-    const query = {
-        selects: [`"${alias}".*`],
-        tables: [{ alias, join: "primary", table: joinTableName }],
-        condition: {
-            kind: "exp",
-            op: "and",
-            conditions: [
-                {
-                    kind: "column",
-                    alias,
-                    column: columnName,
-                    dbType: meta.idDbType,
-                    cond: { kind: "in", value: keys.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: hasJoinTableId
-            ? [{ alias, column: "id", order: "ASC" }]
-            : [
-                { alias, column: columnName, order: "ASC" },
-                { alias, column: otherColumnName, order: "ASC" },
-            ],
-    };
-    const rows = await em["executeFind"](meta, exports.enumCollectionLoadOperation, query, { limit: undefined });
-    await joinRows.loadRows(keys.map((id) => [columnName, id]), rows);
-    const api = (0, EntityManager_1.getEmInternalApi)(em);
-    for (const id of keys) {
-        const entity = em.getEntity(id);
-        if (!entity)
-            continue;
-        const codes = joinRows.getOthers(columnName, entity)
-            .sort((a, b) => a - b)
-            .map((enumId) => otherEnum.findById(enumId).code);
-        api.setPreloadedRelation(entity.idTagged, fieldName, codes);
-    }
+	const { meta, columnName, otherColumnName, joinTableName, hasJoinTableId, otherEnum, fieldName } = collection;
+	const joinRows = getEmInternalApi(em).joinRows(collection);
+	const alias = abbreviation(joinTableName);
+	const query = {
+		selects: [`"${alias}".*`],
+		tables: [{
+			alias,
+			join: "primary",
+			table: joinTableName
+		}],
+		condition: {
+			kind: "exp",
+			op: "and",
+			conditions: [{
+				kind: "column",
+				alias,
+				column: columnName,
+				dbType: meta.idDbType,
+				cond: {
+					kind: "in",
+					value: keys.map((id) => keyToNumber(meta, id))
+				}
+			}]
+		},
+		orderBys: hasJoinTableId ? [{
+			alias,
+			column: "id",
+			order: "ASC"
+		}] : [{
+			alias,
+			column: columnName,
+			order: "ASC"
+		}, {
+			alias,
+			column: otherColumnName,
+			order: "ASC"
+		}]
+	};
+	const rows = await em["executeFind"](meta, enumCollectionLoadOperation, query, { limit: void 0 });
+	await joinRows.loadRows(keys.map((id) => [columnName, id]), rows);
+	const api = getEmInternalApi(em);
+	for (const id of keys) {
+		const entity = em.getEntity(id);
+		if (!entity) continue;
+		const codes = joinRows.getOthers(columnName, entity).sort((a, b) => a - b).map((enumId) => otherEnum.findById(enumId).code);
+		api.setPreloadedRelation(entity.idTagged, fieldName, codes);
+	}
 }
+//#endregion
+export { enumCollectionBatchLoader, enumCollectionLoadOperation };
+
 //# sourceMappingURL=enumCollectionBatchLoader.js.map

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 BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { type EntityManager, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type ManyToManyLike, type ParsedFindQuery, keyToNumber } from \"src/index.ts\";\nimport { abbreviation } from \"src/utils.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");
+const require_queries_entityQueryUtils = require("../queries/entityQueryUtils.cjs");
+const require_queries_find_QueryParser = require("../queries/find/QueryParser.cjs");
+const require_utils = require("../utils.cjs");
+require("../EntityMetadata.cjs");
+const require_loading_HintTree = require("../loading/HintTree.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+const require_BaseEntity = require("../BaseEntity.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_queries_entityQueryUtils.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_queries_find_QueryParser.addTablePerClassJoinsAndClassTag(query, meta, alias, true);
+		const { preloader } = require_EntityManager.getEmInternalApi(em);
+		const preloadHydrator = preloader && preloader.addPreloading(meta, require_loading_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