joist-core 2.3.0 → 2.4.0

package/build/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["import { resetConstructorMap } from \"src/configure.ts\";\nimport { AsyncDefault } from \"src/defaults.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport {\n  type EntityConstructor,\n  type EntityField,\n  type EntityMetadata,\n  type FieldsOf,\n  type LoadHint,\n  type Loaded,\n  type MaybeAbstractEntityConstructor,\n  type Reacted,\n  type ReactiveHint,\n  type RelationsIn,\n  type SettableFields,\n  fail,\n  getMetadata,\n} from \"src/index.ts\";\nimport { convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { type ValidationRule, type ValidationRuleInternal } from \"src/rules.ts\";\nimport { type MaybePromise } from \"src/utils.ts\";\n\nexport type EntityHook =\n  | \"beforeFlush\"\n  | \"beforeCreate\"\n  | \"beforeUpdate\"\n  | \"beforeDelete\"\n  | \"afterValidation\"\n  | \"beforeCommit\"\n  | \"afterCommit\";\ntype HookFn<T extends Entity, C> = (entity: T, ctx: C) => MaybePromise<unknown>;\n\ntype AddReactionOpts = { runOnce?: boolean; name?: string };\n\nexport const constraintNameToValidationError: Record<string, string> = {};\n\ntype Settable<T extends Entity> = keyof SettableFields<FieldsOf<T>> & string;\n\nlet booted = false;\nlet afterMetadataLocked = false;\n\n/**\n * Called at the end of `configureMetadata` to indicate the boot process is complete.\n *\n * We use this flag to prevent users from mistakenly calling `config` methods after the boot\n * process is complete, i.e. from hooks or other post-boot invocations, where the calls are\n * not guaranteed to work because Joist's reactivity graph has already been initialized.\n */\nexport function setBooted(): void {\n  booted = true;\n}\n\nexport function setAfterMetadataLocked(): void {\n  afterMetadataLocked = true;\n}\n\n/** The public API to configure an Entity's hooks & validation rules. */\nexport class ConfigApi<T extends Entity, C> {\n  __data = new ConfigData<T, C>();\n\n  /**\n   * Maps a given `constraintName`, i.e. `authors_publisher_id_unique_index`, to a hard-coded-but-pretty validation errors.\n   *\n   * Note that the validationError must be hard-coded b/c we cannot tease out \"which entity\" caused a given\n   * constraint failure from the SQL database. If you really need pretty-and-custom validation errors, you'll\n   * need to check the constraint by hand ahead of time, before calling `em.flush`.\n   */\n  addConstraintMessage(constraintName: string, validationError: string) {\n    this.ensurePreBoot(getCallerName(), \"addConstraintMessage\");\n    constraintNameToValidationError[constraintName] = validationError;\n  }\n\n  /**\n   * Maps a `RecursiveCycleError` on the given recursive collection field to a custom validation error.\n   *\n   * When a cycle is detected in a recursive collection (e.g. `parentsRecursive`), instead of\n   * throwing a raw `RecursiveCycleError`, `em.flush` will convert it into a `ValidationErrors`\n   * using the provided message function.\n   *\n   * The `messageFn` receives the entity that detected the cycle and the cycle path (array of\n   * entities forming the cycle), and should return a validation error string.\n   */\n  addCycleRule(fieldName: string & keyof T, messageFn: (entity: T, cyclePath: Entity[]) => string) {\n    this.ensurePreBoot(getCallerName(), \"addCycleRule\");\n    this.__data.cycleMessages[fieldName] = messageFn;\n    // Register a reactive rule that loads the recursive collection and catches cycle errors.\n    // The rule uses the recursive collection's underlying relation as a reactive hint so it\n    // triggers when the collection changes.\n    const hint = fieldName as any;\n    const fn = () => {\n      // We don't actually need a try/catch/anything here, b/c if there is a cycle, it\n      // will cause a CycleError during followReverseHint, and never even get to calling this fn.\n    };\n    this.__data.rules.push({ name: `addCycleRule(${getCallerName()})`, fn, hint });\n  }\n\n  /**\n   * Adds a validation rule for this entity.\n   *\n   * If `hint` is passed, then the rule's lambda will be: 1) passed a view of the entity with only\n   * the fields included in `hint` marked as accessible, and 2) the rule will be called reactively any\n   * time any field in the `hint` changes.\n   *\n   * If lambdas want to access fields w/o having them marked for reactivity, the rule can either\n   * include the field as readonly with a `:ro` suffix, i.e. `firstName:ro`, or the lambda can\n   * access the `reacted.entity` property to get a full view of the entity's fields and methods.\n   */\n  addRule<H extends ReactiveHint<T>>(hint: H, rule: ValidationRule<Reacted<T, H>>): void;\n  addRule(rule: ValidationRule<T>): void;\n  addRule(ruleOrHint: ValidationRule<T> | any, maybeRule?: ValidationRule<any>): void {\n    // Keep the name for easy debugging/tracing later\n    const name = `addRule(${getCallerName()})`;\n    this.ensurePreBoot(name, \"addRule\");\n    pushValidationRule(this.__data.rules, name, ruleOrHint, maybeRule);\n  }\n\n  /**\n   * Adds a \"commit rule\" that runs like a regular validation rule (see {@link addRule}), but *after*\n   * the entity's `INSERT`/`UPDATE`/`DELETE` has been flushed to the database and *before* the\n   * transaction `COMMIT`s, i.e. still within the transaction.\n   *\n   * The point of running this late is that any `em.find`s the rule makes will query the _changed_\n   * state (the just-flushed rows), instead of the pre-flush state that regular `addRule` rules see.\n   * This is useful for cross-row invariants that are easiest to express as a query, e.g. \"at most\n   * one active `AuthorSchedule` per author\", where the rule wants to `em.find` the sibling rows\n   * that were themselves just inserted/updated in this same flush.\n   *\n   * Like `addRule`, if a `hint` is passed the rule is reactive: it runs whenever any field in the\n   * hint changes (walking back to the owning entity), and the lambda gets a `Reacted` view.\n   */\n  addCommitRule<H extends ReactiveHint<T>>(hint: H, rule: ValidationRule<Reacted<T, H>>): void;\n  addCommitRule(rule: ValidationRule<T>): void;\n  addCommitRule(ruleOrHint: ValidationRule<T> | any, maybeRule?: ValidationRule<any>): void {\n    // Keep the name for easy debugging/tracing later\n    const name = `addCommitRule(${getCallerName()})`;\n    this.ensurePreBoot(name, \"addCommitRule\");\n    pushValidationRule(this.__data.commitRules, name, ruleOrHint, maybeRule);\n  }\n\n  /** If both this entity, and `cstr` entities, are in the same `em.flush`, run us first. */\n  runHooksBefore(cstr: EntityConstructor<any>): void {\n    this.__data.runHooksBefore.push(cstr);\n  }\n\n  /** Deletes any entity/entities pointed to by `relation` when this entity is deleted. */\n  cascadeDelete(relation: keyof RelationsIn<T> & LoadHint<T>): void {\n    this.ensurePreBoot(getCallerName(), \"cascadeDelete\");\n    this.__data.cascadeDeleteFields.push(relation);\n  }\n\n  touchOnChange(relation: keyof RelationsIn<T>): void {\n    this.ensurePreBoot(getCallerName(), \"touchOnChange\");\n    this.__data.touchOnChange.add(relation);\n  }\n\n  private addHook(hook: EntityHook, ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>) {\n    this.ensurePreBoot(getCallerName(), \"addHook\");\n    if (typeof ruleOrHint === \"function\") {\n      this.__data.hooks[hook].push(ruleOrHint);\n    } else {\n      const fn = async (entity: T, ctx: C) => {\n        // TODO Use this for reactive beforeFlush\n        const loaded = await entity.em.populate(entity, ruleOrHint);\n        return maybeFn!(loaded, ctx);\n      };\n      // Squirrel our hint away where configureMetadata can find it\n      (fn as any).hint = ruleOrHint;\n      this.__data.hooks[hook].push(fn);\n    }\n  }\n\n  afterMetadata(fn: AfterMetadataCallback<T>): void {\n    if (afterMetadataLocked) {\n      throw new Error(\n        `config.afterMetadata on ${getCallerName()} must only be called on boot, before calling \\`configureMetadata\\` and not from other \\`afterMetadata\\` hooks.`,\n      );\n    }\n    this.__data.afterMetadataCallbacks.push(fn);\n  }\n\n  beforeDelete<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;\n  beforeDelete(fn: HookFn<T, C>): void;\n  beforeDelete(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {\n    this.addHook(\"beforeDelete\", ruleOrHint, maybeFn);\n  }\n\n  beforeFlush<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;\n  beforeFlush(fn: HookFn<T, C>): void;\n  beforeFlush(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {\n    this.addHook(\"beforeFlush\", ruleOrHint, maybeFn);\n  }\n\n  // beforeCreate still needs to take a hint because even though the entity itself is New<T>, we might want to load\n  // a nested relation that isn't loaded yet\n  beforeCreate<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;\n  beforeCreate(fn: HookFn<T, C>): void;\n  beforeCreate(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {\n    this.addHook(\"beforeCreate\", ruleOrHint, maybeFn);\n  }\n\n  beforeUpdate<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;\n  beforeUpdate(fn: HookFn<T, C>): void;\n  beforeUpdate(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {\n    this.addHook(\"beforeUpdate\", ruleOrHint, maybeFn);\n  }\n\n  afterValidation<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;\n  afterValidation(fn: HookFn<T, C>): void;\n  afterValidation(ruleOrHint: HookFn<T, C> | any, maybeFn?: HookFn<Loaded<T, any>, C>): void {\n    this.addHook(\"afterValidation\", ruleOrHint, maybeFn);\n  }\n\n  beforeCommit(fn: HookFn<T, C>): void {\n    this.addHook(\"beforeCommit\", fn);\n  }\n\n  afterCommit(fn: HookFn<T, C>): void {\n    this.addHook(\"afterCommit\", fn);\n  }\n\n  /**\n   * Adds a reaction that runs during flush whenever fields in the `hint` change.\n   *\n   * Reactions are somewhere in between hooks and reactive fields/references:\n   * 1. Can make arbitrary changes to any entity like a hook\n   * 2. Only run when the provided hint has changes, not on every flush, like an RF/RR\n   * 3. Run when the entity itself has no changes, like an RF/RF\n   * 4. Can run multiple times per flush, like an RF/RF.  Be careful to avoid creating\n   *    circular dependencies in the hint and to make the function idempotent.\n   *\n   * @param hint The fields to watch for changes and load before running the reaction\n   * @param fn The reaction function to run\n   */\n  addReaction<H extends ReactiveHint<T>>(hint: H, fn: HookFn<Loaded<T, H>, C>): void;\n  /**\n   * Adds a named reaction that runs during flush whenever fields in the `hint` change.\n   *\n   * Reactions are somewhere in between hooks and reactive fields/references:\n   * 1. Can make arbitrary changes to any entity like a hook\n   * 2. Only run when `hint` has changes, not on every flush, like an RF/RR\n   * 3. Can run when the entity itself has no changes, like an RF/RF\n   * 4. Can run multiple times per flush, like an RF/RF.  Be careful to avoid creating\n   *    circular dependencies in the hint and to make the function idempotent.\n   *\n   * @param name A name to identify this reaction for debugging\n   * @param hint The fields to watch for changes and load before running the reaction\n   * @param fn The reaction function to run\n   */\n  addReaction<H extends ReactiveHint<T>>(name: string, hint: H, fn: HookFn<Loaded<T, H>, C>): void;\n  /**\n   * Adds a reaction that runs during flush whenever fields in the `hint` change.\n   *\n   * Reactions are somewhere in between hooks and reactive fields/references:\n   * 1. Can make arbitrary changes to any entity like a hook\n   * 2. Only run when `hint` has changes, not on every flush, like an RF/RR\n   * 3. Can run when the entity itself has no changes, like an RF/RF\n   * 4. Can run multiple times per flush, like an RF/RF.  Be careful to avoid creating\n   *    circular dependencies in the hint and to make the function idempotent.\n   *\n   * @param opts Options object containing:\n   *   - runOnce - If true, the reaction will only run once per flush, not every time the hint changes. Optional.\n   *   default: false.\n   *   - name - A name to identify this reaction for debugging\n   * @param hint The fields to watch for changes and load before running the reaction\n   * @param fn The reaction function to run\n   */\n  addReaction<H extends ReactiveHint<T>>(opts: AddReactionOpts, hint: H, fn: HookFn<Loaded<T, H>, C>): void;\n  addReaction<H extends ReactiveHint<T>>(\n    nameOrOptsOrHint: string | AddReactionOpts | H,\n    hintOrFn: H | HookFn<Loaded<T, H>, C>,\n    maybeFn?: HookFn<Loaded<T, H>, C>,\n  ): void {\n    // Keep the name so we can uniquely identify this reaction later and also aid debugging/tracing\n    const fn = maybeFn ?? (hintOrFn as HookFn<Loaded<T, H>, C>);\n    const hint = (maybeFn ? hintOrFn : nameOrOptsOrHint) as H;\n    const opts = maybeFn\n      ? typeof nameOrOptsOrHint === \"string\"\n        ? { name: nameOrOptsOrHint }\n        : (nameOrOptsOrHint as AddReactionOpts)\n      : {};\n    const { name = getCallerName(), runOnce = false } = opts;\n    this.ensurePreBoot(name, \"addReaction\");\n    // Cache load hints per-meta because CTI subtypes may resolve `hint` to different\n    // load hints (e.g. an AsyncProperty overridden in the subtype with subtype-only relations).\n    const loadHints = new Map<EntityMetadata, LoadHint<T>>();\n    const wrappedFn = (entity: T, ctx: C) => {\n      const meta = getMetadata(entity);\n      let loadHint = loadHints.get(meta);\n      if (loadHint === undefined) {\n        loadHint = convertToLoadHint<T>(meta, hint);\n        loadHints.set(meta, loadHint);\n      }\n      if (Object.keys(loadHint).length > 0) {\n        return entity.em.populate(entity, loadHint).then((loaded) => fn(loaded as Loaded<T, H>, ctx));\n      }\n      return fn(entity as Loaded<T, H>, ctx);\n    };\n    this.__data.reactions.push({ name, fn: wrappedFn, hint, runOnce });\n  }\n\n  /** Adds a synchronous default for `fieldName` to a hard-coded `value`. */\n  setDefault<K extends Settable<T>, F = FieldsOf<T>[K]>(\n    fieldName: K,\n    // Allow returning undefined to mean \"no default\"\n    value: F extends EntityField ? F[\"type\"] : never,\n  ): void;\n  /** Adds a synchronous default for `fieldName` to the result of simple sync lambda. */\n  setDefault<K extends Settable<T>, F = FieldsOf<T>[K]>(\n    fieldName: K,\n    // ...this doesn't technically declare what other fields of `entity` we depend on,\n    // which ideally we want to drive \"which default to set first?\" precedence decisions.\n    fn: (entity: T) => F extends EntityField ? F[\"type\"] | undefined : never,\n  ): void;\n  /** Adds an asynchronous default for `fieldName` to the result of a hinted lambda. */\n  setDefault<K extends Settable<T>, const H extends ReactiveHint<T>, F = FieldsOf<T>[K]>(\n    fieldName: K,\n    // We use a ReactiveHint so that we get field-level dependencies that means someday\n    // we could drive \"which default to set first?\" precedence decisions.\n    hint: H,\n    fn: (\n      entity: Reacted<T, H>,\n      ctx: C,\n    ) => F extends { kind: \"m2o\"; type: infer T extends Entity }\n      ? MaybePromise<T | Reacted<T, {}> | undefined>\n      : F extends EntityField\n        ? MaybePromise<F[\"type\"] | undefined>\n        : never,\n  ): void;\n  setDefault<K extends keyof SettableFields<FieldsOf<T>> & string>(fieldName: K, hintOrFnOrValue: any, fn?: any): void {\n    this.ensurePreBoot(getCallerName(), \"setDefault\");\n    if (fn) {\n      // If we're called once by the codegen, and again by the user, override the syncDefault\n      delete this.__data.syncDefaults[fieldName];\n      this.__data.asyncDefaults[fieldName] = new AsyncDefault(fieldName, hintOrFnOrValue, fn);\n    } else {\n      this.__data.syncDefaults[fieldName] = hintOrFnOrValue;\n    }\n  }\n\n  /**\n   * A noop method that exists solely to keep the `config.placeholder()` line in the initial entity file,\n   * until the user is ready to use it. */\n  placeholder(): void {}\n\n  private ensurePreBoot(name: string, op: string): void {\n    if (booted) {\n      // Detect if this is NextJS and we're in a hot-reload situation\n      if (isRunningInNextJs()) {\n        // Reset our bag of config data to collect only the new rules/hooks\n        this.__data = new ConfigData();\n        resetBootFlag();\n      } else {\n        throw new Error(\n          `config.${op} call on ${name} must only be called on boot, before calling \\`configureMetadata\\`.`,\n        );\n      }\n    }\n  }\n}\n\nfunction isRunningInNextJs(): boolean {\n  return \"__NEXT_HTTP_AGENT\" in globalThis || \"__NEXT_HTTPS_AGENT\" in globalThis;\n}\n\n/**\n * Allows projects to manually reset the internal `booted` flag.\n *\n * This is only necessary if they're using hot-reloading and reloading their entity files\n * without restarting the server.\n *\n * Generally most tools like tsx or ts-node-dev reload the whole process, so don't need\n * to call this, but if Joist is used in a framework that does actual-hot-reloading, this\n * it will be necessary.\n */\nexport function resetBootFlag(): void {\n  booted = false;\n  afterMetadataLocked = false;\n  resetConstructorMap();\n}\n\n/**\n * Stores a path back to a reactive rule.\n *\n * I.e. if `Book` has a `ruleFn` that reacts to `Author.title`, then `Author`'s config will have\n * a `ReactiveRule` with fields `[\"title\"]`, path `books`, and rule `ruleFn`.\n */\nexport interface ReactiveRule {\n  /** The source we're reacting to, specifically which base/subtype cstr. */\n  source: MaybeAbstractEntityConstructor<any>;\n  /** The fields on this source entity that would trigger the downstream rule's eval. */\n  fields: string[];\n  /** The constructor of downstream entity that owns the reactive rule. */\n  cstr: MaybeAbstractEntityConstructor<any>;\n  /** The name (source location) of the downstream reactive rule. */\n  name: string;\n  /** The path from this source entity to the downstream entity that needs evaled. */\n  path: string[];\n  /** The downstream validation rule to eval. */\n  fn: ValidationRule<any>;\n}\n\n/**\n * Stores a path back to a reactive derived field.\n *\n * I.e. if `Book.displayName` is an `asyncField` that reacts to `Author.title`, then `Author`'s config will have\n * a `ReactiveFields` with fields `[\"title\"]`, path `books`, and name `displayName`.\n */\nexport interface ReactiveField {\n  kind: \"populate\" | \"query\";\n  /** The fields on this source entity that would trigger the downstream field's recalc. */\n  fields: string[];\n  /** Read-only/immutable fields that are used in the derived field. */\n  isReadOnly: boolean;\n  /** The constructor of downstream entity that owns the derived field. */\n  cstr: MaybeAbstractEntityConstructor<any>;\n  /** The path from this source entity to the downstream entity that needs recalced. */\n  path: string[];\n  /** The name of the reactive field in the downstream entity to recalc. */\n  name: string;\n  runOnce: false;\n}\n\nexport interface Reaction {\n  kind: \"reaction\";\n  /** The source we're reacting to, specifically which base/subtype cstr. */\n  source: MaybeAbstractEntityConstructor<any>;\n  /** The fields on this source entity that would trigger the downstream hook's eval. */\n  fields: string[];\n  /** Read-only/immutable fields that are used in the function. */\n  isReadOnly: boolean;\n  /** The constructor of downstream entity that owns the reaction. */\n  cstr: MaybeAbstractEntityConstructor<any>;\n  /** The name (source location) of the downstream reaction. */\n  name: string;\n  /** The path from this source entity to the downstream entity for this reaction. */\n  path: string[];\n  /** The downstream reaction function. */\n  fn: HookFn<any, any>;\n  /** If true, the reaction should only run once per flush, not every time the hint changes. */\n  runOnce: boolean;\n}\n\nexport type Reactable = ReactiveField | Reaction;\n\ninterface ReactionInternal<T extends Entity, H extends ReactiveHint<T>, C> {\n  name: string;\n  fn: HookFn<T, C>;\n  hint: H;\n  runOnce: boolean;\n}\n\ntype AfterMetadataCallback<T extends Entity> = (meta: EntityMetadata<T>) => void;\n\n/** The internal state of an entity's configuration data, i.e. validation rules/hooks. */\nexport class ConfigData<T extends Entity, C> {\n  afterMetadataCallbacks: AfterMetadataCallback<T>[] = [];\n  runHooksBefore: EntityConstructor<any>[] = [];\n  /** The validation rules for this entity type. */\n  rules: ValidationRuleInternal<T>[] = [];\n  /** The \"commit rules\" for this entity type, i.e. validation rules that run post-flush/pre-commit. */\n  commitRules: ValidationRuleInternal<T>[] = [];\n  /** The reactions for this entity type. */\n  reactions: ReactionInternal<T, any, C>[] = [];\n  /** The hooks for this entity type. */\n  hooks: Record<EntityHook, HookFn<T, C>[]> = {\n    beforeDelete: [],\n    beforeFlush: [],\n    beforeCreate: [],\n    beforeUpdate: [],\n    afterValidation: [],\n    beforeCommit: [],\n    afterCommit: [],\n  };\n  /** Synchronous defaults for this entity type, invoked on `em.create`. */\n  syncDefaults: Record<string, ((entity: T) => void) | unknown> = {};\n  /** Asynchronous defaults for this entity type, invoked on `em.flush`. */\n  asyncDefaults: Record<string, AsyncDefault<T>> = {};\n\n  // An array of the reactive rules that depend on this entity\n  reactiveRules: ReactiveRule[] = [];\n  // An array of the reactive *commit* rules (post-flush/pre-commit) that depend on this entity\n  reactiveCommitRules: ReactiveRule[] = [];\n  // An array of the reactive fields and reactions that depend on this entity\n  reactables: Reactable[] = [];\n  cascadeDeleteFields: Array<keyof RelationsIn<T>> = [];\n  touchOnChange: Set<keyof RelationsIn<T>> = new Set();\n  // Constantly converting reactive hints to load hints is expense, so cache them here\n  cachedReactiveLoadHints: Record<string, any> = {};\n  /** Maps recursive collection fieldNames to custom cycle error message functions. */\n  cycleMessages: Record<string, (entity: T, cyclePath: Entity[]) => string> = {};\n}\n\nexport function getCallerName(extraFrames: number = 0): string {\n  const err = getStack();\n  // E.g. at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)\n  // (Make sure to drop lines that don't start with 'at' b/c the stack format can differ\n  // slightly i.e. if running via tsx/using a node loader (probably?)\n  const line = err.stack!.split(\"\\n\").filter((line) => line.includes(\" at \"))[3 + extraFrames];\n  const parts = line.split(\"/\");\n  // Get the last part, which will be the file name, i.e. Activity.ts:86:8\n  return parts[parts.length - 1].replace(/:\\d+\\)?$/, \"\");\n}\n\nexport function getFuzzyCallerName(): string {\n  const err = getStack();\n  const lines = err\n    .stack!.split(\"\\n\")\n    // E.g. at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)\n    .filter((line) => line.includes(\" at \"));\n  const line = findUserCodeLine(lines);\n  return getFilePath(line);\n}\n\n/**\n * Given a callstack line return the file name.\n *\n * I.e. `at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)`\n */\nexport function getFilePath(line: string): string {\n  const parts = line.split(\"/\");\n  return parts[parts.length - 1].replace(/:\\d+\\)?$/, \"\"); // Drop the `:8)`at the end\n}\n\n/** Given a callstack, uses heuristics to find the first line that looks like user code. */\nexport function findUserCodeLine(lines: string[]): string {\n  return (\n    lines.find((line) => {\n      // When running Joist's own integration tests, if we ignore `/joist-orm/`, we'll end up ignoring\n      // everything because `joist-orm` is the name of the repository/working copy itself.\n      const withinWorkingCopyJoist = line.includes(\"/packages/orm/\") || line.includes(\"/packages/core\");\n      // But once we're not in a working copy, assume any `/joist-orm/` in the path === internal orm stack frames\n      const withinProductionJoist =\n        !withinWorkingCopyJoist && (line.includes(\"/joist-orm/src/\") || line.includes(\"/joist-core/src\"));\n      const nodeInternals = line.includes(\"node:internal/\") || line.includes(\"Promise.all\");\n      const isUserCode = !withinWorkingCopyJoist && !withinProductionJoist && !nodeInternals;\n      // const isRecalc = line.includes(\".recalcPending\");\n      const isDefault = line.includes(\"/defaults.ts\");\n      // Batched calls like findOrCreate won't have a stack trace back to the true caller, so just stop there\n      const isDataloader = line.includes(\"/dataloaders/\");\n      // If this is the `newTestInstance` call\n      // What about:\n      // recalcSynchronousDerivedFields\n      return (\n        (isDefault || isDataloader || isUserCode) &&\n        !line.includes(\"Codegen.ts\") &&\n        // I wanted to exclude this, but it was actually our utils/entities.ts maybeSetDefault helper method\n        // !line.includes(\"entities.ts\") &&\n        // Ignore loops in joist code like setOpts\n        !line.includes(\"at Array\") &&\n        // Ignore the Author.ts constructor calling setOpts\n        !line.includes(\"at new \")\n      );\n    }) ?? fail(\"Could not find caller name\")\n  );\n}\n\nconst getStack: () => { stack?: string } = \"captureStackTrace\" in Error ? getStackFromCapture : getStackFromObject;\n\nfunction getStackFromCapture(): { stack?: string } {\n  const obj = {};\n  Error.captureStackTrace(obj);\n  return obj as any;\n}\n\nfunction getStackFromObject(): { stack?: string } {\n  try {\n    throw Error(\"\");\n  } catch (err) {\n    return err as Error;\n  }\n}\n\n/** Pushes a validation rule (either the raw or hinted/reactive form) onto `rules`, shared by `addRule`/`addCommitRule`. */\nfunction pushValidationRule<T extends Entity>(\n  rules: ValidationRuleInternal<T>[],\n  name: string,\n  ruleOrHint: ValidationRule<T> | any,\n  maybeRule: ValidationRule<any> | undefined,\n): void {\n  if (typeof ruleOrHint === \"function\") {\n    rules.push({ name, fn: ruleOrHint, hint: undefined });\n  } else {\n    const hint = ruleOrHint;\n    // Cache load hints per-meta because CTI subtypes may resolve `hint` to different\n    // load hints (e.g. an AsyncProperty overridden in the subtype with subtype-only relations).\n    const loadHints = new Map<EntityMetadata, LoadHint<T>>();\n    const fn = (entity: T) => {\n      const meta = getMetadata(entity);\n      let loadHint = loadHints.get(meta);\n      if (loadHint === undefined) {\n        loadHint = convertToLoadHint<T>(meta, hint);\n        loadHints.set(meta, loadHint);\n      }\n      if (Object.keys(loadHint).length > 0) {\n        return entity.em.populate(entity, loadHint).then(maybeRule!);\n      }\n      return maybeRule!(entity);\n    };\n    rules.push({ name, fn, hint });\n  }\n}\n"],"mappings":"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"}

package/build/configure.cjs

@@ -0,0 +1,324 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_reactivity_reactiveHints = require("./reactivity/reactiveHints.cjs");
+const require_keys = require("./keys.cjs");
+require("./relations/ReactiveField.cjs");
+const require_relations_AsyncReactiveField = require("./relations/AsyncReactiveField.cjs");
+require("./relations/index.cjs");
+const require_utils = require("./utils.cjs");
+const require_getProperties = require("./getProperties.cjs");
+const require_rules = require("./rules.cjs");
+const require_runtimeConfig = require("./runtimeConfig.cjs");
+const require_serde_fieldSerde = require("./serde/fieldSerde.cjs");
+const require_config = require("./config.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
+const require_defaults = require("./defaults.cjs");
+require("./EntityManager.cjs");
+require("./Entity.cjs");
+//#region src/configure.ts
+const tagToConstructorMap = /* @__PURE__ */ new Map();
+const tableToMetaMap = /* @__PURE__ */ new Map();
+const typeToMetaMap = /* @__PURE__ */ new Map();
+let previousBootError;
+/** Performs our boot-time initialization, i.e. hooking up reactivity. */
+function configureMetadata(metas) {
+	if (previousBootError) throw previousBootError;
+	try {
+		populateConstructorMaps(metas);
+		hookUpBaseTypeAndSubTypes(metas);
+		installMetadataGetters(metas);
+		sortMetasByBaseType(metas);
+		setImmutableFields(metas);
+		populatePolyComponentFields(metas);
+		fireAfterMetadatas(metas);
+		require_config.setBooted();
+		copyAsyncDefaults(metas);
+		reverseIndexReactivity(metas);
+		installReactiveMetadataGetters(metas);
+		copyRunBeforeBooksToBaseType(metas);
+	} catch (e) {
+		previousBootError = e;
+		throw e;
+	}
+}
+/** Installs lazy lookup getters for metadata-derived caches. */
+function installMetadataGetters(metas) {
+	for (const meta of metas) {
+		require_utils.defineLazyGetter(meta, "subTypesByType", function buildSubTypesByType() {
+			return new Map(meta.subTypes.map((st) => [st.type, st]));
+		});
+		require_utils.defineLazyGetter(meta, "subTypesByStiValue", function buildSubTypesByStiValue() {
+			return new Map(meta.subTypes.map((st) => [st.stiDiscriminatorValue, st]));
+		});
+		require_utils.defineLazyGetter(meta, "stiDiscriminatorColumnName", function buildStiDiscriminatorColumnName() {
+			const field = meta.fields[meta.stiDiscriminatorField];
+			if (field === void 0) throw new Error(`${meta.type} does not have an STI discriminator field`);
+			if (field.kind !== "enum") throw new Error("Discriminator field must be an enum");
+			return field.serde.columns[0].columnName;
+		});
+		require_utils.defineLazyGetter(meta, "lazyFieldNames", function buildLazyFieldNames() {
+			return new Set(Object.values(meta.fields).filter((f) => f.kind === "primitive" && f.lazy).map((f) => f.fieldName));
+		});
+		require_utils.defineLazyGetter(meta, "hasLazyColumns", function buildHasLazyColumns() {
+			return meta.lazyFieldNames.size > 0;
+		});
+		require_utils.defineLazyGetter(meta, "syncDerivedFields", function buildSyncDerivedFields() {
+			return Object.values(meta.allFields).filter((f) => (f.kind === "primitive" || f.kind === "enum") && f.derived === "sync").map((f) => f.fieldName);
+		});
+	}
+}
+/** Installs lazy getters for reactivity caches after reactivity has been reverse-indexed. */
+function installReactiveMetadataGetters(metas) {
+	for (const meta of metas) {
+		require_utils.defineLazyGetter(meta, "reactables", function buildReactables() {
+			return require_EntityMetadata.getBaseAndSelfMetas(meta).flatMap((m) => m.config.__data.reactables).filter((r) => !r.isReadOnly);
+		});
+		require_utils.defineLazyGetter(meta, "reactablesByField", function buildReactablesByField() {
+			return indexReactablesByField(meta.reactables);
+		});
+		require_utils.defineLazyGetter(meta, "reactablesIncludingReadOnly", function buildReactablesIncludingReadOnly() {
+			return require_EntityMetadata.getBaseAndSelfMetas(meta).flatMap((m) => m.config.__data.reactables);
+		});
+		require_utils.defineLazyGetter(meta, "reactablesIncludingReadOnlyByField", function buildReactablesIncludingReadOnlyByField() {
+			return indexReactablesByField(meta.reactablesIncludingReadOnly);
+		});
+		require_utils.defineLazyGetter(meta, "reactiveRules", function buildReactiveRules() {
+			return require_EntityMetadata.getBaseSelfAndSubMetas(meta).flatMap((m) => m.config.__data.reactiveRules);
+		});
+		require_utils.defineLazyGetter(meta, "reactiveCommitRules", function buildReactiveCommitRules() {
+			return require_EntityMetadata.getBaseSelfAndSubMetas(meta).flatMap((m) => m.config.__data.reactiveCommitRules);
+		});
+		require_utils.defineLazyGetter(meta, "hasCommitRules", function buildHasCommitRules() {
+			return meta.reactiveCommitRules.length > 0 || require_EntityMetadata.getBaseSelfAndSubMetas(meta).some((m) => m.config.__data.commitRules.some((r) => r.hint === void 0));
+		});
+	}
+}
+function sortMetasByBaseType(metas) {
+	metas.sort(compareMetasByBaseType);
+}
+function compareMetasByBaseType(a, b) {
+	if (a.baseTypes.length > 0 && b.baseTypes.length === 0) return 1;
+	if (a.baseTypes.length === 0 && b.baseTypes.length > 0) return -1;
+	if (a.baseTypes.some((baseType) => baseType === b)) return 1;
+	if (b.baseTypes.some((baseType) => baseType === a)) return -1;
+	return a.type.localeCompare(b.type);
+}
+function fireAfterMetadatas(metas) {
+	require_config.setAfterMetadataLocked();
+	for (const meta of metas) for (const fn of meta.config.__data.afterMetadataCallbacks) fn(meta);
+}
+function resetConstructorMap() {
+	tagToConstructorMap.clear();
+	require_keys.setTaggedIdDelimiter(":");
+}
+function getConstructorFromTag(tag) {
+	return tagToConstructorMap.get(tag) ?? require_utils.fail(`Unknown tag: "${tag}" `);
+}
+function getConstructorFromTaggedId(id) {
+	return getConstructorFromTag(require_keys.tagFromId(id));
+}
+function getMetadataForTable(tableName) {
+	return tableToMetaMap.get(tableName) ?? require_utils.fail(`Unknown table ${tableName}`);
+}
+function getMetadataForType(typeName) {
+	return typeToMetaMap.get(typeName) ?? require_utils.fail(`Unknown type ${typeName}`);
+}
+/** Returns metadata for `typeName`, if `configureMetadata` has populated the type map. */
+function maybeGetMetadataForType(typeName) {
+	return typeToMetaMap.get(typeName);
+}
+function maybeGetConstructorFromReference(value) {
+	const id = require_keys.maybeResolveReferenceToId(value);
+	return id ? getConstructorFromTaggedId(id) : void 0;
+}
+function populateConstructorMaps(metas) {
+	const runtimeConfig = require_runtimeConfig.maybeGetRuntimeConfig();
+	const tagDelimiter = runtimeConfig && Object.hasOwn(runtimeConfig, "tagDelimiter") ? runtimeConfig.tagDelimiter : ":";
+	require_keys.setTaggedIdDelimiter(tagDelimiter);
+	for (const meta of metas) {
+		if (!meta.baseType) {
+			const existing = tagToConstructorMap.get(meta.tagName);
+			if (existing) throw new Error(`Duplicate tag '${meta.tagName}' for ${meta.type} and ${existing.name}`);
+			tagToConstructorMap.set(meta.tagName, meta.cstr);
+		}
+		tableToMetaMap.set(meta.tableName, meta);
+		typeToMetaMap.set(meta.type, meta);
+	}
+}
+function setImmutableFields(metas) {
+	for (const meta of metas) for (const rule of meta.config.__data.rules) if (require_rules.isCannotBeUpdatedRule(rule.fn) && rule.fn.immutable) {
+		const selfField = meta.fields[rule.fn.field];
+		const baseField = meta.allFields[rule.fn.field];
+		if (!selfField && !baseField) throw new Error(`Missing field '${meta.type}.${rule.fn.field}' for cannotBeUpdated at ${rule.name}`);
+		if (selfField) selfField.immutable = true;
+		if (baseField) baseField.immutable = true;
+	}
+}
+function hookUpBaseTypeAndSubTypes(metas) {
+	const metaByName = metas.reduce((acc, m) => {
+		acc[m.type] = m;
+		return acc;
+	}, {});
+	for (const m of metas) {
+		m.allFields = Object.fromEntries(Object.entries(m.fields).map(([name, field]) => [name, {
+			...field,
+			aliasSuffix: ""
+		}]));
+		if (m.baseType) {
+			const b = metaByName[m.baseType];
+			if (m.inheritanceType === "sti") m.columns = b.columns;
+			m.baseTypes.push(b);
+			b.subTypes.push(m);
+			Object.entries(b.fields).forEach(([name, field]) => {
+				const aliasSuffix = b.inheritanceType === "cti" ? "_b0" : "";
+				if (name in m.allFields && name !== "id") {
+					delete m.fields[name];
+					m.allFields[name].aliasSuffix = aliasSuffix;
+					m.allFields[name].specialized = true;
+				} else m.allFields[name] = {
+					...field,
+					aliasSuffix
+				};
+			});
+		}
+	}
+	for (const m of metas) {
+		m.baseSelfMetas = [...m.baseTypes, m];
+		m.baseSelfAndSubMetas = [
+			...m.baseTypes,
+			m,
+			...m.subTypes
+		];
+	}
+}
+/** Copy/pastes base AsyncDefaults onto subtypes, so that subtypes can have their own default dependencies. */
+function copyAsyncDefaults(metas) {
+	for (const m of metas) for (const b of m.baseTypes) for (const [fieldName, df] of Object.entries(b.config.__data.asyncDefaults)) if (!m.config.__data.asyncDefaults[fieldName]) m.config.__data.asyncDefaults[fieldName] = new require_defaults.AsyncDefault(df.fieldName, df.fieldHint, df.fn);
+}
+function reverseIndexReactivity(metas) {
+	for (const meta of metas) {
+		for (const { name, hint, fn } of meta.config.__data.rules) if (hint) {
+			const reversals = require_reactivity_reactiveHints.reverseReactiveHint(meta.cstr, meta.cstr, hint);
+			for (const { kind, entity, path, fields } of reversals) if (kind === "update") require_EntityMetadata.getMetadata(entity).config.__data.reactiveRules.push({
+				source: entity,
+				cstr: meta.cstr,
+				name,
+				fields,
+				path,
+				fn
+			});
+		}
+		for (const { name, hint, fn } of meta.config.__data.commitRules) if (hint) {
+			const reversals = require_reactivity_reactiveHints.reverseReactiveHint(meta.cstr, meta.cstr, hint);
+			for (const { kind, entity, path, fields } of reversals) if (kind === "update") require_EntityMetadata.getMetadata(entity).config.__data.reactiveCommitRules.push({
+				source: entity,
+				cstr: meta.cstr,
+				name,
+				fields,
+				path,
+				fn
+			});
+		}
+		for (const { name, hint, fn, runOnce } of meta.config.__data.reactions) {
+			const reversals = require_reactivity_reactiveHints.reverseReactiveHint(meta.cstr, meta.cstr, hint);
+			for (const { kind, entity, path, fields } of reversals) require_EntityMetadata.getMetadata(entity).config.__data.reactables.push({
+				kind: "reaction",
+				source: entity,
+				cstr: meta.cstr,
+				isReadOnly: kind === "read-only",
+				name,
+				fields,
+				path,
+				fn,
+				runOnce
+			});
+		}
+		const reactiveRelations = Object.values(meta.allFields).filter((f) => f.kind === "primitive" || f.kind === "m2o" && f.derived === "async" || f.kind === "enum" && f.derived === "async" || f.kind === "m2m" && f.derived === "async");
+		for (const field of reactiveRelations) {
+			const ap = require_getProperties.getProperties(meta)[field.fieldName];
+			if (ap?.reactiveHint) {
+				const reversals = require_reactivity_reactiveHints.reverseReactiveHint(meta.cstr, meta.cstr, ap.reactiveHint);
+				for (const { kind, entity, path, fields } of reversals) require_EntityMetadata.getMetadata(entity).config.__data.reactables.push({
+					kind: ap instanceof require_relations_AsyncReactiveField.AsyncReactiveFieldImpl ? "query" : "populate",
+					cstr: meta.cstr,
+					isReadOnly: kind === "read-only",
+					name: field.fieldName,
+					path,
+					fields,
+					runOnce: false
+				});
+			}
+		}
+	}
+}
+/**
+* In addition to the canonical `meta.allFields`, we populate a `meta.polyComponentFields` to
+* disaggregates the poly's components into individual fields so that `em.find` / `parseFindQuery`
+* can support component-specific find queries.
+*/
+function populatePolyComponentFields(metas) {
+	for (const meta of metas) for (const [key, field] of Object.entries(meta.allFields)) if (field.kind === "poly") {
+		meta.polyComponentFields ??= {};
+		for (const comp of field.components) {
+			const fieldName = `${key}${comp.otherMetadata().type}`;
+			meta.polyComponentFields[fieldName] = {
+				kind: "m2o",
+				fieldName,
+				fieldIdName: `${fieldName}Id`,
+				required: false,
+				immutable: false,
+				derived: false,
+				serde: new require_serde_fieldSerde.SimpleFieldSerde(fieldName, comp.column),
+				otherMetadata: comp.otherMetadata,
+				otherFieldName: comp.otherFieldName,
+				aliasSuffix: field.aliasSuffix
+			};
+		}
+	} else if (field.kind === "m2o") field.otherMetadata().subTypes.forEach((st) => {
+		const fieldName = `${key}${st.type}`;
+		meta.polyComponentFields ??= {};
+		meta.polyComponentFields[fieldName] = {
+			...field,
+			required: false,
+			fieldName,
+			fieldIdName: `${fieldName}Id`,
+			otherMetadata: () => st
+		};
+	});
+	else if (field.kind === "o2m") field.otherMetadata().subTypes.forEach((st) => {
+		const fieldName = `${key}${st.type}`;
+		meta.polyComponentFields ??= {};
+		meta.polyComponentFields[fieldName] = {
+			...field,
+			fieldName,
+			fieldIdName: `${fieldName}Id`,
+			otherMetadata: () => st
+		};
+	});
+}
+function copyRunBeforeBooksToBaseType(meta) {
+	for (const m of meta) for (const b of m.baseTypes) b.config.__data.runHooksBefore.push(...m.config.__data.runHooksBefore);
+}
+/** Indexes reactables once so field setters don't scan every reactable's fields. */
+function indexReactablesByField(reactables) {
+	const byField = /* @__PURE__ */ new Map();
+	for (const reactable of reactables) for (const field of reactable.fields) {
+		let fields = byField.get(field);
+		if (fields === void 0) {
+			fields = [];
+			byField.set(field, fields);
+		}
+		if (!fields.includes(reactable)) fields.push(reactable);
+	}
+	return byField;
+}
+//#endregion
+exports.configureMetadata = configureMetadata;
+exports.getConstructorFromTag = getConstructorFromTag;
+exports.getConstructorFromTaggedId = getConstructorFromTaggedId;
+exports.getMetadataForTable = getMetadataForTable;
+exports.getMetadataForType = getMetadataForType;
+exports.maybeGetConstructorFromReference = maybeGetConstructorFromReference;
+exports.maybeGetMetadataForType = maybeGetMetadataForType;
+exports.resetConstructorMap = resetConstructorMap;
+
+//# sourceMappingURL=configure.cjs.map

package/build/configure.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.cjs","names":["getBaseAndSelfMetas","getBaseSelfAndSubMetas","fail","tagFromId","maybeResolveReferenceToId","maybeGetRuntimeConfig","isCannotBeUpdatedRule","AsyncDefault","reverseReactiveHint","getProperties","AsyncReactiveFieldImpl","SimpleFieldSerde"],"sources":["../src/configure.ts"],"sourcesContent":["import { type Reactable, setAfterMetadataLocked, setBooted } from \"src/config.ts\";\nimport { AsyncDefault } from \"src/defaults.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type MaybeAbstractEntityConstructor, type TaggedId } from \"src/EntityManager.ts\";\nimport {\n  type EntityMetadata,\n  type EnumField,\n  type ManyToOneField,\n  type OneToManyField,\n  getBaseAndSelfMetas,\n  getBaseSelfAndSubMetas,\n  getMetadata,\n} from \"src/EntityMetadata.ts\";\nimport { getProperties } from \"src/getProperties.ts\";\nimport { maybeResolveReferenceToId, setTaggedIdDelimiter, tagFromId } from \"src/keys.ts\";\nimport { reverseReactiveHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AsyncReactiveFieldImpl } from \"src/relations/AsyncReactiveField.ts\";\nimport { type ReactiveManyToManyImpl, type ReactiveReferenceImpl, type Reference } from \"src/relations/index.ts\";\nimport { type ReactiveFieldImpl } from \"src/relations/ReactiveField.ts\";\nimport { isCannotBeUpdatedRule } from \"src/rules.ts\";\nimport { maybeGetRuntimeConfig } from \"src/runtimeConfig.ts\";\nimport { SimpleFieldSerde } from \"src/serde/fieldSerde.ts\";\nimport { defineLazyGetter, fail } from \"src/utils.ts\";\n\nconst tagToConstructorMap = new Map<string, MaybeAbstractEntityConstructor<any>>();\nconst tableToMetaMap = new Map<string, EntityMetadata>();\nconst typeToMetaMap = new Map<string, EntityMetadata>();\n\nlet previousBootError: any;\n\n/** Performs our boot-time initialization, i.e. hooking up reactivity. */\nexport function configureMetadata(metas: EntityMetadata[]): void {\n  // Add explicit \"did we already fail\" check b/c if a transformer like tsx gets a runtime error from\n  // here, it can potentially suppress it, move on to another file, which will naively re-invoke\n  // `configureMetadata` again, and fail with a very confusing \"Duplicate tag\" error\n  if (previousBootError) {\n    throw previousBootError;\n  }\n  try {\n    populateConstructorMaps(metas);\n    hookUpBaseTypeAndSubTypes(metas);\n    installMetadataGetters(metas);\n    sortMetasByBaseType(metas);\n    setImmutableFields(metas);\n    populatePolyComponentFields(metas);\n    fireAfterMetadatas(metas);\n    // Callers can make `config` calls during `afterMetadata` callbacks, but after that\n    // we don't allow any more config changes.\n    setBooted();\n    // Do these after `fireAfterMetadatas`, in case afterMetadata callbacks added more defaults/rules\n    copyAsyncDefaults(metas);\n    reverseIndexReactivity(metas);\n    installReactiveMetadataGetters(metas);\n    copyRunBeforeBooksToBaseType(metas);\n  } catch (e) {\n    previousBootError = e;\n    throw e;\n  }\n}\n\n/** Installs lazy lookup getters for metadata-derived caches. */\nfunction installMetadataGetters(metas: EntityMetadata[]): void {\n  for (const meta of metas) {\n    defineLazyGetter(meta, \"subTypesByType\", function buildSubTypesByType() {\n      return new Map(meta.subTypes.map((st) => [st.type, st]));\n    });\n    defineLazyGetter(meta, \"subTypesByStiValue\", function buildSubTypesByStiValue() {\n      return new Map(meta.subTypes.map((st) => [st.stiDiscriminatorValue, st]));\n    });\n    defineLazyGetter(meta, \"stiDiscriminatorColumnName\", function buildStiDiscriminatorColumnName() {\n      const field = meta.fields[meta.stiDiscriminatorField!];\n      if (field === undefined) throw new Error(`${meta.type} does not have an STI discriminator field`);\n      if (field.kind !== \"enum\") throw new Error(\"Discriminator field must be an enum\");\n      return (field as EnumField).serde.columns[0].columnName;\n    });\n    defineLazyGetter(meta, \"lazyFieldNames\", function buildLazyFieldNames() {\n      return new Set(\n        Object.values(meta.fields)\n          .filter((f) => f.kind === \"primitive\" && f.lazy)\n          .map((f) => f.fieldName),\n      );\n    });\n    defineLazyGetter(meta, \"hasLazyColumns\", function buildHasLazyColumns() {\n      return meta.lazyFieldNames!.size > 0;\n    });\n    defineLazyGetter(meta, \"syncDerivedFields\", function buildSyncDerivedFields() {\n      return Object.values(meta.allFields)\n        .filter((f) => (f.kind === \"primitive\" || f.kind === \"enum\") && f.derived === \"sync\")\n        .map((f) => f.fieldName);\n    });\n  }\n}\n\n/** Installs lazy getters for reactivity caches after reactivity has been reverse-indexed. */\nfunction installReactiveMetadataGetters(metas: EntityMetadata[]): void {\n  for (const meta of metas) {\n    defineLazyGetter(meta, \"reactables\", function buildReactables() {\n      return getBaseAndSelfMetas(meta)\n        .flatMap((m) => m.config.__data.reactables)\n        .filter((r) => !r.isReadOnly);\n    });\n    defineLazyGetter(meta, \"reactablesByField\", function buildReactablesByField() {\n      return indexReactablesByField(meta.reactables!);\n    });\n    defineLazyGetter(meta, \"reactablesIncludingReadOnly\", function buildReactablesIncludingReadOnly() {\n      return getBaseAndSelfMetas(meta).flatMap((m) => m.config.__data.reactables);\n    });\n    defineLazyGetter(meta, \"reactablesIncludingReadOnlyByField\", function buildReactablesIncludingReadOnlyByField() {\n      return indexReactablesByField(meta.reactablesIncludingReadOnly!);\n    });\n    defineLazyGetter(meta, \"reactiveRules\", function buildReactiveRules() {\n      // We use \"AndSub\" because `reactiveRules` is called with `todo.metadata`, which is always\n      // the root type, but ofc we don't want to skip subtype rules.\n      //\n      // I had considered filtering this list with `rr.fields.length > 0`, but even rules with 100%\n      // immutable fields (so all read-only, and so not \"reactive\") need to run on initial entity creation.\n      return getBaseSelfAndSubMetas(meta).flatMap((m) => m.config.__data.reactiveRules);\n    });\n    defineLazyGetter(meta, \"reactiveCommitRules\", function buildReactiveCommitRules() {\n      // Same \"AndSub\" reasoning as `reactiveRules`, just for the post-flush/pre-commit commit rules.\n      return getBaseSelfAndSubMetas(meta).flatMap((m) => m.config.__data.reactiveCommitRules);\n    });\n    defineLazyGetter(meta, \"hasCommitRules\", function buildHasCommitRules() {\n      // True if flushing an entity of this type could trigger commit-rule work, so `em.flush` can\n      // skip the whole commit-rule pass otherwise. We need *both* checks because hinted and\n      // non-hinted commit rules are stored in different places:\n      //\n      // 1. Hinted commit rules are reverse-indexed onto their *trigger* entity's `reactiveCommitRules`,\n      //    which is often a *different* entity than the one the rule is declared on. I.e. a rule\n      //    `config.addCommitRule({ books: \"title\" }, fn)` declared on `Author` lands on\n      //    `Book.reactiveCommitRules`, so flushing a Book must run it even though `Book`'s own\n      //    `config.__data.commitRules` is empty — hence checking `reactiveCommitRules`, not `commitRules`.\n      //\n      // 2. Non-hinted commit rules are *not* reverse-indexed at all; they run on every insert/update of\n      //    the entity they're declared on (via `validateSimpleRules`). I.e. `config.addCommitRule(fn)` on\n      //    `Author` only ever shows up in `Author.config.__data.commitRules` with `hint === undefined`,\n      //    so `reactiveCommitRules` would miss it. (We filter to `hint === undefined` because hinted\n      //    rules are already covered by check #1.)\n      return (\n        meta.reactiveCommitRules!.length > 0 ||\n        getBaseSelfAndSubMetas(meta).some((m) => m.config.__data.commitRules.some((r) => r.hint === undefined))\n      );\n    });\n  }\n}\n\n// Sort metas in place by inheritance hierarchy so that the base type comes before subtypes\nfunction sortMetasByBaseType(metas: EntityMetadata[]): void {\n  metas.sort(compareMetasByBaseType);\n}\n\n// Compare metas by inheritance hierarchy so that the base type sorts before subtypes\nfunction compareMetasByBaseType(a: EntityMetadata, b: EntityMetadata): number {\n  if (a.baseTypes.length > 0 && b.baseTypes.length === 0) return 1;\n  if (a.baseTypes.length === 0 && b.baseTypes.length > 0) return -1;\n  if (a.baseTypes.some((baseType) => baseType === b)) return 1;\n  if (b.baseTypes.some((baseType) => baseType === a)) return -1;\n  return a.type.localeCompare(b.type);\n}\n\nfunction fireAfterMetadatas(metas: EntityMetadata[]): void {\n  setAfterMetadataLocked();\n  for (const meta of metas) {\n    for (const fn of meta.config.__data.afterMetadataCallbacks) fn(meta);\n  }\n}\n\nexport function resetConstructorMap(): void {\n  tagToConstructorMap.clear();\n  setTaggedIdDelimiter(\":\");\n}\n\nexport function getConstructorFromTag(tag: string): MaybeAbstractEntityConstructor<any> {\n  return tagToConstructorMap.get(tag) ?? fail(`Unknown tag: \"${tag}\" `);\n}\n\nexport function getConstructorFromTaggedId(id: TaggedId): MaybeAbstractEntityConstructor<any> {\n  return getConstructorFromTag(tagFromId(id));\n}\n\nexport function getMetadataForTable(tableName: string): EntityMetadata {\n  return tableToMetaMap.get(tableName) ?? fail(`Unknown table ${tableName}`);\n}\n\nexport function getMetadataForType(typeName: string): EntityMetadata {\n  return typeToMetaMap.get(typeName) ?? fail(`Unknown type ${typeName}`);\n}\n\n/** Returns metadata for `typeName`, if `configureMetadata` has populated the type map. */\nexport function maybeGetMetadataForType<T extends Entity = Entity>(typeName: string): EntityMetadata<T> | undefined {\n  return typeToMetaMap.get(typeName) as EntityMetadata<T> | undefined;\n}\n\nexport function maybeGetConstructorFromReference(\n  value: string | Entity | Reference<any, any, any> | undefined,\n): MaybeAbstractEntityConstructor<any> | undefined {\n  const id = maybeResolveReferenceToId(value);\n  return id ? getConstructorFromTaggedId(id) : undefined;\n}\n\nfunction populateConstructorMaps(metas: EntityMetadata[]): void {\n  const runtimeConfig = maybeGetRuntimeConfig();\n  const tagDelimiter = runtimeConfig && Object.hasOwn(runtimeConfig, \"tagDelimiter\") ? runtimeConfig.tagDelimiter : \":\";\n  setTaggedIdDelimiter(tagDelimiter);\n\n  for (const meta of metas) {\n    // Add each (root) constructor into our tag -> constructor map for future lookups\n    if (!meta.baseType) {\n      const existing = tagToConstructorMap.get(meta.tagName);\n      if (existing) throw new Error(`Duplicate tag '${meta.tagName}' for ${meta.type} and ${existing.name}`);\n      tagToConstructorMap.set(meta.tagName, meta.cstr);\n    }\n    // Same for tables, but include subclass tables\n    tableToMetaMap.set(meta.tableName, meta);\n    typeToMetaMap.set(meta.type, meta);\n  }\n}\n\n// Do a first pass to flag immutable fields (which we'll use in reverseReactiveHint)\nfunction setImmutableFields(metas: EntityMetadata[]): void {\n  for (const meta of metas) {\n    // Scan rules for cannotBeUpdated so that we can set `field.immutable`\n    for (const rule of meta.config.__data.rules) {\n      if (isCannotBeUpdatedRule(rule.fn) && rule.fn.immutable) {\n        // Usually the field will exist directly in meta.fields\n        const selfField = meta.fields[rule.fn.field];\n        // Or it might have come in from a base type in meta.allFields\n        const baseField = meta.allFields[rule.fn.field];\n        // Either way, at least one should exist\n        if (!selfField && !baseField) {\n          throw new Error(`Missing field '${meta.type}.${rule.fn.field}' for cannotBeUpdated at ${rule.name}`);\n        }\n        if (selfField) selfField.immutable = true;\n        if (baseField) baseField.immutable = true;\n      }\n    }\n  }\n}\n\n// Setup subTypes/baseTypes\nfunction hookUpBaseTypeAndSubTypes(metas: EntityMetadata[]): void {\n  const metaByName = metas.reduce(\n    (acc, m) => {\n      acc[m.type] = m;\n      return acc;\n    },\n    {} as Record<string, EntityMetadata>,\n  );\n  for (const m of metas) {\n    // This is basically m.fields.mapValues to assign the primary alias\n    m.allFields = Object.fromEntries(\n      Object.entries(m.fields).map(([name, field]) => [name, { ...field, aliasSuffix: \"\" }]),\n    );\n    // Only supporting one level of inheritance for now, ideally would loop `while current !== null`\n    if (m.baseType) {\n      const b = metaByName[m.baseType];\n      if (m.inheritanceType === \"sti\") {\n        m.columns = b.columns;\n      }\n      m.baseTypes.push(b);\n      b.subTypes.push(m);\n      // Add all the base's fields to our allFields, with the base's aliasSuffix, so that in\n      // `WHERE` clauses for `small_publishers`, we'll have joined in `publishers` with an\n      // alias + this alias suffix, so can `WHERE` on `${alias}_b0.name = 'foo'` and get\n      // to the correct table.\n      //\n      // Note that we don't need to do this for subtypes, because `em.find` queries aren't\n      // allowed to `WHERE` against columns in their subtypes. Maybe someday we can support\n      // that like the GraphQL `...on SmallPublisher` syntax, like conditional/subtype-specific\n      // clauses.\n      Object.entries(b.fields).forEach(([name, field]) => {\n        // We use `b0` because that is what addTablePerClassJoinsAndClassTag uses to join in the base table\n        const aliasSuffix = b.inheritanceType === \"cti\" ? \"_b0\" : \"\";\n        if (name in m.allFields && name !== \"id\") {\n          // If the base field (i.e. group) is already in `m.allFields`, it's from a CTI subtype specializing\n          // a base field (i.e. `SmallPublisher.group`), in which case we don't really want it inserted/updated\n          // in the `small_publishers` table itself, so we'll delete it from `m.fields`, *but* leave it in\n          // m.allFields, with appropriate/overridden `otherEntity: SmallPublisherGroup` config so that it\n          // can be used to reverse validation rules/RFs.\n          delete m.fields[name];\n          m.allFields[name].aliasSuffix = aliasSuffix;\n          m.allFields[name].specialized = true;\n        } else {\n          m.allFields[name] = { ...field, aliasSuffix };\n        }\n      });\n    }\n  }\n  // Now that base/sub links are complete, cache the hot-path meta arrays that\n  // `getBaseAndSelfMetas`/`getBaseSelfAndSubMetas` would otherwise re-allocate per call.\n  for (const m of metas) {\n    m.baseSelfMetas = [...m.baseTypes, m];\n    m.baseSelfAndSubMetas = [...m.baseTypes, m, ...m.subTypes];\n  }\n}\n\n/** Copy/pastes base AsyncDefaults onto subtypes, so that subtypes can have their own default dependencies. */\nfunction copyAsyncDefaults(metas: EntityMetadata[]): void {\n  for (const m of metas) {\n    for (const b of m.baseTypes) {\n      // Clone in the base asyncDefaults, unless we override our own\n      for (const [fieldName, df] of Object.entries(b.config.__data.asyncDefaults)) {\n        if (!m.config.__data.asyncDefaults[fieldName]) {\n          // Given our subtype its own instance, because we might have different default dependencies.\n          // I.e. from a sample domain model, something like:\n          // - The base `PlanVersion.type` default depends on `{ identity: \"type\" }`\n          // - The base `Plan.type` has no default itself\n          // - The sub `SpecialPlanVersion` inherits type, and specializes `SPV.identity: SP`\n          // - The sub `SpecialPlan.type` does have a default\n          //\n          // So we need to eval `PlanVersion.type` separately from `SpecialPlanVersion.type`, even\n          // though they come from the same `config.setDefault` call/lambda in `PlanVersion.ts`.\n          m.config.__data.asyncDefaults[fieldName] = new AsyncDefault(df.fieldName, df.fieldHint, df.fn);\n        }\n      }\n    }\n  }\n}\n\n// Now hook up our reactivity\nfunction reverseIndexReactivity(metas: EntityMetadata[]): void {\n  for (const meta of metas) {\n    // Look for reactive validation rules to reverse\n    for (const { name, hint, fn } of meta.config.__data.rules) {\n      if (hint) {\n        const reversals = reverseReactiveHint(meta.cstr, meta.cstr, hint);\n        // For each reversal, tell its config about the reverse hint to force-re-validate\n        // the original rule's instance any time it changes.\n        for (const { kind, entity, path, fields } of reversals) {\n          if (kind === \"update\") {\n            getMetadata(entity).config.__data.reactiveRules.push({\n              source: entity,\n              cstr: meta.cstr,\n              name,\n              fields,\n              path,\n              fn,\n            });\n          }\n        }\n      }\n    }\n\n    // Same reverse-indexing as `rules` above, but for `commitRules` -> `reactiveCommitRules`.\n    for (const { name, hint, fn } of meta.config.__data.commitRules) {\n      if (hint) {\n        const reversals = reverseReactiveHint(meta.cstr, meta.cstr, hint);\n        for (const { kind, entity, path, fields } of reversals) {\n          if (kind === \"update\") {\n            getMetadata(entity).config.__data.reactiveCommitRules.push({\n              source: entity,\n              cstr: meta.cstr,\n              name,\n              fields,\n              path,\n              fn,\n            });\n          }\n        }\n      }\n    }\n\n    // Look for reactions to reverse\n    for (const { name, hint, fn, runOnce } of meta.config.__data.reactions) {\n      const reversals = reverseReactiveHint(meta.cstr, meta.cstr, hint);\n      // For each reversal, tell its config about the reverse hint to force-rerun\n      // the original reaction's instance any time it changes.\n      for (const { kind, entity, path, fields } of reversals) {\n        getMetadata(entity).config.__data.reactables.push({\n          kind: \"reaction\",\n          source: entity,\n          cstr: meta.cstr,\n          isReadOnly: kind === \"read-only\",\n          name,\n          fields,\n          path,\n          fn,\n          runOnce,\n        });\n      }\n    }\n\n    // Look for ReactiveFields, ReactiveReferences, & ReactiveManyToManys to reverse\n    const reactiveRelations = Object.values(meta.allFields).filter(\n      (f) =>\n        f.kind === \"primitive\" ||\n        (f.kind === \"m2o\" && f.derived === \"async\") ||\n        (f.kind === \"enum\" && f.derived === \"async\") ||\n        (f.kind === \"m2m\" && f.derived === \"async\"),\n    );\n    for (const field of reactiveRelations) {\n      const ap = (getProperties(meta) as any)[field.fieldName] as\n        | ReactiveFieldImpl<any, any, any>\n        | AsyncReactiveFieldImpl<any, any, any, any>\n        | ReactiveReferenceImpl<any, any, any, any>\n        | ReactiveManyToManyImpl<any, any, any>\n        | undefined;\n      // We might have an async property configured in joist-config.json that has not yet\n      // been made a `hasReactiveField` in the entity file, so avoid continuing\n      // if we don't actually have a property/loadHint available.\n      if (ap?.reactiveHint) {\n        const reversals = reverseReactiveHint(meta.cstr, meta.cstr, ap.reactiveHint);\n        for (const { kind, entity, path, fields } of reversals) {\n          getMetadata(entity).config.__data.reactables.push({\n            kind: ap instanceof AsyncReactiveFieldImpl ? \"query\" : \"populate\",\n            cstr: meta.cstr,\n            isReadOnly: kind === \"read-only\",\n            name: field.fieldName,\n            path,\n            fields,\n            runOnce: false,\n          });\n        }\n      }\n    }\n  }\n}\n\n/**\n * In addition to the canonical `meta.allFields`, we populate a `meta.polyComponentFields` to\n * disaggregates the poly's components into individual fields so that `em.find` / `parseFindQuery`\n * can support component-specific find queries.\n */\nfunction populatePolyComponentFields(metas: EntityMetadata[]): void {\n  for (const meta of metas) {\n    for (const [key, field] of Object.entries(meta.allFields)) {\n      if (field.kind === \"poly\") {\n        meta.polyComponentFields ??= {};\n        for (const comp of field.components) {\n          const fieldName = `${key}${comp.otherMetadata().type}`;\n          // Synthesize a m2o component that won't be used for any actual read/write serde,\n          // but just to help `parseFindQuery` build `WHERE` clauses.\n          meta.polyComponentFields[fieldName] = {\n            kind: \"m2o\",\n            fieldName,\n            fieldIdName: `${fieldName}Id`,\n            required: false,\n            immutable: false,\n            derived: false,\n            serde: new SimpleFieldSerde(fieldName, comp.column),\n            otherMetadata: comp.otherMetadata,\n            otherFieldName: comp.otherFieldName,\n            aliasSuffix: field.aliasSuffix,\n          } satisfies ManyToOneField & { aliasSuffix: string };\n        }\n      } else if (field.kind === \"m2o\") {\n        field.otherMetadata().subTypes.forEach((st) => {\n          const fieldName = `${key}${st.type}`;\n          meta.polyComponentFields ??= {};\n          meta.polyComponentFields[fieldName] = {\n            ...field,\n            // a subtype specific sub-field (i.e. `publisherLargePublishers`) cannot be required (which turns into\n            // an `inner join`), even if its parent is, since it won't always be present (i.e. the pointed-at publisher\n            // might be a small publisher).\n            required: false,\n            fieldName,\n            fieldIdName: `${fieldName}Id`,\n            otherMetadata: () => st,\n          } satisfies ManyToOneField & { aliasSuffix: string };\n        });\n      } else if (field.kind === \"o2m\") {\n        field.otherMetadata().subTypes.forEach((st) => {\n          const fieldName = `${key}${st.type}`;\n          meta.polyComponentFields ??= {};\n          meta.polyComponentFields[fieldName] = {\n            ...field,\n            fieldName,\n            fieldIdName: `${fieldName}Id`,\n            otherMetadata: () => st,\n          } satisfies OneToManyField & { aliasSuffix: string };\n        });\n      }\n    }\n  }\n}\n\nfunction copyRunBeforeBooksToBaseType(meta: EntityMetadata[]): void {\n  for (const m of meta) {\n    for (const b of m.baseTypes) {\n      b.config.__data.runHooksBefore.push(...m.config.__data.runHooksBefore);\n    }\n  }\n}\n\n/** Indexes reactables once so field setters don't scan every reactable's fields. */\nfunction indexReactablesByField(reactables: readonly Reactable[]): Map<string, Reactable[]> {\n  const byField = new Map<string, Reactable[]>();\n  for (const reactable of reactables) {\n    for (const field of reactable.fields) {\n      let fields = byField.get(field);\n      if (fields === undefined) {\n        fields = [];\n        byField.set(field, fields);\n      }\n      if (!fields.includes(reactable)) fields.push(reactable);\n    }\n  }\n  return byField;\n}\n"],"mappings":"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"}

package/build/configure.d.cts

@@ -0,0 +1,19 @@
+import { Reference } from "./relations/Reference.cjs";
+import "./relations/index.cjs";
+import { EntityMetadata } from "./EntityMetadata.cjs";
+import { MaybeAbstractEntityConstructor, TaggedId } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/configure.d.ts
+/** Performs our boot-time initialization, i.e. hooking up reactivity. */
+declare function configureMetadata(metas: EntityMetadata[]): void;
+declare function resetConstructorMap(): void;
+declare function getConstructorFromTag(tag: string): MaybeAbstractEntityConstructor<any>;
+declare function getConstructorFromTaggedId(id: TaggedId): MaybeAbstractEntityConstructor<any>;
+declare function getMetadataForTable(tableName: string): EntityMetadata;
+declare function getMetadataForType(typeName: string): EntityMetadata;
+/** Returns metadata for `typeName`, if `configureMetadata` has populated the type map. */
+declare function maybeGetMetadataForType<T extends Entity = Entity>(typeName: string): EntityMetadata<T> | undefined;
+declare function maybeGetConstructorFromReference(value: string | Entity | Reference<any, any, any> | undefined): MaybeAbstractEntityConstructor<any> | undefined;
+//#endregion
+export { configureMetadata, getConstructorFromTag, getConstructorFromTaggedId, getMetadataForTable, getMetadataForType, maybeGetConstructorFromReference, maybeGetMetadataForType, resetConstructorMap };
+//# sourceMappingURL=configure.d.cts.map

package/build/configure.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.cts","names":[],"sources":["../src/configure.ts"],"mappings":";;;;;;;iBA+BgB,kBAAkB,OAAO;iBAwIzB;iBAKA,sBAAsB,cAAc;iBAIpC,2BAA2B,IAAI,WAAW;iBAI1C,oBAAoB,oBAAoB;iBAIxC,mBAAmB,mBAAmB;;iBAKtC,wBAAwB,UAAU,SAAS,QAAQ,mBAAmB,eAAe;iBAIrF,iCACd,gBAAgB,SAAS,uCACxB"}

package/build/configure.d.mts

@@ -0,0 +1,19 @@
+import { Reference } from "./relations/Reference.mjs";
+import "./relations/index.mjs";
+import { EntityMetadata } from "./EntityMetadata.mjs";
+import { MaybeAbstractEntityConstructor, TaggedId } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/configure.d.ts
+/** Performs our boot-time initialization, i.e. hooking up reactivity. */
+declare function configureMetadata(metas: EntityMetadata[]): void;
+declare function resetConstructorMap(): void;
+declare function getConstructorFromTag(tag: string): MaybeAbstractEntityConstructor<any>;
+declare function getConstructorFromTaggedId(id: TaggedId): MaybeAbstractEntityConstructor<any>;
+declare function getMetadataForTable(tableName: string): EntityMetadata;
+declare function getMetadataForType(typeName: string): EntityMetadata;
+/** Returns metadata for `typeName`, if `configureMetadata` has populated the type map. */
+declare function maybeGetMetadataForType<T extends Entity = Entity>(typeName: string): EntityMetadata<T> | undefined;
+declare function maybeGetConstructorFromReference(value: string | Entity | Reference<any, any, any> | undefined): MaybeAbstractEntityConstructor<any> | undefined;
+//#endregion
+export { configureMetadata, getConstructorFromTag, getConstructorFromTaggedId, getMetadataForTable, getMetadataForType, maybeGetConstructorFromReference, maybeGetMetadataForType, resetConstructorMap };
+//# sourceMappingURL=configure.d.mts.map

package/build/configure.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure.d.mts","names":[],"sources":["../src/configure.ts"],"mappings":";;;;;;;iBA+BgB,kBAAkB,OAAO;iBAwIzB;iBAKA,sBAAsB,cAAc;iBAIpC,2BAA2B,IAAI,WAAW;iBAI1C,oBAAoB,oBAAoB;iBAIxC,mBAAmB,mBAAmB;;iBAKtC,wBAAwB,UAAU,SAAS,QAAQ,mBAAmB,eAAe;iBAIrF,iCACd,gBAAgB,SAAS,uCACxB"}