velocious 1.0.552 → 1.0.555

package/build/src/testing/factory/factory-runner.d.ts

@@ -0,0 +1,179 @@
+/**
+ * A resolved attribute/transient/association slot in a compiled plan.
+ * @typedef {object} Slot
+ * @property {"attribute" | "transient" | "association"} slotKind - Slot nature.
+ * @property {?} value - Literal/lazy value, override value, or AssociationDeclaration.
+ * @property {boolean} isOverride - Whether the value came from a call-site override.
+ */
+/**
+ * The immutable result of compiling a factory invocation.
+ * @typedef {object} CompiledPlan
+ * @property {string} factoryName - Target factory name.
+ * @property {import("./factory-definition.js").default} factoryDefinition - Target definition.
+ * @property {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.
+ * @property {string[]} chainNames - Inheritance chain names (child last) for sequence scope.
+ * @property {Map<string, Slot>} resolved - Name→slot map (last declaration wins).
+ * @property {Map<string, import("./declarations.js").CallbackDeclaration[]>} callbacks - Deduped callbacks by event.
+ * @property {import("./declarations.js").InitializeWithDeclaration["fn"] | null} initializeWith - Custom constructor, or null.
+ * @property {import("./declarations.js").ToCreateDeclaration["fn"] | null} toCreate - Custom persistence, or null.
+ * @property {boolean} skipCreate - Whether persistence is skipped.
+ */
+/**
+ * Compiles factory invocations into immutable plans by resolving the inheritance
+ * chain, expanding base and requested traits, and folding declarations into a
+ * name→slot map plus a deduped, ordered callback set.
+ */
+export default class FactoryRunner {
+    /**
+     * Builds a runner.
+     * @param {import("./factory-registry.js").default} registry - Owning registry.
+     */
+    constructor(registry: import("./factory-registry.js").default);
+    /** @type {import("./factory-registry.js").default} - Owning registry. */
+    registry: import("./factory-registry.js").default;
+    /**
+     * Compiles a factory invocation into a plan.
+     * @param {string} factoryName - Factory to run.
+     * @param {string[]} requestedTraits - Traits requested at the call site, in order.
+     * @param {Record<string, ?>} overrides - Call-site overrides (highest precedence).
+     * @returns {CompiledPlan} - The compiled plan.
+     */
+    compile(factoryName: string, requestedTraits: string[], overrides: Record<string, unknown>): CompiledPlan;
+    /**
+     * Resolves the inheritance chain from the root parent down to the target.
+     * @param {string} factoryName - Target factory name.
+     * @returns {import("./factory-definition.js").default[]} - Chain (root first, target last).
+     */
+    _resolveChain(factoryName: string): import("./factory-definition.js").default[];
+    /**
+     * Resolves a factory definition by name (or alias).
+     * @param {string} factoryName - Factory name.
+     * @returns {import("./factory-definition.js").default} - The definition.
+     */
+    _resolveFactory(factoryName: string): import("./factory-definition.js").default;
+    /**
+     * Picks the nearest declared model class in the chain (child overrides parent).
+     * @param {import("./factory-definition.js").default[]} chain - Inheritance chain.
+     * @returns {(new (attributes?: Record<string, ?>) => ?) | null} - The model class, or null.
+     */
+    _resolveModelClass(chain: import("./factory-definition.js").default[]): (new (attributes?: Record<string, unknown>) => unknown) | null;
+    /**
+     * Expands one factory's own declarations, inlining base-trait inclusions.
+     * @param {import("./factory-definition.js").default} factoryDefinition - Factory whose declarations are expanded.
+     * @param {import("./factory-definition.js").default} scope - Target factory (for local-trait resolution).
+     * @param {Array<{decl: import("./declarations.js").Declaration}>} out - Flattened output sink.
+     * @returns {void}
+     */
+    _expandFactoryDeclarations(factoryDefinition: import("./factory-definition.js").default, scope: import("./factory-definition.js").default, out: Array<{
+        decl: import("./declarations.js").Declaration;
+    }>): void;
+    /**
+     * Expands a trait (resolving factory-local before global) and its inclusions.
+     * @param {string} traitName - Trait to expand.
+     * @param {import("./factory-definition.js").default} scope - Target factory (for local-trait resolution).
+     * @param {Array<{decl: import("./declarations.js").Declaration}>} out - Flattened output sink.
+     * @param {string[]} activePath - Trait inclusion path (for cycle detection).
+     * @returns {void}
+     */
+    _expandTrait(traitName: string, scope: import("./factory-definition.js").default, out: Array<{
+        decl: import("./declarations.js").Declaration;
+    }>, activePath: string[]): void;
+    /**
+     * Resolves a local trait from the current factory upward through its parents.
+     * @param {string} traitName - Trait name to resolve.
+     * @param {import("./factory-definition.js").default} scope - Declaring/requesting factory scope.
+     * @returns {{trait: import("./trait-definition.js").default, scope: import("./factory-definition.js").default} | undefined} - Nearest local trait and its declaring scope, if any.
+     */
+    _resolveLocalTrait(traitName: string, scope: import("./factory-definition.js").default): {
+        trait: import("./trait-definition.js").default;
+        scope: import("./factory-definition.js").default;
+    } | undefined;
+    /**
+     * Folds flattened declarations plus overrides into a compiled plan.
+     * @param {object} args - Options.
+     * @param {Array<{decl: import("./declarations.js").Declaration}>} args.flattened - Flattened declarations.
+     * @param {Record<string, ?>} args.overrides - Call-site overrides.
+     * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Resolved model class.
+     * @param {import("./factory-definition.js").default} args.target - Target factory definition.
+     * @param {string[]} args.chainNames - Inheritance chain names.
+     * @returns {CompiledPlan} - The compiled plan.
+     */
+    _buildPlan({ flattened, overrides, modelClass, target, chainNames }: {
+        flattened: Array<{
+            decl: import("./declarations.js").Declaration;
+        }>;
+        overrides: Record<string, unknown>;
+        modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null;
+        target: import("./factory-definition.js").default;
+        chainNames: string[];
+    }): CompiledPlan;
+    /**
+     * Applies belongs-to override precedence using the declared model relationship's
+     * real foreign-key metadata. An explicit association object wins over its key;
+     * otherwise an explicit key suppresses the factory-declared association.
+     * @param {Map<string, Slot>} resolved - Folded slots.
+     * @param {Record<string, ?>} overrides - Call-site overrides.
+     * @param {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.
+     * @returns {void}
+     */
+    _arbitrateAssociationOverrides(resolved: Map<string, Slot>, overrides: Record<string, unknown>, modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null): void;
+}
+/**
+ * A resolved attribute/transient/association slot in a compiled plan.
+ */
+export type Slot = {
+    /**
+     * - Slot nature.
+     */
+    slotKind: "attribute" | "transient" | "association";
+    /**
+     * - Literal/lazy value, override value, or AssociationDeclaration.
+     */
+    value: unknown;
+    /**
+     * - Whether the value came from a call-site override.
+     */
+    isOverride: boolean;
+};
+/**
+ * The immutable result of compiling a factory invocation.
+ */
+export type CompiledPlan = {
+    /**
+     * - Target factory name.
+     */
+    factoryName: string;
+    /**
+     * - Target definition.
+     */
+    factoryDefinition: import("./factory-definition.js").default;
+    /**
+     * - Resolved model class.
+     */
+    modelClass: (new (attributes?: Record<string, unknown>) => unknown) | null;
+    /**
+     * - Inheritance chain names (child last) for sequence scope.
+     */
+    chainNames: string[];
+    /**
+     * - Name→slot map (last declaration wins).
+     */
+    resolved: Map<string, Slot>;
+    /**
+     * - Deduped callbacks by event.
+     */
+    callbacks: Map<string, import("./declarations.js").CallbackDeclaration[]>;
+    /**
+     * - Custom constructor, or null.
+     */
+    initializeWith: import("./declarations.js").InitializeWithDeclaration["fn"] | null;
+    /**
+     * - Custom persistence, or null.
+     */
+    toCreate: import("./declarations.js").ToCreateDeclaration["fn"] | null;
+    /**
+     * - Whether persistence is skipped.
+     */
+    skipCreate: boolean;
+};
+//# sourceMappingURL=factory-runner.d.ts.map

package/build/src/testing/factory/factory-runner.d.ts.map

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

package/build/src/testing/factory/factory-runner.js

@@ -0,0 +1,266 @@
+// @ts-check
+import DatabaseRecord from "../../database/record/index.js";
+import { FactoryCycleError, UndefinedFactoryError, UndefinedTraitError } from "./errors.js";
+/**
+ * A resolved attribute/transient/association slot in a compiled plan.
+ * @typedef {object} Slot
+ * @property {"attribute" | "transient" | "association"} slotKind - Slot nature.
+ * @property {?} value - Literal/lazy value, override value, or AssociationDeclaration.
+ * @property {boolean} isOverride - Whether the value came from a call-site override.
+ */
+/**
+ * The immutable result of compiling a factory invocation.
+ * @typedef {object} CompiledPlan
+ * @property {string} factoryName - Target factory name.
+ * @property {import("./factory-definition.js").default} factoryDefinition - Target definition.
+ * @property {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.
+ * @property {string[]} chainNames - Inheritance chain names (child last) for sequence scope.
+ * @property {Map<string, Slot>} resolved - Name→slot map (last declaration wins).
+ * @property {Map<string, import("./declarations.js").CallbackDeclaration[]>} callbacks - Deduped callbacks by event.
+ * @property {import("./declarations.js").InitializeWithDeclaration["fn"] | null} initializeWith - Custom constructor, or null.
+ * @property {import("./declarations.js").ToCreateDeclaration["fn"] | null} toCreate - Custom persistence, or null.
+ * @property {boolean} skipCreate - Whether persistence is skipped.
+ */
+/**
+ * Compiles factory invocations into immutable plans by resolving the inheritance
+ * chain, expanding base and requested traits, and folding declarations into a
+ * name→slot map plus a deduped, ordered callback set.
+ */
+export default class FactoryRunner {
+    /**
+     * Builds a runner.
+     * @param {import("./factory-registry.js").default} registry - Owning registry.
+     */
+    constructor(registry) {
+        /** @type {import("./factory-registry.js").default} - Owning registry. */
+        this.registry = registry;
+    }
+    /**
+     * Compiles a factory invocation into a plan.
+     * @param {string} factoryName - Factory to run.
+     * @param {string[]} requestedTraits - Traits requested at the call site, in order.
+     * @param {Record<string, ?>} overrides - Call-site overrides (highest precedence).
+     * @returns {CompiledPlan} - The compiled plan.
+     */
+    compile(factoryName, requestedTraits, overrides) {
+        const chain = this._resolveChain(factoryName);
+        const target = chain[chain.length - 1];
+        const modelClass = this._resolveModelClass(chain);
+        /** @type {Array<{decl: import("./declarations.js").Declaration}>} */
+        const flattened = [];
+        for (const declaration of this.registry._globalDeclarations) {
+            flattened.push({ decl: declaration });
+        }
+        for (const factoryDefinition of chain) {
+            this._expandFactoryDeclarations(factoryDefinition, factoryDefinition, flattened);
+        }
+        for (const traitName of requestedTraits) {
+            this._expandTrait(traitName, target, flattened, []);
+        }
+        return this._buildPlan({ flattened, overrides, modelClass, target, chainNames: chain.map((definition) => definition.name) });
+    }
+    /**
+     * Resolves the inheritance chain from the root parent down to the target.
+     * @param {string} factoryName - Target factory name.
+     * @returns {import("./factory-definition.js").default[]} - Chain (root first, target last).
+     */
+    _resolveChain(factoryName) {
+        /** @type {import("./factory-definition.js").default[]} */
+        const chain = [];
+        /** @type {Set<string>} */
+        const seen = new Set();
+        /** @type {import("./factory-definition.js").default | null} */
+        let current = this._resolveFactory(factoryName);
+        while (current) {
+            if (seen.has(current.name)) {
+                throw new FactoryCycleError(`Factory inheritance cycle detected: ${[...seen, current.name].join(" -> ")}`);
+            }
+            seen.add(current.name);
+            chain.unshift(current);
+            current = current.parentName ? this._resolveFactory(current.parentName) : null;
+        }
+        return chain;
+    }
+    /**
+     * Resolves a factory definition by name (or alias).
+     * @param {string} factoryName - Factory name.
+     * @returns {import("./factory-definition.js").default} - The definition.
+     */
+    _resolveFactory(factoryName) {
+        const definition = this.registry._factories.get(factoryName);
+        if (!definition) {
+            throw new UndefinedFactoryError(`No factory registered called "${factoryName}". Registered: ${[...this.registry._factories.keys()].join(", ") || "(none)"}`);
+        }
+        return definition;
+    }
+    /**
+     * Picks the nearest declared model class in the chain (child overrides parent).
+     * @param {import("./factory-definition.js").default[]} chain - Inheritance chain.
+     * @returns {(new (attributes?: Record<string, ?>) => ?) | null} - The model class, or null.
+     */
+    _resolveModelClass(chain) {
+        for (let index = chain.length - 1; index >= 0; index--) {
+            if (chain[index].modelClass)
+                return chain[index].modelClass;
+        }
+        return null;
+    }
+    /**
+     * Expands one factory's own declarations, inlining base-trait inclusions.
+     * @param {import("./factory-definition.js").default} factoryDefinition - Factory whose declarations are expanded.
+     * @param {import("./factory-definition.js").default} scope - Target factory (for local-trait resolution).
+     * @param {Array<{decl: import("./declarations.js").Declaration}>} out - Flattened output sink.
+     * @returns {void}
+     */
+    _expandFactoryDeclarations(factoryDefinition, scope, out) {
+        for (const declaration of factoryDefinition.declarations) {
+            if (declaration.kind === "traitInclude") {
+                this._expandTrait(declaration.name, scope, out, []);
+            }
+            else {
+                out.push({ decl: declaration });
+            }
+        }
+    }
+    /**
+     * Expands a trait (resolving factory-local before global) and its inclusions.
+     * @param {string} traitName - Trait to expand.
+     * @param {import("./factory-definition.js").default} scope - Target factory (for local-trait resolution).
+     * @param {Array<{decl: import("./declarations.js").Declaration}>} out - Flattened output sink.
+     * @param {string[]} activePath - Trait inclusion path (for cycle detection).
+     * @returns {void}
+     */
+    _expandTrait(traitName, scope, out, activePath) {
+        if (activePath.includes(traitName)) {
+            throw new FactoryCycleError(`Trait inclusion cycle detected: ${[...activePath, traitName].join(" -> ")}`);
+        }
+        const localTrait = this._resolveLocalTrait(traitName, scope);
+        const trait = localTrait?.trait || this.registry._globalTraits.get(traitName);
+        const inclusionScope = localTrait?.scope || scope;
+        if (!trait) {
+            throw new UndefinedTraitError(`No trait registered called "${traitName}" for factory "${scope.name}"`);
+        }
+        for (const declaration of trait.declarations) {
+            if (declaration.kind === "traitInclude") {
+                this._expandTrait(declaration.name, inclusionScope, out, [...activePath, traitName]);
+            }
+            else {
+                out.push({ decl: declaration });
+            }
+        }
+    }
+    /**
+     * Resolves a local trait from the current factory upward through its parents.
+     * @param {string} traitName - Trait name to resolve.
+     * @param {import("./factory-definition.js").default} scope - Declaring/requesting factory scope.
+     * @returns {{trait: import("./trait-definition.js").default, scope: import("./factory-definition.js").default} | undefined} - Nearest local trait and its declaring scope, if any.
+     */
+    _resolveLocalTrait(traitName, scope) {
+        /** @type {import("./factory-definition.js").default | undefined} */
+        let current = scope;
+        while (current) {
+            const trait = current.localTraits.get(traitName);
+            if (trait)
+                return { trait, scope: current };
+            current = current.parentName ? this._resolveFactory(current.parentName) : undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Folds flattened declarations plus overrides into a compiled plan.
+     * @param {object} args - Options.
+     * @param {Array<{decl: import("./declarations.js").Declaration}>} args.flattened - Flattened declarations.
+     * @param {Record<string, ?>} args.overrides - Call-site overrides.
+     * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Resolved model class.
+     * @param {import("./factory-definition.js").default} args.target - Target factory definition.
+     * @param {string[]} args.chainNames - Inheritance chain names.
+     * @returns {CompiledPlan} - The compiled plan.
+     */
+    _buildPlan({ flattened, overrides, modelClass, target, chainNames }) {
+        /** @type {Map<string, Slot>} */
+        const resolved = new Map();
+        /** @type {Map<string, import("./declarations.js").CallbackDeclaration[]>} */
+        const callbacks = new Map();
+        /** @type {Set<import("./declarations.js").CallbackDeclaration>} */
+        const seenCallbacks = new Set();
+        /** @type {import("./declarations.js").InitializeWithDeclaration["fn"] | null} */
+        let initializeWith = null;
+        /** @type {import("./declarations.js").ToCreateDeclaration["fn"] | null} */
+        let toCreate = null;
+        let skipCreate = false;
+        for (const { decl } of flattened) {
+            if (decl.kind === "attribute") {
+                resolved.set(decl.name, { slotKind: decl.isTransient ? "transient" : "attribute", value: decl.value, isOverride: false });
+            }
+            else if (decl.kind === "association") {
+                resolved.set(decl.name, { slotKind: "association", value: decl, isOverride: false });
+            }
+            else if (decl.kind === "callback") {
+                if (!seenCallbacks.has(decl)) {
+                    seenCallbacks.add(decl);
+                    const eventCallbacks = callbacks.get(decl.event) || [];
+                    eventCallbacks.push(decl);
+                    callbacks.set(decl.event, eventCallbacks);
+                }
+            }
+            else if (decl.kind === "initializeWith") {
+                initializeWith = decl.fn;
+            }
+            else if (decl.kind === "toCreate") {
+                toCreate = decl.fn;
+            }
+            else if (decl.kind === "skipCreate") {
+                skipCreate = true;
+            }
+        }
+        for (const key of Object.keys(overrides)) {
+            const prior = resolved.get(key);
+            resolved.set(key, { slotKind: prior ? prior.slotKind : "attribute", value: overrides[key], isOverride: true });
+        }
+        this._arbitrateAssociationOverrides(resolved, overrides, modelClass);
+        return {
+            factoryName: target.name,
+            factoryDefinition: target,
+            modelClass,
+            chainNames,
+            resolved,
+            callbacks,
+            initializeWith,
+            toCreate,
+            skipCreate
+        };
+    }
+    /**
+     * Applies belongs-to override precedence using the declared model relationship's
+     * real foreign-key metadata. An explicit association object wins over its key;
+     * otherwise an explicit key suppresses the factory-declared association.
+     * @param {Map<string, Slot>} resolved - Folded slots.
+     * @param {Record<string, ?>} overrides - Call-site overrides.
+     * @param {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.
+     * @returns {void}
+     */
+    _arbitrateAssociationOverrides(resolved, overrides, modelClass) {
+        if (typeof modelClass !== "function" || !(modelClass.prototype instanceof DatabaseRecord))
+            return;
+        const backendModelClass = /** @type {typeof DatabaseRecord} */ (modelClass);
+        const columnToAttribute = backendModelClass.getColumnNameToAttributeNameMap();
+        for (const [name, slot] of [...resolved]) {
+            if (slot.slotKind !== "association")
+                continue;
+            const relationship = backendModelClass.getRelationshipByName(name);
+            if (relationship.getType() !== "belongsTo")
+                continue;
+            const foreignKeyColumn = relationship.getForeignKey();
+            const foreignKeyAttribute = columnToAttribute[foreignKeyColumn] || foreignKeyColumn;
+            if (!Object.hasOwn(overrides, foreignKeyAttribute))
+                continue;
+            if (slot.isOverride) {
+                resolved.delete(foreignKeyAttribute);
+            }
+            else {
+                resolved.delete(name);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory-runner.js","sourceRoot":"","sources":["../../../../src/testing/factory/factory-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport DatabaseRecord from \"../../database/record/index.js\"\nimport {FactoryCycleError, UndefinedFactoryError, UndefinedTraitError} from \"./errors.js\"\n\n/**\n * A resolved attribute/transient/association slot in a compiled plan.\n * @typedef {object} Slot\n * @property {\"attribute\" | \"transient\" | \"association\"} slotKind - Slot nature.\n * @property {?} value - Literal/lazy value, override value, or AssociationDeclaration.\n * @property {boolean} isOverride - Whether the value came from a call-site override.\n */\n\n/**\n * The immutable result of compiling a factory invocation.\n * @typedef {object} CompiledPlan\n * @property {string} factoryName - Target factory name.\n * @property {import(\"./factory-definition.js\").default} factoryDefinition - Target definition.\n * @property {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.\n * @property {string[]} chainNames - Inheritance chain names (child last) for sequence scope.\n * @property {Map<string, Slot>} resolved - Name→slot map (last declaration wins).\n * @property {Map<string, import(\"./declarations.js\").CallbackDeclaration[]>} callbacks - Deduped callbacks by event.\n * @property {import(\"./declarations.js\").InitializeWithDeclaration[\"fn\"] | null} initializeWith - Custom constructor, or null.\n * @property {import(\"./declarations.js\").ToCreateDeclaration[\"fn\"] | null} toCreate - Custom persistence, or null.\n * @property {boolean} skipCreate - Whether persistence is skipped.\n */\n\n/**\n * Compiles factory invocations into immutable plans by resolving the inheritance\n * chain, expanding base and requested traits, and folding declarations into a\n * name→slot map plus a deduped, ordered callback set.\n */\nexport default class FactoryRunner {\n  /**\n   * Builds a runner.\n   * @param {import(\"./factory-registry.js\").default} registry - Owning registry.\n   */\n  constructor(registry) {\n    /** @type {import(\"./factory-registry.js\").default} - Owning registry. */\n    this.registry = registry\n  }\n\n  /**\n   * Compiles a factory invocation into a plan.\n   * @param {string} factoryName - Factory to run.\n   * @param {string[]} requestedTraits - Traits requested at the call site, in order.\n   * @param {Record<string, ?>} overrides - Call-site overrides (highest precedence).\n   * @returns {CompiledPlan} - The compiled plan.\n   */\n  compile(factoryName, requestedTraits, overrides) {\n    const chain = this._resolveChain(factoryName)\n    const target = chain[chain.length - 1]\n    const modelClass = this._resolveModelClass(chain)\n\n    /** @type {Array<{decl: import(\"./declarations.js\").Declaration}>} */\n    const flattened = []\n\n    for (const declaration of this.registry._globalDeclarations) {\n      flattened.push({decl: declaration})\n    }\n\n    for (const factoryDefinition of chain) {\n      this._expandFactoryDeclarations(factoryDefinition, factoryDefinition, flattened)\n    }\n\n    for (const traitName of requestedTraits) {\n      this._expandTrait(traitName, target, flattened, [])\n    }\n\n    return this._buildPlan({flattened, overrides, modelClass, target, chainNames: chain.map((definition) => definition.name)})\n  }\n\n  /**\n   * Resolves the inheritance chain from the root parent down to the target.\n   * @param {string} factoryName - Target factory name.\n   * @returns {import(\"./factory-definition.js\").default[]} - Chain (root first, target last).\n   */\n  _resolveChain(factoryName) {\n    /** @type {import(\"./factory-definition.js\").default[]} */\n    const chain = []\n    /** @type {Set<string>} */\n    const seen = new Set()\n    /** @type {import(\"./factory-definition.js\").default | null} */\n    let current = this._resolveFactory(factoryName)\n\n    while (current) {\n      if (seen.has(current.name)) {\n        throw new FactoryCycleError(`Factory inheritance cycle detected: ${[...seen, current.name].join(\" -> \")}`)\n      }\n\n      seen.add(current.name)\n      chain.unshift(current)\n      current = current.parentName ? this._resolveFactory(current.parentName) : null\n    }\n\n    return chain\n  }\n\n  /**\n   * Resolves a factory definition by name (or alias).\n   * @param {string} factoryName - Factory name.\n   * @returns {import(\"./factory-definition.js\").default} - The definition.\n   */\n  _resolveFactory(factoryName) {\n    const definition = this.registry._factories.get(factoryName)\n\n    if (!definition) {\n      throw new UndefinedFactoryError(`No factory registered called \"${factoryName}\". Registered: ${[...this.registry._factories.keys()].join(\", \") || \"(none)\"}`)\n    }\n\n    return definition\n  }\n\n  /**\n   * Picks the nearest declared model class in the chain (child overrides parent).\n   * @param {import(\"./factory-definition.js\").default[]} chain - Inheritance chain.\n   * @returns {(new (attributes?: Record<string, ?>) => ?) | null} - The model class, or null.\n   */\n  _resolveModelClass(chain) {\n    for (let index = chain.length - 1; index >= 0; index--) {\n      if (chain[index].modelClass) return chain[index].modelClass\n    }\n\n    return null\n  }\n\n  /**\n   * Expands one factory's own declarations, inlining base-trait inclusions.\n   * @param {import(\"./factory-definition.js\").default} factoryDefinition - Factory whose declarations are expanded.\n   * @param {import(\"./factory-definition.js\").default} scope - Target factory (for local-trait resolution).\n   * @param {Array<{decl: import(\"./declarations.js\").Declaration}>} out - Flattened output sink.\n   * @returns {void}\n   */\n  _expandFactoryDeclarations(factoryDefinition, scope, out) {\n    for (const declaration of factoryDefinition.declarations) {\n      if (declaration.kind === \"traitInclude\") {\n        this._expandTrait(declaration.name, scope, out, [])\n      } else {\n        out.push({decl: declaration})\n      }\n    }\n  }\n\n  /**\n   * Expands a trait (resolving factory-local before global) and its inclusions.\n   * @param {string} traitName - Trait to expand.\n   * @param {import(\"./factory-definition.js\").default} scope - Target factory (for local-trait resolution).\n   * @param {Array<{decl: import(\"./declarations.js\").Declaration}>} out - Flattened output sink.\n   * @param {string[]} activePath - Trait inclusion path (for cycle detection).\n   * @returns {void}\n   */\n  _expandTrait(traitName, scope, out, activePath) {\n    if (activePath.includes(traitName)) {\n      throw new FactoryCycleError(`Trait inclusion cycle detected: ${[...activePath, traitName].join(\" -> \")}`)\n    }\n\n    const localTrait = this._resolveLocalTrait(traitName, scope)\n    const trait = localTrait?.trait || this.registry._globalTraits.get(traitName)\n    const inclusionScope = localTrait?.scope || scope\n\n    if (!trait) {\n      throw new UndefinedTraitError(`No trait registered called \"${traitName}\" for factory \"${scope.name}\"`)\n    }\n\n    for (const declaration of trait.declarations) {\n      if (declaration.kind === \"traitInclude\") {\n        this._expandTrait(declaration.name, inclusionScope, out, [...activePath, traitName])\n      } else {\n        out.push({decl: declaration})\n      }\n    }\n  }\n\n  /**\n   * Resolves a local trait from the current factory upward through its parents.\n   * @param {string} traitName - Trait name to resolve.\n   * @param {import(\"./factory-definition.js\").default} scope - Declaring/requesting factory scope.\n   * @returns {{trait: import(\"./trait-definition.js\").default, scope: import(\"./factory-definition.js\").default} | undefined} - Nearest local trait and its declaring scope, if any.\n   */\n  _resolveLocalTrait(traitName, scope) {\n    /** @type {import(\"./factory-definition.js\").default | undefined} */\n    let current = scope\n\n    while (current) {\n      const trait = current.localTraits.get(traitName)\n\n      if (trait) return {trait, scope: current}\n\n      current = current.parentName ? this._resolveFactory(current.parentName) : undefined\n    }\n\n    return undefined\n  }\n\n  /**\n   * Folds flattened declarations plus overrides into a compiled plan.\n   * @param {object} args - Options.\n   * @param {Array<{decl: import(\"./declarations.js\").Declaration}>} args.flattened - Flattened declarations.\n   * @param {Record<string, ?>} args.overrides - Call-site overrides.\n   * @param {(new (attributes?: Record<string, ?>) => ?) | null} args.modelClass - Resolved model class.\n   * @param {import(\"./factory-definition.js\").default} args.target - Target factory definition.\n   * @param {string[]} args.chainNames - Inheritance chain names.\n   * @returns {CompiledPlan} - The compiled plan.\n   */\n  _buildPlan({flattened, overrides, modelClass, target, chainNames}) {\n    /** @type {Map<string, Slot>} */\n    const resolved = new Map()\n    /** @type {Map<string, import(\"./declarations.js\").CallbackDeclaration[]>} */\n    const callbacks = new Map()\n    /** @type {Set<import(\"./declarations.js\").CallbackDeclaration>} */\n    const seenCallbacks = new Set()\n    /** @type {import(\"./declarations.js\").InitializeWithDeclaration[\"fn\"] | null} */\n    let initializeWith = null\n    /** @type {import(\"./declarations.js\").ToCreateDeclaration[\"fn\"] | null} */\n    let toCreate = null\n    let skipCreate = false\n\n    for (const {decl} of flattened) {\n      if (decl.kind === \"attribute\") {\n        resolved.set(decl.name, {slotKind: decl.isTransient ? \"transient\" : \"attribute\", value: decl.value, isOverride: false})\n      } else if (decl.kind === \"association\") {\n        resolved.set(decl.name, {slotKind: \"association\", value: decl, isOverride: false})\n      } else if (decl.kind === \"callback\") {\n        if (!seenCallbacks.has(decl)) {\n          seenCallbacks.add(decl)\n\n          const eventCallbacks = callbacks.get(decl.event) || []\n\n          eventCallbacks.push(decl)\n          callbacks.set(decl.event, eventCallbacks)\n        }\n      } else if (decl.kind === \"initializeWith\") {\n        initializeWith = decl.fn\n      } else if (decl.kind === \"toCreate\") {\n        toCreate = decl.fn\n      } else if (decl.kind === \"skipCreate\") {\n        skipCreate = true\n      }\n    }\n\n    for (const key of Object.keys(overrides)) {\n      const prior = resolved.get(key)\n\n      resolved.set(key, {slotKind: prior ? prior.slotKind : \"attribute\", value: overrides[key], isOverride: true})\n    }\n\n    this._arbitrateAssociationOverrides(resolved, overrides, modelClass)\n\n    return {\n      factoryName: target.name,\n      factoryDefinition: target,\n      modelClass,\n      chainNames,\n      resolved,\n      callbacks,\n      initializeWith,\n      toCreate,\n      skipCreate\n    }\n  }\n\n  /**\n   * Applies belongs-to override precedence using the declared model relationship's\n   * real foreign-key metadata. An explicit association object wins over its key;\n   * otherwise an explicit key suppresses the factory-declared association.\n   * @param {Map<string, Slot>} resolved - Folded slots.\n   * @param {Record<string, ?>} overrides - Call-site overrides.\n   * @param {(new (attributes?: Record<string, ?>) => ?) | null} modelClass - Resolved model class.\n   * @returns {void}\n   */\n  _arbitrateAssociationOverrides(resolved, overrides, modelClass) {\n    if (typeof modelClass !== \"function\" || !(modelClass.prototype instanceof DatabaseRecord)) return\n\n    const backendModelClass = /** @type {typeof DatabaseRecord} */ (modelClass)\n    const columnToAttribute = backendModelClass.getColumnNameToAttributeNameMap()\n\n    for (const [name, slot] of [...resolved]) {\n      if (slot.slotKind !== \"association\") continue\n\n      const relationship = backendModelClass.getRelationshipByName(name)\n\n      if (relationship.getType() !== \"belongsTo\") continue\n\n      const foreignKeyColumn = relationship.getForeignKey()\n      const foreignKeyAttribute = columnToAttribute[foreignKeyColumn] || foreignKeyColumn\n\n      if (!Object.hasOwn(overrides, foreignKeyAttribute)) continue\n\n      if (slot.isOverride) {\n        resolved.delete(foreignKeyAttribute)\n      } else {\n        resolved.delete(name)\n      }\n    }\n  }\n}\n"]}

package/build/src/testing/factory/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a fresh, isolated factory registry independent of the default singleton
+ * (for libraries or spec groups that must not share global factory state).
+ * @returns {FactoryRegistry} - A new registry.
+ */
+export function createFactoryRegistry(): FactoryRegistry;
+export default Factory;
+import FactoryRegistry from "./factory-registry.js";
+/**
+ * The default, convenient factory registry singleton. Import it as `Factory` and
+ * call `Factory.define(...)`, `Factory.build(...)`, `Factory.create(...)`,
+ * `Factory.attributesFor(...)` and the list/pair helpers. This module is
+ * browser/Metro-safe: it contains no Node built-ins, filesystem discovery, or
+ * raw `import.meta`. Node-only definition loading lives in `./node/load-definitions.js`.
+ * @type {FactoryRegistry}
+ */
+declare const Factory: FactoryRegistry;
+//# sourceMappingURL=index.d.ts.map

package/build/src/testing/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/index.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,yCAFa,eAAe,CAI3B;;4BAnB2B,uBAAuB;AAEnD;;;;;;;GAOG;AACH,uBAFU,eAAe,CAEY"}

package/build/src/testing/factory/index.js

@@ -0,0 +1,21 @@
+// @ts-check
+import FactoryRegistry from "./factory-registry.js";
+/**
+ * The default, convenient factory registry singleton. Import it as `Factory` and
+ * call `Factory.define(...)`, `Factory.build(...)`, `Factory.create(...)`,
+ * `Factory.attributesFor(...)` and the list/pair helpers. This module is
+ * browser/Metro-safe: it contains no Node built-ins, filesystem discovery, or
+ * raw `import.meta`. Node-only definition loading lives in `./node/load-definitions.js`.
+ * @type {FactoryRegistry}
+ */
+const Factory = new FactoryRegistry();
+/**
+ * Creates a fresh, isolated factory registry independent of the default singleton
+ * (for libraries or spec groups that must not share global factory state).
+ * @returns {FactoryRegistry} - A new registry.
+ */
+export function createFactoryRegistry() {
+    return new FactoryRegistry();
+}
+export default Factory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdGVzdGluZy9mYWN0b3J5L2luZGV4LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLGVBQWUsTUFBTSx1QkFBdUIsQ0FBQTtBQUVuRDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxPQUFPLEdBQUcsSUFBSSxlQUFlLEVBQUUsQ0FBQTtBQUVyQzs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQjtJQUNuQyxPQUFPLElBQUksZUFBZSxFQUFFLENBQUE7QUFDOUIsQ0FBQztBQUVELGVBQWUsT0FBTyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCBGYWN0b3J5UmVnaXN0cnkgZnJvbSBcIi4vZmFjdG9yeS1yZWdpc3RyeS5qc1wiXG5cbi8qKlxuICogVGhlIGRlZmF1bHQsIGNvbnZlbmllbnQgZmFjdG9yeSByZWdpc3RyeSBzaW5nbGV0b24uIEltcG9ydCBpdCBhcyBgRmFjdG9yeWAgYW5kXG4gKiBjYWxsIGBGYWN0b3J5LmRlZmluZSguLi4pYCwgYEZhY3RvcnkuYnVpbGQoLi4uKWAsIGBGYWN0b3J5LmNyZWF0ZSguLi4pYCxcbiAqIGBGYWN0b3J5LmF0dHJpYnV0ZXNGb3IoLi4uKWAgYW5kIHRoZSBsaXN0L3BhaXIgaGVscGVycy4gVGhpcyBtb2R1bGUgaXNcbiAqIGJyb3dzZXIvTWV0cm8tc2FmZTogaXQgY29udGFpbnMgbm8gTm9kZSBidWlsdC1pbnMsIGZpbGVzeXN0ZW0gZGlzY292ZXJ5LCBvclxuICogcmF3IGBpbXBvcnQubWV0YWAuIE5vZGUtb25seSBkZWZpbml0aW9uIGxvYWRpbmcgbGl2ZXMgaW4gYC4vbm9kZS9sb2FkLWRlZmluaXRpb25zLmpzYC5cbiAqIEB0eXBlIHtGYWN0b3J5UmVnaXN0cnl9XG4gKi9cbmNvbnN0IEZhY3RvcnkgPSBuZXcgRmFjdG9yeVJlZ2lzdHJ5KClcblxuLyoqXG4gKiBDcmVhdGVzIGEgZnJlc2gsIGlzb2xhdGVkIGZhY3RvcnkgcmVnaXN0cnkgaW5kZXBlbmRlbnQgb2YgdGhlIGRlZmF1bHQgc2luZ2xldG9uXG4gKiAoZm9yIGxpYnJhcmllcyBvciBzcGVjIGdyb3VwcyB0aGF0IG11c3Qgbm90IHNoYXJlIGdsb2JhbCBmYWN0b3J5IHN0YXRlKS5cbiAqIEByZXR1cm5zIHtGYWN0b3J5UmVnaXN0cnl9IC0gQSBuZXcgcmVnaXN0cnkuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVGYWN0b3J5UmVnaXN0cnkoKSB7XG4gIHJldHVybiBuZXcgRmFjdG9yeVJlZ2lzdHJ5KClcbn1cblxuZXhwb3J0IGRlZmF1bHQgRmFjdG9yeVxuIl19

package/build/src/testing/factory/linter.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Executes registered factories (and optionally their traits) to prove they build
+ * and persist, aggregating every failure by case. For the create strategy each
+ * case runs inside the model's ambient transaction and is rolled back, so no rows
+ * remain in the supported single-connection case. External callback side effects
+ * are not reversible and cross-database writes are not globally atomic.
+ */
+export default class FactoryLinter {
+    /**
+     * Builds a linter.
+     * @param {import("./factory-registry.js").default} registry - Registry to lint.
+     */
+    constructor(registry: import("./factory-registry.js").default);
+    /** @type {import("./factory-registry.js").default} - Registry to lint. */
+    registry: import("./factory-registry.js").default;
+    /**
+     * Lints selected factories and reports every failure together.
+     * @param {object} [options] - Options.
+     * @param {string[]} [options.factories] - Factory names to lint. Defaults to all.
+     * @param {boolean} [options.traits] - Whether to also lint each factory's local traits.
+     * @param {"attributesFor" | "build" | "create"} [options.strategy] - Strategy to lint with. Defaults to create.
+     * @returns {Promise<void>} - Resolves when every case passed; rejects with an aggregate otherwise.
+     */
+    lint({ factories, traits, strategy }?: {
+        factories?: string[] | undefined;
+        traits?: boolean | undefined;
+        strategy?: "create" | "build" | "attributesFor" | undefined;
+    }): Promise<void>;
+    /**
+     * Resolves the unique set of factory definitions to lint.
+     * @param {string[] | undefined} factories - Explicit names, or undefined for all.
+     * @returns {import("./factory-definition.js").default[]} - Unique definitions.
+     */
+    _selectDefinitions(factories: string[] | undefined): import("./factory-definition.js").default[];
+    /**
+     * Lints one factory/trait case, rolling back create-strategy persistence.
+     * @param {import("./factory-definition.js").default} definition - Factory definition.
+     * @param {string[]} traits - Traits to apply for this case.
+     * @param {"attributesFor" | "build" | "create"} strategy - Strategy to run.
+     * @param {Array<{label: string, error: ?}>} failures - Failure sink.
+     * @returns {Promise<void>} - Resolves when the case has been evaluated.
+     */
+    _lintCase(definition: import("./factory-definition.js").default, traits: string[], strategy: "attributesFor" | "build" | "create", failures: Array<{
+        label: string;
+        error: unknown;
+    }>): Promise<void>;
+    /**
+     * Runs a create-strategy case inside a transaction and forces a rollback.
+     * @param {import("./factory-definition.js").default} definition - Factory definition.
+     * @param {string[]} traits - Traits to apply.
+     * @returns {Promise<void>} - Resolves (or rejects) once the rollback completes.
+     */
+    _lintCreateCase(definition: import("./factory-definition.js").default, traits: string[]): Promise<void>;
+}
+//# sourceMappingURL=linter.d.ts.map

package/build/src/testing/factory/linter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/linter.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,sBAFW,OAAO,uBAAuB,EAAE,OAAO,EAKjD;IAFC,0EAA0E;IAC1E,UADW,OAAO,uBAAuB,EAAE,OAAO,CAC1B;IAG1B;;;;;;;OAOG;IACH,uCALG;QAA2B,SAAS;QACV,MAAM;QACuB,QAAQ;KAC/D,GAAU,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;OAIG;IACH,8BAHW,MAAM,EAAE,GAAG,SAAS,GAClB,OAAO,yBAAyB,EAAE,OAAO,EAAE,CAQvD;IAED;;;;;;;OAOG;IACH,sBANW,OAAO,yBAAyB,EAAE,OAAO,UACzC,MAAM,EAAE,YACR,eAAe,GAAG,OAAO,GAAG,QAAQ,YACpC,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAC,CAAA;KAAC,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;OAKG;IACH,4BAJW,OAAO,yBAAyB,EAAE,OAAO,UACzC,MAAM,EAAE,GACN,OAAO,CAAC,IAAI,CAAC,CAiBzB;CACF"}