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

package/build/TypeInfo.d.mts

@@ -0,0 +1,57 @@
+import { EntityMetadata } from "./EntityMetadata.mjs";
+//#region src/TypeInfo.d.ts
+/**
+ * Runtime proof that values can share scalar conversions.
+ *
+ * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.
+ * A compound uses one decoder per output column and retains an encoder for later comparisons and
+ * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply
+ * equal logical domains.
+ *
+ * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while
+ * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()
+ * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and
+ * JSON-schema domain tokens also prevent unrelated conversions from mixing.
+ *
+ * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent
+ * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain
+ * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`
+ * annotations supply no runtime evidence. This descriptor does not implement conversions.
+ */
+interface TypeInfo {
+  dbType: string;
+  domain: unknown;
+  idMeta?: EntityMetadata;
+  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */
+  arrayElementSafe?: boolean;
+}
+/**
+ * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
+ * The output compatibility checks compare these names, so normalize only spellings of the same type.
+ *
+ * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.
+ * Keeping these spellings distinct would reject compatible outputs just because their serdes use
+ * different names for the same representation.
+ *
+ * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number
+ * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder
+ * cannot handle the common SQL type. This function does not choose or apply a conversion.
+ *
+ * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,
+ * which matters when a set operation compares rows. A user-defined `app.email` domain over text can
+ * also impose constraints that text does not. Unknown names remain unchanged, including their schema
+ * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.
+ */
+declare function canonicalDbType(dbType: string): string;
+/**
+ * Describes elementwise conversion only for known physical array parsers and stable domain conversion.
+ *
+ * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar
+ * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.
+ * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers
+ * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.
+ */
+declare function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined;
+//#endregion
+export { TypeInfo, arrayOutputType, canonicalDbType };
+//# sourceMappingURL=TypeInfo.d.mts.map

package/build/TypeInfo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.d.mts","names":[],"sources":["../src/TypeInfo.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAqBiB;EACf;EACA;EACA,SAAS;;EAET;;;;;;;;;;;;;;;;;;;iBAoBc,gBAAgB;;;;;;;;;iBA+DhB,gBAAgB,YAAY,uBAAuB"}

package/build/TypeInfo.js

@@ -0,0 +1,78 @@
+//#region src/TypeInfo.ts
+/**
+* Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
+* The output compatibility checks compare these names, so normalize only spellings of the same type.
+*
+* I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.
+* Keeping these spellings distinct would reject compatible outputs just because their serdes use
+* different names for the same representation.
+*
+* I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number
+* and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder
+* cannot handle the common SQL type. This function does not choose or apply a conversion.
+*
+* I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,
+* which matters when a set operation compares rows. A user-defined `app.email` domain over text can
+* also impose constraints that text does not. Unknown names remain unchanged, including their schema
+* and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.
+*/
+function canonicalDbType(dbType) {
+	if (dbType.endsWith("[]")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;
+	switch (dbType) {
+		case "smallint": return "int2";
+		case "int":
+		case "integer": return "int4";
+		case "bigint": return "int8";
+		case "decimal": return "numeric";
+		case "real": return "float4";
+		case "double precision": return "float8";
+		case "boolean": return "bool";
+		case "character varying": return "varchar";
+		case "character": return "bpchar";
+		case "timestamp without time zone": return "timestamp";
+		case "timestamp with time zone": return "timestamptz";
+		case "time without time zone": return "time";
+		case "time with time zone": return "timetz";
+		default: return dbType;
+	}
+}
+const arrayDomains = /* @__PURE__ */ new Map();
+const arrayElementDbTypes = /* @__PURE__ */ new Set([
+	"bool",
+	"bytea",
+	"int2",
+	"int4",
+	"int8",
+	"float4",
+	"float8",
+	"numeric",
+	"text",
+	"varchar",
+	"bpchar",
+	"uuid",
+	"json",
+	"jsonb"
+]);
+/**
+* Describes elementwise conversion only for known physical array parsers and stable domain conversion.
+*
+* I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar
+* `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.
+* Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers
+* in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.
+*/
+function arrayOutputType(outputType) {
+	if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return void 0;
+	let domains = arrayDomains.get(outputType.domain);
+	if (!domains) arrayDomains.set(outputType.domain, domains = /* @__PURE__ */ new Map());
+	let domain = domains.get(outputType.idMeta);
+	if (!domain) domains.set(outputType.idMeta, domain = Symbol("joist.arrayOutput"));
+	return {
+		dbType: `${outputType.dbType}[]`,
+		domain
+	};
+}
+//#endregion
+export { arrayOutputType, canonicalDbType };
+
+//# sourceMappingURL=TypeInfo.js.map

package/build/TypeInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.js","names":[],"sources":["../src/TypeInfo.ts"],"sourcesContent":["// Keep compatibility metadata a runtime leaf in both CJS and ESM builds.\nimport type { EntityMetadata } from \"./EntityMetadata.ts\";\n\n/**\n * Runtime proof that values can share scalar conversions.\n *\n * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.\n * A compound uses one decoder per output column and retains an encoder for later comparisons and\n * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply\n * equal logical domains.\n *\n * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while\n * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()\n * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and\n * JSON-schema domain tokens also prevent unrelated conversions from mixing.\n *\n * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent\n * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain\n * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`\n * annotations supply no runtime evidence. This descriptor does not implement conversions.\n */\nexport interface TypeInfo {\n  dbType: string;\n  domain: unknown;\n  idMeta?: EntityMetadata;\n  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */\n  arrayElementSafe?: boolean;\n}\n\n/**\n * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.\n * The output compatibility checks compare these names, so normalize only spellings of the same type.\n *\n * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.\n * Keeping these spellings distinct would reject compatible outputs just because their serdes use\n * different names for the same representation.\n *\n * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number\n * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder\n * cannot handle the common SQL type. This function does not choose or apply a conversion.\n *\n * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,\n * which matters when a set operation compares rows. A user-defined `app.email` domain over text can\n * also impose constraints that text does not. Unknown names remain unchanged, including their schema\n * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.\n */\nexport function canonicalDbType(dbType: string): string {\n  if (dbType.endsWith(\"[]\")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;\n  switch (dbType) {\n    case \"smallint\":\n      return \"int2\";\n    case \"int\":\n    case \"integer\":\n      return \"int4\";\n    case \"bigint\":\n      return \"int8\";\n    case \"decimal\":\n      return \"numeric\";\n    case \"real\":\n      return \"float4\";\n    case \"double precision\":\n      return \"float8\";\n    case \"boolean\":\n      return \"bool\";\n    case \"character varying\":\n      return \"varchar\";\n    case \"character\":\n      return \"bpchar\";\n    case \"timestamp without time zone\":\n      return \"timestamp\";\n    case \"timestamp with time zone\":\n      return \"timestamptz\";\n    case \"time without time zone\":\n      return \"time\";\n    case \"time with time zone\":\n      return \"timetz\";\n    default:\n      return dbType;\n  }\n}\n\nconst arrayDomains = new Map<unknown, Map<EntityMetadata | undefined, symbol>>();\n\n// Both classic pg and lazy binary reads decode these physical arrays, not an unparsed array string.\nconst arrayElementDbTypes = new Set([\n  \"bool\",\n  \"bytea\",\n  \"int2\",\n  \"int4\",\n  \"int8\",\n  \"float4\",\n  \"float8\",\n  \"numeric\",\n  \"text\",\n  \"varchar\",\n  \"bpchar\",\n  \"uuid\",\n  \"json\",\n  \"jsonb\",\n]);\n\n/**\n * Describes elementwise conversion only for known physical array parsers and stable domain conversion.\n *\n * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar\n * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.\n * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers\n * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.\n */\nexport function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined {\n  if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return undefined;\n  let domains = arrayDomains.get(outputType.domain);\n  if (!domains) arrayDomains.set(outputType.domain, (domains = new Map()));\n  let domain = domains.get(outputType.idMeta);\n  if (!domain) domains.set(outputType.idMeta, (domain = Symbol(\"joist.arrayOutput\")));\n  return { dbType: `${outputType.dbType}[]`, domain };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8CA,SAAgB,gBAAgB,QAAwB;CACtD,IAAI,OAAO,SAAS,IAAI,GAAG,OAAO,GAAG,gBAAgB,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE;CAC1E,QAAQ,QAAR;EACE,KAAK,YACH,OAAO;EACT,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,oBACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,qBACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK,+BACH,OAAO;EACT,KAAK,4BACH,OAAO;EACT,KAAK,0BACH,OAAO;EACT,KAAK,uBACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAEA,MAAM,+BAAe,IAAI,IAAsD;AAG/E,MAAM,sCAAsB,IAAI,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;AAUD,SAAgB,gBAAgB,YAAwD;CACtF,IAAI,CAAC,YAAY,oBAAoB,CAAC,oBAAoB,IAAI,WAAW,MAAM,GAAG,OAAO,KAAA;CACzF,IAAI,UAAU,aAAa,IAAI,WAAW,MAAM;CAChD,IAAI,CAAC,SAAS,aAAa,IAAI,WAAW,QAAS,0BAAU,IAAI,IAAI,CAAE;CACvE,IAAI,SAAS,QAAQ,IAAI,WAAW,MAAM;CAC1C,IAAI,CAAC,QAAQ,QAAQ,IAAI,WAAW,QAAS,SAAS,OAAO,mBAAmB,CAAE;CAClF,OAAO;EAAE,QAAQ,GAAG,WAAW,OAAO;EAAK;CAAO;AACpD"}

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 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,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 "../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 "../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