joist-core 2.3.0 → 2.4.0

package/build/config.js

@@ -1,331 +1,285 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigData = exports.ConfigApi = exports.constraintNameToValidationError = void 0;
-exports.setBooted = setBooted;
-exports.setAfterMetadataLocked = setAfterMetadataLocked;
-exports.resetBootFlag = resetBootFlag;
-exports.getCallerName = getCallerName;
-exports.getFuzzyCallerName = getFuzzyCallerName;
-exports.getFilePath = getFilePath;
-exports.findUserCodeLine = findUserCodeLine;
-const configure_1 = require("./configure");
-const defaults_1 = require("./defaults");
-const index_1 = require("./index");
-const reactiveHints_1 = require("./reactiveHints");
-exports.constraintNameToValidationError = {};
+import { convertToLoadHint } from "./reactivity/reactiveHints.js";
+import { fail } from "./utils.js";
+import "./rules.js";
+import { resetConstructorMap } from "./configure.js";
+import { getMetadata } from "./EntityMetadata.js";
+import { AsyncDefault } from "./defaults.js";
+import "./index.js";
+import "./Entity.js";
+//#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.
- */
+* 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;
+	booted = true;
 }
 function setAfterMetadataLocked() {
-    afterMetadataLocked = true;
+	afterMetadataLocked = true;
 }
 /** The public API to configure an Entity's hooks & validation rules. */
-class ConfigApi {
-    __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");
-        exports.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;
-        // Register a reactive rule that loads the recursive collection and catches cycle errors.
-        // The rule uses the recursive collection's underlying relation as a reactive hint so it
-        // triggers when the collection changes.
-        const hint = fieldName;
-        const fn = () => {
-            // We don't actually need a try/catch/anything here, b/c if there is a cycle, it
-            // will cause a CycleError during followReverseHint, and never even get to calling this fn.
-        };
-        this.__data.rules.push({ name: `addCycleRule(${getCallerName()})`, fn, hint });
-    }
-    addRule(ruleOrHint, maybeRule) {
-        // Keep the name for easy debugging/tracing later
-        const name = `addRule(${getCallerName()})`;
-        this.ensurePreBoot(name, "addRule");
-        if (typeof ruleOrHint === "function") {
-            const fn = ruleOrHint;
-            this.__data.rules.push({ name, fn, hint: undefined });
-        }
-        else {
-            const hint = ruleOrHint;
-            // Cache load hints per-meta because CTI subtypes may resolve `hint` to different
-            // load hints (e.g. an AsyncProperty overridden in the subtype with subtype-only relations).
-            const loadHints = new Map();
-            const fn = (entity) => {
-                const meta = (0, index_1.getMetadata)(entity);
-                let loadHint = loadHints.get(meta);
-                if (loadHint === undefined) {
-                    loadHint = (0, reactiveHints_1.convertToLoadHint)(meta, hint);
-                    loadHints.set(meta, loadHint);
-                }
-                if (Object.keys(loadHint).length > 0) {
-                    return entity.em.populate(entity, loadHint).then(maybeRule);
-                }
-                return maybeRule(entity);
-            };
-            this.__data.rules.push({ name, fn, hint });
-        }
-    }
-    /** 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) => {
-                // TODO Use this for reactive beforeFlush
-                const loaded = await entity.em.populate(entity, ruleOrHint);
-                return maybeFn(loaded, ctx);
-            };
-            // Squirrel our hint away where configureMetadata can find it
-            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) {
-        // Keep the name so we can uniquely identify this reaction later and also aid debugging/tracing
-        const fn = maybeFn ?? hintOrFn;
-        const hint = (maybeFn ? hintOrFn : nameOrOptsOrHint);
-        const opts = maybeFn
-            ? typeof nameOrOptsOrHint === "string"
-                ? { name: nameOrOptsOrHint }
-                : nameOrOptsOrHint
-            : {};
-        const { name = getCallerName(), runOnce = false } = opts;
-        this.ensurePreBoot(name, "addReaction");
-        // Cache load hints per-meta because CTI subtypes may resolve `hint` to different
-        // load hints (e.g. an AsyncProperty overridden in the subtype with subtype-only relations).
-        const loadHints = new Map();
-        const wrappedFn = (entity, ctx) => {
-            const meta = (0, index_1.getMetadata)(entity);
-            let loadHint = loadHints.get(meta);
-            if (loadHint === undefined) {
-                loadHint = (0, reactiveHints_1.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) {
-            // If we're called once by the codegen, and again by the user, override the syncDefault
-            delete this.__data.syncDefaults[fieldName];
-            this.__data.asyncDefaults[fieldName] = new defaults_1.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) {
-            // Detect if this is NextJS and we're in a hot-reload situation
-            if (isRunningInNextJs()) {
-                // Reset our bag of config data to collect only the new rules/hooks
-                this.__data = new ConfigData();
-                resetBootFlag();
-            }
-            else {
-                throw new Error(`config.${op} call on ${name} must only be called on boot, before calling \`configureMetadata\`.`);
-            }
-        }
-    }
-}
-exports.ConfigApi = ConfigApi;
+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 = getMetadata(entity);
+			let loadHint = loadHints.get(meta);
+			if (loadHint === void 0) {
+				loadHint = 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 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;
+	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.
- */
+* 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;
-    (0, configure_1.resetConstructorMap)();
+	booted = false;
+	afterMetadataLocked = false;
+	resetConstructorMap();
 }
 /** The internal state of an entity's configuration data, i.e. validation rules/hooks. */
-class ConfigData {
-    afterMetadataCallbacks = [];
-    runHooksBefore = [];
-    /** The validation rules for this entity type. */
-    rules = [];
-    /** 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 = {};
-    // An array of the reactive rules that depend on this entity
-    reactiveRules = [];
-    // An array of the reactive fields and reactions that depend on this entity
-    reactables = [];
-    cascadeDeleteFields = [];
-    touchOnChange = new Set();
-    // Constantly converting reactive hints to load hints is expense, so cache them here
-    cachedReactiveLoadHints = {};
-    /** Maps recursive collection fieldNames to custom cycle error message functions. */
-    cycleMessages = {};
-}
-exports.ConfigData = ConfigData;
+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 err = getStack();
-    // E.g. at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)
-    // (Make sure to drop lines that don't start with 'at' b/c the stack format can differ
-    // slightly i.e. if running via tsx/using a node loader (probably?)
-    const line = err.stack.split("\n").filter((line) => line.includes(" at "))[3 + extraFrames];
-    const parts = line.split("/");
-    // Get the last part, which will be the file name, i.e. Activity.ts:86:8
-    return parts[parts.length - 1].replace(/:\d+\)?$/, "");
+	const parts = getStack().stack.split("\n").filter((line) => line.includes(" at "))[3 + extraFrames].split("/");
+	return parts[parts.length - 1].replace(/:\d+\)?$/, "");
 }
 function getFuzzyCallerName() {
-    const err = getStack();
-    const lines = err
-        .stack.split("\n")
-        // E.g. at Object.<anonymous> (/home/stephen/homebound/graphql-service/src/entities/Activity.ts:86:8)
-        .filter((line) => line.includes(" at "));
-    const line = findUserCodeLine(lines);
-    return getFilePath(line);
+	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)`
- */
+* 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+\)?$/, ""); // Drop the `:8)`at the end
+	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) => {
-        // When running Joist's own integration tests, if we ignore `/joist-orm/`, we'll end up ignoring
-        // everything because `joist-orm` is the name of the repository/working copy itself.
-        const withinWorkingCopyJoist = line.includes("/packages/orm/") || line.includes("/packages/core");
-        // But once we're not in a working copy, assume any `/joist-orm/` in the path === internal orm stack frames
-        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 isRecalc = line.includes(".recalcPending");
-        const isDefault = line.includes("/defaults.ts");
-        // Batched calls like findOrCreate won't have a stack trace back to the true caller, so just stop there
-        const isDataloader = line.includes("/dataloaders/");
-        // If this is the `newTestInstance` call
-        // What about:
-        // recalcSynchronousDerivedFields
-        return ((isDefault || isDataloader || isUserCode) &&
-            !line.includes("Codegen.ts") &&
-            // I wanted to exclude this, but it was actually our utils/entities.ts maybeSetDefault helper method
-            // !line.includes("entities.ts") &&
-            // Ignore loops in joist code like setOpts
-            !line.includes("at Array") &&
-            // Ignore the Author.ts constructor calling setOpts
-            !line.includes("at new "));
-    }) ?? (0, index_1.fail)("Could not find caller name"));
+	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 ");
+	}) ?? fail("Could not find caller name");
 }
 const getStack = "captureStackTrace" in Error ? getStackFromCapture : getStackFromObject;
 function getStackFromCapture() {
-    const obj = {};
-    Error.captureStackTrace(obj);
-    return obj;
+	const obj = {};
+	Error.captureStackTrace(obj);
+	return obj;
 }
 function getStackFromObject() {
-    try {
-        throw Error("");
-    }
-    catch (err) {
-        return err;
-    }
+	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 = getMetadata(entity);
+			let loadHint = loadHints.get(meta);
+			if (loadHint === void 0) {
+				loadHint = 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
+export { ConfigApi, ConfigData, constraintNameToValidationError, findUserCodeLine, getCallerName, getFilePath, getFuzzyCallerName, resetBootFlag, setAfterMetadataLocked, setBooted };
+
 //# sourceMappingURL=config.js.map