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

package/build/relations/Collection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"Collection.cjs","names":["OneToManyCollection","ManyToManyCollection","ReactiveManyToManyImpl","ReactiveManyToManyOtherSideImpl","CustomCollection"],"sources":["../../src/relations/Collection.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf } from \"../EntityManager.ts\";\nimport {\n  CustomCollection,\n  ManyToManyCollection,\n  OneToManyCollection,\n  ReactiveManyToManyImpl,\n  ReactiveManyToManyOtherSideImpl,\n  type Relation,\n} from \"./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"}
+{"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.js

@@ -1,6 +1,6 @@
-import { OneToManyCollection } from "./OneToManyCollection.js";
 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";

package/build/relations/Collection.js.map

@@ -1 +1 @@
-{"version":3,"file":"Collection.js","names":[],"sources":["../../src/relations/Collection.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf } from \"../EntityManager.ts\";\nimport {\n  CustomCollection,\n  ManyToManyCollection,\n  OneToManyCollection,\n  ReactiveManyToManyImpl,\n  ReactiveManyToManyOtherSideImpl,\n  type Relation,\n} from \"./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"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"CustomCollection.cjs","names":["lazyField","AbstractRelationImpl","#isLoaded","#loadHint","#hasBeenSet","RelationT","RelationU"],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { RelationT, RelationU } from \"./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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"}
+{"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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"}

package/build/relations/CustomCollection.d.cts

@@ -1,7 +1,7 @@
 import { Collection } from "./Collection.cjs";
 import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
 import { RelationT, RelationU } from "./RelationSymbols.cjs";
-import { LoadHint } from "../loadHints.cjs";
+import { LoadHint } from "../loading/loadHints.cjs";
 import "../index.cjs";
 import { IdOf } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";

package/build/relations/CustomCollection.d.mts

@@ -1,7 +1,7 @@
 import { Collection } from "./Collection.mjs";
 import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
 import { RelationT, RelationU } from "./RelationSymbols.mjs";
-import { LoadHint } from "../loadHints.mjs";
+import { LoadHint } from "../loading/loadHints.mjs";
 import "../index.mjs";
 import { IdOf } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";

package/build/relations/CustomCollection.js.map

@@ -1 +1 @@
-{"version":3,"file":"CustomCollection.js","names":["#isLoaded","#loadHint","#hasBeenSet"],"sources":["../../src/relations/CustomCollection.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type Collection, type LoadHint, ensureNotDeleted, fail } from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { RelationT, RelationU } from \"./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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"}
+{"version":3,"file":"CustomCollection.js","names":["#isLoaded","#loadHint","#hasBeenSet"],"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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"}

package/build/relations/CustomReference.cjs

@@ -3,8 +3,8 @@ const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.c
 const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
 const require_relations_ReferenceSymbols = require("./ReferenceSymbols.cjs");
 const require_utils = require("../utils.cjs");
-const require_getProperties = require("../getProperties.cjs");
 const require_newEntity = require("../newEntity.cjs");
+const require_getProperties = require("../getProperties.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 const require_index = require("../index.cjs");
 const require_EntityManager = require("../EntityManager.cjs");

package/build/relations/CustomReference.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"CustomReference.cjs","names":["lazyField","AbstractRelationImpl","#isLoaded","#loadHint","fail","#hasBeenSet","getProperties","getMetadata","RelationT","RelationU","ReferenceN"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"./ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\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<unknown>;\n  get: (entity: T) => U | N;\n  set?: (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 reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references 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 `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\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<U | N> {\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  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\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 CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\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  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"CustomReference.cjs","names":["lazyField","AbstractRelationImpl","#isLoaded","#loadHint","fail","#hasBeenSet","getProperties","getMetadata","RelationT","RelationU","ReferenceN"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\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<unknown>;\n  get: (entity: T) => U | N;\n  set?: (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 reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references 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 `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\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<U | N> {\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  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\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 CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\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  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}

package/build/relations/CustomReference.d.cts

@@ -2,7 +2,7 @@ import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
 import { RelationT, RelationU } from "./RelationSymbols.cjs";
 import { ReferenceN } from "./ReferenceSymbols.cjs";
 import { Reference } from "./Reference.cjs";
-import { LoadHint } from "../loadHints.cjs";
+import { LoadHint } from "../loading/loadHints.cjs";
 import "../index.cjs";
 import { IdOf, TaggedId } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";

package/build/relations/CustomReference.d.mts

@@ -2,7 +2,7 @@ import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
 import { RelationT, RelationU } from "./RelationSymbols.mjs";
 import { ReferenceN } from "./ReferenceSymbols.mjs";
 import { Reference } from "./Reference.mjs";
-import { LoadHint } from "../loadHints.mjs";
+import { LoadHint } from "../loading/loadHints.mjs";
 import "../index.mjs";
 import { IdOf, TaggedId } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";

package/build/relations/CustomReference.js

@@ -2,8 +2,8 @@ import { AbstractRelationImpl } from "./AbstractRelationImpl.js";
 import { RelationT, RelationU } from "./RelationSymbols.js";
 import { ReferenceN } from "./ReferenceSymbols.js";
 import { fail } from "../utils.js";
-import { getProperties } from "../getProperties.js";
 import { lazyField } from "../newEntity.js";
+import { getProperties } from "../getProperties.js";
 import { getMetadata } from "../EntityMetadata.js";
 import { ensureNotDeleted } from "../index.js";
 import { getEmInternalApi } from "../EntityManager.js";

package/build/relations/CustomReference.js.map

@@ -1 +1 @@
-{"version":3,"file":"CustomReference.js","names":["#isLoaded","#loadHint","#hasBeenSet"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"../Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"../EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"../index.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"./ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\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<unknown>;\n  get: (entity: T) => U | N;\n  set?: (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 reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references 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 `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\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<U | N> {\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  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\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 CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\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  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"CustomReference.js","names":["#isLoaded","#loadHint","#hasBeenSet"],"sources":["../../src/relations/CustomReference.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type IdOf, type TaggedId, getEmInternalApi } from \"src/EntityManager.ts\";\nimport { type LoadHint, type Reference, ensureNotDeleted, fail, getMetadata, getProperties } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\n/** An alias for creating `CustomReference`s. */\nexport function hasCustomReference<T extends Entity, U extends Entity, N extends never | undefined>(\n  opts: CustomReferenceOpts<T, U, N>,\n): CustomReference<T, U, N> {\n  return lazyField((entity: T) => {\n    return new CustomReference<T, U, N>(entity, opts);\n  });\n}\n\nexport type CustomReferenceOpts<T extends Entity, U extends Entity, N extends never | undefined> = {\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<unknown>;\n  get: (entity: T) => U | N;\n  set?: (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 reference.  Currently\n   * only used by em.importEntity and can be omitted if the reference isn't used with it.\n   */\n  loadHint?: ((entity: T) => LoadHint<T>) | LoadHint<T>;\n};\n\n/**\n * Allows user-defined references 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 `CustomReference` API is fairly low-level; users should more likely prefer higher-level\n * abstractions like `hasOneThrough`, which are built on `CustomReference.\n */\nexport class CustomReference<T extends Entity, U extends Entity, N extends never | undefined>\n  extends AbstractRelationImpl<T, U>\n  implements Reference<T, U, N>\n{\n  // We keep both a promise+loaded flag and not an actual `this.loaded = await load` because\n  // the value can become stale; we want to each `.get` call to repeatedly evaluate the latest value.\n  private loadPromise: Promise<unknown> | undefined;\n  #hasBeenSet = false;\n  #isLoaded: boolean | undefined;\n  #loadHint: LoadHint<T> | undefined;\n\n  constructor(\n    entity: T,\n    private opts: CustomReferenceOpts<T, U, N>,\n  ) {\n    super(entity);\n  }\n\n  get get(): U | N {\n    return this.doGet({ withDeleted: false });\n  }\n\n  get getWithDeleted(): U | N {\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<U | N> {\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  get id(): IdOf<U> {\n    return fail(`CustomReference cannot resolve 'id'`);\n  }\n\n  get idMaybe(): IdOf<U> | undefined {\n    return fail(`CustomReference cannot resolve 'idMaybe'`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    return fail(`CustomReference cannot resolve 'idTaggedMaybe'`);\n  }\n\n  get idUntagged(): string {\n    return fail(`CustomReference cannot resolve 'idUntagged'`);\n  }\n\n  get idUntaggedMaybe(): string | undefined {\n    return fail(`CustomReference cannot resolve 'idUntaggedMaybe'`);\n  }\n\n  get isSet(): boolean {\n    this.ensureNewOrLoaded();\n    const { get } = this.opts;\n    return get(this.entity) !== undefined;\n  }\n\n  set(value: U): void {\n    // We allow setting CustomReferences on new entities w/o being loaded\n    if (!this.entity.isNewEntity) {\n      this.ensureNewOrLoaded();\n    }\n    const { set } = this.opts;\n    if (set === undefined) {\n      throw new Error(`'set' not implemented on ${this}`);\n    }\n    set(this.entity, value);\n    this.#hasBeenSet = true;\n  }\n\n  setFromOpts(value: U): void {\n    this.set(value);\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 CustomReferences field name by looking in the entity for the key that we're assigned to. */\n  get fieldName(): string {\n    return Object.entries(getProperties(getMetadata(this.entity))).filter(\n      ([key]) => (this.entity as any)[key] === this,\n    )[0][0];\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `CustomReference(entity: ${this.entity}, fieldName: ${this.fieldName})`;\n  }\n\n  private doGet(opts?: { withDeleted?: boolean }): U | N {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.ensureNewOrLoaded();\n    return this.filterDeleted(this.opts.get(this.entity), opts);\n  }\n\n  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);\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  [ReferenceN]: N = null!;\n}\n"],"mappings":"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"}

package/build/relations/EnumCollection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"EnumCollection.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","#loaded","getInstanceData","#getPreloaded","#loadPromise","enumCollectionBatchLoader","appendStack","#pendingSet","#applySet","#joinRows","#idOf","#hasBeenSet","#codesFor","getEmInternalApi","getMetadataForField","RelationT","RelationU"],"sources":["../../src/relations/EnumCollection.ts"],"sourcesContent":["import {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyEnumField,\n  type ManyToManyLike,\n  appendStack,\n  ensureNotDeleted,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n} from \"..//index.ts\";\nimport { enumCollectionBatchLoader } from \"../batchloaders/enumCollectionBatchLoader.ts\";\nimport { type EnumMetadata } from \"../EnumMetadata.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { remove } from \"../utils.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */\ndeclare const enumCollectionTag: unique symbol;\n\n/**\n * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum \"table\".\n *\n * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array\n * column it is lazy and so needs a load hint, like any other relation.\n */\nexport interface EnumCollection<T extends Entity, E> {\n  [enumCollectionTag]: true;\n  [RelationT]: T;\n  [RelationU]: E;\n\n  load(opts?: { forceReload?: boolean }): Promise<ReadonlyArray<E>>;\n\n  add(code: E): void;\n\n  remove(code: E): void;\n\n  /**\n   * Sets the collection to `codes`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(codes: readonly E[]): void;\n\n  includes(code: E): Promise<boolean>;\n\n  readonly isLoaded: boolean;\n  readonly entity: Entity;\n  readonly hasBeenSet: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {\n  get: ReadonlyArray<E>;\n\n  removeAll(): void;\n}\n\n/** An alias for creating `EnumCollection`s. */\nexport function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as ManyToManyEnumField;\n    return new EnumCollectionImpl<T, E>(entity, field);\n  });\n}\n\nexport class EnumCollectionImpl<T extends Entity, E>\n  extends AbstractRelationImpl<T, E[]>\n  implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike\n{\n  readonly #field: ManyToManyEnumField;\n  #loaded: boolean;\n  #loadPromise: any;\n  #hasBeenSet = false;\n  /** Holds a pending `set()` when called on an unloaded collection, resolved at load. */\n  #pendingSet: E[] | undefined;\n\n  constructor(entity: T, field: ManyToManyEnumField) {\n    super(entity);\n    this.#field = field;\n    this.#loaded = getInstanceData(entity).isOrWasNew;\n  }\n\n  async load(opts: { forceReload?: boolean } = {}): Promise<ReadonlyArray<E>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded || (opts.forceReload && !this.entity.isNewEntity)) {\n      if (this.#getPreloaded() !== undefined) {\n        this.#loaded = true;\n      } else {\n        await (this.#loadPromise ??= enumCollectionBatchLoader(this.entity.em, this).load(this.entity.idTagged!))\n          .then(() => {\n            this.#loaded = true;\n          })\n          .catch(function load(err: any) {\n            throw appendStack(err, new Error());\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          });\n      }\n      if (this.#pendingSet) {\n        const pending = this.#pendingSet;\n        this.#pendingSet = undefined;\n        this.#applySet(pending);\n      }\n    }\n    return this.get;\n  }\n\n  add(code: E): void {\n    ensureNotDeleted(this.entity);\n    if (this.#pendingSet) {\n      if (!this.#pendingSet.includes(code)) this.#pendingSet.push(code);\n      return;\n    }\n    if (this.#loaded && this.get.includes(code)) return;\n    this.#joinRows.addNew(this, this.entity, this.#idOf(code));\n  }\n\n  remove(code: E): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) {\n      remove(this.#pendingSet, code);\n      return;\n    }\n    this.#joinRows.addRemove(this, this.entity, this.#idOf(code));\n  }\n\n  set(codes: readonly E[]): void {\n    ensureNotDeleted(this.entity);\n    this.#hasBeenSet = true;\n    if (!this.#loaded) {\n      this.#pendingSet = [...codes];\n      getEmInternalApi(this.entity.em).pendingLoads.add(this as any);\n      return;\n    }\n    this.#applySet(codes);\n  }\n\n  async includes(code: E): Promise<boolean> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) return this.#pendingSet.includes(code);\n    if (this.#loaded) return this.get.includes(code);\n    if (this.entity.isNewEntity) return false;\n    await this.load();\n    return this.get.includes(code);\n  }\n\n  removeAll(): void {\n    ensureNotDeleted(this.entity);\n    if (!this.#loaded) throw new Error(\"removeAll was called when not loaded\");\n    for (const code of [...this.get]) this.remove(code);\n  }\n\n  get get(): E[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded) {\n      throw new Error(`${this.entity}.${this.fieldName}.get was called when not loaded`);\n    }\n    return this.#codesFor(this.entity);\n  }\n\n  get isLoaded(): boolean {\n    return this.#loaded;\n  }\n\n  get isPreloaded(): boolean {\n    return this.#getPreloaded() !== undefined;\n  }\n\n  preload(): void {\n    if (this.#getPreloaded() !== undefined) this.#loaded = true;\n  }\n\n  setFromOpts(codes: E[]): void {\n    this.#loaded = true;\n    for (const code of codes ?? []) this.add(code);\n  }\n\n  /**\n   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.\n   *\n   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not\n   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.\n   */\n  import(other: EnumCollectionImpl<T, E>): void {\n    if (!other.isLoaded) return;\n    this.#loaded = true;\n    for (const code of other.get) {\n      this.#joinRows.addPreloadedRow(this, undefined, this.entity, this.#idOf(code));\n    }\n  }\n\n  maybeCascadeDelete(): void {\n    // The join table FK cascades on the db side, so there's nothing to cascade in memory.\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // The db cascade-deletes our join rows, so just drop any pending in-memory changes for us.\n    this.#joinRows.removeAllFor(this.columnName, this.entity);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `EnumCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, enum: ${this.#field.enumDetailType.name})`;\n  }\n\n  #applySet(codes: readonly E[]): void {\n    const current = this.get;\n    for (const code of current) if (!codes.includes(code)) this.remove(code);\n    for (const code of codes) if (!current.includes(code)) this.add(code);\n  }\n\n  /** The current (non-deleted) codes for `entity`, sorted by enum id for a stable order. */\n  #codesFor(entity: Entity): E[] {\n    return (this.#joinRows.getOthers(this.columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((id) => this.#field.enumDetailType.findById(id)!.code as E);\n  }\n\n  #idOf(code: E): number {\n    return this.#field.enumDetailType.getByCode(code).id;\n  }\n\n  #getPreloaded(): E[] | undefined {\n    if (this.entity.isNewEntity) return undefined;\n    return getEmInternalApi(this.entity.em).getPreloadedRelation<E>(this.entity.idTagged, this.fieldName);\n  }\n\n  get #joinRows() {\n    return getEmInternalApi(this.entity.em).joinRows(this);\n  }\n\n  // The `ManyToManyLike` surface, so JoinRows/batch loaders can use us directly. There is no\n  // `otherMeta`/`otherFieldName` because the \"other\" side is an enum table, not an entity.\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.#field.fieldName);\n  }\n\n  get otherEnum(): EnumMetadata<any, any, number> {\n    return this.#field.enumDetailType;\n  }\n\n  get otherMeta(): undefined {\n    return undefined;\n  }\n\n  get otherFieldName(): undefined {\n    return undefined;\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  declare [enumCollectionTag]: true;\n  [RelationT]: T = null!;\n  [RelationU]: E = null!;\n}\n"],"mappings":";;;;;;;;;;;;AA6DA,SAAgB,oBAA+D;CAC7E,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,MAAM,QAAQC,uBAAAA,YAAY,MAAM,CAAC,CAAC,UAAU;EAC5C,OAAO,IAAI,mBAAyB,QAAQ,KAAK;CACnD,CAAC;AACH;AAEA,IAAa,qBAAb,cACUC,uCAAAA,qBAEV;CACE;CACA;CACA;CACA,cAAc;;CAEd;CAEA,YAAY,QAAW,OAA4B;EACjD,MAAM,MAAM;EACZ,KAAKC,SAAS;EACd,KAAKC,UAAUC,mBAAAA,gBAAgB,MAAM,CAAC,CAAC;CACzC;CAEA,MAAM,KAAK,OAAkC,CAAC,GAA8B;EAC1E,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAKD,WAAY,KAAK,eAAe,CAAC,KAAK,OAAO,aAAc;GACnE,IAAI,KAAKE,cAAc,MAAM,KAAA,GAC3B,KAAKF,UAAU;QAEf,OAAO,KAAKG,iBAAiBC,+CAAAA,0BAA0B,KAAK,OAAO,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,QAAS,EAAA,CACpG,WAAW;IACV,KAAKJ,UAAU;GACjB,CAAC,CAAC,CACD,MAAM,SAAS,KAAK,KAAU;IAC7B,MAAMK,sBAAAA,YAAY,qBAAK,IAAI,MAAM,CAAC;GACpC,CAAC,CAAC,CACD,cAAc;IACb,KAAKF,eAAe,KAAA;GACtB,CAAC;GAEL,IAAI,KAAKG,aAAa;IACpB,MAAM,UAAU,KAAKA;IACrB,KAAKA,cAAc,KAAA;IACnB,KAAKC,UAAU,OAAO;GACxB;EACF;EACA,OAAO,KAAK;CACd;CAEA,IAAI,MAAe;EACjB,cAAA,iBAAiB,KAAK,MAAM;EAC5B,IAAI,KAAKD,aAAa;GACpB,IAAI,CAAC,KAAKA,YAAY,SAAS,IAAI,GAAG,KAAKA,YAAY,KAAK,IAAI;GAChE;EACF;EACA,IAAI,KAAKN,WAAW,KAAK,IAAI,SAAS,IAAI,GAAG;EAC7C,KAAKQ,UAAU,OAAO,MAAM,KAAK,QAAQ,KAAKC,MAAM,IAAI,CAAC;CAC3D;CAEA,OAAO,MAAe;EACpB,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,KAAKH,aAAa;GACpB,cAAA,OAAO,KAAKA,aAAa,IAAI;GAC7B;EACF;EACA,KAAKE,UAAU,UAAU,MAAM,KAAK,QAAQ,KAAKC,MAAM,IAAI,CAAC;CAC9D;CAEA,IAAI,OAA2B;EAC7B,cAAA,iBAAiB,KAAK,MAAM;EAC5B,KAAKC,cAAc;EACnB,IAAI,CAAC,KAAKV,SAAS;GACjB,KAAKM,cAAc,CAAC,GAAG,KAAK;GAC5B,sBAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,aAAa,IAAI,IAAW;GAC7D;EACF;EACA,KAAKC,UAAU,KAAK;CACtB;CAEA,MAAM,SAAS,MAA2B;EACxC,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,KAAKD,aAAa,OAAO,KAAKA,YAAY,SAAS,IAAI;EAC3D,IAAI,KAAKN,SAAS,OAAO,KAAK,IAAI,SAAS,IAAI;EAC/C,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,MAAM,KAAK,KAAK;EAChB,OAAO,KAAK,IAAI,SAAS,IAAI;CAC/B;CAEA,YAAkB;EAChB,cAAA,iBAAiB,KAAK,MAAM;EAC5B,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,sCAAsC;EACzE,KAAK,MAAM,QAAQ,CAAC,GAAG,KAAK,GAAG,GAAG,KAAK,OAAO,IAAI;CACpD;CAEA,IAAI,MAAW;EACb,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAKA,SACR,MAAM,IAAI,MAAM,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gCAAgC;EAEnF,OAAO,KAAKW,UAAU,KAAK,MAAM;CACnC;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAKX;CACd;CAEA,IAAI,cAAuB;EACzB,OAAO,KAAKE,cAAc,MAAM,KAAA;CAClC;CAEA,UAAgB;EACd,IAAI,KAAKA,cAAc,MAAM,KAAA,GAAW,KAAKF,UAAU;CACzD;CAEA,YAAY,OAAkB;EAC5B,KAAKA,UAAU;EACf,KAAK,MAAM,QAAQ,SAAS,CAAC,GAAG,KAAK,IAAI,IAAI;CAC/C;;;;;;;CAQA,OAAO,OAAuC;EAC5C,IAAI,CAAC,MAAM,UAAU;EACrB,KAAKA,UAAU;EACf,KAAK,MAAM,QAAQ,MAAM,KACvB,KAAKQ,UAAU,gBAAgB,MAAM,KAAA,GAAW,KAAK,QAAQ,KAAKC,MAAM,IAAI,CAAC;CAEjF;CAEA,qBAA2B,CAE3B;CAEA,MAAM,yBAAwC;EAE5C,KAAKD,UAAU,aAAa,KAAK,YAAY,KAAK,MAAM;CAC1D;CAEA,IAAI,YAAoB;EACtB,OAAO,KAAKT,OAAO;CACrB;CAEA,IAAI,aAAsB;EACxB,OAAO,KAAKW;CACd;CAEA,WAAmB;EACjB,OAAO,0BAA0B,KAAK,OAAO,eAAe,KAAK,UAAU,UAAU,KAAKX,OAAO,eAAe,KAAK;CACvH;CAEA,UAAU,OAA2B;EACnC,MAAM,UAAU,KAAK;EACrB,KAAK,MAAM,QAAQ,SAAS,IAAI,CAAC,MAAM,SAAS,IAAI,GAAG,KAAK,OAAO,IAAI;EACvE,KAAK,MAAM,QAAQ,OAAO,IAAI,CAAC,QAAQ,SAAS,IAAI,GAAG,KAAK,IAAI,IAAI;CACtE;;CAGA,UAAU,QAAqB;EAC7B,OAAQ,KAAKS,UAAU,UAAU,KAAK,YAAY,MAAM,CAAC,CACtD,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,CACrB,KAAK,OAAO,KAAKT,OAAO,eAAe,SAAS,EAAE,CAAC,CAAE,IAAS;CACnE;CAEA,MAAM,MAAiB;EACrB,OAAO,KAAKA,OAAO,eAAe,UAAU,IAAI,CAAC,CAAC;CACpD;CAEA,gBAAiC;EAC/B,IAAI,KAAK,OAAO,aAAa,OAAO,KAAA;EACpC,OAAOa,sBAAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,qBAAwB,KAAK,OAAO,UAAU,KAAK,SAAS;CACtG;CAEA,IAAIJ,YAAY;EACd,OAAOI,sBAAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,SAAS,IAAI;CACvD;CAKA,IAAI,gBAAwB;EAC1B,OAAO,KAAKb,OAAO;CACrB;CAEA,IAAI,aAAqB;EACvB,OAAO,KAAKA,OAAO,YAAY;CACjC;CAEA,IAAI,kBAA0B;EAC5B,OAAO,KAAKA,OAAO,YAAY;CACjC;CAEA,IAAI,OAAuB;EACzB,OAAOc,uBAAAA,oBAAoBhB,uBAAAA,YAAY,KAAK,MAAM,GAAG,KAAKE,OAAO,SAAS;CAC5E;CAEA,IAAI,YAA4C;EAC9C,OAAO,KAAKA,OAAO;CACrB;CAEA,IAAI,YAAuB,CAE3B;CAEA,IAAI,iBAA4B,CAEhC;CAEA,IAAI,iBAA0B;EAC5B,OAAO,KAAKA,OAAO;CACrB;CAGA,CAACe,kCAAAA,aAAgB;CACjB,CAACC,kCAAAA,aAAgB;AACnB"}
+{"version":3,"file":"EnumCollection.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","#loaded","getInstanceData","#getPreloaded","#loadPromise","enumCollectionBatchLoader","appendStack","#pendingSet","#applySet","#joinRows","#idOf","#hasBeenSet","#codesFor","getEmInternalApi","getMetadataForField","RelationT","RelationU"],"sources":["../../src/relations/EnumCollection.ts"],"sourcesContent":["import { enumCollectionBatchLoader } from \"src/batchloaders/enumCollectionBatchLoader.ts\";\nimport { type EnumMetadata } from \"src/EnumMetadata.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyEnumField,\n  type ManyToManyLike,\n  appendStack,\n  ensureNotDeleted,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n} 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\";\nimport { remove } from \"src/utils.ts\";\n\n/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */\ndeclare const enumCollectionTag: unique symbol;\n\n/**\n * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum \"table\".\n *\n * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array\n * column it is lazy and so needs a load hint, like any other relation.\n */\nexport interface EnumCollection<T extends Entity, E> {\n  [enumCollectionTag]: true;\n  [RelationT]: T;\n  [RelationU]: E;\n\n  load(opts?: { forceReload?: boolean }): Promise<ReadonlyArray<E>>;\n\n  add(code: E): void;\n\n  remove(code: E): void;\n\n  /**\n   * Sets the collection to `codes`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(codes: readonly E[]): void;\n\n  includes(code: E): Promise<boolean>;\n\n  readonly isLoaded: boolean;\n  readonly entity: Entity;\n  readonly hasBeenSet: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {\n  get: ReadonlyArray<E>;\n\n  removeAll(): void;\n}\n\n/** An alias for creating `EnumCollection`s. */\nexport function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as ManyToManyEnumField;\n    return new EnumCollectionImpl<T, E>(entity, field);\n  });\n}\n\nexport class EnumCollectionImpl<T extends Entity, E>\n  extends AbstractRelationImpl<T, E[]>\n  implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike\n{\n  readonly #field: ManyToManyEnumField;\n  #loaded: boolean;\n  #loadPromise: any;\n  #hasBeenSet = false;\n  /** Holds a pending `set()` when called on an unloaded collection, resolved at load. */\n  #pendingSet: E[] | undefined;\n\n  constructor(entity: T, field: ManyToManyEnumField) {\n    super(entity);\n    this.#field = field;\n    this.#loaded = getInstanceData(entity).isOrWasNew;\n  }\n\n  async load(opts: { forceReload?: boolean } = {}): Promise<ReadonlyArray<E>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded || (opts.forceReload && !this.entity.isNewEntity)) {\n      if (this.#getPreloaded() !== undefined) {\n        this.#loaded = true;\n      } else {\n        await (this.#loadPromise ??= enumCollectionBatchLoader(this.entity.em, this).load(this.entity.idTagged!))\n          .then(() => {\n            this.#loaded = true;\n          })\n          .catch(function load(err: any) {\n            throw appendStack(err, new Error());\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          });\n      }\n      if (this.#pendingSet) {\n        const pending = this.#pendingSet;\n        this.#pendingSet = undefined;\n        this.#applySet(pending);\n      }\n    }\n    return this.get;\n  }\n\n  add(code: E): void {\n    ensureNotDeleted(this.entity);\n    if (this.#pendingSet) {\n      if (!this.#pendingSet.includes(code)) this.#pendingSet.push(code);\n      return;\n    }\n    if (this.#loaded && this.get.includes(code)) return;\n    this.#joinRows.addNew(this, this.entity, this.#idOf(code));\n  }\n\n  remove(code: E): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) {\n      remove(this.#pendingSet, code);\n      return;\n    }\n    this.#joinRows.addRemove(this, this.entity, this.#idOf(code));\n  }\n\n  set(codes: readonly E[]): void {\n    ensureNotDeleted(this.entity);\n    this.#hasBeenSet = true;\n    if (!this.#loaded) {\n      this.#pendingSet = [...codes];\n      getEmInternalApi(this.entity.em).pendingLoads.add(this as any);\n      return;\n    }\n    this.#applySet(codes);\n  }\n\n  async includes(code: E): Promise<boolean> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) return this.#pendingSet.includes(code);\n    if (this.#loaded) return this.get.includes(code);\n    if (this.entity.isNewEntity) return false;\n    await this.load();\n    return this.get.includes(code);\n  }\n\n  removeAll(): void {\n    ensureNotDeleted(this.entity);\n    if (!this.#loaded) throw new Error(\"removeAll was called when not loaded\");\n    for (const code of [...this.get]) this.remove(code);\n  }\n\n  get get(): E[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded) {\n      throw new Error(`${this.entity}.${this.fieldName}.get was called when not loaded`);\n    }\n    return this.#codesFor(this.entity);\n  }\n\n  get isLoaded(): boolean {\n    return this.#loaded;\n  }\n\n  get isPreloaded(): boolean {\n    return this.#getPreloaded() !== undefined;\n  }\n\n  preload(): void {\n    if (this.#getPreloaded() !== undefined) this.#loaded = true;\n  }\n\n  setFromOpts(codes: E[]): void {\n    this.#loaded = true;\n    for (const code of codes ?? []) this.add(code);\n  }\n\n  /**\n   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.\n   *\n   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not\n   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.\n   */\n  import(other: EnumCollectionImpl<T, E>): void {\n    if (!other.isLoaded) return;\n    this.#loaded = true;\n    for (const code of other.get) {\n      this.#joinRows.addPreloadedRow(this, undefined, this.entity, this.#idOf(code));\n    }\n  }\n\n  maybeCascadeDelete(): void {\n    // The join table FK cascades on the db side, so there's nothing to cascade in memory.\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // The db cascade-deletes our join rows, so just drop any pending in-memory changes for us.\n    this.#joinRows.removeAllFor(this.columnName, this.entity);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `EnumCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, enum: ${this.#field.enumDetailType.name})`;\n  }\n\n  #applySet(codes: readonly E[]): void {\n    const current = this.get;\n    for (const code of current) if (!codes.includes(code)) this.remove(code);\n    for (const code of codes) if (!current.includes(code)) this.add(code);\n  }\n\n  /** The current (non-deleted) codes for `entity`, sorted by enum id for a stable order. */\n  #codesFor(entity: Entity): E[] {\n    return (this.#joinRows.getOthers(this.columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((id) => this.#field.enumDetailType.findById(id)!.code as E);\n  }\n\n  #idOf(code: E): number {\n    return this.#field.enumDetailType.getByCode(code).id;\n  }\n\n  #getPreloaded(): E[] | undefined {\n    if (this.entity.isNewEntity) return undefined;\n    return getEmInternalApi(this.entity.em).getPreloadedRelation<E>(this.entity.idTagged, this.fieldName);\n  }\n\n  get #joinRows() {\n    return getEmInternalApi(this.entity.em).joinRows(this);\n  }\n\n  // The `ManyToManyLike` surface, so JoinRows/batch loaders can use us directly. There is no\n  // `otherMeta`/`otherFieldName` because the \"other\" side is an enum table, not an entity.\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.#field.fieldName);\n  }\n\n  get otherEnum(): EnumMetadata<any, any, number> {\n    return this.#field.enumDetailType;\n  }\n\n  get otherMeta(): undefined {\n    return undefined;\n  }\n\n  get otherFieldName(): undefined {\n    return undefined;\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  declare [enumCollectionTag]: true;\n  [RelationT]: T = null!;\n  [RelationU]: E = null!;\n}\n"],"mappings":"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"}

package/build/relations/EnumCollection.d.cts

@@ -1,7 +1,7 @@
 import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
 import { RelationT, RelationU } from "./RelationSymbols.cjs";
 import { EnumMetadata } from "../EnumMetadata.cjs";
-import { ManyToManyLike } from "../JoinRows.cjs";
+import { ManyToManyLike } from "../flush/JoinRows.cjs";
 import { EntityMetadata, ManyToManyEnumField } from "../EntityMetadata.cjs";
 import "../index.cjs";
 import { Entity } from "../Entity.cjs";

package/build/relations/EnumCollection.d.mts

@@ -1,7 +1,7 @@
 import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
 import { RelationT, RelationU } from "./RelationSymbols.mjs";
 import { EnumMetadata } from "../EnumMetadata.mjs";
-import { ManyToManyLike } from "../JoinRows.mjs";
+import { ManyToManyLike } from "../flush/JoinRows.mjs";
 import { EntityMetadata, ManyToManyEnumField } from "../EntityMetadata.mjs";
 import "../index.mjs";
 import { Entity } from "../Entity.mjs";

package/build/relations/EnumCollection.js.map

@@ -1 +1 @@
-{"version":3,"file":"EnumCollection.js","names":["#field","#loaded","#getPreloaded","#loadPromise","#pendingSet","#applySet","#joinRows","#idOf","#hasBeenSet","#codesFor"],"sources":["../../src/relations/EnumCollection.ts"],"sourcesContent":["import {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyEnumField,\n  type ManyToManyLike,\n  appendStack,\n  ensureNotDeleted,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n} from \"..//index.ts\";\nimport { enumCollectionBatchLoader } from \"../batchloaders/enumCollectionBatchLoader.ts\";\nimport { type EnumMetadata } from \"../EnumMetadata.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport { remove } from \"../utils.ts\";\nimport { AbstractRelationImpl } from \"./AbstractRelationImpl.ts\";\nimport { RelationT, RelationU } from \"./RelationSymbols.ts\";\n\n/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */\ndeclare const enumCollectionTag: unique symbol;\n\n/**\n * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum \"table\".\n *\n * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array\n * column it is lazy and so needs a load hint, like any other relation.\n */\nexport interface EnumCollection<T extends Entity, E> {\n  [enumCollectionTag]: true;\n  [RelationT]: T;\n  [RelationU]: E;\n\n  load(opts?: { forceReload?: boolean }): Promise<ReadonlyArray<E>>;\n\n  add(code: E): void;\n\n  remove(code: E): void;\n\n  /**\n   * Sets the collection to `codes`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(codes: readonly E[]): void;\n\n  includes(code: E): Promise<boolean>;\n\n  readonly isLoaded: boolean;\n  readonly entity: Entity;\n  readonly hasBeenSet: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {\n  get: ReadonlyArray<E>;\n\n  removeAll(): void;\n}\n\n/** An alias for creating `EnumCollection`s. */\nexport function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as ManyToManyEnumField;\n    return new EnumCollectionImpl<T, E>(entity, field);\n  });\n}\n\nexport class EnumCollectionImpl<T extends Entity, E>\n  extends AbstractRelationImpl<T, E[]>\n  implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike\n{\n  readonly #field: ManyToManyEnumField;\n  #loaded: boolean;\n  #loadPromise: any;\n  #hasBeenSet = false;\n  /** Holds a pending `set()` when called on an unloaded collection, resolved at load. */\n  #pendingSet: E[] | undefined;\n\n  constructor(entity: T, field: ManyToManyEnumField) {\n    super(entity);\n    this.#field = field;\n    this.#loaded = getInstanceData(entity).isOrWasNew;\n  }\n\n  async load(opts: { forceReload?: boolean } = {}): Promise<ReadonlyArray<E>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded || (opts.forceReload && !this.entity.isNewEntity)) {\n      if (this.#getPreloaded() !== undefined) {\n        this.#loaded = true;\n      } else {\n        await (this.#loadPromise ??= enumCollectionBatchLoader(this.entity.em, this).load(this.entity.idTagged!))\n          .then(() => {\n            this.#loaded = true;\n          })\n          .catch(function load(err: any) {\n            throw appendStack(err, new Error());\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          });\n      }\n      if (this.#pendingSet) {\n        const pending = this.#pendingSet;\n        this.#pendingSet = undefined;\n        this.#applySet(pending);\n      }\n    }\n    return this.get;\n  }\n\n  add(code: E): void {\n    ensureNotDeleted(this.entity);\n    if (this.#pendingSet) {\n      if (!this.#pendingSet.includes(code)) this.#pendingSet.push(code);\n      return;\n    }\n    if (this.#loaded && this.get.includes(code)) return;\n    this.#joinRows.addNew(this, this.entity, this.#idOf(code));\n  }\n\n  remove(code: E): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) {\n      remove(this.#pendingSet, code);\n      return;\n    }\n    this.#joinRows.addRemove(this, this.entity, this.#idOf(code));\n  }\n\n  set(codes: readonly E[]): void {\n    ensureNotDeleted(this.entity);\n    this.#hasBeenSet = true;\n    if (!this.#loaded) {\n      this.#pendingSet = [...codes];\n      getEmInternalApi(this.entity.em).pendingLoads.add(this as any);\n      return;\n    }\n    this.#applySet(codes);\n  }\n\n  async includes(code: E): Promise<boolean> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) return this.#pendingSet.includes(code);\n    if (this.#loaded) return this.get.includes(code);\n    if (this.entity.isNewEntity) return false;\n    await this.load();\n    return this.get.includes(code);\n  }\n\n  removeAll(): void {\n    ensureNotDeleted(this.entity);\n    if (!this.#loaded) throw new Error(\"removeAll was called when not loaded\");\n    for (const code of [...this.get]) this.remove(code);\n  }\n\n  get get(): E[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded) {\n      throw new Error(`${this.entity}.${this.fieldName}.get was called when not loaded`);\n    }\n    return this.#codesFor(this.entity);\n  }\n\n  get isLoaded(): boolean {\n    return this.#loaded;\n  }\n\n  get isPreloaded(): boolean {\n    return this.#getPreloaded() !== undefined;\n  }\n\n  preload(): void {\n    if (this.#getPreloaded() !== undefined) this.#loaded = true;\n  }\n\n  setFromOpts(codes: E[]): void {\n    this.#loaded = true;\n    for (const code of codes ?? []) this.add(code);\n  }\n\n  /**\n   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.\n   *\n   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not\n   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.\n   */\n  import(other: EnumCollectionImpl<T, E>): void {\n    if (!other.isLoaded) return;\n    this.#loaded = true;\n    for (const code of other.get) {\n      this.#joinRows.addPreloadedRow(this, undefined, this.entity, this.#idOf(code));\n    }\n  }\n\n  maybeCascadeDelete(): void {\n    // The join table FK cascades on the db side, so there's nothing to cascade in memory.\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // The db cascade-deletes our join rows, so just drop any pending in-memory changes for us.\n    this.#joinRows.removeAllFor(this.columnName, this.entity);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `EnumCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, enum: ${this.#field.enumDetailType.name})`;\n  }\n\n  #applySet(codes: readonly E[]): void {\n    const current = this.get;\n    for (const code of current) if (!codes.includes(code)) this.remove(code);\n    for (const code of codes) if (!current.includes(code)) this.add(code);\n  }\n\n  /** The current (non-deleted) codes for `entity`, sorted by enum id for a stable order. */\n  #codesFor(entity: Entity): E[] {\n    return (this.#joinRows.getOthers(this.columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((id) => this.#field.enumDetailType.findById(id)!.code as E);\n  }\n\n  #idOf(code: E): number {\n    return this.#field.enumDetailType.getByCode(code).id;\n  }\n\n  #getPreloaded(): E[] | undefined {\n    if (this.entity.isNewEntity) return undefined;\n    return getEmInternalApi(this.entity.em).getPreloadedRelation<E>(this.entity.idTagged, this.fieldName);\n  }\n\n  get #joinRows() {\n    return getEmInternalApi(this.entity.em).joinRows(this);\n  }\n\n  // The `ManyToManyLike` surface, so JoinRows/batch loaders can use us directly. There is no\n  // `otherMeta`/`otherFieldName` because the \"other\" side is an enum table, not an entity.\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.#field.fieldName);\n  }\n\n  get otherEnum(): EnumMetadata<any, any, number> {\n    return this.#field.enumDetailType;\n  }\n\n  get otherMeta(): undefined {\n    return undefined;\n  }\n\n  get otherFieldName(): undefined {\n    return undefined;\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  declare [enumCollectionTag]: true;\n  [RelationT]: T = null!;\n  [RelationU]: E = null!;\n}\n"],"mappings":"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"}
+{"version":3,"file":"EnumCollection.js","names":["#field","#loaded","#getPreloaded","#loadPromise","#pendingSet","#applySet","#joinRows","#idOf","#hasBeenSet","#codesFor"],"sources":["../../src/relations/EnumCollection.ts"],"sourcesContent":["import { enumCollectionBatchLoader } from \"src/batchloaders/enumCollectionBatchLoader.ts\";\nimport { type EnumMetadata } from \"src/EnumMetadata.ts\";\nimport {\n  type Entity,\n  type EntityMetadata,\n  type ManyToManyEnumField,\n  type ManyToManyLike,\n  appendStack,\n  ensureNotDeleted,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n  getMetadataForField,\n} 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\";\nimport { remove } from \"src/utils.ts\";\n\n/** A nominal brand so `EnumCollection` is not structurally confused with a regular `Collection`. */\ndeclare const enumCollectionTag: unique symbol;\n\n/**\n * A collection of enum codes `E` within `T`, backed by a m2m join table to an enum \"table\".\n *\n * To the user it looks like an array of enum codes (e.g. `Color[]`), but unlike an enum-array\n * column it is lazy and so needs a load hint, like any other relation.\n */\nexport interface EnumCollection<T extends Entity, E> {\n  [enumCollectionTag]: true;\n  [RelationT]: T;\n  [RelationU]: E;\n\n  load(opts?: { forceReload?: boolean }): Promise<ReadonlyArray<E>>;\n\n  add(code: E): void;\n\n  remove(code: E): void;\n\n  /**\n   * Sets the collection to `codes`.\n   *\n   * Can be called on unloaded collections - the diff will be resolved at load or flush time.\n   */\n  set(codes: readonly E[]): void;\n\n  includes(code: E): Promise<boolean>;\n\n  readonly isLoaded: boolean;\n  readonly entity: Entity;\n  readonly hasBeenSet: boolean;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedEnumCollection<T extends Entity, E> extends EnumCollection<T, E> {\n  get: ReadonlyArray<E>;\n\n  removeAll(): void;\n}\n\n/** An alias for creating `EnumCollection`s. */\nexport function hasEnumCollection<T extends Entity, E>(): EnumCollection<T, E> {\n  return lazyField((entity: T, fieldName) => {\n    const field = getMetadata(entity).allFields[fieldName] as ManyToManyEnumField;\n    return new EnumCollectionImpl<T, E>(entity, field);\n  });\n}\n\nexport class EnumCollectionImpl<T extends Entity, E>\n  extends AbstractRelationImpl<T, E[]>\n  implements EnumCollection<T, E>, LoadedEnumCollection<T, E>, ManyToManyLike\n{\n  readonly #field: ManyToManyEnumField;\n  #loaded: boolean;\n  #loadPromise: any;\n  #hasBeenSet = false;\n  /** Holds a pending `set()` when called on an unloaded collection, resolved at load. */\n  #pendingSet: E[] | undefined;\n\n  constructor(entity: T, field: ManyToManyEnumField) {\n    super(entity);\n    this.#field = field;\n    this.#loaded = getInstanceData(entity).isOrWasNew;\n  }\n\n  async load(opts: { forceReload?: boolean } = {}): Promise<ReadonlyArray<E>> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded || (opts.forceReload && !this.entity.isNewEntity)) {\n      if (this.#getPreloaded() !== undefined) {\n        this.#loaded = true;\n      } else {\n        await (this.#loadPromise ??= enumCollectionBatchLoader(this.entity.em, this).load(this.entity.idTagged!))\n          .then(() => {\n            this.#loaded = true;\n          })\n          .catch(function load(err: any) {\n            throw appendStack(err, new Error());\n          })\n          .finally(() => {\n            this.#loadPromise = undefined;\n          });\n      }\n      if (this.#pendingSet) {\n        const pending = this.#pendingSet;\n        this.#pendingSet = undefined;\n        this.#applySet(pending);\n      }\n    }\n    return this.get;\n  }\n\n  add(code: E): void {\n    ensureNotDeleted(this.entity);\n    if (this.#pendingSet) {\n      if (!this.#pendingSet.includes(code)) this.#pendingSet.push(code);\n      return;\n    }\n    if (this.#loaded && this.get.includes(code)) return;\n    this.#joinRows.addNew(this, this.entity, this.#idOf(code));\n  }\n\n  remove(code: E): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) {\n      remove(this.#pendingSet, code);\n      return;\n    }\n    this.#joinRows.addRemove(this, this.entity, this.#idOf(code));\n  }\n\n  set(codes: readonly E[]): void {\n    ensureNotDeleted(this.entity);\n    this.#hasBeenSet = true;\n    if (!this.#loaded) {\n      this.#pendingSet = [...codes];\n      getEmInternalApi(this.entity.em).pendingLoads.add(this as any);\n      return;\n    }\n    this.#applySet(codes);\n  }\n\n  async includes(code: E): Promise<boolean> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this.#pendingSet) return this.#pendingSet.includes(code);\n    if (this.#loaded) return this.get.includes(code);\n    if (this.entity.isNewEntity) return false;\n    await this.load();\n    return this.get.includes(code);\n  }\n\n  removeAll(): void {\n    ensureNotDeleted(this.entity);\n    if (!this.#loaded) throw new Error(\"removeAll was called when not loaded\");\n    for (const code of [...this.get]) this.remove(code);\n  }\n\n  get get(): E[] {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this.#loaded) {\n      throw new Error(`${this.entity}.${this.fieldName}.get was called when not loaded`);\n    }\n    return this.#codesFor(this.entity);\n  }\n\n  get isLoaded(): boolean {\n    return this.#loaded;\n  }\n\n  get isPreloaded(): boolean {\n    return this.#getPreloaded() !== undefined;\n  }\n\n  preload(): void {\n    if (this.#getPreloaded() !== undefined) this.#loaded = true;\n  }\n\n  setFromOpts(codes: E[]): void {\n    this.#loaded = true;\n    for (const code of codes ?? []) this.add(code);\n  }\n\n  /**\n   * Mirrors `other`'s codes into us for `em.fork`/`importEntity`.\n   *\n   * Enum codes have no entity identity to remap, and we copy them as already-persisted rows (not\n   * pending adds) so the receiving em doesn't think it has spurious inserts to flush.\n   */\n  import(other: EnumCollectionImpl<T, E>): void {\n    if (!other.isLoaded) return;\n    this.#loaded = true;\n    for (const code of other.get) {\n      this.#joinRows.addPreloadedRow(this, undefined, this.entity, this.#idOf(code));\n    }\n  }\n\n  maybeCascadeDelete(): void {\n    // The join table FK cascades on the db side, so there's nothing to cascade in memory.\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // The db cascade-deletes our join rows, so just drop any pending in-memory changes for us.\n    this.#joinRows.removeAllFor(this.columnName, this.entity);\n  }\n\n  get fieldName(): string {\n    return this.#field.fieldName;\n  }\n\n  get hasBeenSet(): boolean {\n    return this.#hasBeenSet;\n  }\n\n  toString(): string {\n    return `EnumCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, enum: ${this.#field.enumDetailType.name})`;\n  }\n\n  #applySet(codes: readonly E[]): void {\n    const current = this.get;\n    for (const code of current) if (!codes.includes(code)) this.remove(code);\n    for (const code of codes) if (!current.includes(code)) this.add(code);\n  }\n\n  /** The current (non-deleted) codes for `entity`, sorted by enum id for a stable order. */\n  #codesFor(entity: Entity): E[] {\n    return (this.#joinRows.getOthers(this.columnName, entity) as number[])\n      .sort((a, b) => a - b)\n      .map((id) => this.#field.enumDetailType.findById(id)!.code as E);\n  }\n\n  #idOf(code: E): number {\n    return this.#field.enumDetailType.getByCode(code).id;\n  }\n\n  #getPreloaded(): E[] | undefined {\n    if (this.entity.isNewEntity) return undefined;\n    return getEmInternalApi(this.entity.em).getPreloadedRelation<E>(this.entity.idTagged, this.fieldName);\n  }\n\n  get #joinRows() {\n    return getEmInternalApi(this.entity.em).joinRows(this);\n  }\n\n  // The `ManyToManyLike` surface, so JoinRows/batch loaders can use us directly. There is no\n  // `otherMeta`/`otherFieldName` because the \"other\" side is an enum table, not an entity.\n\n  get joinTableName(): string {\n    return this.#field.joinTableName;\n  }\n\n  get columnName(): string {\n    return this.#field.columnNames[0];\n  }\n\n  get otherColumnName(): string {\n    return this.#field.columnNames[1];\n  }\n\n  get meta(): EntityMetadata {\n    return getMetadataForField(getMetadata(this.entity), this.#field.fieldName);\n  }\n\n  get otherEnum(): EnumMetadata<any, any, number> {\n    return this.#field.enumDetailType;\n  }\n\n  get otherMeta(): undefined {\n    return undefined;\n  }\n\n  get otherFieldName(): undefined {\n    return undefined;\n  }\n\n  get hasJoinTableId(): boolean {\n    return this.#field.hasJoinTableId;\n  }\n\n  declare [enumCollectionTag]: true;\n  [RelationT]: T = null!;\n  [RelationU]: E = null!;\n}\n"],"mappings":"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"}

package/build/relations/LazyField.cjs

@@ -1,14 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../batchloaders/BatchLoader.cjs");
-const require_fields = require("../fields.cjs");
 const require_relations_AbstractPropertyImpl = require("./AbstractPropertyImpl.cjs");
-const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
-const require_RowData = require("../RowData.cjs");
 const require_relations_PropertySymbols = require("./PropertySymbols.cjs");
 require("./hasProperty.cjs");
+const require_fields = require("../fields.cjs");
+const require_keys = require("../keys.cjs");
+const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
+const require_RowData = require("../RowData.cjs");
 const require_utils = require("../utils.cjs");
 const require_newEntity = require("../newEntity.cjs");
-const require_keys = require("../keys.cjs");
 const require_EntityMetadata = require("../EntityMetadata.cjs");
 require("../EntityManager.cjs");
 require("../Entity.cjs");

package/build/relations/LazyField.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"LazyField.cjs","names":["lazyField","AbstractPropertyImpl","#fieldName","#loaded","#loadPromise","#value","getMetadata","getInstanceData","PropertyT","abbreviation","keyToNumber","kqDot","PojoRowData","tagId"],"sources":["../../src/relations/LazyField.ts"],"sourcesContent":["import { getInstanceData } from \"../BaseEntity.ts\";\nimport { type BatchLoader } from \"../batchloaders/BatchLoader.ts\";\nimport { type Entity } from \"../Entity.ts\";\nimport { type EntityManager } from \"../EntityManager.ts\";\nimport { type EntityMetadata, type PrimitiveField, getMetadata } from \"../EntityMetadata.ts\";\nimport { setField } from \"../fields.ts\";\nimport { keyToNumber, tagId } from \"../keys.ts\";\nimport { lazyField } from \"../newEntity.ts\";\nimport type { ParsedFindQuery } from \"../queries/find/QueryParser.ts\";\nimport { kqDot } from \"../queries/sql/keywords.ts\";\nimport { PojoRowData } from \"../RowData.ts\";\nimport { abbreviation } from \"../utils.ts\";\nimport { AbstractPropertyImpl } from \"./AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"./hasProperty.ts\";\nimport { PropertyT } from \"./PropertySymbols.ts\";\n\nexport const lazyColumnLoadOperation = \"lazy-column-load\";\n\n/**\n * The \"original value\" of an unloaded lazy column: unknown, and never equal to any set value.\n *\n * Seeded into `__orm.data` by `LazyFieldImpl.set` so that setting an unloaded column (even to\n * `undefined`) always registers as a change, i.e. instead of comparing equal to the `undefined`\n * that the excluded column would otherwise read as.\n */\nexport const notLoadedValue = Symbol(\"notLoadedValue\");\n\n/**\n * A single-column primitive (i.e. a large `jsonb`/`text`) that is deliberately excluded from the\n * entity's default SELECT and only fetched from the database on demand.\n *\n * I.e. `await author.someBigColumn.load()`, or synchronously via `.get` after `em.populate`.\n */\nexport interface LazyField<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n  /** Sets the value in memory (dirtied for the next flush), i.e. without loading the current db value first. */\n  set(value: V): void;\n}\n\n/** Creates a `LazyField` for a column that codegen has marked `lazy: true`. */\nexport function hasLazyField<T extends Entity, V>(): LazyField<T, V> {\n  return lazyField((entity: T, fieldName: string) => new LazyFieldImpl<T, V>(entity, fieldName));\n}\n\nexport class LazyFieldImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements LazyField<T, V> {\n  #fieldName: string;\n  #loaded = false;\n  #loadPromise: Promise<V> | undefined;\n\n  constructor(entity: T, fieldName: string) {\n    super(entity);\n    this.#fieldName = fieldName;\n  }\n\n  /** Fetches this column from the database (batched across peers) and caches it on the entity. */\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    const { entity } = this;\n    if (opts?.forceReload) {\n      this.#loaded = false;\n      this.#loadPromise = undefined;\n    }\n    if (this.isLoaded) return Promise.resolve(this.#value);\n    const meta = getMetadata(entity);\n    return (this.#loadPromise ??= lazyColumnBatchLoader(entity.em, meta, this.#fieldName)\n      .load(entity.idTagged)\n      .then(() => {\n        this.#loaded = true;\n        return this.#value;\n      }));\n  }\n\n  get get(): V {\n    if (!this.isLoaded) {\n      throw new Error(`${this.#fieldName} has not been loaded yet, use '.load()' or an 'em.populate' hint`);\n    }\n    return this.#value;\n  }\n\n  /** Sets the value in memory; the column is dirtied and written on the next `em.flush`. */\n  set(value: V): void {\n    if (this.isLoaded) {\n      setField(this.entity, this.#fieldName, value);\n    } else {\n      // Seed `notLoadedValue` as the current value so the set always registers as a change against\n      // the unknown db value: an unloaded column otherwise reads as `undefined`, which would make\n      // `set(undefined)` a silent no-op, and a later `set(undefined)` falsely revert to clean.\n      const { data } = getInstanceData(this.entity);\n      data[this.#fieldName] = notLoadedValue;\n      try {\n        setField(this.entity, this.#fieldName, value);\n      } catch (e) {\n        // Don't leak the marker as a readable value, i.e. if setting on a deleted entity throws\n        delete data[this.#fieldName];\n        throw e;\n      }\n    }\n    this.#loaded = true;\n  }\n\n  get isLoaded(): boolean {\n    // New entities keep their value in-memory, so there's nothing to lazy-load.\n    if (getInstanceData(this.entity).isOrWasNew) return true;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value, since the db state may have changed. */\n  resetAfterFlush(): void {\n    this.#loaded = false;\n    this.#loadPromise = undefined;\n  }\n\n  /** The domain value, which `load`/`set` keep in the entity's `__orm.data` like any other column. */\n  get #value(): V {\n    return getInstanceData(this.entity).data[this.#fieldName] as V;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a LazyField. */\nexport function isLazyField(maybe: any): maybe is LazyField<any, any> {\n  return maybe instanceof LazyFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded LazyField. */\nexport function isLoadedLazyField(maybe: any): maybe is LazyField<any, any> & LoadedProperty<any, any> {\n  return isLazyField(maybe) && maybe.isLoaded;\n}\n\n/** Batches `LazyField.load`s for the same column into a single `SELECT id, <column> ... WHERE id IN (...)`. */\nfunction lazyColumnBatchLoader(em: EntityManager, meta: EntityMetadata, fieldName: string): BatchLoader<string> {\n  return em.getBatchLoader(lazyColumnLoadOperation, `${meta.tableName}-${fieldName}`, async (taggedIds) => {\n    const field = meta.allFields[fieldName] as PrimitiveField;\n    const column = field.serde.columns[0];\n    const alias = abbreviation(meta.tableName);\n    const keys = taggedIds.map((id) => keyToNumber(meta, id));\n    const query: ParsedFindQuery = {\n      selects: [`${kqDot(alias, \"id\")} as id`, kqDot(alias, column.columnName)],\n      tables: [{ alias, join: \"primary\", table: meta.tableName }],\n      condition: {\n        kind: \"exp\",\n        op: \"and\",\n        conditions: [{ kind: \"column\", alias, column: \"id\", dbType: meta.idDbType, cond: { kind: \"in\", value: keys } }],\n      },\n      orderBys: [],\n    };\n    const rows = await em[\"executeFind\"](meta, lazyColumnLoadOperation, query, {});\n    const rowData = new PojoRowData(rows);\n    for (let i = 0; i < rows.length; i++) {\n      const entity = em.findExistingInstance(tagId(meta, rows[i].id));\n      if (entity) getInstanceData(entity).data[fieldName] = field.serde.fromRow(rowData, i);\n    }\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"LazyField.cjs","names":["lazyField","AbstractPropertyImpl","#fieldName","#loaded","#loadPromise","#value","getMetadata","getInstanceData","PropertyT","abbreviation","keyToNumber","kqDot","PojoRowData","tagId"],"sources":["../../src/relations/LazyField.ts"],"sourcesContent":["import { getInstanceData } from \"src/BaseEntity.ts\";\nimport { type BatchLoader } from \"src/batchloaders/BatchLoader.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, type PrimitiveField, getMetadata } from \"src/EntityMetadata.ts\";\nimport { setField } from \"src/fields.ts\";\nimport { keyToNumber, tagId } from \"src/keys.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { kqDot } from \"src/queries/sql/keywords.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { PojoRowData } from \"src/RowData.ts\";\nimport { abbreviation } from \"src/utils.ts\";\n\nexport const lazyColumnLoadOperation = \"lazy-column-load\";\n\n/**\n * The \"original value\" of an unloaded lazy column: unknown, and never equal to any set value.\n *\n * Seeded into `__orm.data` by `LazyFieldImpl.set` so that setting an unloaded column (even to\n * `undefined`) always registers as a change, i.e. instead of comparing equal to the `undefined`\n * that the excluded column would otherwise read as.\n */\nexport const notLoadedValue = Symbol(\"notLoadedValue\");\n\n/**\n * A single-column primitive (i.e. a large `jsonb`/`text`) that is deliberately excluded from the\n * entity's default SELECT and only fetched from the database on demand.\n *\n * I.e. `await author.someBigColumn.load()`, or synchronously via `.get` after `em.populate`.\n */\nexport interface LazyField<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n  /** Sets the value in memory (dirtied for the next flush), i.e. without loading the current db value first. */\n  set(value: V): void;\n}\n\n/** Creates a `LazyField` for a column that codegen has marked `lazy: true`. */\nexport function hasLazyField<T extends Entity, V>(): LazyField<T, V> {\n  return lazyField((entity: T, fieldName: string) => new LazyFieldImpl<T, V>(entity, fieldName));\n}\n\nexport class LazyFieldImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements LazyField<T, V> {\n  #fieldName: string;\n  #loaded = false;\n  #loadPromise: Promise<V> | undefined;\n\n  constructor(entity: T, fieldName: string) {\n    super(entity);\n    this.#fieldName = fieldName;\n  }\n\n  /** Fetches this column from the database (batched across peers) and caches it on the entity. */\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    const { entity } = this;\n    if (opts?.forceReload) {\n      this.#loaded = false;\n      this.#loadPromise = undefined;\n    }\n    if (this.isLoaded) return Promise.resolve(this.#value);\n    const meta = getMetadata(entity);\n    return (this.#loadPromise ??= lazyColumnBatchLoader(entity.em, meta, this.#fieldName)\n      .load(entity.idTagged)\n      .then(() => {\n        this.#loaded = true;\n        return this.#value;\n      }));\n  }\n\n  get get(): V {\n    if (!this.isLoaded) {\n      throw new Error(`${this.#fieldName} has not been loaded yet, use '.load()' or an 'em.populate' hint`);\n    }\n    return this.#value;\n  }\n\n  /** Sets the value in memory; the column is dirtied and written on the next `em.flush`. */\n  set(value: V): void {\n    if (this.isLoaded) {\n      setField(this.entity, this.#fieldName, value);\n    } else {\n      // Seed `notLoadedValue` as the current value so the set always registers as a change against\n      // the unknown db value: an unloaded column otherwise reads as `undefined`, which would make\n      // `set(undefined)` a silent no-op, and a later `set(undefined)` falsely revert to clean.\n      const { data } = getInstanceData(this.entity);\n      data[this.#fieldName] = notLoadedValue;\n      try {\n        setField(this.entity, this.#fieldName, value);\n      } catch (e) {\n        // Don't leak the marker as a readable value, i.e. if setting on a deleted entity throws\n        delete data[this.#fieldName];\n        throw e;\n      }\n    }\n    this.#loaded = true;\n  }\n\n  get isLoaded(): boolean {\n    // New entities keep their value in-memory, so there's nothing to lazy-load.\n    if (getInstanceData(this.entity).isOrWasNew) return true;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value, since the db state may have changed. */\n  resetAfterFlush(): void {\n    this.#loaded = false;\n    this.#loadPromise = undefined;\n  }\n\n  /** The domain value, which `load`/`set` keep in the entity's `__orm.data` like any other column. */\n  get #value(): V {\n    return getInstanceData(this.entity).data[this.#fieldName] as V;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is a LazyField. */\nexport function isLazyField(maybe: any): maybe is LazyField<any, any> {\n  return maybe instanceof LazyFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded LazyField. */\nexport function isLoadedLazyField(maybe: any): maybe is LazyField<any, any> & LoadedProperty<any, any> {\n  return isLazyField(maybe) && maybe.isLoaded;\n}\n\n/** Batches `LazyField.load`s for the same column into a single `SELECT id, <column> ... WHERE id IN (...)`. */\nfunction lazyColumnBatchLoader(em: EntityManager, meta: EntityMetadata, fieldName: string): BatchLoader<string> {\n  return em.getBatchLoader(lazyColumnLoadOperation, `${meta.tableName}-${fieldName}`, async (taggedIds) => {\n    const field = meta.allFields[fieldName] as PrimitiveField;\n    const column = field.serde.columns[0];\n    const alias = abbreviation(meta.tableName);\n    const keys = taggedIds.map((id) => keyToNumber(meta, id));\n    const query: ParsedFindQuery = {\n      selects: [`${kqDot(alias, \"id\")} as id`, kqDot(alias, column.columnName)],\n      tables: [{ alias, join: \"primary\", table: meta.tableName }],\n      condition: {\n        kind: \"exp\",\n        op: \"and\",\n        conditions: [{ kind: \"column\", alias, column: \"id\", dbType: meta.idDbType, cond: { kind: \"in\", value: keys } }],\n      },\n      orderBys: [],\n    };\n    const rows = await em[\"executeFind\"](meta, lazyColumnLoadOperation, query, {});\n    const rowData = new PojoRowData(rows);\n    for (let i = 0; i < rows.length; i++) {\n      const entity = em.findExistingInstance(tagId(meta, rows[i].id));\n      if (entity) getInstanceData(entity).data[fieldName] = field.serde.fromRow(rowData, i);\n    }\n  });\n}\n"],"mappings":"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"}

package/build/relations/LazyField.js

@@ -1,13 +1,13 @@
 import "../batchloaders/BatchLoader.js";
-import { setField } from "../fields.js";
 import { AbstractPropertyImpl } from "./AbstractPropertyImpl.js";
-import { kqDot } from "../queries/sql/keywords.js";
-import { PojoRowData } from "../RowData.js";
 import { PropertyT } from "./PropertySymbols.js";
 import "./hasProperty.js";
+import { setField } from "../fields.js";
+import { keyToNumber, tagId } from "../keys.js";
+import { kqDot } from "../queries/sql/keywords.js";
+import { PojoRowData } from "../RowData.js";
 import { abbreviation } from "../utils.js";
 import { lazyField } from "../newEntity.js";
-import { keyToNumber, tagId } from "../keys.js";
 import { getMetadata } from "../EntityMetadata.js";
 import "../EntityManager.js";
 import "../Entity.js";