joist-orm 0.1.536 → 1.0.0

package/src/collections/ManyToOneReference.ts

@@ -1,215 +0,0 @@
-import { Entity, EntityMetadata, IdOf, isEntity } from "../EntityManager";
-import {
-  deTagIds,
-  ensureNotDeleted,
-  fail,
-  getEm,
-  maybeResolveReferenceToId,
-  OneToOneReference,
-  Reference,
-  setField,
-} from "../index";
-import { AbstractRelationImpl } from "./AbstractRelationImpl";
-import { OneToManyCollection } from "./OneToManyCollection";
-
-/**
- * Manages a foreign key from one entity to another, i.e. `Book.author --> Author`.
- *
- * We keep the current `author` / `author_id` value in the `__orm.data` hash, where the
- * current value could be either the (string) author id from the database, or an entity
- * `Author` that the user has set.
- *
- * Note that if our `images.author_id` column is unique, this `ManyToOneReference` will essentially
- * be half of a one-to-one relationship, but we'll keep using this reference on the "owning"
- * side; the other side, i.e. `Author.image` will use a `OneToOneReference` to point back to us.
- */
-export class ManyToOneReference<T extends Entity, U extends Entity, N extends never | undefined>
-  extends AbstractRelationImpl<U>
-  implements Reference<T, U, N> {
-  private loaded!: U | N;
-  // We need a separate boolean to b/c loaded == undefined can still mean "isLoaded" for nullable fks.
-  private isLoaded = false;
-  private isCascadeDelete: boolean;
-
-  constructor(
-    private entity: T,
-    public otherMeta: EntityMetadata<U>,
-    private fieldName: keyof T,
-    public otherFieldName: keyof U,
-  ) {
-    super();
-    this.isCascadeDelete = otherMeta.config.__data.cascadeDeleteFields.includes(fieldName as any);
-  }
-
-  async load(opts?: { withDeleted?: boolean }): Promise<U | N> {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    const current = this.current();
-    // Resolve the id to an entity
-    if (!isEntity(current) && current !== undefined) {
-      this.loaded = ((await getEm(this.entity).load(this.otherMeta.cstr, current)) as any) as U;
-    }
-    this.isLoaded = true;
-    return this.filterDeleted(this.loaded, opts);
-  }
-
-  set(other: U | N): void {
-    this.setImpl(other);
-  }
-
-  get isSet(): boolean {
-    return this.current() !== undefined;
-  }
-
-  private doGet(opts?: { withDeleted?: boolean }): U | N {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    // This should only be callable in the type system if we've already resolved this to an instance,
-    // but, just in case we somehow got here in an unloaded state, check to see if we're already in the UoW
-    if (!this.isLoaded) {
-      const existing = this.maybeFindExisting();
-      if (existing === undefined) {
-        throw new Error(`${this.entity}.${this.fieldName} was not loaded`);
-      }
-      this.loaded = existing;
-      this.isLoaded = true;
-    }
-
-    return this.filterDeleted(this.loaded, opts);
-  }
-
-  get getWithDeleted(): U | N {
-    return this.doGet({ withDeleted: true });
-  }
-
-  get get(): U | N {
-    return this.doGet({ withDeleted: false });
-  }
-
-  get id(): IdOf<U> | undefined {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    return maybeResolveReferenceToId(this.current()) as IdOf<U> | undefined;
-  }
-
-  get idOrFail(): IdOf<U> {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    return this.id || fail("Reference is unset or assigned to a new entity");
-  }
-
-  get idUntagged(): string | undefined {
-    return this.id && deTagIds(this.otherMeta, [this.id])[0];
-  }
-
-  get idUntaggedOrFail(): string {
-    return this.idUntagged || fail("Reference is unset or assigned to a new entity");
-  }
-
-  // private impl
-
-  setFromOpts(other: U): void {
-    this.setImpl(other);
-  }
-
-  initializeForNewEntity(): void {
-    // Our codegen'd Opts type will ensure our field is inititalized if necessary/notNull
-    this.isLoaded = true;
-  }
-
-  async refreshIfLoaded(): Promise<void> {
-    // TODO We should remember what load hints have been applied to this collection and re-apply them.
-    if (this.isLoaded) {
-      const current = this.current();
-      if (typeof current === "string") {
-        this.loaded = ((await getEm(this.entity).load(this.otherMeta.cstr, current)) as any) as U;
-      } else {
-        this.loaded = current;
-      }
-    }
-  }
-
-  onEntityDelete(): void {
-    if (this.isCascadeDelete) {
-      const current = this.current({ withDeleted: true });
-      if (current !== undefined && typeof current !== "string") {
-        getEm(this.entity).delete(current as U);
-      }
-    }
-  }
-
-  async onEntityDeletedAndFlushing(): Promise<void> {
-    const current = await this.load({ withDeleted: true });
-    if (current !== undefined) {
-      const o2m = this.getOtherRelation(current);
-      if (o2m instanceof OneToManyCollection) {
-        o2m.remove(this.entity, { requireLoaded: false });
-      } else {
-        o2m.set(undefined as any);
-      }
-    }
-    setField(this.entity, this.fieldName as string, undefined);
-    this.loaded = undefined as any;
-    this.isLoaded = true;
-  }
-
-  // Internal method used by OneToManyCollection
-  setImpl(other: U | N): void {
-    if (other?.isNewEntity ? other === this.loaded : this.id === other?.id) {
-      return;
-    }
-
-    // we may not be loaded yet, but our previous entity might already be in the UoW
-    const previousLoaded = this.loaded ?? this.maybeFindExisting();
-
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-
-    // Prefer to keep the id in our data hash, but if this is a new entity w/o an id, use the entity itself
-    const changed = setField(this.entity, this.fieldName as string, other?.id ?? other);
-    if (!changed) {
-      return;
-    }
-    this.loaded = other;
-    this.isLoaded = true;
-
-    // If had an existing value, remove us from its collection
-    if (previousLoaded) {
-      const prevRelation = this.getOtherRelation(previousLoaded);
-      if (prevRelation instanceof OneToManyCollection) {
-        prevRelation.removeIfLoaded(this.entity);
-      } else {
-        prevRelation.set(undefined as any);
-      }
-    }
-    if (other !== undefined) {
-      const newRelation = this.getOtherRelation(other);
-      if (newRelation instanceof OneToManyCollection) {
-        newRelation.add(this.entity);
-      } else {
-        newRelation.set(this.entity);
-      }
-    }
-  }
-
-  // We need to keep U in data[fieldName] to handle entities without an id assigned yet.
-  current(opts?: { withDeleted?: boolean }): U | string | N {
-    const current = this.entity.__orm.data[this.fieldName];
-    if (current !== undefined && isEntity(current)) {
-      return this.filterDeleted(current as U, opts);
-    }
-    return current;
-  }
-
-  public toString(): string {
-    return `ManyToOneReference(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName}, id: ${this.id})`;
-  }
-
-  private filterDeleted(entity: U | N, opts?: { withDeleted?: boolean }): U | N {
-    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : (undefined as N);
-  }
-
-  /** Returns the other relation that points back at us, i.e. we're `book.author_id` and this is `Author.books`. */
-  private getOtherRelation(other: U): OneToManyCollection<U, T> | OneToOneReference<U, T> {
-    return (other as U)[this.otherFieldName] as any;
-  }
-
-  private maybeFindExisting(): U | undefined {
-    return this.id !== undefined ? getEm(this.entity)["findExistingInstance"](this.id) : undefined;
-  }
-}

package/src/collections/OneToManyCollection.ts

@@ -1,254 +0,0 @@
-import DataLoader from "dataloader";
-import {
-  assertIdsAreTagged,
-  Collection,
-  deTagIds,
-  ensureNotDeleted,
-  Entity,
-  EntityMetadata,
-  getEm,
-  getMetadata,
-  IdOf,
-  maybeResolveReferenceToId,
-} from "../index";
-import { getOrSet, groupBy, remove } from "../utils";
-import { AbstractRelationImpl } from "./AbstractRelationImpl";
-import { ManyToOneReference } from "./ManyToOneReference";
-
-export class OneToManyCollection<T extends Entity, U extends Entity> extends AbstractRelationImpl<U[]>
-  implements Collection<T, U> {
-  private loaded: U[] | undefined;
-  // We don't need to track removedBeforeLoaded, because if a child is removed in our unloaded state,
-  // when we load and get back the `child X has parent_id = our id` rows from the db, `loaderForCollection`
-  // groups the hydrated rows by their _current parent m2o field value_, which for a removed child will no
-  // longer be us, so it will effectively not show up in our post-load `loaded` array.
-  private addedBeforeLoaded: U[] = [];
-  private isCascadeDelete: boolean;
-
-  constructor(
-    // These are public to our internal implementation but not exposed in the Collection API
-    public entity: T,
-    public otherMeta: EntityMetadata<U>,
-    public fieldName: keyof T,
-    public otherFieldName: keyof U,
-    public otherColumnName: string,
-  ) {
-    super();
-    this.isCascadeDelete = getMetadata(entity).config.__data.cascadeDeleteFields.includes(fieldName as any);
-  }
-
-  // opts is an internal parameter
-  async load(opts?: { withDeleted?: boolean }): Promise<readonly U[]> {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    if (this.loaded === undefined) {
-      if (this.entity.id === undefined) {
-        this.loaded = [];
-      } else {
-        this.loaded = await loaderForCollection(this).load(this.entity.id);
-      }
-      this.maybeAppendAddedBeforeLoaded();
-    }
-    return this.filterDeleted(this.loaded, opts);
-  }
-
-  async find(id: IdOf<U>): Promise<U | undefined> {
-    return (await this.load()).find((u) => u.id === id);
-  }
-
-  get get(): U[] {
-    return this.filterDeleted(this.doGet(), { withDeleted: false });
-  }
-
-  get getWithDeleted(): U[] {
-    return this.filterDeleted(this.doGet(), { withDeleted: true });
-  }
-
-  private doGet(): U[] {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    if (this.loaded === undefined) {
-      if (this.entity.id === undefined) {
-        return this.addedBeforeLoaded;
-      } else {
-        // This should only be callable in the type system if we've already resolved this to an instance
-        throw new Error("get was called when not preloaded");
-      }
-    }
-    return this.loaded;
-  }
-
-  set(values: U[]): void {
-    ensureNotDeleted(this.entity);
-    if (this.loaded === undefined) {
-      throw new Error("set was called when not loaded");
-    }
-    // Make a copy for safe iteration
-    const loaded = [...this.loaded];
-    // Remove old values
-    for (const other of loaded) {
-      if (!values.includes(other)) {
-        this.remove(other);
-      }
-    }
-    for (const other of values) {
-      if (!loaded.includes(other)) {
-        this.add(other);
-      }
-    }
-  }
-
-  add(other: U): void {
-    ensureNotDeleted(this.entity);
-    if (this.loaded === undefined) {
-      if (!this.addedBeforeLoaded.includes(other)) {
-        this.addedBeforeLoaded.push(other);
-      }
-    } else {
-      if (!this.loaded.includes(other)) {
-        this.loaded.push(other);
-      }
-    }
-    // This will no-op and mark other dirty if necessary
-    this.getOtherRelation(other).set(this.entity);
-  }
-
-  // We're not supported remove(other) because that might leave other.otherFieldName as undefined,
-  // which we don't know if that's valid or not, i.e. depending on whether the field is nullable.
-  remove(other: U, opts: { requireLoaded: boolean } = { requireLoaded: true }) {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    if (this.loaded === undefined && opts.requireLoaded) {
-      throw new Error("remove was called when not loaded");
-    }
-    remove(this.loaded || this.addedBeforeLoaded, other);
-    // This will no-op and mark other dirty if necessary
-    this.getOtherRelation(other).set(undefined);
-  }
-
-  removeAll(): void {
-    ensureNotDeleted(this.entity);
-    if (this.loaded === undefined) {
-      throw new Error("removeAll was called when not loaded");
-    }
-    for (const other of [...this.loaded]) {
-      this.remove(other);
-    }
-  }
-
-  // internal impl
-
-  setFromOpts(others: U[]): void {
-    this.loaded = [];
-    others.forEach((o) => this.add(o));
-  }
-
-  initializeForNewEntity(): void {
-    // Don't overwrite any opts values
-    if (this.loaded === undefined) {
-      this.loaded = [];
-    }
-  }
-
-  removeIfLoaded(other: U) {
-    if (this.loaded !== undefined) {
-      remove(this.loaded, other);
-    } else {
-      remove(this.addedBeforeLoaded, other);
-    }
-  }
-
-  async refreshIfLoaded(): Promise<void> {
-    // TODO We should remember what load hints have been applied to this collection and re-apply them.
-    if (this.loaded !== undefined && this.entity.id !== undefined) {
-      const loader = loaderForCollection(this);
-      loader.clear(this.entity.id);
-      this.loaded = await loader.load(this.entity.id);
-    }
-  }
-
-  onEntityDelete(): void {
-    if (this.isCascadeDelete) {
-      this.current({ withDeleted: true }).forEach(getEm(this.entity).delete);
-    }
-  }
-
-  // We already unhooked all children in our addedBeforeLoaded list; now load the full list if necessary.
-  async onEntityDeletedAndFlushing(): Promise<void> {
-    const current = await this.load({ withDeleted: true });
-    current.forEach((other) => {
-      const m2o = this.getOtherRelation(other);
-      if (maybeResolveReferenceToId(m2o.current()) === this.entity.id) {
-        // TODO What if other.otherFieldName is required/not-null?
-        m2o.set(undefined);
-      }
-    });
-    this.loaded = [];
-    this.addedBeforeLoaded = [];
-  }
-
-  private maybeAppendAddedBeforeLoaded(): void {
-    if (this.loaded) {
-      const newEntities = this.addedBeforeLoaded.filter((e) => !this.loaded?.includes(e));
-      // Push on the end to better match the db order of "newer things come last"
-      for (const e of newEntities) {
-        this.loaded.push(e);
-      }
-      this.addedBeforeLoaded = [];
-    }
-  }
-
-  current(opts?: { withDeleted?: boolean }): U[] {
-    return this.filterDeleted(this.loaded || this.addedBeforeLoaded, opts);
-  }
-
-  public toString(): string {
-    return `OneToManyCollection(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;
-  }
-
-  private filterDeleted(entities: U[], opts?: { withDeleted?: boolean }): U[] {
-    return opts?.withDeleted === true ? [...entities] : entities.filter((e) => !e.isDeletedEntity);
-  }
-
-  /** Returns the other relation that points back at us, i.e. we're `Author.image` and this is `Image.author_id`. */
-  private getOtherRelation(other: U): ManyToOneReference<U, T, any> {
-    return (other as U)[this.otherFieldName] as any;
-  }
-}
-
-function loaderForCollection<T extends Entity, U extends Entity>(
-  collection: OneToManyCollection<T, U>,
-): DataLoader<string, U[]> {
-  const em = getEm(collection.entity);
-  // The metadata for the entity that contains the collection
-  const meta = getMetadata(collection.entity);
-  const loaderName = `${meta.tableName}.${collection.fieldName}`;
-  return getOrSet(em.__data.loaders, loaderName, () => {
-    return new DataLoader<string, U[]>(async (_keys) => {
-      const { otherMeta } = collection;
-
-      assertIdsAreTagged(_keys);
-      const keys = deTagIds(meta, _keys);
-
-      const rows = await em.knex
-        .select("*")
-        .from(otherMeta.tableName)
-        .whereIn(collection.otherColumnName, keys)
-        .orderBy("id");
-
-      const entities = rows.map((row) => em.hydrate(otherMeta.cstr, row, { overwriteExisting: false }));
-      // .filter((e) => !e.isDeletedEntity);
-
-      const rowsById = groupBy(entities, (entity) => {
-        // TODO If this came from the UoW, it may not be an id? I.e. pre-insert.
-        const ownerId = maybeResolveReferenceToId(entity.__orm.data[collection.otherFieldName]);
-        // We almost always expect ownerId to be found, b/c normally we just hydrated this entity
-        // directly from a SQL row with owner_id=X, however we might be loading this collection
-        // (i.e. find all children where owner_id=X) when the SQL thinks a child is still pointing
-        // at the parent (i.e. owner_id=X in the db), but our already-loaded child has had its
-        // `child.owner` field either changed to some other owner, or set to undefined. In either,
-        // that child should no longer be parent of this owner's collection, so just return a
-        // dummy value.
-        return ownerId ?? "dummyNoLongerOwned";
-      });
-      return _keys.map((k) => rowsById.get(k) || []);
-    });
-  });
-}

package/src/collections/OneToOneReference.ts

@@ -1,153 +0,0 @@
-import { deTagIds, ensureNotDeleted, fail, getEm, IdOf, Reference, unsafeDeTagIds } from "../";
-import { Entity, EntityMetadata, getMetadata } from "../EntityManager";
-import { AbstractRelationImpl } from "./AbstractRelationImpl";
-import { ManyToOneReference } from "./ManyToOneReference";
-
-/**
- * Represents the "many" side of a one-to-one relationship.
- *
- * I.e. in a one-to-many from Book -> Reviews, there is a review.book_id that can have many books.
- *
- * This class is for when that `review.book_id` column is itself unique, i.e. like `image.book_id`, and
- * so instead of `Book.images: OneToManyCollection` we have a `Book.image: OneToOneReference`.
- *
- * This class implements `Reference` because it is essentially like "one entity pointing/refereing to another",
- * however because we require a `.load` call to lazily know the value of other side (unlike ManyToOneReference
- * which has it's `book_id` column immediately available in the entity `data` hash), there is some wonkiness
- * around methods like `Reference.id` that are usually callable without `load`/`populate`, that for this
- * class can actually only be called post `load`/`populate`.
- *
- * Currently we enforce this with a runtime check, which is not great, but the trade-off of implementing
- * `Reference` seemed worth the downside of a un-type-safe `.id` property.
- */
-export class OneToOneReference<T extends Entity, U extends Entity> extends AbstractRelationImpl<U>
-  implements Reference<T, U, undefined> {
-  private loaded: U | undefined;
-  private isLoaded: boolean = false;
-  private isCascadeDelete: boolean;
-
-  constructor(
-    // These are public to our internal implementation but not exposed in the Collection API
-    public entity: T,
-    public otherMeta: EntityMetadata<U>,
-    public fieldName: keyof T,
-    public otherFieldName: keyof U,
-  ) {
-    super();
-    this.isCascadeDelete = getMetadata(entity).config.__data.cascadeDeleteFields.includes(fieldName as any);
-  }
-
-  get id(): IdOf<U> | undefined {
-    if (this.isLoaded) {
-      return this.loaded?.id as IdOf<U> | undefined;
-    }
-    throw new Error(`${this.entity}.${this.fieldName} was not loaded`);
-  }
-
-  get idOrFail(): IdOf<U> {
-    return this.id || fail(`${this.entity}.${this.fieldName} has no id yet`);
-  }
-
-  get idUntagged(): string | undefined {
-    return this.id && deTagIds(this.otherMeta, [this.id])[0];
-  }
-
-  get idUntaggedOrFail(): string {
-    return this.idUntagged || fail("Reference is unset or assigned to a new entity");
-  }
-
-  get isSet(): boolean {
-    // This will failure if we're not loaded yet
-    return this.id !== undefined;
-  }
-
-  // opts is an internal parameter
-  async load(opts?: { withDeleted?: boolean }): Promise<U | undefined> {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    if (!this.isLoaded) {
-      if (this.entity.id !== undefined) {
-        this.loaded = (
-          await getEm(this.entity).find(this.otherMeta.cstr, {
-            [this.otherFieldName]: this.entity,
-          } as any)
-        )[0];
-      }
-      // this.maybeAppendAddedBeforeLoaded();
-      this.isLoaded = true;
-    }
-    return this.filterDeleted(this.loaded, opts);
-  }
-
-  set(other: U): void {
-    ensureNotDeleted(this.entity);
-    if (other === this.loaded) {
-      return;
-    }
-    if (this.isLoaded) {
-      if (this.loaded) {
-        this.getOtherRelation(this.loaded).set(undefined);
-      }
-    }
-    this.loaded = other;
-    this.isLoaded = true;
-    // This will no-op and mark other dirty if necessary
-    if (other) {
-      this.getOtherRelation(other).set(this.entity);
-    }
-  }
-
-  get getWithDeleted(): U | undefined {
-    return this.filterDeleted(this.doGet(), { withDeleted: true });
-  }
-
-  get get(): U | undefined {
-    return this.filterDeleted(this.doGet(), { withDeleted: false });
-  }
-
-  private doGet(): U | undefined {
-    ensureNotDeleted(this.entity, { ignore: "pending" });
-    if (!this.isLoaded) {
-      // This should only be callable in the type system if we've already resolved this to an instance
-      throw new Error("get was called when not preloaded");
-    }
-    return this.loaded;
-  }
-
-  // internal impl
-
-  setFromOpts(other: U): void {
-    this.set(other);
-  }
-
-  initializeForNewEntity(): void {
-    this.isLoaded = true;
-  }
-
-  async refreshIfLoaded(): Promise<void> {
-    if (this.isLoaded) {
-      this.isLoaded = false;
-      await this.load();
-    }
-  }
-
-  onEntityDelete(): void {
-    // if (this.isCascadeDelete) {
-    //   this.current({ withDeleted: true }).forEach(getEm(this.entity).delete);
-    // }
-  }
-
-  async onEntityDeletedAndFlushing(): Promise<void> {}
-
-  public toString(): string {
-    return `OneToOneReference(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;
-  }
-
-  private filterDeleted(entity: U | undefined, opts?: { withDeleted?: boolean }): U | undefined {
-    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : undefined;
-  }
-
-  /** Returns the other relation that points back at us, i.e. we're `Author.image` and this is `Image.author_id`. */
-  private getOtherRelation(other: U): ManyToOneReference<U, T, any> {
-    return (other as U)[this.otherFieldName] as any;
-  }
-}

package/src/collections/hasManyDerived.ts

@@ -1,29 +0,0 @@
-import { currentlyInstantiatingEntity, getEm, Collection } from "../";
-import { Entity, Loaded, LoadHint } from "../EntityManager";
-import { CustomCollection } from "./CustomCollection";
-
-type HasManyDerivedOpts<T extends Entity, U extends Entity, H extends LoadHint<T>> = {
-  load?: (entity: T) => Promise<any>;
-  get: (entity: Loaded<T, H>) => readonly U[];
-  set?: (entity: Loaded<T, H>, values: U[]) => void;
-  add?: (entity: Loaded<T, H>, value: U) => void;
-  remove?: (entity: Loaded<T, H>, value: U) => void;
-};
-/**
- * Creates a CustomCollection that can conditionally walk across references in the object graph.
- *
- * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
- *
- * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
- */
-export function hasManyDerived<T extends Entity, U extends Entity, H extends LoadHint<T>>(
-  loadHint: H,
-  opts: HasManyDerivedOpts<T, U, H>,
-): Collection<T, U> {
-  const entity: T = currentlyInstantiatingEntity as T;
-  const { load, ...rest } = opts;
-  return new CustomCollection<T, U>(entity, {
-    load: load ?? ((entity) => getEm(entity).populate(entity, loadHint)),
-    ...(rest as any),
-  });
-}

package/src/collections/hasManyThrough.ts

@@ -1,20 +0,0 @@
-import { Collection, CustomCollection, currentlyInstantiatingEntity, Entity, getLens, Lens, loadLens } from "../index";
-
-/**
- * Creates a CustomCollection that will walk across references in the object graph.
- *
- * I.e. An Author "has many reviews" through the `author -> books -> reviews` relation.
- *
- * Because this is based on `CustomCollection`, it will work in populates, i.e. `em.populate(author, "reviews")`.
- */
-export function hasManyThrough<T extends Entity, U extends Entity>(
-  lens: (lens: Lens<T>) => Lens<U, U[]>,
-): Collection<T, U> {
-  const entity: T = currentlyInstantiatingEntity as T;
-  return new CustomCollection<T, U>(entity, {
-    load: async (entity) => {
-      await loadLens(entity, lens);
-    },
-    get: () => getLens(entity, lens),
-  });
-}

package/src/collections/hasOneDerived.ts

@@ -1,26 +0,0 @@
-import { currentlyInstantiatingEntity, getEm, Reference } from "../";
-import { Entity, Loaded, LoadHint } from "../EntityManager";
-import { CustomReference } from "./CustomReference";
-
-/**
- * Creates a CustomReference that can conditionally walk across references in the object graph.
- *
- * I.e. A BookReview "has one author" through the `review -> book -> author` relation.
- *
- * Because this is based on `CustomReference`, it will work in populates, i.e. `em.populate(review, "author")`.
- */
-export function hasOneDerived<
-  T extends Entity,
-  U extends Entity,
-  N extends never | undefined,
-  V extends U | N,
-  H extends LoadHint<T>
->(loadHint: H, get: (entity: Loaded<T, H>) => V): Reference<T, U, N> {
-  const entity: T = currentlyInstantiatingEntity as T;
-  return new CustomReference<T, U, N>(entity, {
-    load: async (entity) => {
-      await getEm(entity).populate(entity, loadHint);
-    },
-    get: () => get(entity as Loaded<T, H>),
-  });
-}