joist-core 2.3.0-next.96 → 2.3.0-next.97

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

@@ -1 +1 @@
-{"version":3,"file":"ReactiveReference.d.cts","names":[],"sources":["../../src/relations/ReactiveReference.ts"],"mappings":";;;;;;;;;;;UA4BiB,kBAAkB,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,UAC1G,GACA,GACA;EAEA;EACA;EAEA,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;;;;;;;;EASxE,YAAY,IAAI;;EAGhB,IAAI,KAAK;;EAGT,SAAS,KAAK;EAEd;EAEA;;iBAGc,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KACjD,kBAAkB,GAAG;iBACR,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,iBACjD,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;cAoCX,sBACX,UAAU,QACV,UAAU,QACV,UAAU,aAAa,IACvB,qCAEQ,qBAAqB,GAAG,cACrB,kBAAkB,GAAG,GAAG,IAAI;;EAc9B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,gBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KAAK;EAiB3D,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;MAsD1E;EAkBJ;UAKQ;MAmCJ,cAAc,IAAI;MAIlB,kBAAkB,IAAI;MAItB,OAAO,IAAI;EAIf,IAAI,GAAG,IAAI;MAIP;EAKJ,QAAQ,QAAQ,IAAI;MAShB;EAIJ;UAMQ;EAOR,OAAO,OAAO,sBAAsB,GAAG,GAAG,GAAG,IAAI,aAAa,GAAG,MAAM;;MAOnE,iBAAiB,WAAW;MAK5B,MAAM,KAAK;MAIX;MAIA,WAAW,KAAK,KAAK;MAIrB;MAIA;;cAQQ;cAKA;EAIZ,YAAY,GAAG,IAAI,KAAK,KAAK;EAI7B;EASM,0BAA0B;EAWhC,QAAQ;IAAS;MAA0B,aAAa;MAQpD;MAIO,aAAa,eAAe;MAI5B;EAIJ;;;;;;;;;;UAeC;cAOI;;;;;EAQZ,mBAAmB,IAAI;GAYtB,YAAY;GACZ,YAAY;GACZ,aAAa;;;iBAIA,oBAAoB,wBAAwB,oBAAoB"}
+{"version":3,"file":"ReactiveReference.d.cts","names":[],"sources":["../../src/relations/ReactiveReference.ts"],"mappings":";;;;;;;;;;;UA6BiB,kBAAkB,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,UAC1G,GACA,GACA;EAEA;EACA;EAEA,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;;;;;;;;EASxE,YAAY,IAAI;;EAGhB,IAAI,KAAK;;EAGT,SAAS,KAAK;EAEd;EAEA;;iBAGc,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KACjD,kBAAkB,GAAG;iBACR,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,iBACjD,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;cAoCX,sBACX,UAAU,QACV,UAAU,QACV,UAAU,aAAa,IACvB,qCAEQ,qBAAqB,GAAG,cACrB,kBAAkB,GAAG,GAAG,IAAI;;EAc9B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,gBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KAAK;EAiB3D,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;MAsD1E;EAkBJ;UAKQ;MAmCJ,cAAc,IAAI;MAIlB,kBAAkB,IAAI;MAItB,OAAO,IAAI;EAIf,IAAI,GAAG,IAAI;MAIP;EAKJ,QAAQ,QAAQ,IAAI;MAShB;EAIJ;UAMQ;EAOR,OAAO,OAAO,sBAAsB,GAAG,GAAG,GAAG,IAAI,aAAa,GAAG,MAAM;;MAOnE,iBAAiB,WAAW;MAK5B,MAAM,KAAK;MAIX;MAIA,WAAW,KAAK,KAAK;MAIrB;MAIA;;cAQQ;cAKA;EAIZ,YAAY,GAAG,IAAI,KAAK,KAAK;EAI7B;EASM,0BAA0B;EAWhC,QAAQ;IAAS;MAA0B,aAAa;MAQpD;MAIO,aAAa,eAAe;MAI5B;EAIJ;;;;;;;;;;UAeC;cAOI;;;;;EAQZ,mBAAmB,IAAI;GAYtB,YAAY;GACZ,YAAY;GACZ,aAAa;;;iBAIA,oBAAoB,wBAAwB,oBAAoB"}

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

@@ -1 +1 @@
-{"version":3,"file":"ReactiveReference.d.mts","names":[],"sources":["../../src/relations/ReactiveReference.ts"],"mappings":";;;;;;;;;;;UA4BiB,kBAAkB,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,UAC1G,GACA,GACA;EAEA;EACA;EAEA,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;;;;;;;;EASxE,YAAY,IAAI;;EAGhB,IAAI,KAAK;;EAGT,SAAS,KAAK;EAEd;EAEA;;iBAGc,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KACjD,kBAAkB,GAAG;iBACR,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,iBACjD,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;cAoCX,sBACX,UAAU,QACV,UAAU,QACV,UAAU,aAAa,IACvB,qCAEQ,qBAAqB,GAAG,cACrB,kBAAkB,GAAG,GAAG,IAAI;;EAc9B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,gBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KAAK;EAiB3D,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;MAsD1E;EAkBJ;UAKQ;MAmCJ,cAAc,IAAI;MAIlB,kBAAkB,IAAI;MAItB,OAAO,IAAI;EAIf,IAAI,GAAG,IAAI;MAIP;EAKJ,QAAQ,QAAQ,IAAI;MAShB;EAIJ;UAMQ;EAOR,OAAO,OAAO,sBAAsB,GAAG,GAAG,GAAG,IAAI,aAAa,GAAG,MAAM;;MAOnE,iBAAiB,WAAW;MAK5B,MAAM,KAAK;MAIX;MAIA,WAAW,KAAK,KAAK;MAIrB;MAIA;;cAQQ;cAKA;EAIZ,YAAY,GAAG,IAAI,KAAK,KAAK;EAI7B;EASM,0BAA0B;EAWhC,QAAQ;IAAS;MAA0B,aAAa;MAQpD;MAIO,aAAa,eAAe;MAI5B;EAIJ;;;;;;;;;;UAeC;cAOI;;;;;EAQZ,mBAAmB,IAAI;GAYtB,YAAY;GACZ,YAAY;GACZ,aAAa;;;iBAIA,oBAAoB,wBAAwB,oBAAoB"}
+{"version":3,"file":"ReactiveReference.d.mts","names":[],"sources":["../../src/relations/ReactiveReference.ts"],"mappings":";;;;;;;;;;;UA6BiB,kBAAkB,UAAU,QAAQ,UAAU,QAAQ,qCAAqC,UAC1G,GACA,GACA;EAEA;EACA;EAEA,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;;;;;;;;EASxE,YAAY,IAAI;;EAGhB,IAAI,KAAK;;EAGT,SAAS,KAAK;EAEd;EAEA;;iBAGc,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KACjD,kBAAkB,GAAG;iBACR,qBAAqB,UAAU,QAAQ,UAAU,cAAc,UAAU,aAAa,IACpG,MAAM,GACN,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,iBACjD,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;cAoCX,sBACX,UAAU,QACV,UAAU,QACV,UAAU,aAAa,IACvB,qCAEQ,qBAAqB,GAAG,cACrB,kBAAkB,GAAG,GAAG,IAAI;;EAc9B,cAAc;UACb;EAJV,YACE,QAAQ,GACR,OAAO,gBACA,cAAc,GACb,KAAK,QAAQ,QAAQ,GAAG,OAAO,mBAAmB,KAAK;EAiB3D,KAAK;IAAS;IAAuB;MAAuB,QAAQ,IAAI;MAsD1E;EAkBJ;UAKQ;MAmCJ,cAAc,IAAI;MAIlB,kBAAkB,IAAI;MAItB,OAAO,IAAI;EAIf,IAAI,GAAG,IAAI;MAIP;EAKJ,QAAQ,QAAQ,IAAI;MAShB;EAIJ;UAMQ;EAOR,OAAO,OAAO,sBAAsB,GAAG,GAAG,GAAG,IAAI,aAAa,GAAG,MAAM;;MAOnE,iBAAiB,WAAW;MAK5B,MAAM,KAAK;MAIX;MAIA,WAAW,KAAK,KAAK;MAIrB;MAIA;;cAQQ;cAKA;EAIZ,YAAY,GAAG,IAAI,KAAK,KAAK;EAI7B;EASM,0BAA0B;EAWhC,QAAQ;IAAS;MAA0B,aAAa;MAQpD;MAIO,aAAa,eAAe;MAI5B;EAIJ;;;;;;;;;;UAeC;cAOI;;;;;EAQZ,mBAAmB,IAAI;GAYtB,YAAY;GACZ,YAAY;GACZ,aAAa;;;iBAIA,oBAAoB,wBAAwB,oBAAoB"}

package/build/relations/ReactiveReference.js

@@ -1,16 +1,17 @@
-import { lazyField } from "../newEntity.js";
-import { AbstractRelationImpl, isCascadeDelete } from "./AbstractRelationImpl.js";
+import { getField, setField } from "../fields.js";
+import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
-import { ReferenceN } from "./ReferenceSymbols.js";
-import "./Reference.js";
+import { isCascadeDelete } from "./isCascadeDelete.js";
 import "../IsLoadedCache.js";
+import { ReferenceN } from "./ReferenceSymbols.js";
 import { failIfNewEntity, failNoId } from "./ManyToOneReference.js";
-import { deTagId, maybeResolveReferenceToId, toIdOf } from "../keys.js";
-import { getMetadata } from "../EntityMetadata.js";
-import { getField, setField } from "../fields.js";
+import "./Reference.js";
 import { convertToLoadHint } from "../reactiveHints.js";
 import { isLoaded } from "../loadHints.js";
 import { fail } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { deTagId, maybeResolveReferenceToId, toIdOf } from "../keys.js";
+import { getMetadata } from "../EntityMetadata.js";
 import { ensureNotDeleted } from "../index.js";
 import { getEmInternalApi, sameEntity } from "../EntityManager.js";
 import { isEntity } from "../Entity.js";

package/build/relations/ReactiveReference.js.map

@@ -1 +1 @@
-{"version":3,"file":"ReactiveReference.js","names":["#fieldName","#otherMeta","#state","#loadPromise","#isLoaded","#isCached","#rr","#loaded"],"sources":["../../src/relations/ReactiveReference.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf } from \"../EntityManager.ts\";\nimport { getField, setField } from \"../fields.ts\";\nimport {\n  type EntityMetadata,\n  type ManyToOneField,\n  type TaggedId,\n  deTagId,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  isEntity,\n  isLoaded,\n  maybeResolveReferenceToId,\n  sameEntity,\n  toIdOf,\n} from \"../index.ts\";\nimport { type IsLoadedCachable } from \"../IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type MaybeReactedEntity, type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { AbstractRelationImpl, isCascadeDelete } from \"./AbstractRelationImpl.ts\";\nimport { failIfNewEntity, failNoId } from \"./ManyToOneReference.ts\";\nimport { type Reference } from \"./Reference.ts\";\nimport { ReferenceN } from \"./ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\nexport interface ReactiveReference<T extends Entity, U extends Entity, N extends never | undefined> extends Reference<\n  T,\n  U,\n  N\n> {\n  isLoaded: boolean;\n  isSet: boolean;\n\n  load(opts?: { withDeleted?: boolean; forceReload?: true }): Promise<U | N>;\n\n  /**\n   * Returns the as-of-last-flush previously-calculated entity.\n   *\n   * This is useful if you have to purposefully avoid using the lambda to calc the latest entity,\n   * i.e. if you're in a test and want to watch a calculated entity change from some dummy entity\n   * to the new derived entity.\n   * */\n  fieldValue: U | N;\n\n  /** Returns the id of the current assigned entity, or a runtime error if either 1) unset or 2) set to a new entity that doesn't have an `id` yet. */\n  id: IdOf<U>;\n\n  /** Returns the id of the current assigned entity, undefined if unset, or a runtime error if set to a new entity. */\n  idIfSet: IdOf<U> | undefined;\n\n  idUntagged: string;\n\n  idUntaggedIfSet: string | undefined;\n}\n\nexport function hasReactiveReference<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U>,\n): ReactiveReference<T, U, never>;\nexport function hasReactiveReference<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U> | undefined,\n): ReactiveReference<T, U, undefined>;\n/** Creates a `ReactiveReference`. */\nexport function hasReactiveReference<\n  T extends Entity,\n  U extends Entity,\n  const H extends ReactiveHint<T>,\n  N extends never | undefined,\n>(hint: H, fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U> | N): ReactiveReference<T, U, N> {\n  return lazyField((entity: T, fieldName) => {\n    const m2o = getMetadata(entity).allFields[fieldName] as ManyToOneField;\n    return new ReactiveReferenceImpl<T, U, H, N>(entity, m2o, hint, fn);\n  });\n}\n\n/**\n * Implements ReactiveReferences.\n *\n * This is a bit trickier than ReactiveFields, because we have to differentiate our loaded\n * between:\n *\n * - our load hint is loaded, and we can directly calculate the referenced entity, or\n * - we've fetched the calculated/stored entity from the database, but not purposefully\n *   not re-calculating it (which would require fetching the load hint, which might be\n *   expensive, and defeat the point of having our field materialized in the database)\n *\n * Further, want to support all of:\n *\n * - When loaded & `.get` has been called, we cache the value\n *\n * - If a WIP mutation happens, we invalidate `.get` *but* if we check `.isLoaded`,\n *   we can return the live/updated value, without an `await`.\n *\n * - If a WIP mutation happens, we invalidate `.isLoaded`, and if we're *no longer loaded*,\n *   we want to keep returning the stale value (as asserted by the tests), but the next\n *   `load` / `populate` should load the graph & recalculate the value.\n */\nexport class ReactiveReferenceImpl<\n  T extends Entity,\n  U extends Entity,\n  H extends ReactiveHint<T>,\n  N extends never | undefined,\n>\n  extends AbstractRelationImpl<T, U>\n  implements ReactiveReference<T, U, N>, IsLoadedCachable\n{\n  readonly #fieldName: keyof T & string;\n  readonly #otherMeta: EntityMetadata;\n  #state: RRState<U, N>;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<U | N> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToOneField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U> | N,\n  ) {\n    super(entity);\n    // Minimizing changes until the other PR lands...\n    this.#fieldName = field.fieldName as keyof T & string;\n    this.#otherMeta = field.otherMetadata();\n    this.#state = new RRUnloadedState<U, N>(this);\n    // We can be initialized with [entity | id | undefined], and if it's entity or id, then setImpl\n    // will set loaded appropriately; but if we're initialized undefined, then mark loaded here\n    if (entity.isNewEntity) {\n      // const isLoaded = isEntity(this.current()) ? true : undefined;\n    }\n    // If the property transformer is not enabled, then the RR will not be in the relations map because they are\n    // defined in the implementation file and not the codegen file.  So we should insert ourselves regardless.\n    (getInstanceData(entity).relations ??= {})[field.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: true }): Promise<U | N> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      // Just because we're not loaded, doesn't mean we necessarily need to load our full hint.\n      // We prefer to load only our previously-calculated/materialized value, and only load the\n      // full load hint if we need recalculated.\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n      if (maybeDirty) {\n        return (this.#loadPromise ??= em\n          .populate(this.entity, { hint: loadHint, ...opts })\n          .then(() => {\n            this.#state = this.#state.enterRecalcMode(this);\n            this.#isLoaded = true;\n            getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n            // Go through `this.get` so that `setField` is called to set our latest value\n            this.#isCached = false;\n            return this.doGet(opts);\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          }));\n      } else {\n        // If we don't need a full recalc, just make sure we have the entity in memory\n        // ...ideally we would check `isSet` and whether the key was in the `instanceData`\n        const current = this.current();\n        if (isEntity(current) || current === undefined) {\n          this.#state = new RRRefState<U, N>(this, current as U | N | undefined);\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return current as U | N;\n        } else {\n          return (this.#loadPromise ??= em\n            .load(this.#otherMeta.cstr, current)\n            .then((loaded) => {\n              this.#state = new RRRefState<U, N>(this, loaded);\n              this.#isLoaded = true;\n              getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n              return loaded;\n            })\n            .finally(() => {\n              this.#loadPromise = undefined;\n            }));\n        }\n      }\n    }\n    // The ReactiveField.load() always sets `#isCached = false`, but our assertion is that our\n    // IsLoadedCache/resetIsLoaded infra is good enough to \"see all invalidating mutations\",\n    // so we don't need this explicit reset.\n    // this.#isCached = false;\n    return this.doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    // If we've cached an isLoaded value, just use that, see https://github.com/joist-orm/joist-orm/issues/1166\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#state = this.#state.enterRecalcMode(this);\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = this.#state.canReturnValue;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.filterDeleted(this.#state.doGet() as U | N, opts);\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#state.kind === \"full\") {\n      const newValue = this.filterDeleted(fn(this.entity as any) as any, opts);\n      // It's cheap to set this every time we're called, i.e. even if it's not the\n      // official \"being called during em.flush\" update (...unless we're accessing it\n      // during the validate phase of `em.flush`, then skip it to avoid tripping up\n      // the \"cannot change entities during flush\" logic.)\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.setImpl(newValue);\n      }\n      this.#state = new RRFullState<U, N>(this, newValue);\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (this.#state.canReturnValue) {\n      // We're either in ref mode, or in full mode but not actually fully loaded,\n      // but in theory those states only get set after `.load()` / `.preload()` / import,\n      // so we should have some stored value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.filterDeleted(this.#state.doGet() as U | N, opts);\n  }\n\n  get fieldValue(): U | N {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get getWithDeleted(): U | N {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  set(_: U | N): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveReference directly.`);\n  }\n\n  get isSet(): boolean {\n    return this.current() !== undefined;\n  }\n\n  // Internal method used by OneToManyCollection\n  setImpl(entity: U | N): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (sameEntity(entity, this.current({ withDeleted: true }))) {\n      return;\n    }\n    // Prefer to keep the id in our data hash, but if this is a new entity w/o an id, use the entity itself\n    setField(this.entity, this.fieldName, isEntity(entity) ? (entity.idTaggedMaybe ?? entity) : entity);\n  }\n\n  get isPreloaded(): boolean {\n    return !!this.maybeFindEntity();\n  }\n\n  preload(): void {\n    this.#state = new RRRefState<U, N>(this, this.maybeFindEntity());\n    this.#isLoaded = true;\n    this.#isCached = true;\n  }\n\n  private unload(): void {\n    this.#state = new RRUnloadedState<U, N>(this);\n    this.#isLoaded = false;\n    this.#isCached = false;\n    this.#loadPromise = undefined;\n  }\n\n  import(other: ReactiveReferenceImpl<T, U, H, N>, findEntity: (e: U) => U): void {\n    this.#state = other.#state.import(this, findEntity);\n    this.#isLoaded = true;\n    this.#isCached = true;\n  }\n\n  /** Returns the tagged id of the current value. */\n  get idTaggedMaybe(): TaggedId | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    return maybeResolveReferenceToId(this.current()) as TaggedId | N;\n  }\n\n  get id(): IdOf<U> {\n    return this.idMaybe || failNoId(this.entity, this.fieldName, this.current());\n  }\n\n  get idUntagged(): string {\n    return this.idUntaggedMaybe || failNoId(this.entity, this.fieldName, this.current());\n  }\n\n  get idIfSet(): IdOf<U> | N | undefined {\n    return this.idMaybe || failIfNewEntity(this.entity, this.fieldName, this.current());\n  }\n\n  get idUntaggedIfSet(): string | undefined {\n    return this.idUntaggedMaybe || failIfNewEntity(this.entity, this.fieldName, this.current());\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  // private impl\n\n  /** Returns the id of the current value. */\n  private get idMaybe(): IdOf<U> | undefined {\n    ensureNotDeleted(this.entity, \"pending\");\n    return toIdOf(this.otherMeta, this.idTaggedMaybe);\n  }\n\n  private get idUntaggedMaybe(): string | undefined {\n    return deTagId(this.otherMeta, this.idMaybe);\n  }\n\n  setFromOpts(_: U | IdOf<U> | N): void {\n    throw new Error(`ReactiveReference ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.isCascadeDelete) {\n      const current = this.current({ withDeleted: true });\n      if (current !== undefined && typeof current !== \"string\") {\n        this.entity.em.delete(current as U);\n      }\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // if we are going to delete this relation as well, then we don't need to clean it up\n    if (this.isCascadeDelete) return;\n    setField(this.entity, this.fieldName, undefined);\n    this.#state = new RRRefState<U, N>(this, undefined as N);\n    this.#isLoaded = false;\n    this.#isCached = false;\n    this.#loadPromise = undefined;\n  }\n\n  // We need to keep U in data[fieldName] to handle entities without an id assigned yet.\n  current(opts?: { withDeleted?: boolean }): U | string | N {\n    const current = getField(this.entity, this.fieldName);\n    if (current !== undefined && isEntity(current)) {\n      return this.filterDeleted(current as U, opts);\n    }\n    return current;\n  }\n\n  get fieldName(): string {\n    return this.#fieldName;\n  }\n\n  public get otherMeta(): EntityMetadata<U> {\n    return (getMetadata(this.entity).allFields[this.#fieldName] as ManyToOneField).otherMetadata();\n  }\n\n  public get hasBeenSet(): boolean {\n    return true;\n  }\n\n  public toString(): string {\n    return `ReactiveReference(entity: ${this.entity}, hint: ${this.loadHint}, fieldName: ${this.fieldName}, otherMeta: {\n      this.otherMeta.type\n    }, id: ${this.id})`;\n  }\n\n  /**\n   * Removes pending-hard-delete (but not soft-deleted), unless explicitly asked for.\n   *\n   * Note that we leave soft-deleted entities b/c the call signature of a `book.author.get`\n   * very likely does not expect a soft-deleted entity to result in `undefined`.\n   *\n   * (Contrasted with `author.books.get` which is more intuitive to have soft-deleted\n   * entities filtered out, i.e. it doesn't fundamentally change the return type.)\n   */\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    if (entity && (!opts || !opts.withDeleted) && entity.isDeletedEntity) {\n      return undefined!;\n    }\n    return entity;\n  }\n\n  private get isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#fieldName);\n  }\n\n  /**\n   * Looks for an entity in `EntityManager`, b/c we may have it in memory even if\n   * our reference is not specifically loaded.\n   */\n  maybeFindEntity(): U | N {\n    // Check this.loaded first b/c a new entity won't have an id yet\n    if (this.#state.canReturnValue) {\n      const loaded = this.#state.doGet();\n      if (loaded !== undefined) {\n        return loaded;\n      }\n    }\n    const { idTaggedMaybe } = this;\n    return idTaggedMaybe !== undefined ? (this.entity.em.getEntity(idTaggedMaybe) as U | N) : (undefined as N);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n  [ReferenceN]: N = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveReference. */\nexport function isReactiveReference(maybeReactiveRef: any): maybeReactiveRef is ReactiveReference<any, any, any> {\n  return maybeReactiveRef instanceof ReactiveReferenceImpl;\n}\n\ninterface RRState<U extends Entity, N extends never | undefined> {\n  readonly kind: \"unloaded\" | \"ref\" | \"full\";\n  readonly canReturnValue: boolean;\n  doGet(): U | N | undefined;\n  /**\n   * Switches from \"materialized ref value\" semantics to \"recalc from reactive graph when available\" semantics.\n   *\n   * This is synchronous because it does not mean the load hint is fully loaded yet. It only means this\n   * reference should now behave as recalc-capable: if `isLoaded(loadHint)` later reports true, `doGet`\n   * will recalculate from `fn(...)`; otherwise we keep returning the last known/stale value until `load()`\n   * populates the graph.\n   */\n  enterRecalcMode(target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N>;\n  import(target: ReactiveReferenceImpl<any, any, any, any>, findEntity: (e: U) => U): RRState<U, N>;\n}\n\nclass RRUnloadedState<U extends Entity, N extends never | undefined> implements RRState<U, N> {\n  readonly kind = \"unloaded\";\n  readonly canReturnValue = false;\n  #rr: ReactiveReferenceImpl<any, any, any, any>;\n\n  constructor(rr: ReactiveReferenceImpl<any, any, any, any>) {\n    this.#rr = rr;\n  }\n\n  doGet(): U | N | undefined {\n    throw new Error(`${this.#rr.entity}.${this.#rr.fieldName} was not loaded`);\n  }\n\n  enterRecalcMode(target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N> {\n    return new RRFullState<U, N>(target, undefined);\n  }\n\n  import(target: ReactiveReferenceImpl<any, any, any, any>, _findEntity: (e: U) => U): RRState<U, N> {\n    return new RRUnloadedState<U, N>(target);\n  }\n}\n\nclass RRRefState<U extends Entity, N extends never | undefined> implements RRState<U, N> {\n  readonly kind = \"ref\";\n  readonly canReturnValue = true;\n  #loaded: U | N | undefined;\n\n  constructor(_rr: ReactiveReferenceImpl<any, any, any, any>, loaded: U | N | undefined) {\n    this.#loaded = loaded;\n  }\n\n  doGet(): U | N | undefined {\n    return this.#loaded;\n  }\n\n  enterRecalcMode(target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N> {\n    return new RRFullState<U, N>(target, this.#loaded);\n  }\n\n  import(target: ReactiveReferenceImpl<any, any, any, any>, findEntity: (e: U) => U): RRState<U, N> {\n    return new RRRefState<U, N>(target, mapReactiveReferenceEntity(this.#loaded, findEntity));\n  }\n}\n\nclass RRFullState<U extends Entity, N extends never | undefined> implements RRState<U, N> {\n  readonly kind = \"full\";\n  readonly canReturnValue = true;\n  #loaded: U | N | undefined;\n\n  constructor(_rr: ReactiveReferenceImpl<any, any, any, any>, loaded: U | N | undefined) {\n    this.#loaded = loaded;\n  }\n\n  doGet(): U | N | undefined {\n    return this.#loaded;\n  }\n\n  enterRecalcMode(_target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N> {\n    return this;\n  }\n\n  import(target: ReactiveReferenceImpl<any, any, any, any>, findEntity: (e: U) => U): RRState<U, N> {\n    return new RRRefState<U, N>(target, mapReactiveReferenceEntity(this.#loaded, findEntity));\n  }\n}\n\nfunction mapReactiveReferenceEntity<U extends Entity, N extends never | undefined>(\n  entity: U | N | undefined,\n  findEntity: (e: U) => U,\n): U | N | undefined {\n  return isEntity(entity) ? findEntity(entity) : entity;\n}\n"],"mappings":"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"}
+{"version":3,"file":"ReactiveReference.js","names":["#fieldName","#otherMeta","#state","#loadPromise","#isLoaded","#isCached","#rr","#loaded"],"sources":["../../src/relations/ReactiveReference.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf } from \"../EntityManager.ts\";\nimport { getField, setField } from \"../fields.ts\";\nimport {\n  type EntityMetadata,\n  type ManyToOneField,\n  type TaggedId,\n  deTagId,\n  ensureNotDeleted,\n  fail,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  isEntity,\n  isLoaded,\n  maybeResolveReferenceToId,\n  sameEntity,\n  toIdOf,\n} from \"../index.ts\";\nimport { type IsLoadedCachable } from \"../IsLoadedCache.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { type MaybeReactedEntity, type Reacted, type ReactiveHint, convertToLoadHint } from \"../reactiveHints.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"./isCascadeDelete.ts\";\nimport { failIfNewEntity, failNoId } from \"./ManyToOneReference.ts\";\nimport { type Reference } from \"./Reference.ts\";\nimport { ReferenceN } from \"./ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\nexport interface ReactiveReference<T extends Entity, U extends Entity, N extends never | undefined> extends Reference<\n  T,\n  U,\n  N\n> {\n  isLoaded: boolean;\n  isSet: boolean;\n\n  load(opts?: { withDeleted?: boolean; forceReload?: true }): Promise<U | N>;\n\n  /**\n   * Returns the as-of-last-flush previously-calculated entity.\n   *\n   * This is useful if you have to purposefully avoid using the lambda to calc the latest entity,\n   * i.e. if you're in a test and want to watch a calculated entity change from some dummy entity\n   * to the new derived entity.\n   * */\n  fieldValue: U | N;\n\n  /** Returns the id of the current assigned entity, or a runtime error if either 1) unset or 2) set to a new entity that doesn't have an `id` yet. */\n  id: IdOf<U>;\n\n  /** Returns the id of the current assigned entity, undefined if unset, or a runtime error if set to a new entity. */\n  idIfSet: IdOf<U> | undefined;\n\n  idUntagged: string;\n\n  idUntaggedIfSet: string | undefined;\n}\n\nexport function hasReactiveReference<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U>,\n): ReactiveReference<T, U, never>;\nexport function hasReactiveReference<T extends Entity, U extends Entity, const H extends ReactiveHint<T>>(\n  hint: H,\n  fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U> | undefined,\n): ReactiveReference<T, U, undefined>;\n/** Creates a `ReactiveReference`. */\nexport function hasReactiveReference<\n  T extends Entity,\n  U extends Entity,\n  const H extends ReactiveHint<T>,\n  N extends never | undefined,\n>(hint: H, fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U> | N): ReactiveReference<T, U, N> {\n  return lazyField((entity: T, fieldName) => {\n    const m2o = getMetadata(entity).allFields[fieldName] as ManyToOneField;\n    return new ReactiveReferenceImpl<T, U, H, N>(entity, m2o, hint, fn);\n  });\n}\n\n/**\n * Implements ReactiveReferences.\n *\n * This is a bit trickier than ReactiveFields, because we have to differentiate our loaded\n * between:\n *\n * - our load hint is loaded, and we can directly calculate the referenced entity, or\n * - we've fetched the calculated/stored entity from the database, but not purposefully\n *   not re-calculating it (which would require fetching the load hint, which might be\n *   expensive, and defeat the point of having our field materialized in the database)\n *\n * Further, want to support all of:\n *\n * - When loaded & `.get` has been called, we cache the value\n *\n * - If a WIP mutation happens, we invalidate `.get` *but* if we check `.isLoaded`,\n *   we can return the live/updated value, without an `await`.\n *\n * - If a WIP mutation happens, we invalidate `.isLoaded`, and if we're *no longer loaded*,\n *   we want to keep returning the stale value (as asserted by the tests), but the next\n *   `load` / `populate` should load the graph & recalculate the value.\n */\nexport class ReactiveReferenceImpl<\n  T extends Entity,\n  U extends Entity,\n  H extends ReactiveHint<T>,\n  N extends never | undefined,\n>\n  extends AbstractRelationImpl<T, U>\n  implements ReactiveReference<T, U, N>, IsLoadedCachable\n{\n  readonly #fieldName: keyof T & string;\n  readonly #otherMeta: EntityMetadata;\n  #state: RRState<U, N>;\n  // #isLoaded doesn't necessary care if we're ref-mode or full-mode, it's just\n  // whether a caller can call `.get` and not have it blow up.\n  #isLoaded: boolean | undefined = undefined;\n  #isCached: boolean = false;\n  #loadPromise: Promise<U | N> | undefined;\n\n  constructor(\n    entity: T,\n    field: ManyToOneField,\n    public reactiveHint: H,\n    private fn: (entity: Reacted<T, H>) => MaybeReactedEntity<U> | N,\n  ) {\n    super(entity);\n    // Minimizing changes until the other PR lands...\n    this.#fieldName = field.fieldName as keyof T & string;\n    this.#otherMeta = field.otherMetadata();\n    this.#state = new RRUnloadedState<U, N>(this);\n    // We can be initialized with [entity | id | undefined], and if it's entity or id, then setImpl\n    // will set loaded appropriately; but if we're initialized undefined, then mark loaded here\n    if (entity.isNewEntity) {\n      // const isLoaded = isEntity(this.current()) ? true : undefined;\n    }\n    // If the property transformer is not enabled, then the RR will not be in the relations map because they are\n    // defined in the implementation file and not the codegen file.  So we should insert ourselves regardless.\n    (getInstanceData(entity).relations ??= {})[field.fieldName] = this;\n  }\n\n  async load(opts?: { withDeleted?: boolean; forceReload?: true }): Promise<U | N> {\n    ensureNotDeleted(this.entity, \"pending\");\n    const { loadHint } = this;\n    if (!this.isLoaded || opts?.forceReload) {\n      const { em } = this.entity;\n      // Just because we're not loaded, doesn't mean we necessarily need to load our full hint.\n      // We prefer to load only our previously-calculated/materialized value, and only load the\n      // full load hint if we need recalculated.\n      const maybeDirty = opts?.forceReload || getEmInternalApi(em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n      if (maybeDirty) {\n        return (this.#loadPromise ??= em\n          .populate(this.entity, { hint: loadHint, ...opts })\n          .then(() => {\n            this.#state = this.#state.enterRecalcMode(this);\n            this.#isLoaded = true;\n            getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n            // Go through `this.get` so that `setField` is called to set our latest value\n            this.#isCached = false;\n            return this.doGet(opts);\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          }));\n      } else {\n        // If we don't need a full recalc, just make sure we have the entity in memory\n        // ...ideally we would check `isSet` and whether the key was in the `instanceData`\n        const current = this.current();\n        if (isEntity(current) || current === undefined) {\n          this.#state = new RRRefState<U, N>(this, current as U | N | undefined);\n          this.#isLoaded = true;\n          getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n          return current as U | N;\n        } else {\n          return (this.#loadPromise ??= em\n            .load(this.#otherMeta.cstr, current)\n            .then((loaded) => {\n              this.#state = new RRRefState<U, N>(this, loaded);\n              this.#isLoaded = true;\n              getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n              return loaded;\n            })\n            .finally(() => {\n              this.#loadPromise = undefined;\n            }));\n        }\n      }\n    }\n    // The ReactiveField.load() always sets `#isCached = false`, but our assertion is that our\n    // IsLoadedCache/resetIsLoaded infra is good enough to \"see all invalidating mutations\",\n    // so we don't need this explicit reset.\n    // this.#isCached = false;\n    return this.doGet(opts);\n  }\n\n  get isLoaded(): boolean {\n    // If we've cached an isLoaded value, just use that, see https://github.com/joist-orm/joist-orm/issues/1166\n    if (this.#isLoaded !== undefined) return this.#isLoaded;\n    getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    // If a WIP mutation has marked our field as potentially dirty, we need to be \"full\" loaded\n    const maybeDirty = getEmInternalApi(this.entity.em).rm.isMaybePendingRecalc(this.entity, this.fieldName);\n    if (maybeDirty) {\n      // If we're dirty, only being \"full\" loaded is good enough to recalc\n      this.#state = this.#state.enterRecalcMode(this);\n      this.#isLoaded = isLoaded(this.entity, this.loadHint);\n      this.#isCached = false;\n    } else {\n      // If we've had `.load` called before, assume we're still loaded\n      this.#isLoaded = this.#state.canReturnValue;\n    }\n    return this.#isLoaded;\n  }\n\n  resetIsLoaded(): void {\n    this.#isLoaded = undefined;\n    this.#isCached = false;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    const { fn } = this;\n    ensureNotDeleted(this.entity, \"pending\");\n    // Fast pass if we've already calculated this (cache invalidation will happen on\n    // any mutation via #resetIsLoaded)..\n    if (this.#isCached) {\n      return this.filterDeleted(this.#state.doGet() as U | N, opts);\n    }\n    // Call isLoaded to probe the load hint, and get `#isLoaded` set, but still have\n    // our `if` check the raw `#isLoaded` to know if we should eval-latest or return `loaded`.\n    if (this.isLoaded && this.#state.kind === \"full\") {\n      const newValue = this.filterDeleted(fn(this.entity as any) as any, opts);\n      // It's cheap to set this every time we're called, i.e. even if it's not the\n      // official \"being called during em.flush\" update (...unless we're accessing it\n      // during the validate phase of `em.flush`, then skip it to avoid tripping up\n      // the \"cannot change entities during flush\" logic.)\n      if (!getEmInternalApi(this.entity.em).isValidating) {\n        this.setImpl(newValue);\n      }\n      this.#state = new RRFullState<U, N>(this, newValue);\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else if (this.#state.canReturnValue) {\n      // We're either in ref mode, or in full mode but not actually fully loaded,\n      // but in theory those states only get set after `.load()` / `.preload()` / import,\n      // so we should have some stored value, even if it's not fully up-to-date.\n      this.#isCached = true;\n      getEmInternalApi(this.entity.em).isLoadedCache.add(this);\n    } else {\n      const noun = this.entity.isNewEntity ? \"derived\" : \"loaded\";\n      throw new Error(`${this.entity}.${this.fieldName} has not been ${noun} yet`);\n    }\n    return this.filterDeleted(this.#state.doGet() as U | N, opts);\n  }\n\n  get fieldValue(): U | N {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get getWithDeleted(): U | N {\n    return this.doGet({ withDeleted: true });\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  set(_: U | N): void {\n    fail(`Cannot set ${this.entity}.${this.fieldName} ReactiveReference directly.`);\n  }\n\n  get isSet(): boolean {\n    return this.current() !== undefined;\n  }\n\n  // Internal method used by OneToManyCollection\n  setImpl(entity: U | N): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (sameEntity(entity, this.current({ withDeleted: true }))) {\n      return;\n    }\n    // Prefer to keep the id in our data hash, but if this is a new entity w/o an id, use the entity itself\n    setField(this.entity, this.fieldName, isEntity(entity) ? (entity.idTaggedMaybe ?? entity) : entity);\n  }\n\n  get isPreloaded(): boolean {\n    return !!this.maybeFindEntity();\n  }\n\n  preload(): void {\n    this.#state = new RRRefState<U, N>(this, this.maybeFindEntity());\n    this.#isLoaded = true;\n    this.#isCached = true;\n  }\n\n  private unload(): void {\n    this.#state = new RRUnloadedState<U, N>(this);\n    this.#isLoaded = false;\n    this.#isCached = false;\n    this.#loadPromise = undefined;\n  }\n\n  import(other: ReactiveReferenceImpl<T, U, H, N>, findEntity: (e: U) => U): void {\n    this.#state = other.#state.import(this, findEntity);\n    this.#isLoaded = true;\n    this.#isCached = true;\n  }\n\n  /** Returns the tagged id of the current value. */\n  get idTaggedMaybe(): TaggedId | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    return maybeResolveReferenceToId(this.current()) as TaggedId | N;\n  }\n\n  get id(): IdOf<U> {\n    return this.idMaybe || failNoId(this.entity, this.fieldName, this.current());\n  }\n\n  get idUntagged(): string {\n    return this.idUntaggedMaybe || failNoId(this.entity, this.fieldName, this.current());\n  }\n\n  get idIfSet(): IdOf<U> | N | undefined {\n    return this.idMaybe || failIfNewEntity(this.entity, this.fieldName, this.current());\n  }\n\n  get idUntaggedIfSet(): string | undefined {\n    return this.idUntaggedMaybe || failIfNewEntity(this.entity, this.fieldName, this.current());\n  }\n\n  get loadHint(): any {\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.reactiveHint));\n  }\n\n  // private impl\n\n  /** Returns the id of the current value. */\n  private get idMaybe(): IdOf<U> | undefined {\n    ensureNotDeleted(this.entity, \"pending\");\n    return toIdOf(this.otherMeta, this.idTaggedMaybe);\n  }\n\n  private get idUntaggedMaybe(): string | undefined {\n    return deTagId(this.otherMeta, this.idMaybe);\n  }\n\n  setFromOpts(_: U | IdOf<U> | N): void {\n    throw new Error(`ReactiveReference ${this.entity}.${this.fieldName} cannot be set via opts`);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.isCascadeDelete) {\n      const current = this.current({ withDeleted: true });\n      if (current !== undefined && typeof current !== \"string\") {\n        this.entity.em.delete(current as U);\n      }\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // if we are going to delete this relation as well, then we don't need to clean it up\n    if (this.isCascadeDelete) return;\n    setField(this.entity, this.fieldName, undefined);\n    this.#state = new RRRefState<U, N>(this, undefined as N);\n    this.#isLoaded = false;\n    this.#isCached = false;\n    this.#loadPromise = undefined;\n  }\n\n  // We need to keep U in data[fieldName] to handle entities without an id assigned yet.\n  current(opts?: { withDeleted?: boolean }): U | string | N {\n    const current = getField(this.entity, this.fieldName);\n    if (current !== undefined && isEntity(current)) {\n      return this.filterDeleted(current as U, opts);\n    }\n    return current;\n  }\n\n  get fieldName(): string {\n    return this.#fieldName;\n  }\n\n  public get otherMeta(): EntityMetadata<U> {\n    return (getMetadata(this.entity).allFields[this.#fieldName] as ManyToOneField).otherMetadata();\n  }\n\n  public get hasBeenSet(): boolean {\n    return true;\n  }\n\n  public toString(): string {\n    return `ReactiveReference(entity: ${this.entity}, hint: ${this.loadHint}, fieldName: ${this.fieldName}, otherMeta: {\n      this.otherMeta.type\n    }, id: ${this.id})`;\n  }\n\n  /**\n   * Removes pending-hard-delete (but not soft-deleted), unless explicitly asked for.\n   *\n   * Note that we leave soft-deleted entities b/c the call signature of a `book.author.get`\n   * very likely does not expect a soft-deleted entity to result in `undefined`.\n   *\n   * (Contrasted with `author.books.get` which is more intuitive to have soft-deleted\n   * entities filtered out, i.e. it doesn't fundamentally change the return type.)\n   */\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    if (entity && (!opts || !opts.withDeleted) && entity.isDeletedEntity) {\n      return undefined!;\n    }\n    return entity;\n  }\n\n  private get isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.#fieldName);\n  }\n\n  /**\n   * Looks for an entity in `EntityManager`, b/c we may have it in memory even if\n   * our reference is not specifically loaded.\n   */\n  maybeFindEntity(): U | N {\n    // Check this.loaded first b/c a new entity won't have an id yet\n    if (this.#state.canReturnValue) {\n      const loaded = this.#state.doGet();\n      if (loaded !== undefined) {\n        return loaded;\n      }\n    }\n    const { idTaggedMaybe } = this;\n    return idTaggedMaybe !== undefined ? (this.entity.em.getEntity(idTaggedMaybe) as U | N) : (undefined as N);\n  }\n\n  [RelationT]: T = null!;\n  [RelationU]: U = null!;\n  [ReferenceN]: N = null!;\n}\n\n/** Type guard utility for determining if an entity field is a ReactiveReference. */\nexport function isReactiveReference(maybeReactiveRef: any): maybeReactiveRef is ReactiveReference<any, any, any> {\n  return maybeReactiveRef instanceof ReactiveReferenceImpl;\n}\n\ninterface RRState<U extends Entity, N extends never | undefined> {\n  readonly kind: \"unloaded\" | \"ref\" | \"full\";\n  readonly canReturnValue: boolean;\n  doGet(): U | N | undefined;\n  /**\n   * Switches from \"materialized ref value\" semantics to \"recalc from reactive graph when available\" semantics.\n   *\n   * This is synchronous because it does not mean the load hint is fully loaded yet. It only means this\n   * reference should now behave as recalc-capable: if `isLoaded(loadHint)` later reports true, `doGet`\n   * will recalculate from `fn(...)`; otherwise we keep returning the last known/stale value until `load()`\n   * populates the graph.\n   */\n  enterRecalcMode(target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N>;\n  import(target: ReactiveReferenceImpl<any, any, any, any>, findEntity: (e: U) => U): RRState<U, N>;\n}\n\nclass RRUnloadedState<U extends Entity, N extends never | undefined> implements RRState<U, N> {\n  readonly kind = \"unloaded\";\n  readonly canReturnValue = false;\n  #rr: ReactiveReferenceImpl<any, any, any, any>;\n\n  constructor(rr: ReactiveReferenceImpl<any, any, any, any>) {\n    this.#rr = rr;\n  }\n\n  doGet(): U | N | undefined {\n    throw new Error(`${this.#rr.entity}.${this.#rr.fieldName} was not loaded`);\n  }\n\n  enterRecalcMode(target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N> {\n    return new RRFullState<U, N>(target, undefined);\n  }\n\n  import(target: ReactiveReferenceImpl<any, any, any, any>, _findEntity: (e: U) => U): RRState<U, N> {\n    return new RRUnloadedState<U, N>(target);\n  }\n}\n\nclass RRRefState<U extends Entity, N extends never | undefined> implements RRState<U, N> {\n  readonly kind = \"ref\";\n  readonly canReturnValue = true;\n  #loaded: U | N | undefined;\n\n  constructor(_rr: ReactiveReferenceImpl<any, any, any, any>, loaded: U | N | undefined) {\n    this.#loaded = loaded;\n  }\n\n  doGet(): U | N | undefined {\n    return this.#loaded;\n  }\n\n  enterRecalcMode(target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N> {\n    return new RRFullState<U, N>(target, this.#loaded);\n  }\n\n  import(target: ReactiveReferenceImpl<any, any, any, any>, findEntity: (e: U) => U): RRState<U, N> {\n    return new RRRefState<U, N>(target, mapReactiveReferenceEntity(this.#loaded, findEntity));\n  }\n}\n\nclass RRFullState<U extends Entity, N extends never | undefined> implements RRState<U, N> {\n  readonly kind = \"full\";\n  readonly canReturnValue = true;\n  #loaded: U | N | undefined;\n\n  constructor(_rr: ReactiveReferenceImpl<any, any, any, any>, loaded: U | N | undefined) {\n    this.#loaded = loaded;\n  }\n\n  doGet(): U | N | undefined {\n    return this.#loaded;\n  }\n\n  enterRecalcMode(_target: ReactiveReferenceImpl<any, any, any, any>): RRFullState<U, N> {\n    return this;\n  }\n\n  import(target: ReactiveReferenceImpl<any, any, any, any>, findEntity: (e: U) => U): RRState<U, N> {\n    return new RRRefState<U, N>(target, mapReactiveReferenceEntity(this.#loaded, findEntity));\n  }\n}\n\nfunction mapReactiveReferenceEntity<U extends Entity, N extends never | undefined>(\n  entity: U | N | undefined,\n  findEntity: (e: U) => U,\n): U | N | undefined {\n  return isEntity(entity) ? findEntity(entity) : entity;\n}\n"],"mappings":"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"}

package/build/relations/RecursiveCollection.cjs

@@ -1,18 +1,18 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_Collection = require("./Collection.cjs");
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
 const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
 const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_relations_Reference = require("./Reference.cjs");
 require("../IsLoadedCache.cjs");
+const require_relations_Reference = require("./Reference.cjs");
 const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
 const require_batchloaders_recursiveChildrenBatchLoader = require("../batchloaders/recursiveChildrenBatchLoader.cjs");
 const require_batchloaders_recursiveM2mBatchLoader = require("../batchloaders/recursiveM2mBatchLoader.cjs");
 const require_batchloaders_recursiveParentsBatchLoader = require("../batchloaders/recursiveParentsBatchLoader.cjs");
 require("./ReadOnlyCollection.cjs");
-const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_index = require("../index.cjs");
 const require_EntityManager = require("../EntityManager.cjs");
 //#region src/relations/RecursiveCollection.ts

package/build/relations/RecursiveCollection.js

@@ -1,17 +1,17 @@
 import { isCollection, isLoadedCollection } from "./Collection.js";
-import { lazyField } from "../newEntity.js";
 import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
 import { RecursiveCycleError } from "./RecursiveCycleError.js";
-import { isLoadedReference, isReference } from "./Reference.js";
 import "../IsLoadedCache.js";
+import { isLoadedReference, isReference } from "./Reference.js";
 import { isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
 import { recursiveChildrenBatchLoader } from "../batchloaders/recursiveChildrenBatchLoader.js";
 import { recursiveM2mBatchLoader } from "../batchloaders/recursiveM2mBatchLoader.js";
 import { recursiveParentsBatchLoader } from "../batchloaders/recursiveParentsBatchLoader.js";
 import "./ReadOnlyCollection.js";
-import { getMetadata } from "../EntityMetadata.js";
 import { fail } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
 import { ensureNotDeleted } from "../index.js";
 import { appendStack, getEmInternalApi } from "../EntityManager.js";
 //#region src/relations/RecursiveCollection.ts

package/build/relations/Reference.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_ReferenceSymbols = require("./ReferenceSymbols.cjs");
-const require_relations_CustomReference = require("./CustomReference.cjs");
 const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
 const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
 const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
+const require_relations_CustomReference = require("./CustomReference.cjs");
 const require_relations_PolymorphicReference = require("./PolymorphicReference.cjs");
 require("./index.cjs");
 require("../EntityManager.cjs");

package/build/relations/Reference.js

@@ -1,8 +1,8 @@
 import { ReferenceN } from "./ReferenceSymbols.js";
-import { CustomReference } from "./CustomReference.js";
 import { ManyToOneReferenceImpl } from "./ManyToOneReference.js";
 import { ReactiveReferenceImpl } from "./ReactiveReference.js";
 import { OneToOneReferenceImpl } from "./OneToOneReference.js";
+import { CustomReference } from "./CustomReference.js";
 import { PolymorphicReferenceImpl } from "./PolymorphicReference.js";
 import "./index.js";
 import "../EntityManager.js";

package/build/relations/hasAsyncMethod.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_loadHints = require("../loadHints.cjs");
+const require_newEntity = require("../newEntity.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasAsyncMethod.ts
 const AsyncMethodM = Symbol();

package/build/relations/hasAsyncMethod.js

@@ -1,5 +1,5 @@
-import { lazyField } from "../newEntity.js";
 import { isLoaded } from "../loadHints.js";
+import { lazyField } from "../newEntity.js";
 import "../Entity.js";
 //#region src/relations/hasAsyncMethod.ts
 const AsyncMethodM = Symbol();

package/build/relations/hasManyDerived.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_loadHints = require("../loadHints.cjs");
 const require_newEntity = require("../newEntity.cjs");
 const require_relations_CustomCollection = require("./CustomCollection.cjs");
-const require_loadHints = require("../loadHints.cjs");
 require("../index.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasManyDerived.ts

package/build/relations/hasManyDerived.js

@@ -1,6 +1,6 @@
+import { isLoaded } from "../loadHints.js";
 import { lazyField } from "../newEntity.js";
 import { CustomCollection } from "./CustomCollection.js";
-import { isLoaded } from "../loadHints.js";
 import "../index.js";
 import "../Entity.js";
 //#region src/relations/hasManyDerived.ts

package/build/relations/hasOneDerived.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
-const require_relations_CustomReference = require("./CustomReference.cjs");
 require("./Reference.cjs");
 const require_loadHints = require("../loadHints.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_relations_CustomReference = require("./CustomReference.cjs");
 require("../index.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasOneDerived.ts

package/build/relations/hasOneDerived.js

@@ -1,7 +1,7 @@
-import { lazyField } from "../newEntity.js";
-import { CustomReference } from "./CustomReference.js";
 import "./Reference.js";
 import { isLoaded } from "../loadHints.js";
+import { lazyField } from "../newEntity.js";
+import { CustomReference } from "./CustomReference.js";
 import "../index.js";
 import "../Entity.js";
 //#region src/relations/hasOneDerived.ts

package/build/relations/hasProperty.cjs

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_newEntity = require("../newEntity.cjs");
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
 const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
-const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_reactiveHints = require("../reactiveHints.cjs");
 const require_loadHints = require("../loadHints.cjs");
 const require_utils = require("../utils.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
 require("../Entity.cjs");
 //#region src/relations/hasProperty.ts
 /**

package/build/relations/hasProperty.js

@@ -1,10 +1,10 @@
-import { lazyField } from "../newEntity.js";
 import { PropertyT } from "./PropertySymbols.js";
 import { RecursiveCycleError } from "./RecursiveCycleError.js";
-import { getMetadata } from "../EntityMetadata.js";
 import { convertToLoadHint } from "../reactiveHints.js";
 import { isLoaded } from "../loadHints.js";
 import { tryResolve } from "../utils.js";
+import { lazyField } from "../newEntity.js";
+import { getMetadata } from "../EntityMetadata.js";
 import "../Entity.js";
 //#region src/relations/hasProperty.ts
 /**

package/build/relations/index.cjs

@@ -1,34 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_relations_Collection = require("./Collection.cjs");
-const require_relations_CustomCollection = require("./CustomCollection.cjs");
 const require_relations_EnumCollection = require("./EnumCollection.cjs");
-const require_relations_CustomReference = require("./CustomReference.cjs");
-const require_relations_hasAsyncMethod = require("./hasAsyncMethod.cjs");
 const require_relations_RecursiveCycleError = require("./RecursiveCycleError.cjs");
 const require_relations_hasProperty = require("./hasProperty.cjs");
-const require_relations_AsyncProperty = require("./AsyncProperty.cjs");
 const require_relations_LazyField = require("./LazyField.cjs");
+const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
+const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
+const require_relations_Reference = require("./Reference.cjs");
+const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
+const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
+const require_relations_ReactiveGetter = require("./ReactiveGetter.cjs");
+const require_relations_Relation = require("./Relation.cjs");
+const require_relations_ReadOnlyCollection = require("./ReadOnlyCollection.cjs");
+const require_relations_RecursiveCollection = require("./RecursiveCollection.cjs");
+const require_relations_CustomCollection = require("./CustomCollection.cjs");
+const require_relations_CustomReference = require("./CustomReference.cjs");
+const require_relations_hasAsyncMethod = require("./hasAsyncMethod.cjs");
+const require_relations_AsyncProperty = require("./AsyncProperty.cjs");
 const require_relations_hasManyDerived = require("./hasManyDerived.cjs");
 const require_relations_hasManyThrough = require("./hasManyThrough.cjs");
-const require_relations_Reference = require("./Reference.cjs");
 const require_relations_hasOneDerived = require("./hasOneDerived.cjs");
 const require_relations_hasOneThrough = require("./hasOneThrough.cjs");
 const require_relations_ManyToManyCollection = require("./ManyToManyCollection.cjs");
-const require_relations_Relation = require("./Relation.cjs");
 const require_relations_ManyToManyLargeCollection = require("./ManyToManyLargeCollection.cjs");
-const require_relations_OneToManyCollection = require("./OneToManyCollection.cjs");
-const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
 const require_relations_OneToManyLargeCollection = require("./OneToManyLargeCollection.cjs");
-const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
-const require_relations_OneToOneReference = require("./OneToOneReference.cjs");
 const require_relations_PolymorphicReference = require("./PolymorphicReference.cjs");
 const require_relations_ReactiveField = require("./ReactiveField.cjs");
-const require_relations_ReactiveGetter = require("./ReactiveGetter.cjs");
 const require_relations_ReactiveManyToMany = require("./ReactiveManyToMany.cjs");
 const require_relations_ReactiveManyToManyOtherSide = require("./ReactiveManyToManyOtherSide.cjs");
 const require_relations_AsyncReactiveField = require("./AsyncReactiveField.cjs");
-const require_relations_RecursiveCollection = require("./RecursiveCollection.cjs");
-const require_relations_ReadOnlyCollection = require("./ReadOnlyCollection.cjs");
 exports.AsyncPropertyImpl = require_relations_AsyncProperty.AsyncPropertyImpl;
 exports.CustomCollection = require_relations_CustomCollection.CustomCollection;
 exports.CustomReference = require_relations_CustomReference.CustomReference;

package/build/relations/index.js

@@ -1,31 +1,31 @@
 import { isCollection, isLoadedCollection } from "./Collection.js";
-import { CustomCollection, hasCustomCollection } from "./CustomCollection.js";
 import { EnumCollectionImpl, hasEnumCollection } from "./EnumCollection.js";
-import { CustomReference, hasCustomReference } from "./CustomReference.js";
-import { hasAsyncMethod } from "./hasAsyncMethod.js";
 import { RecursiveCycleError } from "./RecursiveCycleError.js";
 import { PropertyImpl, hasProperty, hasReactiveProperty, isLoadedProperty, isProperty } from "./hasProperty.js";
-import { AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty } from "./AsyncProperty.js";
 import { LazyFieldImpl, hasLazyField, isLazyField, isLoadedLazyField } from "./LazyField.js";
+import { OneToManyCollection, hasMany } from "./OneToManyCollection.js";
+import { ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.js";
+import { isLoadedReference, isReference } from "./Reference.js";
+import { ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.js";
+import { OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
+import { hasReactiveGetter, isReactiveGetter } from "./ReactiveGetter.js";
+import { isRelation } from "./Relation.js";
+import { isLoadedReadOnlyCollection, isReadOnlyCollection } from "./ReadOnlyCollection.js";
+import { hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents } from "./RecursiveCollection.js";
+import { CustomCollection, hasCustomCollection } from "./CustomCollection.js";
+import { CustomReference, hasCustomReference } from "./CustomReference.js";
+import { hasAsyncMethod } from "./hasAsyncMethod.js";
+import { AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty } from "./AsyncProperty.js";
 import { hasManyDerived } from "./hasManyDerived.js";
 import { hasManyThrough } from "./hasManyThrough.js";
-import { isLoadedReference, isReference } from "./Reference.js";
 import { hasOneDerived } from "./hasOneDerived.js";
 import { hasOneThrough } from "./hasOneThrough.js";
 import { ManyToManyCollection, hasManyToMany } from "./ManyToManyCollection.js";
-import { isRelation } from "./Relation.js";
 import { ManyToManyLargeCollection, hasLargeManyToMany } from "./ManyToManyLargeCollection.js";
-import { OneToManyCollection, hasMany } from "./OneToManyCollection.js";
-import { ManyToOneReferenceImpl, hasOne, isManyToOneReference } from "./ManyToOneReference.js";
 import { OneToManyLargeCollection, hasLargeMany } from "./OneToManyLargeCollection.js";
-import { ReactiveReferenceImpl, hasReactiveReference, isReactiveReference } from "./ReactiveReference.js";
-import { OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference } from "./OneToOneReference.js";
 import { PolymorphicReferenceImpl, hasOnePolymorphic, isPolymorphicReference } from "./PolymorphicReference.js";
 import { hasReactiveField, isReactiveField } from "./ReactiveField.js";
-import { hasReactiveGetter, isReactiveGetter } from "./ReactiveGetter.js";
 import { ReactiveManyToManyImpl, hasReactiveManyToMany, isReactiveManyToMany } from "./ReactiveManyToMany.js";
 import { ReactiveManyToManyOtherSideImpl, hasReactiveManyToManyOtherSide, isReactiveManyToManyOtherSide } from "./ReactiveManyToManyOtherSide.js";
 import { hasAsyncReactiveField, isAsyncReactiveField } from "./AsyncReactiveField.js";
-import { hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents } from "./RecursiveCollection.js";
-import { isLoadedReadOnlyCollection, isReadOnlyCollection } from "./ReadOnlyCollection.js";
 export { AsyncPropertyImpl, CustomCollection, CustomReference, EnumCollectionImpl, LazyFieldImpl, ManyToManyCollection, ManyToManyLargeCollection, ManyToOneReferenceImpl, OneToManyCollection, OneToManyLargeCollection, OneToOneReferenceImpl, PolymorphicReferenceImpl, PropertyImpl, ReactiveManyToManyImpl, ReactiveManyToManyOtherSideImpl, ReactiveReferenceImpl, RecursiveCycleError, hasAsyncMethod, hasAsyncProperty, hasAsyncReactiveField, hasCustomCollection, hasCustomReference, hasEnumCollection, hasLargeMany, hasLargeManyToMany, hasLazyField, hasMany, hasManyDerived, hasManyThrough, hasManyToMany, hasOne, hasOneDerived, hasOnePolymorphic, hasOneThrough, hasOneToOne, hasProperty, hasReactiveField, hasReactiveGetter, hasReactiveManyToMany, hasReactiveManyToManyOtherSide, hasReactiveProperty, hasReactiveReference, hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents, isAsyncProperty, isAsyncReactiveField, isCollection, isLazyField, isLoadedAsyncProperty, isLoadedCollection, isLoadedLazyField, isLoadedOneToOneReference, isLoadedProperty, isLoadedReadOnlyCollection, isLoadedReference, isManyToOneReference, isOneToOneReference, isPolymorphicReference, isProperty, isReactiveField, isReactiveGetter, isReactiveManyToMany, isReactiveManyToManyOtherSide, isReactiveReference, isReadOnlyCollection, isReference, isRelation };

package/build/relations/isCascadeDelete.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+//#region src/relations/isCascadeDelete.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+function isCascadeDelete(relation, fieldName) {
+	return require_EntityMetadata.getBaseAndSelfMetas(require_EntityMetadata.getMetadata(relation.entity)).some((meta) => meta.config.__data.cascadeDeleteFields.includes(fieldName));
+}
+//#endregion
+exports.isCascadeDelete = isCascadeDelete;
+
+//# sourceMappingURL=isCascadeDelete.cjs.map

package/build/relations/isCascadeDelete.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.cjs","names":["getBaseAndSelfMetas","getMetadata"],"sources":["../../src/relations/isCascadeDelete.ts"],"sourcesContent":["import { getBaseAndSelfMetas, getMetadata } from \"../EntityMetadata.ts\";\nimport type { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\n\n// Keep metadata imports out of AbstractRelationImpl so query imports cannot evaluate a relation\n// subclass before its base class has initialized.\n/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */\nexport function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean {\n  return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) =>\n    meta.config.__data.cascadeDeleteFields.includes(fieldName as any),\n  );\n}\n"],"mappings":";;;;AAMA,SAAgB,gBAAgB,UAA0C,WAA4B;CACpG,OAAOA,uBAAAA,oBAAoBC,uBAAAA,YAAY,SAAS,MAAM,CAAC,CAAC,CAAC,MAAM,SAC7D,KAAK,OAAO,OAAO,oBAAoB,SAAS,SAAgB,CAClE;AACF"}

package/build/relations/isCascadeDelete.d.cts

@@ -0,0 +1,7 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
+//#region src/relations/isCascadeDelete.d.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+declare function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean;
+//#endregion
+export { isCascadeDelete };
+//# sourceMappingURL=isCascadeDelete.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.d.cts","names":[],"sources":["../../src/relations/isCascadeDelete.ts"],"mappings":";;;iBAMgB,gBAAgB,UAAU,gCAAgC"}

package/build/relations/isCascadeDelete.d.mts

@@ -0,0 +1,7 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
+//#region src/relations/isCascadeDelete.d.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+declare function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean;
+//#endregion
+export { isCascadeDelete };
+//# sourceMappingURL=isCascadeDelete.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.d.mts","names":[],"sources":["../../src/relations/isCascadeDelete.ts"],"mappings":";;;iBAMgB,gBAAgB,UAAU,gCAAgC"}

package/build/relations/isCascadeDelete.js

@@ -0,0 +1,10 @@
+import { getBaseAndSelfMetas, getMetadata } from "../EntityMetadata.js";
+//#region src/relations/isCascadeDelete.ts
+/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */
+function isCascadeDelete(relation, fieldName) {
+	return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) => meta.config.__data.cascadeDeleteFields.includes(fieldName));
+}
+//#endregion
+export { isCascadeDelete };
+
+//# sourceMappingURL=isCascadeDelete.js.map

package/build/relations/isCascadeDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCascadeDelete.js","names":[],"sources":["../../src/relations/isCascadeDelete.ts"],"sourcesContent":["import { getBaseAndSelfMetas, getMetadata } from \"../EntityMetadata.ts\";\nimport type { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\n\n// Keep metadata imports out of AbstractRelationImpl so query imports cannot evaluate a relation\n// subclass before its base class has initialized.\n/** Returns whether this relation is configured for cascade deletion on the entity or a base type. */\nexport function isCascadeDelete(relation: AbstractRelationImpl<any, any>, fieldName: string): boolean {\n  return getBaseAndSelfMetas(getMetadata(relation.entity)).some((meta) =>\n    meta.config.__data.cascadeDeleteFields.includes(fieldName as any),\n  );\n}\n"],"mappings":";;;AAMA,SAAgB,gBAAgB,UAA0C,WAA4B;CACpG,OAAO,oBAAoB,YAAY,SAAS,MAAM,CAAC,CAAC,CAAC,MAAM,SAC7D,KAAK,OAAO,OAAO,oBAAoB,SAAS,SAAgB,CAClE;AACF"}

package/build/resurrection.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_EntityMetadata = require("./EntityMetadata.cjs");
 const require_fields = require("./fields.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
 const require_EntityManager = require("./EntityManager.cjs");
 const require_Entity = require("./Entity.cjs");
 //#region src/resurrection.ts

package/build/resurrection.js

@@ -1,5 +1,5 @@
-import { getBaseMeta, getMetadata } from "./EntityMetadata.js";
 import { setField } from "./fields.js";
+import { getBaseMeta, getMetadata } from "./EntityMetadata.js";
 import { TooManyError } from "./EntityManager.js";
 import { isEntity } from "./Entity.js";
 //#region src/resurrection.ts

package/build/rules.cjs

@@ -1,12 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./typeMap.cjs");
-const require_relations_Reference = require("./relations/Reference.cjs");
-const require_relations_AsyncReactiveField = require("./relations/AsyncReactiveField.cjs");
-require("./relations/index.cjs");
 const require_fields = require("./fields.cjs");
+require("./typeMap.cjs");
 require("./changes.cjs");
+const require_relations_Reference = require("./relations/Reference.cjs");
 require("./reactiveHints.cjs");
 const require_utils = require("./utils.cjs");
+const require_relations_AsyncReactiveField = require("./relations/AsyncReactiveField.cjs");
+require("./relations/index.cjs");
 const require_EntityManager = require("./EntityManager.cjs");
 require("./Entity.cjs");
 //#region src/rules.ts

package/build/rules.js

@@ -1,11 +1,11 @@
-import "./typeMap.js";
-import { isLoadedReference } from "./relations/Reference.js";
-import { isAsyncReactiveField } from "./relations/AsyncReactiveField.js";
-import "./relations/index.js";
 import { getField } from "./fields.js";
+import "./typeMap.js";
 import "./changes.js";
+import { isLoadedReference } from "./relations/Reference.js";
 import "./reactiveHints.js";
 import { groupBy, maybePromiseThen } from "./utils.js";
+import { isAsyncReactiveField } from "./relations/AsyncReactiveField.js";
+import "./relations/index.js";
 import { getEmInternalApi } from "./EntityManager.js";
 import "./Entity.js";
 //#region src/rules.ts

package/build/serde.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_keys = require("./keys.cjs");
 const require_temporal = require("./temporal.cjs");
 const require_TypeInfo = require("./TypeInfo.cjs");
+const require_keys = require("./keys.cjs");
 const require_runtimeConfig = require("./runtimeConfig.cjs");
 const require_temporalMappers = require("./temporalMappers.cjs");
 require("./index.cjs");

package/build/serde.js

@@ -1,6 +1,6 @@
-import { keyToNumber, keyToTaggedId, maybeResolveReferenceToId } from "./keys.js";
 import { requireTemporal } from "./temporal.js";
 import { arrayOutputType, canonicalDbType } from "./TypeInfo.js";
+import { keyToNumber, keyToTaggedId, maybeResolveReferenceToId } from "./keys.js";
 import { getRuntimeConfig } from "./runtimeConfig.js";
 import { plainDateMapper, plainDateTimeMapper, plainTimeMapper, zonedDateTimeMapper } from "./temporalMappers.js";
 import "./index.js";

package/build/unnest.cjs

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./drivers/EntityWriter.cjs");
-require("./QueryParser.cjs");
 //#region src/unnest.ts
 /**
 * Creates a CTE named `alias` that bulk-injects the `columnValues` into a SQL query.

package/build/unnest.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"unnest.cjs","names":[],"sources":["../src/unnest.ts"],"sourcesContent":["import { type OpColumn } from \"./drivers/EntityWriter.ts\";\nimport { type ParsedCteClause } from \"./QueryParser.ts\";\n\n/**\n * Creates a CTE named `alias` that bulk-injects the `columnValues` into a SQL query.\n *\n * I.e. `columns = [first_name, last_name]` means columnValues would be all first names,\n * then all last names, i.e.`[[\"f1\",\"f2\"], [\"l1\",\"l2\"]]`.\n *\n * Note that `columnValues` will be mutated if any array columns need to be made rectangular.\n */\nexport function buildUnnestCte(alias: string, columns: OpColumn[], columnValues: any[][]): ParsedCteClause {\n  // Make any arrays-of-arrays rectangular by filling them with nulls\n  ensureRectangularArraySizes(columns, columnValues);\n  // Use unnest or unnest_arrays depending on whether the column is an array column\n  const selects = columns.map((c) => {\n    if (c.dbType.endsWith(\"[]\")) {\n      if (c.isNullableArray) {\n        return `unnest_arrays(?::${c.dbType}[], true)`;\n      } else {\n        return `unnest_arrays(?::${c.dbType}[])`;\n      }\n    } else {\n      return `unnest(?::${c.dbType}[])`;\n    }\n  });\n  return {\n    alias,\n    columns,\n    query: { kind: \"raw\", sql: `SELECT ${selects.join(\", \")}`, bindings: columnValues },\n  };\n}\n\nexport function ensureRectangularArraySizes(columns: OpColumn[], columnValues: any[][]): void {\n  for (let i = 0; i < columns.length; i++) {\n    const column = columns[i];\n    if (column.dbType.endsWith(\"[]\")) {\n      const values = columnValues[i];\n      const fillTo = findArrayMaxSize(values);\n      for (let j = 0; j < values.length; j++) {\n        values[j] = fillArrayWithNulls(column, values[j], fillTo);\n      }\n    }\n  }\n}\n\nfunction findArrayMaxSize(columnValues: readonly any[][]): number {\n  let max = 1; // postgres really doesn't like `{{}}` so always send at least 1 element\n  for (let i = 0; i < columnValues.length; i++) max = Math.max(max, columnValues[i]?.length ?? 0);\n  return max;\n}\n\n// Because postgres array-of-arrays must be rectangular, we fill all arrays up the same max size\n// to put on the wire, and then later strip the padded nulls during the unnest_arrays call.\nfunction fillArrayWithNulls(c: OpColumn, array: any[] | null, maxSize: number): any[] {\n  const wasNull = array === null;\n  const result = array ? [...array] : [];\n  const nullsToAdd = Math.max(0, maxSize - (array?.length ?? 0));\n  for (let i = 0; i < nullsToAdd; i++) result.push(null);\n  // Add our unset marker\n  if (c.isNullableArray) result.unshift(wasNull ? null : notNullMarker(c));\n  return result;\n}\n\nfunction notNullMarker(c: OpColumn): any {\n  // Should probably push this into an OpColumn.notNullMarker value\n  if (c.dbType.startsWith(\"varchar\") || c.dbType.startsWith(\"character\") || c.dbType.startsWith(\"text\")) {\n    return \"\";\n  } else if (c.dbType.startsWith(\"int\")) {\n    return 1;\n  } else if (c.dbType.startsWith(\"date\")) {\n    return new Date(); // maybe something temporal?\n  } else if (c.dbType.startsWith(\"timestamp\")) {\n    return new Date(); // maybe something temporal?\n  } else {\n    throw new Error(\"Unhandled nullable array column type \" + c.dbType);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,eAAe,OAAe,SAAqB,cAAwC;CAEzG,4BAA4B,SAAS,YAAY;CAajD,OAAO;EACL;EACA;EACA,OAAO;GAAE,MAAM;GAAO,KAAK,UAdb,QAAQ,KAAK,MAAM;IACjC,IAAI,EAAE,OAAO,SAAS,IAAI,GAAG;KAC3B,IAAI,EAAE,iBACJ,OAAO,oBAAoB,EAAE,OAAO;UAEpC,OAAO,oBAAoB,EAAE,OAAO;IAExC,OACE,OAAO,aAAa,EAAE,OAAO;GAEjC,CAI6C,CAAC,CAAC,KAAK,IAAI;GAAK,UAAU;EAAa;CACpF;AACF;AAEA,SAAgB,4BAA4B,SAAqB,cAA6B;CAC5F,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,SAAS,QAAQ;EACvB,IAAI,OAAO,OAAO,SAAS,IAAI,GAAG;GAChC,MAAM,SAAS,aAAa;GAC5B,MAAM,SAAS,iBAAiB,MAAM;GACtC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KACjC,OAAO,KAAK,mBAAmB,QAAQ,OAAO,IAAI,MAAM;EAE5D;CACF;AACF;AAEA,SAAS,iBAAiB,cAAwC;CAChE,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,KAAK,aAAa,EAAE,EAAE,UAAU,CAAC;CAC9F,OAAO;AACT;AAIA,SAAS,mBAAmB,GAAa,OAAqB,SAAwB;CACpF,MAAM,UAAU,UAAU;CAC1B,MAAM,SAAS,QAAQ,CAAC,GAAG,KAAK,IAAI,CAAC;CACrC,MAAM,aAAa,KAAK,IAAI,GAAG,WAAW,OAAO,UAAU,EAAE;CAC7D,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAAK,OAAO,KAAK,IAAI;CAErD,IAAI,EAAE,iBAAiB,OAAO,QAAQ,UAAU,OAAO,cAAc,CAAC,CAAC;CACvE,OAAO;AACT;AAEA,SAAS,cAAc,GAAkB;CAEvC,IAAI,EAAE,OAAO,WAAW,SAAS,KAAK,EAAE,OAAO,WAAW,WAAW,KAAK,EAAE,OAAO,WAAW,MAAM,GAClG,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,KAAK,GAClC,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,MAAM,GACnC,uBAAO,IAAI,KAAK;MACX,IAAI,EAAE,OAAO,WAAW,WAAW,GACxC,uBAAO,IAAI,KAAK;MAEhB,MAAM,IAAI,MAAM,0CAA0C,EAAE,MAAM;AAEtE"}
+{"version":3,"file":"unnest.cjs","names":[],"sources":["../src/unnest.ts"],"sourcesContent":["import { type OpColumn } from \"./drivers/EntityWriter.ts\";\nimport type { ParsedCteClause } from \"./queries/find/QueryParser.ts\";\n\n/**\n * Creates a CTE named `alias` that bulk-injects the `columnValues` into a SQL query.\n *\n * I.e. `columns = [first_name, last_name]` means columnValues would be all first names,\n * then all last names, i.e.`[[\"f1\",\"f2\"], [\"l1\",\"l2\"]]`.\n *\n * Note that `columnValues` will be mutated if any array columns need to be made rectangular.\n */\nexport function buildUnnestCte(alias: string, columns: OpColumn[], columnValues: any[][]): ParsedCteClause {\n  // Make any arrays-of-arrays rectangular by filling them with nulls\n  ensureRectangularArraySizes(columns, columnValues);\n  // Use unnest or unnest_arrays depending on whether the column is an array column\n  const selects = columns.map((c) => {\n    if (c.dbType.endsWith(\"[]\")) {\n      if (c.isNullableArray) {\n        return `unnest_arrays(?::${c.dbType}[], true)`;\n      } else {\n        return `unnest_arrays(?::${c.dbType}[])`;\n      }\n    } else {\n      return `unnest(?::${c.dbType}[])`;\n    }\n  });\n  return {\n    alias,\n    columns,\n    query: { kind: \"raw\", sql: `SELECT ${selects.join(\", \")}`, bindings: columnValues },\n  };\n}\n\nexport function ensureRectangularArraySizes(columns: OpColumn[], columnValues: any[][]): void {\n  for (let i = 0; i < columns.length; i++) {\n    const column = columns[i];\n    if (column.dbType.endsWith(\"[]\")) {\n      const values = columnValues[i];\n      const fillTo = findArrayMaxSize(values);\n      for (let j = 0; j < values.length; j++) {\n        values[j] = fillArrayWithNulls(column, values[j], fillTo);\n      }\n    }\n  }\n}\n\nfunction findArrayMaxSize(columnValues: readonly any[][]): number {\n  let max = 1; // postgres really doesn't like `{{}}` so always send at least 1 element\n  for (let i = 0; i < columnValues.length; i++) max = Math.max(max, columnValues[i]?.length ?? 0);\n  return max;\n}\n\n// Because postgres array-of-arrays must be rectangular, we fill all arrays up the same max size\n// to put on the wire, and then later strip the padded nulls during the unnest_arrays call.\nfunction fillArrayWithNulls(c: OpColumn, array: any[] | null, maxSize: number): any[] {\n  const wasNull = array === null;\n  const result = array ? [...array] : [];\n  const nullsToAdd = Math.max(0, maxSize - (array?.length ?? 0));\n  for (let i = 0; i < nullsToAdd; i++) result.push(null);\n  // Add our unset marker\n  if (c.isNullableArray) result.unshift(wasNull ? null : notNullMarker(c));\n  return result;\n}\n\nfunction notNullMarker(c: OpColumn): any {\n  // Should probably push this into an OpColumn.notNullMarker value\n  if (c.dbType.startsWith(\"varchar\") || c.dbType.startsWith(\"character\") || c.dbType.startsWith(\"text\")) {\n    return \"\";\n  } else if (c.dbType.startsWith(\"int\")) {\n    return 1;\n  } else if (c.dbType.startsWith(\"date\")) {\n    return new Date(); // maybe something temporal?\n  } else if (c.dbType.startsWith(\"timestamp\")) {\n    return new Date(); // maybe something temporal?\n  } else {\n    throw new Error(\"Unhandled nullable array column type \" + c.dbType);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,eAAe,OAAe,SAAqB,cAAwC;CAEzG,4BAA4B,SAAS,YAAY;CAajD,OAAO;EACL;EACA;EACA,OAAO;GAAE,MAAM;GAAO,KAAK,UAdb,QAAQ,KAAK,MAAM;IACjC,IAAI,EAAE,OAAO,SAAS,IAAI,GAAG;KAC3B,IAAI,EAAE,iBACJ,OAAO,oBAAoB,EAAE,OAAO;UAEpC,OAAO,oBAAoB,EAAE,OAAO;IAExC,OACE,OAAO,aAAa,EAAE,OAAO;GAEjC,CAI6C,CAAC,CAAC,KAAK,IAAI;GAAK,UAAU;EAAa;CACpF;AACF;AAEA,SAAgB,4BAA4B,SAAqB,cAA6B;CAC5F,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,SAAS,QAAQ;EACvB,IAAI,OAAO,OAAO,SAAS,IAAI,GAAG;GAChC,MAAM,SAAS,aAAa;GAC5B,MAAM,SAAS,iBAAiB,MAAM;GACtC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KACjC,OAAO,KAAK,mBAAmB,QAAQ,OAAO,IAAI,MAAM;EAE5D;CACF;AACF;AAEA,SAAS,iBAAiB,cAAwC;CAChE,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,KAAK,aAAa,EAAE,EAAE,UAAU,CAAC;CAC9F,OAAO;AACT;AAIA,SAAS,mBAAmB,GAAa,OAAqB,SAAwB;CACpF,MAAM,UAAU,UAAU;CAC1B,MAAM,SAAS,QAAQ,CAAC,GAAG,KAAK,IAAI,CAAC;CACrC,MAAM,aAAa,KAAK,IAAI,GAAG,WAAW,OAAO,UAAU,EAAE;CAC7D,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAAK,OAAO,KAAK,IAAI;CAErD,IAAI,EAAE,iBAAiB,OAAO,QAAQ,UAAU,OAAO,cAAc,CAAC,CAAC;CACvE,OAAO;AACT;AAEA,SAAS,cAAc,GAAkB;CAEvC,IAAI,EAAE,OAAO,WAAW,SAAS,KAAK,EAAE,OAAO,WAAW,WAAW,KAAK,EAAE,OAAO,WAAW,MAAM,GAClG,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,KAAK,GAClC,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,MAAM,GACnC,uBAAO,IAAI,KAAK;MACX,IAAI,EAAE,OAAO,WAAW,WAAW,GACxC,uBAAO,IAAI,KAAK;MAEhB,MAAM,IAAI,MAAM,0CAA0C,EAAE,MAAM;AAEtE"}