joist-core 2.3.0 → 2.4.0-next.10

package/build/relations/AsyncReactiveField.js

@@ -1,125 +1,106 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncReactiveFieldImpl = void 0;
-exports.hasAsyncReactiveField = hasAsyncReactiveField;
-exports.isAsyncReactiveField = isAsyncReactiveField;
-exports.isLoadedAsyncReactiveField = isLoadedAsyncReactiveField;
-const EntityMetadata_1 = require("../EntityMetadata");
-const fields_1 = require("../fields");
-const index_1 = require("../index");
-const newEntity_1 = require("../newEntity");
-const reactiveHints_1 = require("../reactiveHints");
-const utils_1 = require("../utils");
-const AbstractPropertyImpl_1 = require("./AbstractPropertyImpl");
-const hasProperty_1 = require("./hasProperty");
+import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
+import { deepNormalizeHint } from "../normalizeHints.js";
+import { PropertyT } from "./PropertySymbols.js";
+import { convertToLoadHint } from "../reactivity/reactiveHints.js";
+import { isLoaded } from "../loading/loadHints.js";
+import { getField, isFieldSet, setField } from "../fields.js";
+import { mergeNormalizedHints } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
+import "../index.js";
+import "../Entity.js";
+//#region src/relations/AsyncReactiveField.ts
 /**
- * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
- * a `ReactiveField`, but when the value needs to be calculated from SQL because
- * it would be too expensive to calculate in-memory.
- *
- * The `fn` lambda will be called when any data referred to by either the `paramHint` or
- * `dbHint` reactive hints have changed, but only the `paramHint`'s data will be pulled
- * into memory.
- */
-function hasAsyncReactiveField(paramHint, dbHint, fn) {
-    return (0, newEntity_1.lazyField)((entity, fieldName) => {
-        return new AsyncReactiveFieldImpl(entity, fieldName, paramHint, dbHint, fn);
-    });
+* An `AsyncReactiveField` is a value that is derived from a SQL query, similar to
+* a `ReactiveField`, but when the value needs to be calculated from SQL because
+* it would be too expensive to calculate in-memory.
+*
+* Its hint is split in two: the `loadHint` names data that is both reacted-to *and*
+* loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is
+* only reacted-to (its changes recompute the value) but is left in the database rather
+* than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
+* changes, but only the `loadHint`'s data is populated.
+*/
+function hasAsyncReactiveField(loadHint, reactiveHint, fn) {
+	return lazyField((entity, fieldName) => {
+		return new AsyncReactiveFieldImpl(entity, fieldName, loadHint, reactiveHint, fn);
+	});
 }
-class AsyncReactiveFieldImpl extends AbstractPropertyImpl_1.AbstractPropertyImpl {
-    fieldName;
-    paramHint;
-    dbHint;
-    fn;
-    #paramHint;
-    #dbHint;
-    #loadPromise;
-    #loaded;
-    #useFactoryValue = false;
-    constructor(entity, fieldName, paramHint, dbHint, fn) {
-        super(entity);
-        this.fieldName = fieldName;
-        this.paramHint = paramHint;
-        this.dbHint = dbHint;
-        this.fn = fn;
-        this.#paramHint = paramHint;
-        this.#dbHint = dbHint;
-        this.#loaded = false;
-    }
-    /** Our combined param + db reactivity hint, so that we react to changes within both. */
-    get reactiveHint() {
-        // We do this in a getter (instead of the constructor) b/c it might be a little expensive,
-        // and I'm pretty sure this is only called on boot, when hooking up the reactivity.
-        const hint = (0, index_1.deepNormalizeHint)(this.#paramHint);
-        (0, utils_1.mergeNormalizedHints)(hint, (0, index_1.deepNormalizeHint)(this.#dbHint));
-        return hint;
-    }
-    load(opts) {
-        // if (!this.isSet || opts?.forceReload) {
-        return (this.#loadPromise ??= this.entity.em
-            .populate(this.entity, { hint: this.loadHint })
-            .then(() => {
-            // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value
-            return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity);
-        })
-            .then((newValue) => {
-            (0, fields_1.setField)(this.entity, this.fieldName, newValue);
-            this.#loadPromise = undefined;
-            this.#loaded = true;
-            return newValue;
-        })
-            .catch((e) => {
-            // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make
-            // sure that the next `.load` call tries again.
-            this.#loadPromise = undefined;
-            throw e;
-        }));
-        // }
-        // return tryResolve(() => this.get);
-    }
-    /** Returns the previously-calculated value. */
-    get get() {
-        // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure
-        // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally
-        // calculated from DB queries, we can only return the previously-calculated value, if set.
-        if (this.isSet) {
-            return this.fieldValue;
-        }
-        else {
-            throw new Error(`${this.fieldName} has not been derived yet`);
-        }
-    }
-    get fieldValue() {
-        return (0, fields_1.getField)(this.entity, this.fieldName);
-    }
-    get isSet() {
-        return (0, fields_1.isFieldSet)(this.entity, this.fieldName);
-    }
-    get isLoaded() {
-        const hintLoaded = (0, index_1.isLoaded)(this.entity, this.loadHint);
-        if (hintLoaded) {
-            this.#loaded = true;
-        }
-        return hintLoaded;
-    }
-    get loadHint() {
-        // Only convert the paramHint, so we don't pull the dbHint-referenced data into memory
-        const meta = (0, EntityMetadata_1.getMetadata)(this.entity);
-        return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= (0, reactiveHints_1.convertToLoadHint)(meta, this.#paramHint));
-    }
-    setFactoryValue(newValue) {
-        this.#useFactoryValue = true;
-        (0, fields_1.setField)(this.entity, this.fieldName, newValue);
-    }
-    [hasProperty_1.PropertyT] = undefined;
-}
-exports.AsyncReactiveFieldImpl = AsyncReactiveFieldImpl;
+var AsyncReactiveFieldImpl = class extends AbstractPropertyImpl {
+	fieldName;
+	fn;
+	#loadHint;
+	#reactiveHint;
+	#loadPromise;
+	#loaded;
+	#useFactoryValue = false;
+	constructor(entity, fieldName, loadHint, reactiveHint, fn) {
+		super(entity);
+		this.fieldName = fieldName;
+		this.fn = fn;
+		this.#loadHint = loadHint;
+		this.#reactiveHint = reactiveHint;
+		this.#loaded = false;
+	}
+	/**
+	* Our combined load + reactive-only hint, so that we react to changes within both.
+	*
+	* The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`
+	* half only triggers recalculation, so its data stays in the database.
+	*/
+	get reactiveHint() {
+		const hint = deepNormalizeHint(this.#loadHint);
+		mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));
+		return hint;
+	}
+	load(opts) {
+		return this.#loadPromise ??= this.entity.em.populate(this.entity, { hint: this.loadHint }).then(() => {
+			return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity);
+		}).then((newValue) => {
+			setField(this.entity, this.fieldName, newValue);
+			this.#loadPromise = void 0;
+			this.#loaded = true;
+			return newValue;
+		}).catch((e) => {
+			this.#loadPromise = void 0;
+			throw e;
+		});
+	}
+	/** Returns the previously-calculated value. */
+	get get() {
+		if (this.isSet) return this.fieldValue;
+		else throw new Error(`${this.fieldName} has not been derived yet`);
+	}
+	get fieldValue() {
+		return getField(this.entity, this.fieldName);
+	}
+	get isSet() {
+		return isFieldSet(this.entity, this.fieldName);
+	}
+	get isLoaded() {
+		const hintLoaded = isLoaded(this.entity, this.loadHint);
+		if (hintLoaded) this.#loaded = true;
+		return hintLoaded;
+	}
+	get loadHint() {
+		const meta = getMetadata(this.entity);
+		return meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint);
+	}
+	setFactoryValue(newValue) {
+		this.#useFactoryValue = true;
+		setField(this.entity, this.fieldName, newValue);
+	}
+	[PropertyT] = void 0;
+};
 /** Type guard utility for determining if an entity field is an AsyncReactiveField. */
 function isAsyncReactiveField(maybe) {
-    return maybe instanceof AsyncReactiveFieldImpl;
+	return maybe instanceof AsyncReactiveFieldImpl;
 }
 /** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
 function isLoadedAsyncReactiveField(maybe) {
-    return isAsyncReactiveField(maybe) && maybe.isLoaded;
+	return isAsyncReactiveField(maybe) && maybe.isLoaded;
 }
+//#endregion
+export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
+
 //# sourceMappingURL=AsyncReactiveField.js.map

package/build/relations/AsyncReactiveField.js.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncReactiveField.js","sourceRoot":"","sources":["../../src/relations/AsyncReactiveField.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AsyncReactiveField.js","names":["#loadHint","#reactiveHint","#loaded","#loadPromise","#useFactoryValue"],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"src/fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { mergeNormalizedHints } from \"src/utils.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACU,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAKA,YAAY;EACjB,KAAKC,gBAAgB;EACrB,KAAKC,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAO,kBAAkB,KAAKF,SAAS;EAC7C,qBAAqB,MAAM,kBAAkB,KAAKC,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAKE,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAKC,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAKD,eAAe,KAAA;GACpB,KAAKD,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAKC,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAO,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAO,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAa,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAKD,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAO,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAe,kBAAkB,MAAM,KAAKF,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAKI,mBAAmB;EACxB,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}

package/build/relations/Collection.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_CustomCollection = require("./CustomCollection.cjs");
+const require_relations_ManyToManyCollection = require("./ManyToManyCollection.cjs");
+const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
+const require_relations_ReactiveManyToMany = require("./ReactiveManyToMany.cjs");
+const require_relations_ReactiveManyToManyOtherSide = require("./ReactiveManyToManyOtherSide.cjs");
+require("./index.cjs");
+require("../EntityManager.cjs");
+require("../Entity.cjs");
+//#region src/relations/Collection.ts
+/** Type guard utility for determining if an entity field is a Collection. */
+function isCollection(maybeCollection) {
+	return maybeCollection instanceof require_relations_OneToManyCollection.OneToManyCollection || maybeCollection instanceof require_relations_ManyToManyCollection.ManyToManyCollection || maybeCollection instanceof require_relations_ReactiveManyToMany.ReactiveManyToManyImpl || maybeCollection instanceof require_relations_ReactiveManyToManyOtherSide.ReactiveManyToManyOtherSideImpl || maybeCollection instanceof require_relations_CustomCollection.CustomCollection;
+}
+/** Type guard utility for determining if an entity field is a loaded Collection. */
+function isLoadedCollection(maybeCollection) {
+	return isCollection(maybeCollection) && maybeCollection.isLoaded;
+}
+//#endregion
+exports.isCollection = isCollection;
+exports.isLoadedCollection = isLoadedCollection;
+
+//# sourceMappingURL=Collection.cjs.map

package/build/relations/Collection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.cjs","names":["OneToManyCollection","ManyToManyCollection","ReactiveManyToManyImpl","ReactiveManyToManyOtherSideImpl","CustomCollection"],"sources":["../../src/relations/Collection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf } from \"src/EntityManager.ts\";\nimport {\n  CustomCollection,\n  ManyToManyCollection,\n  OneToManyCollection,\n  ReactiveManyToManyImpl,\n  ReactiveManyToManyOtherSideImpl,\n  type Relation,\n} from \"src/relations/index.ts\";\n\n/** A collection of `U` within `T`, either one-to-many or many-to-many. */\nexport interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {\n  load(opts?: { withDeleted: boolean }): Promise<ReadonlyArray<U>>;\n\n  /** Looks up the specific `id` without fully loading the collection. */\n  find(id: IdOf<U>): Promise<U | undefined>;\n\n  /** Looks up the specific `other` without fully loading the collection. */\n  includes(other: U): Promise<boolean>;\n\n  add(other: U): void;\n\n  remove(other: U): void;\n\n  /**\n   * Sets the collection to `values`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(values: U[]): void;\n\n  readonly isLoaded: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {\n  get: ReadonlyArray<U>;\n\n  getWithDeleted: ReadonlyArray<U>;\n\n  removeAll(): void;\n}\n\n/** Type guard utility for determining if an entity field is a Collection. */\nexport function isCollection(maybeCollection: any): maybeCollection is Collection<any, any> {\n  return (\n    maybeCollection instanceof OneToManyCollection ||\n    maybeCollection instanceof ManyToManyCollection ||\n    maybeCollection instanceof ReactiveManyToManyImpl ||\n    maybeCollection instanceof ReactiveManyToManyOtherSideImpl ||\n    maybeCollection instanceof CustomCollection\n  );\n}\n\n/** Type guard utility for determining if an entity field is a loaded Collection. */\nexport function isLoadedCollection(\n  maybeCollection: any,\n): maybeCollection is Collection<any, any> & LoadedCollection<any, any> {\n  return isCollection(maybeCollection) && maybeCollection.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;AA6CA,SAAgB,aAAa,iBAA+D;CAC1F,OACE,2BAA2BA,sCAAAA,uBAC3B,2BAA2BC,uCAAAA,wBAC3B,2BAA2BC,qCAAAA,0BAC3B,2BAA2BC,8CAAAA,mCAC3B,2BAA2BC,mCAAAA;AAE/B;;AAGA,SAAgB,mBACd,iBACsE;CACtE,OAAO,aAAa,eAAe,KAAK,gBAAgB;AAC1D"}

package/build/relations/Collection.d.cts

@@ -0,0 +1,37 @@
+import { Relation } from "./Relation.cjs";
+import "./index.cjs";
+import { IdOf } from "../EntityManager.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/Collection.d.ts
+/** A collection of `U` within `T`, either one-to-many or many-to-many. */
+interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
+  load(opts?: {
+    withDeleted: boolean;
+  }): Promise<ReadonlyArray<U>>;
+  /** Looks up the specific `id` without fully loading the collection. */
+  find(id: IdOf<U>): Promise<U | undefined>;
+  /** Looks up the specific `other` without fully loading the collection. */
+  includes(other: U): Promise<boolean>;
+  add(other: U): void;
+  remove(other: U): void;
+  /**
+   * Sets the collection to `values`.
+   *
+   * Can be called on unloaded collections - the diff will be resolved at load or flush time.
+   */
+  set(values: U[]): void;
+  readonly isLoaded: boolean;
+}
+/** Adds a known-safe `get` accessor. */
+interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
+  get: ReadonlyArray<U>;
+  getWithDeleted: ReadonlyArray<U>;
+  removeAll(): void;
+}
+/** Type guard utility for determining if an entity field is a Collection. */
+declare function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
+/** Type guard utility for determining if an entity field is a loaded Collection. */
+declare function isLoadedCollection(maybeCollection: any): maybeCollection is Collection<any, any> & LoadedCollection<any, any>;
+//#endregion
+export { Collection, LoadedCollection, isCollection, isLoadedCollection };
+//# sourceMappingURL=Collection.d.cts.map

package/build/relations/Collection.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.d.cts","names":[],"sources":["../../src/relations/Collection.ts"],"mappings":";;;;;;UAYiB,WAAW,UAAU,QAAQ,UAAU,gBAAgB,SAAS,GAAG;EAClF,KAAK;IAAS;MAAyB,QAAQ,cAAc;;EAG7D,KAAK,IAAI,KAAK,KAAK,QAAQ;;EAG3B,SAAS,OAAO,IAAI;EAEpB,IAAI,OAAO;EAEX,OAAO,OAAO;;;;;;EAOd,IAAI,QAAQ;WAEH;;;UAIM,iBAAiB,UAAU,QAAQ,UAAU,gBAAgB,WAAW,GAAG;EAC1F,KAAK,cAAc;EAEnB,gBAAgB,cAAc;EAE9B;;;iBAIc,aAAa,uBAAuB,mBAAmB;;iBAWvD,mBACd,uBACC,mBAAmB,uBAAuB"}

package/build/relations/Collection.d.mts

@@ -0,0 +1,37 @@
+import { Relation } from "./Relation.mjs";
+import "./index.mjs";
+import { IdOf } from "../EntityManager.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/Collection.d.ts
+/** A collection of `U` within `T`, either one-to-many or many-to-many. */
+interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
+  load(opts?: {
+    withDeleted: boolean;
+  }): Promise<ReadonlyArray<U>>;
+  /** Looks up the specific `id` without fully loading the collection. */
+  find(id: IdOf<U>): Promise<U | undefined>;
+  /** Looks up the specific `other` without fully loading the collection. */
+  includes(other: U): Promise<boolean>;
+  add(other: U): void;
+  remove(other: U): void;
+  /**
+   * Sets the collection to `values`.
+   *
+   * Can be called on unloaded collections - the diff will be resolved at load or flush time.
+   */
+  set(values: U[]): void;
+  readonly isLoaded: boolean;
+}
+/** Adds a known-safe `get` accessor. */
+interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
+  get: ReadonlyArray<U>;
+  getWithDeleted: ReadonlyArray<U>;
+  removeAll(): void;
+}
+/** Type guard utility for determining if an entity field is a Collection. */
+declare function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
+/** Type guard utility for determining if an entity field is a loaded Collection. */
+declare function isLoadedCollection(maybeCollection: any): maybeCollection is Collection<any, any> & LoadedCollection<any, any>;
+//#endregion
+export { Collection, LoadedCollection, isCollection, isLoadedCollection };
+//# sourceMappingURL=Collection.d.mts.map

package/build/relations/Collection.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.d.mts","names":[],"sources":["../../src/relations/Collection.ts"],"mappings":";;;;;;UAYiB,WAAW,UAAU,QAAQ,UAAU,gBAAgB,SAAS,GAAG;EAClF,KAAK;IAAS;MAAyB,QAAQ,cAAc;;EAG7D,KAAK,IAAI,KAAK,KAAK,QAAQ;;EAG3B,SAAS,OAAO,IAAI;EAEpB,IAAI,OAAO;EAEX,OAAO,OAAO;;;;;;EAOd,IAAI,QAAQ;WAEH;;;UAIM,iBAAiB,UAAU,QAAQ,UAAU,gBAAgB,WAAW,GAAG;EAC1F,KAAK,cAAc;EAEnB,gBAAgB,cAAc;EAE9B;;;iBAIc,aAAa,uBAAuB,mBAAmB;;iBAWvD,mBACd,uBACC,mBAAmB,uBAAuB"}

package/build/relations/Collection.js

@@ -1,18 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCollection = isCollection;
-exports.isLoadedCollection = isLoadedCollection;
-const index_1 = require("./index");
+import { CustomCollection } from "./CustomCollection.js";
+import { ManyToManyCollection } from "./ManyToManyCollection.js";
+import { OneToManyCollection } from "./OneToManyCollection.js";
+import { ReactiveManyToManyImpl } from "./ReactiveManyToMany.js";
+import { ReactiveManyToManyOtherSideImpl } from "./ReactiveManyToManyOtherSide.js";
+import "./index.js";
+import "../EntityManager.js";
+import "../Entity.js";
+//#region src/relations/Collection.ts
 /** Type guard utility for determining if an entity field is a Collection. */
 function isCollection(maybeCollection) {
-    return (maybeCollection instanceof index_1.OneToManyCollection ||
-        maybeCollection instanceof index_1.ManyToManyCollection ||
-        maybeCollection instanceof index_1.ReactiveManyToManyImpl ||
-        maybeCollection instanceof index_1.ReactiveManyToManyOtherSideImpl ||
-        maybeCollection instanceof index_1.CustomCollection);
+	return maybeCollection instanceof OneToManyCollection || maybeCollection instanceof ManyToManyCollection || maybeCollection instanceof ReactiveManyToManyImpl || maybeCollection instanceof ReactiveManyToManyOtherSideImpl || maybeCollection instanceof CustomCollection;
 }
 /** Type guard utility for determining if an entity field is a loaded Collection. */
 function isLoadedCollection(maybeCollection) {
-    return isCollection(maybeCollection) && maybeCollection.isLoaded;
+	return isCollection(maybeCollection) && maybeCollection.isLoaded;
 }
+//#endregion
+export { isCollection, isLoadedCollection };
+
 //# sourceMappingURL=Collection.js.map

package/build/relations/Collection.js.map

@@ -1 +1 @@
-{"version":3,"file":"Collection.js","sourceRoot":"","sources":["../../src/relations/Collection.ts"],"names":[],"mappings":";;AA6CA,oCAQC;AAGD,gDAIC;AA1DD,mCAOiB;AAmCjB,6EAA6E;AAC7E,SAAgB,YAAY,CAAC,eAAoB;IAC/C,OAAO,CACL,eAAe,YAAY,2BAAmB;QAC9C,eAAe,YAAY,4BAAoB;QAC/C,eAAe,YAAY,8BAAsB;QACjD,eAAe,YAAY,uCAA+B;QAC1D,eAAe,YAAY,wBAAgB,CAC5C,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,SAAgB,kBAAkB,CAChC,eAAoB;IAEpB,OAAO,YAAY,CAAC,eAAe,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC;AACnE,CAAC"}
+{"version":3,"file":"Collection.js","names":[],"sources":["../../src/relations/Collection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf } from \"src/EntityManager.ts\";\nimport {\n  CustomCollection,\n  ManyToManyCollection,\n  OneToManyCollection,\n  ReactiveManyToManyImpl,\n  ReactiveManyToManyOtherSideImpl,\n  type Relation,\n} from \"src/relations/index.ts\";\n\n/** A collection of `U` within `T`, either one-to-many or many-to-many. */\nexport interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {\n  load(opts?: { withDeleted: boolean }): Promise<ReadonlyArray<U>>;\n\n  /** Looks up the specific `id` without fully loading the collection. */\n  find(id: IdOf<U>): Promise<U | undefined>;\n\n  /** Looks up the specific `other` without fully loading the collection. */\n  includes(other: U): Promise<boolean>;\n\n  add(other: U): void;\n\n  remove(other: U): void;\n\n  /**\n   * Sets the collection to `values`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(values: U[]): void;\n\n  readonly isLoaded: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {\n  get: ReadonlyArray<U>;\n\n  getWithDeleted: ReadonlyArray<U>;\n\n  removeAll(): void;\n}\n\n/** Type guard utility for determining if an entity field is a Collection. */\nexport function isCollection(maybeCollection: any): maybeCollection is Collection<any, any> {\n  return (\n    maybeCollection instanceof OneToManyCollection ||\n    maybeCollection instanceof ManyToManyCollection ||\n    maybeCollection instanceof ReactiveManyToManyImpl ||\n    maybeCollection instanceof ReactiveManyToManyOtherSideImpl ||\n    maybeCollection instanceof CustomCollection\n  );\n}\n\n/** Type guard utility for determining if an entity field is a loaded Collection. */\nexport function isLoadedCollection(\n  maybeCollection: any,\n): maybeCollection is Collection<any, any> & LoadedCollection<any, any> {\n  return isCollection(maybeCollection) && maybeCollection.isLoaded;\n}\n"],"mappings":";;;;;;;;;;AA6CA,SAAgB,aAAa,iBAA+D;CAC1F,OACE,2BAA2B,uBAC3B,2BAA2B,wBAC3B,2BAA2B,0BAC3B,2BAA2B,mCAC3B,2BAA2B;AAE/B;;AAGA,SAAgB,mBACd,iBACsE;CACtE,OAAO,aAAa,eAAe,KAAK,gBAAgB;AAC1D"}

package/build/relations/CustomCollection.cjs

@@ -0,0 +1,144 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
+const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
+const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_index = require("../index.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+require("../Entity.cjs");
+//#region src/relations/CustomCollection.ts
+function hasCustomCollection(opts) {
+	return require_newEntity.lazyField((entity) => {
+		return new CustomCollection(entity, opts);
+	});
+}
+/**
+* Allows user-defined collections that will work in `populate` / preload hints.
+*
+* This works because Joist's `populate`/preloading is not based on creating giant SQL joins,
+* but instead by just walking "1 dataloader per level". Given this, we don't really care
+* what happens at each "level" of resolution, as long as: a) it's a promise, and b) the
+* caller uses dataloader to be batch friendly.
+*
+* This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level
+* abstractions like `hasManyThrough`, which are built on `CustomCollection`.
+*/
+var CustomCollection = class extends require_relations_AbstractRelationImpl.AbstractRelationImpl {
+	opts;
+	loadPromise;
+	#hasBeenSet = false;
+	#isLoaded = void 0;
+	#loadHint;
+	constructor(entity, opts) {
+		super(entity);
+		this.opts = opts;
+	}
+	get get() {
+		return this.doGet({ withDeleted: false });
+	}
+	get getWithDeleted() {
+		return this.doGet({ withDeleted: true });
+	}
+	get isLoaded() {
+		if (this.#isLoaded !== void 0) return this.#isLoaded;
+		require_EntityManager.getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);
+		this.#isLoaded = this.opts.isLoaded(this.entity);
+		return this.#isLoaded;
+	}
+	resetIsLoaded() {
+		this.#isLoaded = void 0;
+	}
+	get loadHint() {
+		if (this.#loadHint === void 0 && this.opts.loadHint !== void 0) {
+			const { loadHint } = this.opts;
+			this.#loadHint = typeof loadHint === "function" ? loadHint(this.entity) : loadHint;
+		}
+		return this.#loadHint;
+	}
+	async load(opts = {}) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (!this.isLoaded || opts.forceReload) {
+			if (this.loadPromise === void 0) {
+				this.loadPromise = this.opts.load(this.entity, opts);
+				await this.loadPromise;
+				this.loadPromise = void 0;
+				this.#isLoaded = true;
+			} else await this.loadPromise;
+		}
+		return this.doGet(opts);
+	}
+	get isPreloaded() {
+		return false;
+	}
+	preload() {
+		throw new Error("Not implemented");
+	}
+	set(values) {
+		this.ensureNewOrLoaded();
+		const { set, add, remove } = this.opts;
+		if (set !== void 0) {
+			set(this.entity, values);
+			this.#hasBeenSet = true;
+		} else if (add !== void 0 && remove !== void 0) {
+			const current = this.get;
+			current.filter((value) => !values.includes(value)).forEach((value) => this.remove(value));
+			values.filter((value) => !current.includes(value)).forEach((value) => this.add(value));
+			this.#hasBeenSet = true;
+		} else require_utils.fail(`'set' not implemented and not inferrable from 'add'/'remove' on ${this}`);
+	}
+	setFromOpts(values) {
+		this.set(values);
+	}
+	async find(id) {
+		if (!this.isLoaded) await this.load();
+		const { find } = this.opts;
+		if (find === void 0) return this.doGet().find((other) => other.id === id);
+		else return find(this.entity, id);
+	}
+	async includes(other) {
+		throw new Error("Not implemented");
+	}
+	add(other) {
+		this.ensureNewOrLoaded();
+		const { add } = this.opts;
+		if (add === void 0) require_utils.fail(`'add' not implemented on ${this}`);
+		add(this.entity, other);
+	}
+	remove(other) {
+		this.ensureNewOrLoaded();
+		const { remove } = this.opts;
+		if (remove === void 0) require_utils.fail(`'add' not implemented on ${this}`);
+		remove(this.entity, other);
+	}
+	async cleanupOnEntityDeleted() {}
+	maybeCascadeDelete() {}
+	/** Finds this CustomCollections field name by looking in the entity for the key that we're assigned to. */
+	get fieldName() {
+		return Object.entries(this.entity).filter((e) => e[1] === this)[0]?.[0];
+	}
+	get hasBeenSet() {
+		return this.#hasBeenSet;
+	}
+	toString() {
+		return `CustomCollection(entity: ${this.entity}, fieldName: ${this.fieldName})`;
+	}
+	doGet(opts) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		this.ensureNewOrLoaded();
+		return this.filterDeleted(this.opts.get(this.entity), opts);
+	}
+	filterDeleted(entities, opts) {
+		return entities.filter((entity) => opts?.withDeleted === true || !entity.isDeletedEntity);
+	}
+	ensureNewOrLoaded() {
+		if (this.isLoaded) return;
+		require_utils.fail(`${this.entity}.${this.fieldName} was not loaded`);
+	}
+	[require_relations_RelationSymbols.RelationT] = null;
+	[require_relations_RelationSymbols.RelationU] = null;
+};
+//#endregion
+exports.CustomCollection = CustomCollection;
+exports.hasCustomCollection = hasCustomCollection;
+
+//# sourceMappingURL=CustomCollection.cjs.map

package/build/relations/CustomCollection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomCollection.cjs","names":["lazyField","AbstractRelationImpl","#isLoaded","#loadHint","#hasBeenSet","RelationT","RelationU"],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\nexport type CustomCollectionOpts<T extends Entity, U extends Entity> = {\n  // We purposefully don't capture the return value of `load` b/c we want `get` to re-calc from `entity`\n  // each time it's invoked so that it reflects any changed values.\n  load: (entity: T, opts: { forceReload?: boolean }) => Promise<any>;\n  get: (entity: T) => readonly U[];\n  set?: (entity: T, other: U[]) => void;\n  find?: (entity: T, id: IdOf<U>) => U | undefined;\n  add?: (entity: T, other: U) => void;\n  remove?: (entity: T, other: U) => void;\n  /** Whether the reference is loaded, even w/o an explicit `.load` call, i.e. for DeepNew test instances. */\n  isLoaded: (entity: T) => boolean;\n  /**\n   * A load hint that can be used to speculatively traverse the dependencies of this collection.  Currently\n   * only used by em.importEntity and can be omitted if the collection isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\nexport function hasCustomCollection<T extends Entity, U extends Entity>(\n  opts: CustomCollectionOpts<T, U>,\n): CustomCollection<T, U> {\n  return lazyField((entity: T) => {\n    return new CustomCollection<T, U>(entity, opts);\n  });\n}\n\n/**\n * Allows user-defined collections that will work in `populate` / preload hints.\n *\n * This works because Joist's `populate`/preloading is not based on creating giant SQL joins,\n * but instead by just walking \"1 dataloader per level\". Given this, we don't really care\n * what happens at each \"level\" of resolution, as long as: a) it's a promise, and b) the\n * caller uses dataloader to be batch friendly.\n *\n * This `CustomCollection` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasManyThrough`, which are built on `CustomCollection`.\n */\nexport class CustomCollection<T extends Entity, U extends Entity>\n  extends AbstractRelationImpl<T, readonly U[]>\n  implements Collection<T, U>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the values can become stale; we want to each `.get` call to repeatedly evaluate the latest values.\n  private loadPromise: Promise<any> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined = undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomCollectionOpts<T, U>,\n  ) {\n    super(entity);\n  }\n\n  get get(): readonly U[] {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): readonly U[] {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get isLoaded(): boolean {\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.addNaive(this);\n    this.#isLoaded = this.opts.isLoaded(this.entity);\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n  }\n\n  get loadHint(): LoadHint<T> | undefined {\n    if (this.#loadHint === undefined && this.opts.loadHint !== undefined) {\n      const { loadHint } = this.opts;\n      this.#loadHint = typeof loadHint === \"function\" ? loadHint(this.entity) : loadHint;\n    }\n    return this.#loadHint;\n  }\n\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<readonly U[]> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.isLoaded || opts.forceReload) {\n      if (this.loadPromise === undefined) {\n        this.loadPromise = this.opts.load(this.entity, opts);\n        await this.loadPromise;\n        this.loadPromise = undefined;\n        this.#isLoaded = true;\n      } else {\n        await this.loadPromise;\n      }\n    }\n    return this.doGet(opts);\n  }\n\n  get isPreloaded(): boolean {\n    return false;\n  }\n\n  preload(): void {\n    throw new Error(\"Not implemented\");\n  }\n\n  set(values: U[]): void {\n    this.ensureNewOrLoaded();\n    const { set, add, remove } = this.opts;\n    if (set !== undefined) {\n      set(this.entity, values);\n      this.#hasBeenSet = true;\n    } else if (add !== undefined && remove !== undefined) {\n      const current = this.get;\n      current.filter((value) => !values.includes(value)).forEach((value) => this.remove(value));\n      values.filter((value) => !current.includes(value)).forEach((value) => this.add(value));\n      this.#hasBeenSet = true;\n    } else {\n      fail(`'set' not implemented and not inferrable from 'add'/'remove' on ${this}`);\n    }\n  }\n\n  setFromOpts(values: U[]): void {\n    this.set(values);\n  }\n\n  async find(id: IdOf<U>): Promise<U | undefined> {\n    if (!this.isLoaded) {\n      await this.load();\n    }\n    const { find } = this.opts;\n    if (find === undefined) {\n      return this.doGet().find((other) => other.id === id);\n    } else {\n      return find(this.entity, id);\n    }\n  }\n\n  async includes(other: U): Promise<boolean> {\n    throw new Error(\"Not implemented\");\n  }\n\n  add(other: U): void {\n    this.ensureNewOrLoaded();\n    const { add } = this.opts;\n    if (add === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    add(this.entity, other);\n  }\n\n  remove(other: U): void {\n    this.ensureNewOrLoaded();\n    const { remove } = this.opts;\n    if (remove === undefined) {\n      fail(`'add' not implemented on ${this}`);\n    }\n    remove(this.entity, other);\n  }\n\n  // these callbacks should be no-ops as they ought to be handled by the underlying relations\n  async cleanupOnEntityDeleted(): Promise<void> {}\n  maybeCascadeDelete(): void {}\n\n  /** Finds this CustomCollections field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    // Something about running with the transformations breaks the `[0][0]` and it can NPE\n    return Object.entries(this.entity).filter((e) => e[1] === this)[0]?.[0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomCollection(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): readonly U[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entities: readonly U[], opts?: { withDeleted?: boolean }): readonly U[] {\n    return entities.filter((entity) => opts?.withDeleted === true || !entity.isDeletedEntity);\n  }\n\n  private ensureNewOrLoaded() {\n    // This should only be callable in the type system if we've already resolved this to an instance\n    if (this.isLoaded) {\n      return;\n    }\n    fail(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n}\n"],"mappings":"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"}