joist-orm 0.1.538 → 1.0.0

package/src/collections/hasOneThrough.ts

@@ -1,20 +0,0 @@
-import { currentlyInstantiatingEntity, CustomReference, Entity, getLens, Lens, loadLens, Reference } from "../index";
-
-/**
- * Creates a CustomReference that will 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 hasOneThrough<T extends Entity, U extends Entity, N extends never | undefined, V extends U | N>(
-  lens: (lens: Lens<T>) => Lens<V>,
-): Reference<T, U, N> {
-  const entity: T = currentlyInstantiatingEntity as T;
-  return new CustomReference<T, U, N>(entity, {
-    load: async (entity) => {
-      await loadLens(entity, lens);
-    },
-    get: () => getLens(entity, lens),
-  });
-}

package/src/collections/index.ts

@@ -1,74 +0,0 @@
-import {
-  Collection,
-  currentlyInstantiatingEntity,
-  Entity,
-  EntityMetadata,
-  ManyToManyCollection,
-  ManyToOneReference,
-  OneToManyCollection,
-  OneToOneReference,
-  Reference,
-} from "../";
-
-export { OneToManyCollection } from "./OneToManyCollection";
-export { OneToOneReference } from "./OneToOneReference";
-export { ManyToOneReference } from "./ManyToOneReference";
-export { ManyToManyCollection } from "./ManyToManyCollection";
-export { CustomReference } from "./CustomReference";
-export { hasOneThrough } from "./hasOneThrough";
-export { hasOneDerived } from "./hasOneDerived";
-export { CustomCollection } from "./CustomCollection";
-export { hasManyThrough } from "./hasManyThrough";
-export { hasManyDerived } from "./hasManyDerived";
-
-/** An alias for creating `OneToManyCollection`s. */
-export function hasMany<T extends Entity, U extends Entity>(
-  otherMeta: EntityMetadata<U>,
-  fieldName: keyof T,
-  otherFieldName: keyof U,
-  otherColumnName: string,
-): Collection<T, U> {
-  const entity = currentlyInstantiatingEntity as T;
-  return new OneToManyCollection(entity, otherMeta, fieldName, otherFieldName, otherColumnName);
-}
-
-/** An alias for creating `ManyToOneReference`s. */
-export function hasOne<T extends Entity, U extends Entity, N extends never | undefined>(
-  otherMeta: EntityMetadata<U>,
-  fieldName: keyof T,
-  otherFieldName: keyof U,
-): Reference<T, U, N> {
-  const entity = currentlyInstantiatingEntity as T;
-  return new ManyToOneReference<T, U, N>(entity, otherMeta, fieldName, otherFieldName);
-}
-
-/** An alias for creating `OneToOneReference`s. */
-export function hasOneToOne<T extends Entity, U extends Entity>(
-  otherMeta: EntityMetadata<U>,
-  fieldName: keyof T,
-  otherFieldName: keyof U,
-): Reference<T, U, undefined> {
-  const entity = currentlyInstantiatingEntity as T;
-  return new OneToOneReference<T, U>(entity, otherMeta, fieldName, otherFieldName);
-}
-
-/** An alias for creating `ManyToManyCollections`s. */
-export function hasManyToMany<T extends Entity, U extends Entity>(
-  joinTableName: string,
-  fieldName: keyof T,
-  columnName: string,
-  otherMeta: EntityMetadata<U>,
-  otherFieldName: keyof U,
-  otherColumnName: string,
-): Collection<T, U> {
-  const entity = currentlyInstantiatingEntity as T;
-  return new ManyToManyCollection<T, U>(
-    joinTableName,
-    entity,
-    fieldName,
-    columnName,
-    otherMeta,
-    otherFieldName,
-    otherColumnName,
-  );
-}

package/src/createOrUpdatePartial.ts

@@ -1,144 +0,0 @@
-import { NullOrDefinedOr } from "./utils";
-import {
-  Entity,
-  EntityConstructor,
-  EntityManager,
-  getMetadata,
-  IdOf,
-  isEntity,
-  isKey,
-  OptIdsOf,
-  OptsOf,
-} from "./EntityManager";
-import { PartialOrNull } from "./index";
-
-/**
- * The type for `EntityManager.createOrUpdateUnsafe` that allows "upsert"-ish behavior.
- *
- * I.e. `T` is an entity with an optional id (create if unset, update if set), and we recurse
- * into any relations (references or collections) to allow those relations themselves to be
- * any combination of 1) ids to existing entities, 2) entities directly, 3) null/undefined
- * with the appropriate partial-update behavior, or 4) partials.
- */
-export type DeepPartialOrNull<T extends Entity> = { id?: IdOf<T> | null } & AllowRelationsToBeIdsOrEntitiesOrPartials<
-  PartialOrNull<OptsOf<T> & OptIdsOf<T>>
-> &
-  OptIdsOf<T>;
-
-type AllowRelationsToBeIdsOrEntitiesOrPartials<T> = {
-  [P in keyof T]: T[P] extends NullOrDefinedOr<infer U>
-    ? U extends Array<infer V>
-      ? V extends Entity
-        ? Array<V | (DeepPartialOrNull<V> & { delete?: boolean | null; remove?: boolean | null }) | IdOf<V>> | null
-        : T[P]
-      : U extends Entity
-      ? U | DeepPartialOrNull<U> | IdOf<U> | null
-      : T[P]
-    : T[P];
-};
-
-/**
- * A utility function to create-or-update entities coming from a partial-update style API.
- */
-export async function createOrUpdatePartial<T extends Entity>(
-  em: EntityManager,
-  constructor: EntityConstructor<T>,
-  opts: DeepPartialOrNull<T>,
-): Promise<T> {
-  const { id, ...others } = opts as any;
-  const meta = getMetadata(constructor);
-  const isNew = id === null || id === undefined;
-
-  // The values in others might be themselves partials, so walk through and resolve them to entities.
-  const p = Object.entries(others).map(async ([key, value]) => {
-    // Watch for the `bookId` / `bookIds` aliases
-    const field = meta.fields.find((f) => f.fieldName === key) || meta.fields.find((f) => f.fieldIdName === key);
-
-    if (!field) {
-      // Allow delete/remove flags that we assume the API layer (i.e. GraphQL) will have specifically
-      // allowed, i.e. this isn't the Rails form bug where users can POST in any random field they want.
-      const flagField = key === "delete" || key === "remove";
-      if (flagField) {
-        // Pass these along for setOpts to look for
-        return [key, value];
-      }
-      throw new Error(`Unknown field ${key}`);
-    }
-
-    // Don't use key b/c it might be the bookId alias
-    const name = field.fieldName;
-
-    if (field.kind === "m2o" && !isEntity(value)) {
-      if (!value || isEntity(value)) {
-        return [name, value];
-      } else if (isKey(value)) {
-        // This is a many-to-one reference
-        const entity = await em.load(field.otherMetadata().cstr, value);
-        return [name, entity];
-      } else if (typeof value === "object" && value && !("id" in value)) {
-        // This is a many-to-one partial into an existing reference that we need to resolve
-        let currentValue: any;
-        if (isNew) {
-          // The parent is brand new so the child is defacto brand new as well
-          currentValue = await createOrUpdatePartial(em, field.otherMetadata().cstr, value);
-        } else {
-          // The parent exists, see if it has an existing child we can update
-          const parentEntity = await em.load(constructor, id, [name] as any);
-          currentValue = (parentEntity as any)[name].get;
-          if (currentValue) {
-            await createOrUpdatePartial(em, field.otherMetadata().cstr, { id: currentValue.id, ...value });
-          } else {
-            // If it doesn't, go ahead and create a new one
-            currentValue = await createOrUpdatePartial(em, field.otherMetadata().cstr, value);
-          }
-        }
-        return [name, currentValue];
-      } else {
-        // This is a many-to-one partial into a new entity
-        const entity = await createOrUpdatePartial(em, field.otherMetadata().cstr, value as any);
-        return [name, entity];
-      }
-    } else if (field.kind === "o2m" || field.kind === "m2m") {
-      // Look for one-to-many/many-to-many partials
-
-      // We allow `delete` and `remove` commands but only if they don't collide with existing fields
-      // Also we trust the API layer, i.e. GraphQL, to not let these fields leak unless explicitly allowed.
-      const allowDelete = !field.otherMetadata().fields.some((f) => f.fieldName === "delete");
-      const allowRemove = !field.otherMetadata().fields.some((f) => f.fieldName === "remove");
-
-      const entities = !value
-        ? []
-        : (value as Array<any>).map(async (value) => {
-            if (!value || isEntity(value)) {
-              return value;
-            } else if (isKey(value)) {
-              return await em.load(field.otherMetadata().cstr, value);
-            } else {
-              // Look for `delete: true/false` and `remove: true/false` markers
-              const deleteMarker = allowDelete && value["delete"];
-              const removeMarker = allowRemove && value["remove"];
-              // Remove the markers, regardless of true/false, before recursing into createOrUpdatePartial to avoid unknown fields
-              if (deleteMarker !== undefined) delete value.delete;
-              if (removeMarker !== undefined) delete value.remove;
-              const entity = await createOrUpdatePartial(em, field.otherMetadata().cstr, value as any);
-              // Put the markers back for setOpts to find
-              if (deleteMarker === true) entity.delete = true;
-              if (removeMarker === true) entity.remove = true;
-              return entity;
-            }
-          });
-      return [name, await Promise.all(entities)];
-    } else {
-      return [name, value];
-    }
-  });
-  const _opts = Object.fromEntries(await Promise.all(p)) as OptsOf<T>;
-
-  if (isNew) {
-    return em.createPartial(constructor, _opts);
-  } else {
-    const entity = await em.load(constructor, id);
-    entity.setPartial(_opts);
-    return entity;
-  }
-}

package/src/getProperties.ts

@@ -1,27 +0,0 @@
-import * as EM from "./EntityManager";
-import { Entity, EntityMetadata } from "./EntityManager";
-
-// Hack to make currentlyInstantiatingEntity assignable
-const em = EM;
-
-/**
- * Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.
- *
- * This is a little tricky because field assignments don't show up on the prototype, so we actually
- * instantiate a throw-away instance to observe the side-effect of what fields it has.
- */
-export function getProperties<T extends Entity>(meta: EntityMetadata<T>): string[] {
-  return [
-    ...Object.getOwnPropertyNames(meta.cstr.prototype),
-    ...Object.keys(
-      new meta.cstr(
-        {
-          register: (metadata: any, entity: any) => {
-            em.currentlyInstantiatingEntity = entity;
-          },
-        } as any,
-        {},
-      ),
-    ),
-  ].filter((key) => key !== "constructor" && !key.startsWith("__"));
-}

package/src/index.ts

@@ -1,400 +0,0 @@
-import { AbstractRelationImpl } from "./collections/AbstractRelationImpl";
-import {
-  currentFlushSecret,
-  Entity,
-  EntityConstructor,
-  EntityManager,
-  EntityMetadata,
-  EntityOrmField,
-  getMetadata,
-  IdOf,
-  Loaded,
-  LoadHint,
-  OptsOf,
-  RelationsIn,
-} from "./EntityManager";
-import { reverseHint } from "./reverseHint";
-
-export * from "./keys";
-export * from "./serde";
-export * from "./EntityManager";
-export { newPgConnectionConfig } from "joist-utils";
-export * from "./reverseHint";
-export * from "./changes";
-export { DeepPartialOrNull } from "./createOrUpdatePartial";
-export { fail } from "./utils";
-export * from "./collections";
-export * from "./QueryBuilder";
-export { BaseEntity } from "./BaseEntity";
-export * from "./loadLens";
-export * from "./getProperties";
-export * from "./newTestInstance";
-
-const F = Symbol();
-const G = Symbol();
-const H = Symbol();
-
-/** A relationship from `T` to `U`, could be any of many-to-one, one-to-many, or many-to-many. */
-export interface Relation<T extends Entity, U extends Entity> {
-  // Make our Relation somewhat non-structural, otherwise since it's a marker interface,
-  // types like `number` or `string` will match it. This also seems to nudge the type
-  // inference inside of `LoadHint` to go beyond "this generic T of Entity has id and __orm"
-  // to "no really this generic T has fields firstName, title, etc.".
-  // See https://stackoverflow.com/questions/53448100/generic-type-of-extended-interface-not-inferred
-  [F]?: T;
-  [G]?: U;
-}
-
-/**
- * A many-to-one / foreign key from `T` to `U`, i.e. book to author.
- *
- * The `N` generic is for whether the field is optional (i.e. the foreign key column is
- * nullable). If it is optional, `N` will be `undefined`, which makes the return types
- * `U | undefined`. If it is not optional, `N` will be `never`, making the return types
- * `U | never` which becomes just `U`.
- */
-export interface Reference<T extends Entity, U extends Entity, N extends never | undefined> extends Relation<T, U> {
-  /** Returns the id of the current assigned entity, or `undefined` if the assigned entity has no id yet, or `undefined` if this column is nullable and currently unset. */
-  id: IdOf<U> | undefined;
-
-  /** Returns the id of the current assigned entity or a runtime error if it's either a) unset or b) set to a new entity that doesn't have an `id` yet. */
-  idOrFail: IdOf<U>;
-
-  idUntagged: string | undefined;
-
-  idUntaggedOrFail: string;
-
-  load(opts?: { withDeleted: boolean }): Promise<U | N>;
-
-  set(other: U | N): void;
-
-  /** Returns `true` if this relation is currently set (i.e. regardless of whether it's loaded, or if it is set but the assigned entity doesn't have an id saved. */
-  isSet: boolean;
-
-  [H]?: N;
-}
-
-/** Adds a known-safe `get` accessor. */
-export interface LoadedReference<T extends Entity, U extends Entity, N extends never | undefined>
-  extends Omit<Reference<T, U, N>, "id"> {
-  // Since we've fetched the entity from the db, we're going to omit out the "| undefined" from Reference.id
-  // which handles "this reference is set to a new entity" and just assume the id is there (or else N which
-  // is for nullable references, which will just always be potentially `undefined`).
-  //
-  // Note that, similar to `.get`, this is _usually_ right, but if the user mutates the object graph after the
-  // populate, i.e. they change some fields to have actually-new / not-included-in-the-`populate` call entities,
-  // then these might turn into runtime errors. But the ergonomics are sufficiently better that it is worth it.
-  id: IdOf<T> | N;
-
-  getWithDeleted: U | N;
-  get: U | N;
-}
-
-/** A collection of `U` within `T`, either one-to-many or many-to-many. */
-export interface Collection<T extends Entity, U extends Entity> extends Relation<T, U> {
-  load(opts?: { withDeleted: boolean }): Promise<ReadonlyArray<U>>;
-
-  find(id: IdOf<U>): Promise<U | undefined>;
-
-  add(other: U): void;
-
-  remove(other: U): void;
-}
-
-/** Adds a known-safe `get` accessor. */
-export interface LoadedCollection<T extends Entity, U extends Entity> extends Collection<T, U> {
-  getWithDeleted: ReadonlyArray<U>;
-  get: ReadonlyArray<U>;
-
-  set(values: U[]): void;
-
-  removeAll(): void;
-}
-
-// https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/
-interface Flavoring<FlavorT> {
-  _type?: FlavorT;
-}
-export type Flavor<T, FlavorT> = T & Flavoring<FlavorT>;
-
-export function setField(entity: Entity, fieldName: string, newValue: any): boolean {
-  ensureNotDeleted(entity, { ignore: "pending" });
-  const em = getEm(entity);
-
-  if (em.isFlushing) {
-    const { flushSecret } = currentFlushSecret.getStore() || {};
-
-    if (flushSecret === undefined) {
-      throw new Error(`Cannot set '${fieldName}' on ${entity} during a flush outside of a entity hook`);
-    }
-
-    if (flushSecret !== em["flushSecret"]) {
-      throw new Error(`Attempting to reuse a hook context outside its flush loop`);
-    }
-  }
-
-  const { data, originalData } = entity.__orm;
-
-  // "Un-dirty" our originalData if newValue is reverting to originalData
-  if (fieldName in originalData) {
-    if (originalData[fieldName] === newValue) {
-      data[fieldName] = newValue;
-      delete originalData[fieldName];
-      return true;
-    }
-  }
-
-  // Push this logic into a field serde type abstraction?
-  const currentValue = data[fieldName];
-  if (currentValue === newValue) {
-    return false;
-  }
-
-  // Only save the currentValue on the 1st change of this field
-  if (!(fieldName in originalData)) {
-    originalData[fieldName] = currentValue;
-  }
-  data[fieldName] = newValue;
-  return true;
-}
-
-/**
- * Sets each value in `values` on the current entity.
- *
- * The default behavior is that passing a value as either `null` or `undefined` will set
- * the field as `undefined`, i.e. automatic `null` to `undefined` conversion.
- *
- * However, if you pass `ignoreUndefined: true`, then any opt that is `undefined` will be treated
- * as "do not set", and `null` will still mean "set to `undefined`". This is useful for implementing
- * APIs were an input of `undefined` means "do not set / noop" and `null` means "unset".
- */
-export function setOpts<T extends Entity>(
-  entity: T,
-  values: Partial<OptsOf<T>> | string | undefined,
-  opts?: { calledFromConstructor?: boolean; partial?: boolean },
-): void {
-  // If `values` is a string (i.e. the id), this instance is being hydrated from a database row, so skip all this.
-  // If `values` is undefined, we're being called by `createPartial` that will do its own opt handling.
-  if (values === undefined || typeof values === "string") {
-    return;
-  }
-  const { calledFromConstructor, partial } = opts || {};
-  const meta = getMetadata(entity);
-
-  Object.entries(values as {}).forEach(([key, _value]) => {
-    const field = meta.fields.find((f) => f.fieldName === key);
-    if (!field) {
-      throw new Error(`Unknown field ${key}`);
-    }
-
-    // If ignoreUndefined is set, we treat undefined as a noop
-    if (partial && _value === undefined) {
-      return;
-    }
-    // We let optional opts fields be `| null` for convenience, and convert to undefined.
-    const value = _value === null || (typeof _value === "string" && _value.trim() === "") ? undefined : _value;
-    const current = (entity as any)[key];
-    if (current instanceof AbstractRelationImpl) {
-      if (calledFromConstructor) {
-        current.setFromOpts(value);
-      } else if (partial && (field.kind === "o2m" || field.kind === "m2m")) {
-        // For setPartial collections, we individually add/remove instead of set.
-        const allowDelete = !field.otherMetadata().fields.some((f) => f.fieldName === "delete");
-        const allowRemove = !field.otherMetadata().fields.some((f) => f.fieldName === "remove");
-        (value as any[]).forEach((e) => {
-          if (allowDelete && e.delete === true) {
-            getEm(entity).delete(e);
-          } else if (allowRemove && e.remove === true) {
-            (current as any).remove(e);
-          } else {
-            (current as any).add(e);
-          }
-        });
-      } else {
-        current.set(value);
-      }
-    } else {
-      (entity as any)[key] = value;
-    }
-  });
-  if (calledFromConstructor) {
-    Object.values(entity).forEach((v) => {
-      if (v instanceof AbstractRelationImpl) {
-        v.initializeForNewEntity();
-      }
-    });
-  }
-}
-
-export function ensureNotDeleted(entity: Entity, opts: { ignore?: EntityOrmField["deleted"] } = {}): void {
-  if (entity.isDeletedEntity && (opts.ignore === undefined || entity.__orm.deleted !== opts.ignore)) {
-    throw new Error(`${entity} is marked as deleted`);
-  }
-}
-
-/** Adds `null` to every key in `T` to accept partial-update-style input. */
-export type PartialOrNull<T> = {
-  [P in keyof T]?: T[P] | null;
-};
-
-export function getRequiredKeys<T extends Entity>(entity: T): string[];
-export function getRequiredKeys<T extends Entity>(type: EntityConstructor<T>): string[];
-export function getRequiredKeys<T extends Entity>(entityOrType: T | EntityConstructor<T>): string[] {
-  return getMetadata(entityOrType as any)
-    .fields.filter((f) => f.required)
-    .map((f) => f.fieldName);
-}
-
-/** Entity validation errors; if `entity` is invalid, throw a `ValidationError`. */
-export type ValidationRule<T extends Entity> = (
-  entity: T,
-) => MaybePromise<string | ValidationError | ValidationError[] | undefined>;
-
-type MaybePromise<T> = T | PromiseLike<T>;
-
-export type ValidationError = { entity: Entity; message: string };
-
-export class ValidationErrors extends Error {
-  constructor(public errors: ValidationError[]) {
-    super(errorMessage(errors));
-  }
-}
-
-export function newRequiredRule<T extends Entity>(key: keyof T): ValidationRule<T> {
-  return (entity) => (entity.__orm.data[key] === undefined ? `${key} is required` : undefined);
-}
-
-function errorMessage(errors: ValidationError[]): string {
-  if (errors.length === 1) {
-    return `Validation error: ${errors[0].message}`;
-  } else {
-    return `Validation errors (${errors.length}): ${errors.map((e) => e.message).join(", ")}`;
-  }
-}
-
-export type EntityHook = "beforeFlush" | "beforeDelete" | "afterValidation" | "afterCommit";
-type HookFn<T extends Entity, C> = (entity: T, ctx: C) => MaybePromise<void>;
-
-export class ConfigData<T extends Entity, C> {
-  /** The validation rules for this entity type. */
-  rules: ValidationRule<T>[] = [];
-  /** The async derived fields for this entity type. */
-  asyncDerivedFields: Partial<Record<keyof T, [LoadHint<T>, (entity: T) => any]>> = {};
-  /** The hooks for this instance. */
-  hooks: Record<EntityHook, HookFn<T, C>[]> = {
-    beforeDelete: [],
-    beforeFlush: [],
-    afterCommit: [],
-    afterValidation: [],
-  };
-  // Load-hint-ish structures that point back to instances that depend on us for validation rules.
-  reactiveRules: string[][] = [];
-  // Load-hint-ish structures that point back to instances that depend on us for derived values.
-  reactiveDerivedValues: string[][] = [];
-  cascadeDeleteFields: Array<keyof RelationsIn<T>> = [];
-}
-
-export class ConfigApi<T extends Entity, C> {
-  __data = new ConfigData<T, C>();
-
-  addRule<H extends LoadHint<T>>(populate: H, rule: ValidationRule<Loaded<T, H>>): void;
-  addRule(rule: ValidationRule<T>): void;
-  addRule(ruleOrHint: ValidationRule<T> | any, maybeRule?: ValidationRule<any>): void {
-    if (typeof ruleOrHint === "function") {
-      this.__data.rules.push(ruleOrHint);
-    } else {
-      const fn = async (entity: T) => {
-        const em = getEm(entity);
-        const loaded = await em.populate(entity, ruleOrHint);
-        return maybeRule!(loaded);
-      };
-      // Squirrel our hint away where configureMetadata can find it
-      (fn as any).hint = ruleOrHint;
-      this.__data.rules.push(fn);
-    }
-  }
-
-  cascadeDelete(relationship: keyof RelationsIn<T>): void {
-    this.__data.cascadeDeleteFields.push(relationship);
-    this.beforeDelete(relationship, (entity) => {
-      const relation = (entity[relationship] as any) as AbstractRelationImpl<T>;
-      relation.onEntityDelete();
-    });
-  }
-
-  /** Registers `fn` as the lambda to provide the async value for `key`. */
-  setAsyncDerivedField<P extends keyof T, H extends LoadHint<T>>(
-    key: P,
-    populate: H,
-    fn: (entity: Loaded<T, H>) => T[P],
-  ): void {
-    this.__data.asyncDerivedFields[key] = [populate, fn as any];
-  }
-
-  private addHook(hook: EntityHook, ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>) {
-    if (typeof ruleOrHint === "function") {
-      this.__data.hooks[hook].push(ruleOrHint);
-    } else {
-      const fn = async (entity: T, ctx: C) => {
-        // TODO Use this for reactive beforeFlush
-        const em = getEm(entity);
-        const loaded = await em.populate(entity, ruleOrHint);
-        return maybeFn!(loaded, ctx);
-      };
-      // Squirrel our hint away where configureMetadata can find it
-      (fn as any).hint = ruleOrHint;
-      this.__data.hooks[hook].push(fn);
-    }
-  }
-
-  beforeDelete<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
-  beforeDelete(fn: HookFn<T, C>): void;
-  beforeDelete(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {
-    this.addHook("beforeDelete", ruleOrHint, maybeFn);
-  }
-
-  beforeFlush<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
-  beforeFlush(fn: HookFn<T, C>): void;
-  beforeFlush(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {
-    this.addHook("beforeFlush", ruleOrHint, maybeFn);
-  }
-
-  afterValidation<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
-  afterValidation(fn: HookFn<T, C>): void;
-  afterValidation(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {
-    this.addHook("afterValidation", ruleOrHint, maybeFn);
-  }
-
-  afterCommit(fn: HookFn<T, C>): void {
-    this.addHook("afterCommit", fn);
-  }
-}
-
-/** Processes the metas based on any custom calls to the `configApi` hooks. */
-export function configureMetadata(metas: EntityMetadata<any>[]): void {
-  metas.forEach((meta) => {
-    // Look for reactive validation rules to reverse
-    meta.config.__data.rules.forEach((rule) => {
-      if ((rule as any).hint) {
-        const reversals = reverseHint(meta.cstr, (rule as any).hint);
-        // For each reversal, tell its config about the reverse hint to force-re-validate
-        // the original rule's instance any time it changes.
-        reversals.forEach(([otherEntity, reverseHint]) => {
-          getMetadata(otherEntity).config.__data.reactiveRules.push(reverseHint);
-        });
-      }
-    });
-    // Look for reactive async derived values rules to reverse
-    Object.entries(meta.config.__data.asyncDerivedFields).forEach(([, entry]) => {
-      const hint = entry![0];
-      const reversals = reverseHint(meta.cstr, hint);
-      reversals.forEach(([otherEntity, reverseHint]) => {
-        getMetadata(otherEntity).config.__data.reactiveDerivedValues.push(reverseHint);
-      });
-    });
-  });
-}
-
-export function getEm(entity: Entity): EntityManager {
-  return entity.__orm.em;
-}