joist-core 2.3.0 → 2.4.0-next.2

package/build/config.cjs

@@ -0,0 +1,295 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_reactivity_reactiveHints = require("./reactivity/reactiveHints.cjs");
+const require_utils = require("./utils.cjs");
+require("./rules.cjs");
+const require_configure = require("./configure.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
+const require_defaults = require("./defaults.cjs");
+require("./index.cjs");
+require("./Entity.cjs");
+//#region src/config.ts
+const constraintNameToValidationError = {};
+let booted = false;
+let afterMetadataLocked = false;
+/**
+* Called at the end of `configureMetadata` to indicate the boot process is complete.
+*
+* We use this flag to prevent users from mistakenly calling `config` methods after the boot
+* process is complete, i.e. from hooks or other post-boot invocations, where the calls are
+* not guaranteed to work because Joist's reactivity graph has already been initialized.
+*/
+function setBooted() {
+	booted = true;
+}
+function setAfterMetadataLocked() {
+	afterMetadataLocked = true;
+}
+/** The public API to configure an Entity's hooks & validation rules. */
+var ConfigApi = class {
+	__data = new ConfigData();
+	/**
+	* Maps a given `constraintName`, i.e. `authors_publisher_id_unique_index`, to a hard-coded-but-pretty validation errors.
+	*
+	* Note that the validationError must be hard-coded b/c we cannot tease out "which entity" caused a given
+	* constraint failure from the SQL database. If you really need pretty-and-custom validation errors, you'll
+	* need to check the constraint by hand ahead of time, before calling `em.flush`.
+	*/
+	addConstraintMessage(constraintName, validationError) {
+		this.ensurePreBoot(getCallerName(), "addConstraintMessage");
+		constraintNameToValidationError[constraintName] = validationError;
+	}
+	/**
+	* Maps a `RecursiveCycleError` on the given recursive collection field to a custom validation error.
+	*
+	* When a cycle is detected in a recursive collection (e.g. `parentsRecursive`), instead of
+	* throwing a raw `RecursiveCycleError`, `em.flush` will convert it into a `ValidationErrors`
+	* using the provided message function.
+	*
+	* The `messageFn` receives the entity that detected the cycle and the cycle path (array of
+	* entities forming the cycle), and should return a validation error string.
+	*/
+	addCycleRule(fieldName, messageFn) {
+		this.ensurePreBoot(getCallerName(), "addCycleRule");
+		this.__data.cycleMessages[fieldName] = messageFn;
+		const hint = fieldName;
+		const fn = () => {};
+		this.__data.rules.push({
+			name: `addCycleRule(${getCallerName()})`,
+			fn,
+			hint
+		});
+	}
+	addRule(ruleOrHint, maybeRule) {
+		const name = `addRule(${getCallerName()})`;
+		this.ensurePreBoot(name, "addRule");
+		pushValidationRule(this.__data.rules, name, ruleOrHint, maybeRule);
+	}
+	addCommitRule(ruleOrHint, maybeRule) {
+		const name = `addCommitRule(${getCallerName()})`;
+		this.ensurePreBoot(name, "addCommitRule");
+		pushValidationRule(this.__data.commitRules, name, ruleOrHint, maybeRule);
+	}
+	/** If both this entity, and `cstr` entities, are in the same `em.flush`, run us first. */
+	runHooksBefore(cstr) {
+		this.__data.runHooksBefore.push(cstr);
+	}
+	/** Deletes any entity/entities pointed to by `relation` when this entity is deleted. */
+	cascadeDelete(relation) {
+		this.ensurePreBoot(getCallerName(), "cascadeDelete");
+		this.__data.cascadeDeleteFields.push(relation);
+	}
+	touchOnChange(relation) {
+		this.ensurePreBoot(getCallerName(), "touchOnChange");
+		this.__data.touchOnChange.add(relation);
+	}
+	addHook(hook, ruleOrHint, maybeFn) {
+		this.ensurePreBoot(getCallerName(), "addHook");
+		if (typeof ruleOrHint === "function") this.__data.hooks[hook].push(ruleOrHint);
+		else {
+			const fn = async (entity, ctx) => {
+				return maybeFn(await entity.em.populate(entity, ruleOrHint), ctx);
+			};
+			fn.hint = ruleOrHint;
+			this.__data.hooks[hook].push(fn);
+		}
+	}
+	afterMetadata(fn) {
+		if (afterMetadataLocked) throw new Error(`config.afterMetadata on ${getCallerName()} must only be called on boot, before calling \`configureMetadata\` and not from other \`afterMetadata\` hooks.`);
+		this.__data.afterMetadataCallbacks.push(fn);
+	}
+	beforeDelete(ruleOrHint, maybeFn) {
+		this.addHook("beforeDelete", ruleOrHint, maybeFn);
+	}
+	beforeFlush(ruleOrHint, maybeFn) {
+		this.addHook("beforeFlush", ruleOrHint, maybeFn);
+	}
+	beforeCreate(ruleOrHint, maybeFn) {
+		this.addHook("beforeCreate", ruleOrHint, maybeFn);
+	}
+	beforeUpdate(ruleOrHint, maybeFn) {
+		this.addHook("beforeUpdate", ruleOrHint, maybeFn);
+	}
+	afterValidation(ruleOrHint, maybeFn) {
+		this.addHook("afterValidation", ruleOrHint, maybeFn);
+	}
+	beforeCommit(fn) {
+		this.addHook("beforeCommit", fn);
+	}
+	afterCommit(fn) {
+		this.addHook("afterCommit", fn);
+	}
+	addReaction(nameOrOptsOrHint, hintOrFn, maybeFn) {
+		const fn = maybeFn ?? hintOrFn;
+		const hint = maybeFn ? hintOrFn : nameOrOptsOrHint;
+		const { name = getCallerName(), runOnce = false } = maybeFn ? typeof nameOrOptsOrHint === "string" ? { name: nameOrOptsOrHint } : nameOrOptsOrHint : {};
+		this.ensurePreBoot(name, "addReaction");
+		const loadHints = /* @__PURE__ */ new Map();
+		const wrappedFn = (entity, ctx) => {
+			const meta = require_EntityMetadata.getMetadata(entity);
+			let loadHint = loadHints.get(meta);
+			if (loadHint === void 0) {
+				loadHint = require_reactivity_reactiveHints.convertToLoadHint(meta, hint);
+				loadHints.set(meta, loadHint);
+			}
+			if (Object.keys(loadHint).length > 0) return entity.em.populate(entity, loadHint).then((loaded) => fn(loaded, ctx));
+			return fn(entity, ctx);
+		};
+		this.__data.reactions.push({
+			name,
+			fn: wrappedFn,
+			hint,
+			runOnce
+		});
+	}
+	setDefault(fieldName, hintOrFnOrValue, fn) {
+		this.ensurePreBoot(getCallerName(), "setDefault");
+		if (fn) {
+			delete this.__data.syncDefaults[fieldName];
+			this.__data.asyncDefaults[fieldName] = new require_defaults.AsyncDefault(fieldName, hintOrFnOrValue, fn);
+		} else this.__data.syncDefaults[fieldName] = hintOrFnOrValue;
+	}
+	/**
+	* A noop method that exists solely to keep the `config.placeholder()` line in the initial entity file,
+	* until the user is ready to use it. */
+	placeholder() {}
+	ensurePreBoot(name, op) {
+		if (booted) {
+			if (isRunningInNextJs()) {
+				this.__data = new ConfigData();
+				resetBootFlag();
+			} else throw new Error(`config.${op} call on ${name} must only be called on boot, before calling \`configureMetadata\`.`);
+		}
+	}
+};
+function isRunningInNextJs() {
+	return "__NEXT_HTTP_AGENT" in globalThis || "__NEXT_HTTPS_AGENT" in globalThis;
+}
+/**
+* Allows projects to manually reset the internal `booted` flag.
+*
+* This is only necessary if they're using hot-reloading and reloading their entity files
+* without restarting the server.
+*
+* Generally most tools like tsx or ts-node-dev reload the whole process, so don't need
+* to call this, but if Joist is used in a framework that does actual-hot-reloading, this
+* it will be necessary.
+*/
+function resetBootFlag() {
+	booted = false;
+	afterMetadataLocked = false;
+	require_configure.resetConstructorMap();
+}
+/** The internal state of an entity's configuration data, i.e. validation rules/hooks. */
+var ConfigData = class {
+	afterMetadataCallbacks = [];
+	runHooksBefore = [];
+	/** The validation rules for this entity type. */
+	rules = [];
+	/** The "commit rules" for this entity type, i.e. validation rules that run post-flush/pre-commit. */
+	commitRules = [];
+	/** The reactions for this entity type. */
+	reactions = [];
+	/** The hooks for this entity type. */
+	hooks = {
+		beforeDelete: [],
+		beforeFlush: [],
+		beforeCreate: [],
+		beforeUpdate: [],
+		afterValidation: [],
+		beforeCommit: [],
+		afterCommit: []
+	};
+	/** Synchronous defaults for this entity type, invoked on `em.create`. */
+	syncDefaults = {};
+	/** Asynchronous defaults for this entity type, invoked on `em.flush`. */
+	asyncDefaults = {};
+	reactiveRules = [];
+	reactiveCommitRules = [];
+	reactables = [];
+	cascadeDeleteFields = [];
+	touchOnChange = /* @__PURE__ */ new Set();
+	cachedReactiveLoadHints = {};
+	/** Maps recursive collection fieldNames to custom cycle error message functions. */
+	cycleMessages = {};
+};
+function getCallerName(extraFrames = 0) {
+	const parts = getStack().stack.split("\n").filter((line) => line.includes(" at "))[3 + extraFrames].split("/");
+	return parts[parts.length - 1].replace(/:\d+\)?$/, "");
+}
+function getFuzzyCallerName() {
+	return getFilePath(findUserCodeLine(getStack().stack.split("\n").filter((line) => line.includes(" at "))));
+}
+/**
+* Given a callstack line return the file name.
+*
+* I.e. `at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)`
+*/
+function getFilePath(line) {
+	const parts = line.split("/");
+	return parts[parts.length - 1].replace(/:\d+\)?$/, "");
+}
+/** Given a callstack, uses heuristics to find the first line that looks like user code. */
+function findUserCodeLine(lines) {
+	return lines.find((line) => {
+		const withinWorkingCopyJoist = line.includes("/packages/orm/") || line.includes("/packages/core");
+		const withinProductionJoist = !withinWorkingCopyJoist && (line.includes("/joist-orm/src/") || line.includes("/joist-core/src"));
+		const nodeInternals = line.includes("node:internal/") || line.includes("Promise.all");
+		const isUserCode = !withinWorkingCopyJoist && !withinProductionJoist && !nodeInternals;
+		const isDefault = line.includes("/defaults.ts");
+		const isDataloader = line.includes("/dataloaders/");
+		return (isDefault || isDataloader || isUserCode) && !line.includes("Codegen.ts") && !line.includes("at Array") && !line.includes("at new ");
+	}) ?? require_utils.fail("Could not find caller name");
+}
+const getStack = "captureStackTrace" in Error ? getStackFromCapture : getStackFromObject;
+function getStackFromCapture() {
+	const obj = {};
+	Error.captureStackTrace(obj);
+	return obj;
+}
+function getStackFromObject() {
+	try {
+		throw Error("");
+	} catch (err) {
+		return err;
+	}
+}
+/** Pushes a validation rule (either the raw or hinted/reactive form) onto `rules`, shared by `addRule`/`addCommitRule`. */
+function pushValidationRule(rules, name, ruleOrHint, maybeRule) {
+	if (typeof ruleOrHint === "function") rules.push({
+		name,
+		fn: ruleOrHint,
+		hint: void 0
+	});
+	else {
+		const hint = ruleOrHint;
+		const loadHints = /* @__PURE__ */ new Map();
+		const fn = (entity) => {
+			const meta = require_EntityMetadata.getMetadata(entity);
+			let loadHint = loadHints.get(meta);
+			if (loadHint === void 0) {
+				loadHint = require_reactivity_reactiveHints.convertToLoadHint(meta, hint);
+				loadHints.set(meta, loadHint);
+			}
+			if (Object.keys(loadHint).length > 0) return entity.em.populate(entity, loadHint).then(maybeRule);
+			return maybeRule(entity);
+		};
+		rules.push({
+			name,
+			fn,
+			hint
+		});
+	}
+}
+//#endregion
+exports.ConfigApi = ConfigApi;
+exports.ConfigData = ConfigData;
+exports.constraintNameToValidationError = constraintNameToValidationError;
+exports.findUserCodeLine = findUserCodeLine;
+exports.getCallerName = getCallerName;
+exports.getFilePath = getFilePath;
+exports.getFuzzyCallerName = getFuzzyCallerName;
+exports.resetBootFlag = resetBootFlag;
+exports.setAfterMetadataLocked = setAfterMetadataLocked;
+exports.setBooted = setBooted;
+
+//# sourceMappingURL=config.cjs.map

package/build/config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.cjs","names":["getMetadata","convertToLoadHint","AsyncDefault","fail"],"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/config.d.cts

@@ -0,0 +1,277 @@
+import { FieldsOf } from "./typeMap.cjs";
+import { MaybePromise } from "./utils.cjs";
+import { LoadHint, Loaded, RelationsIn } from "./loading/loadHints.cjs";
+import { Reacted, ReactiveHint } from "./reactivity/reactiveHints.cjs";
+import { ValidationRule, ValidationRuleInternal } from "./rules.cjs";
+import { EntityMetadata } from "./EntityMetadata.cjs";
+import { AsyncDefault } from "./defaults.cjs";
+import { EntityField, SettableFields } from "./EntityFields.cjs";
+import "./index.cjs";
+import { EntityConstructor, MaybeAbstractEntityConstructor } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/config.d.ts
+type EntityHook = "beforeFlush" | "beforeCreate" | "beforeUpdate" | "beforeDelete" | "afterValidation" | "beforeCommit" | "afterCommit";
+type HookFn<T extends Entity, C> = (entity: T, ctx: C) => MaybePromise<unknown>;
+type AddReactionOpts = {
+  runOnce?: boolean;
+  name?: string;
+};
+declare const constraintNameToValidationError: Record<string, string>;
+type Settable<T extends Entity> = keyof SettableFields<FieldsOf<T>> & string;
+/**
+ * Called at the end of `configureMetadata` to indicate the boot process is complete.
+ *
+ * We use this flag to prevent users from mistakenly calling `config` methods after the boot
+ * process is complete, i.e. from hooks or other post-boot invocations, where the calls are
+ * not guaranteed to work because Joist's reactivity graph has already been initialized.
+ */
+declare function setBooted(): void;
+declare function setAfterMetadataLocked(): void;
+/** The public API to configure an Entity's hooks & validation rules. */
+declare class ConfigApi<T extends Entity, C> {
+  __data: ConfigData<T, C>;
+  /**
+   * Maps a given `constraintName`, i.e. `authors_publisher_id_unique_index`, to a hard-coded-but-pretty validation errors.
+   *
+   * Note that the validationError must be hard-coded b/c we cannot tease out "which entity" caused a given
+   * constraint failure from the SQL database. If you really need pretty-and-custom validation errors, you'll
+   * need to check the constraint by hand ahead of time, before calling `em.flush`.
+   */
+  addConstraintMessage(constraintName: string, validationError: string): void;
+  /**
+   * Maps a `RecursiveCycleError` on the given recursive collection field to a custom validation error.
+   *
+   * When a cycle is detected in a recursive collection (e.g. `parentsRecursive`), instead of
+   * throwing a raw `RecursiveCycleError`, `em.flush` will convert it into a `ValidationErrors`
+   * using the provided message function.
+   *
+   * The `messageFn` receives the entity that detected the cycle and the cycle path (array of
+   * entities forming the cycle), and should return a validation error string.
+   */
+  addCycleRule(fieldName: string & keyof T, messageFn: (entity: T, cyclePath: Entity[]) => string): void;
+  /**
+   * Adds a validation rule for this entity.
+   *
+   * If `hint` is passed, then the rule's lambda will be: 1) passed a view of the entity with only
+   * the fields included in `hint` marked as accessible, and 2) the rule will be called reactively any
+   * time any field in the `hint` changes.
+   *
+   * If lambdas want to access fields w/o having them marked for reactivity, the rule can either
+   * include the field as readonly with a `:ro` suffix, i.e. `firstName:ro`, or the lambda can
+   * access the `reacted.entity` property to get a full view of the entity's fields and methods.
+   */
+  addRule<H extends ReactiveHint<T>>(hint: H, rule: ValidationRule<Reacted<T, H>>): void;
+  addRule(rule: ValidationRule<T>): void;
+  /**
+   * Adds a "commit rule" that runs like a regular validation rule (see {@link addRule}), but *after*
+   * the entity's `INSERT`/`UPDATE`/`DELETE` has been flushed to the database and *before* the
+   * transaction `COMMIT`s, i.e. still within the transaction.
+   *
+   * The point of running this late is that any `em.find`s the rule makes will query the _changed_
+   * state (the just-flushed rows), instead of the pre-flush state that regular `addRule` rules see.
+   * This is useful for cross-row invariants that are easiest to express as a query, e.g. "at most
+   * one active `AuthorSchedule` per author", where the rule wants to `em.find` the sibling rows
+   * that were themselves just inserted/updated in this same flush.
+   *
+   * Like `addRule`, if a `hint` is passed the rule is reactive: it runs whenever any field in the
+   * hint changes (walking back to the owning entity), and the lambda gets a `Reacted` view.
+   */
+  addCommitRule<H extends ReactiveHint<T>>(hint: H, rule: ValidationRule<Reacted<T, H>>): void;
+  addCommitRule(rule: ValidationRule<T>): void;
+  /** If both this entity, and `cstr` entities, are in the same `em.flush`, run us first. */
+  runHooksBefore(cstr: EntityConstructor<any>): void;
+  /** Deletes any entity/entities pointed to by `relation` when this entity is deleted. */
+  cascadeDelete(relation: keyof RelationsIn<T> & LoadHint<T>): void;
+  touchOnChange(relation: keyof RelationsIn<T>): void;
+  private addHook;
+  afterMetadata(fn: AfterMetadataCallback<T>): void;
+  beforeDelete<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
+  beforeDelete(fn: HookFn<T, C>): void;
+  beforeFlush<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
+  beforeFlush(fn: HookFn<T, C>): void;
+  beforeCreate<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
+  beforeCreate(fn: HookFn<T, C>): void;
+  beforeUpdate<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
+  beforeUpdate(fn: HookFn<T, C>): void;
+  afterValidation<H extends LoadHint<T>>(populate: H, fn: HookFn<Loaded<T, H>, C>): void;
+  afterValidation(fn: HookFn<T, C>): void;
+  beforeCommit(fn: HookFn<T, C>): void;
+  afterCommit(fn: HookFn<T, C>): void;
+  /**
+   * Adds a reaction that runs during flush whenever fields in the `hint` change.
+   *
+   * Reactions are somewhere in between hooks and reactive fields/references:
+   * 1. Can make arbitrary changes to any entity like a hook
+   * 2. Only run when the provided hint has changes, not on every flush, like an RF/RR
+   * 3. Run when the entity itself has no changes, like an RF/RF
+   * 4. Can run multiple times per flush, like an RF/RF.  Be careful to avoid creating
+   *    circular dependencies in the hint and to make the function idempotent.
+   *
+   * @param hint The fields to watch for changes and load before running the reaction
+   * @param fn The reaction function to run
+   */
+  addReaction<H extends ReactiveHint<T>>(hint: H, fn: HookFn<Loaded<T, H>, C>): void;
+  /**
+   * Adds a named reaction that runs during flush whenever fields in the `hint` change.
+   *
+   * Reactions are somewhere in between hooks and reactive fields/references:
+   * 1. Can make arbitrary changes to any entity like a hook
+   * 2. Only run when `hint` has changes, not on every flush, like an RF/RR
+   * 3. Can run when the entity itself has no changes, like an RF/RF
+   * 4. Can run multiple times per flush, like an RF/RF.  Be careful to avoid creating
+   *    circular dependencies in the hint and to make the function idempotent.
+   *
+   * @param name A name to identify this reaction for debugging
+   * @param hint The fields to watch for changes and load before running the reaction
+   * @param fn The reaction function to run
+   */
+  addReaction<H extends ReactiveHint<T>>(name: string, hint: H, fn: HookFn<Loaded<T, H>, C>): void;
+  /**
+   * Adds a reaction that runs during flush whenever fields in the `hint` change.
+   *
+   * Reactions are somewhere in between hooks and reactive fields/references:
+   * 1. Can make arbitrary changes to any entity like a hook
+   * 2. Only run when `hint` has changes, not on every flush, like an RF/RR
+   * 3. Can run when the entity itself has no changes, like an RF/RF
+   * 4. Can run multiple times per flush, like an RF/RF.  Be careful to avoid creating
+   *    circular dependencies in the hint and to make the function idempotent.
+   *
+   * @param opts Options object containing:
+   *   - runOnce - If true, the reaction will only run once per flush, not every time the hint changes. Optional.
+   *   default: false.
+   *   - name - A name to identify this reaction for debugging
+   * @param hint The fields to watch for changes and load before running the reaction
+   * @param fn The reaction function to run
+   */
+  addReaction<H extends ReactiveHint<T>>(opts: AddReactionOpts, hint: H, fn: HookFn<Loaded<T, H>, C>): void;
+  /** Adds a synchronous default for `fieldName` to a hard-coded `value`. */
+  setDefault<K extends Settable<T>, F = FieldsOf<T>[K]>(fieldName: K, value: F extends EntityField ? F["type"] : never): void;
+  /** Adds a synchronous default for `fieldName` to the result of simple sync lambda. */
+  setDefault<K extends Settable<T>, F = FieldsOf<T>[K]>(fieldName: K, fn: (entity: T) => F extends EntityField ? F["type"] | undefined : never): void;
+  /** Adds an asynchronous default for `fieldName` to the result of a hinted lambda. */
+  setDefault<K extends Settable<T>, const H extends ReactiveHint<T>, F = FieldsOf<T>[K]>(fieldName: K, hint: H, fn: (entity: Reacted<T, H>, ctx: C) => F extends {
+    kind: "m2o";
+    type: infer T extends Entity;
+  } ? MaybePromise<T | Reacted<T, {}> | undefined> : F extends EntityField ? MaybePromise<F["type"] | undefined> : never): void;
+  /**
+   * A noop method that exists solely to keep the `config.placeholder()` line in the initial entity file,
+   * until the user is ready to use it. */
+  placeholder(): void;
+  private ensurePreBoot;
+}
+/**
+ * Allows projects to manually reset the internal `booted` flag.
+ *
+ * This is only necessary if they're using hot-reloading and reloading their entity files
+ * without restarting the server.
+ *
+ * Generally most tools like tsx or ts-node-dev reload the whole process, so don't need
+ * to call this, but if Joist is used in a framework that does actual-hot-reloading, this
+ * it will be necessary.
+ */
+declare function resetBootFlag(): void;
+/**
+ * Stores a path back to a reactive rule.
+ *
+ * I.e. if `Book` has a `ruleFn` that reacts to `Author.title`, then `Author`'s config will have
+ * a `ReactiveRule` with fields `["title"]`, path `books`, and rule `ruleFn`.
+ */
+interface ReactiveRule {
+  /** The source we're reacting to, specifically which base/subtype cstr. */
+  source: MaybeAbstractEntityConstructor<any>;
+  /** The fields on this source entity that would trigger the downstream rule's eval. */
+  fields: string[];
+  /** The constructor of downstream entity that owns the reactive rule. */
+  cstr: MaybeAbstractEntityConstructor<any>;
+  /** The name (source location) of the downstream reactive rule. */
+  name: string;
+  /** The path from this source entity to the downstream entity that needs evaled. */
+  path: string[];
+  /** The downstream validation rule to eval. */
+  fn: ValidationRule<any>;
+}
+/**
+ * Stores a path back to a reactive derived field.
+ *
+ * I.e. if `Book.displayName` is an `asyncField` that reacts to `Author.title`, then `Author`'s config will have
+ * a `ReactiveFields` with fields `["title"]`, path `books`, and name `displayName`.
+ */
+interface ReactiveField {
+  kind: "populate" | "query";
+  /** The fields on this source entity that would trigger the downstream field's recalc. */
+  fields: string[];
+  /** Read-only/immutable fields that are used in the derived field. */
+  isReadOnly: boolean;
+  /** The constructor of downstream entity that owns the derived field. */
+  cstr: MaybeAbstractEntityConstructor<any>;
+  /** The path from this source entity to the downstream entity that needs recalced. */
+  path: string[];
+  /** The name of the reactive field in the downstream entity to recalc. */
+  name: string;
+  runOnce: false;
+}
+interface Reaction {
+  kind: "reaction";
+  /** The source we're reacting to, specifically which base/subtype cstr. */
+  source: MaybeAbstractEntityConstructor<any>;
+  /** The fields on this source entity that would trigger the downstream hook's eval. */
+  fields: string[];
+  /** Read-only/immutable fields that are used in the function. */
+  isReadOnly: boolean;
+  /** The constructor of downstream entity that owns the reaction. */
+  cstr: MaybeAbstractEntityConstructor<any>;
+  /** The name (source location) of the downstream reaction. */
+  name: string;
+  /** The path from this source entity to the downstream entity for this reaction. */
+  path: string[];
+  /** The downstream reaction function. */
+  fn: HookFn<any, any>;
+  /** If true, the reaction should only run once per flush, not every time the hint changes. */
+  runOnce: boolean;
+}
+type Reactable = ReactiveField | Reaction;
+interface ReactionInternal<T extends Entity, H extends ReactiveHint<T>, C> {
+  name: string;
+  fn: HookFn<T, C>;
+  hint: H;
+  runOnce: boolean;
+}
+type AfterMetadataCallback<T extends Entity> = (meta: EntityMetadata<T>) => void;
+/** The internal state of an entity's configuration data, i.e. validation rules/hooks. */
+declare class ConfigData<T extends Entity, C> {
+  afterMetadataCallbacks: AfterMetadataCallback<T>[];
+  runHooksBefore: EntityConstructor<any>[];
+  /** The validation rules for this entity type. */
+  rules: ValidationRuleInternal<T>[];
+  /** The "commit rules" for this entity type, i.e. validation rules that run post-flush/pre-commit. */
+  commitRules: ValidationRuleInternal<T>[];
+  /** The reactions for this entity type. */
+  reactions: ReactionInternal<T, any, C>[];
+  /** The hooks for this entity type. */
+  hooks: Record<EntityHook, HookFn<T, C>[]>;
+  /** Synchronous defaults for this entity type, invoked on `em.create`. */
+  syncDefaults: Record<string, ((entity: T) => void) | unknown>;
+  /** Asynchronous defaults for this entity type, invoked on `em.flush`. */
+  asyncDefaults: Record<string, AsyncDefault<T>>;
+  reactiveRules: ReactiveRule[];
+  reactiveCommitRules: ReactiveRule[];
+  reactables: Reactable[];
+  cascadeDeleteFields: Array<keyof RelationsIn<T>>;
+  touchOnChange: Set<keyof RelationsIn<T>>;
+  cachedReactiveLoadHints: Record<string, any>;
+  /** Maps recursive collection fieldNames to custom cycle error message functions. */
+  cycleMessages: Record<string, (entity: T, cyclePath: Entity[]) => string>;
+}
+declare function getCallerName(extraFrames?: number): string;
+declare function getFuzzyCallerName(): string;
+/**
+ * Given a callstack line return the file name.
+ *
+ * I.e. `at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)`
+ */
+declare function getFilePath(line: string): string;
+/** Given a callstack, uses heuristics to find the first line that looks like user code. */
+declare function findUserCodeLine(lines: string[]): string;
+//#endregion
+export { ConfigApi, ConfigData, EntityHook, Reactable, Reaction, ReactiveField, ReactiveRule, constraintNameToValidationError, findUserCodeLine, getCallerName, getFilePath, getFuzzyCallerName, resetBootFlag, setAfterMetadataLocked, setBooted };
+//# sourceMappingURL=config.d.cts.map

package/build/config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"mappings":"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"}