velocious 1.0.552 → 1.0.555

package/build/src/testing/factory/definition-builder.js

@@ -0,0 +1,417 @@
+// @ts-check
+import { isPlainObject } from "is-plain-object";
+import DatabaseRecord from "../../database/record/index.js";
+import { attributeDeclaration, callbackDeclaration, initializeWithDeclaration, skipCreateDeclaration, toCreateDeclaration, traitIncludeDeclaration } from "./declarations.js";
+import AssociationDeclaration from "./association-declaration.js";
+import FactoryDefinition from "./factory-definition.js";
+import Sequence from "./sequence.js";
+import TraitDefinition from "./trait-definition.js";
+import { InvalidDefinitionError } from "./errors.js";
+/** Callback phases accepted by `before`/`after` mapped to their event suffix. */
+const CALLBACK_PHASES = { all: "All", build: "Build", create: "Create" };
+/**
+ * Resolves a `before`/`after` phase into the concrete event name.
+ * @param {"before" | "after"} prefix - Callback prefix.
+ * @param {string} phase - Declared phase (all/build/create).
+ * @returns {string} - Concrete event name (e.g. "afterCreate").
+ */
+function eventNameFor(prefix, phase) {
+    const suffix = /** @type {Record<string, string>} */ (CALLBACK_PHASES)[phase];
+    if (!suffix) {
+        throw new InvalidDefinitionError(`Unknown callback phase "${String(phase)}". Use one of: ${Object.keys(CALLBACK_PHASES).join(", ")}`);
+    }
+    return `${prefix}${suffix}`;
+}
+/**
+ * Validates a declared name is a non-empty string.
+ * @param {string} name - Name to validate.
+ * @param {string} what - What is being named (for the message).
+ * @returns {void}
+ */
+function assertName(name, what) {
+    if (!name || typeof name !== "string") {
+        throw new InvalidDefinitionError(`${what} name must be a non-empty string, got: ${String(name)}`);
+    }
+}
+/**
+ * Builds an association declaration from the loose `association(name, ...)` args:
+ * leading strings are traits and a trailing plain object supplies factory/strategy
+ * plus overrides.
+ * @param {string} name - Relationship name.
+ * @param {Array<?>} args - Remaining arguments.
+ * @returns {AssociationDeclaration} - The declaration.
+ */
+function buildAssociationDeclaration(name, args) {
+    /** @type {string[]} */
+    const traits = [];
+    /** @type {Record<string, ?>} */
+    let options = {};
+    for (const arg of args) {
+        if (typeof arg === "string") {
+            traits.push(arg);
+        }
+        else if (isPlainObject(arg)) {
+            options = arg;
+        }
+        else {
+            throw new InvalidDefinitionError(`Invalid association argument for "${name}": ${String(arg)}`);
+        }
+    }
+    const { factory, strategy, ...overrides } = options;
+    return new AssociationDeclaration({ name, factory, strategy, traits, overrides });
+}
+/**
+ * Parses the polymorphic `sequence(name, ...)` argument forms into a Sequence.
+ * @param {string} name - Sequence name.
+ * @param {Array<?>} args - Remaining arguments (initial/options and/or formatter).
+ * @returns {Sequence} - The constructed sequence.
+ */
+function buildSequence(name, args) {
+    assertName(name, "Sequence");
+    let initial = 1;
+    /** @type {string[]} */
+    let aliases = [];
+    /** @type {import("./sequence.js").SequenceFormatter | undefined} */
+    let formatter;
+    for (const arg of args) {
+        if (typeof arg === "function") {
+            formatter = arg;
+        }
+        else if (typeof arg === "number") {
+            initial = arg;
+        }
+        else if (isPlainObject(arg)) {
+            if (typeof arg.initial === "number")
+                initial = arg.initial;
+            if (Array.isArray(arg.aliases))
+                aliases = arg.aliases;
+        }
+        else if (arg !== undefined) {
+            throw new InvalidDefinitionError(`Invalid sequence argument for "${name}": ${String(arg)}`);
+        }
+    }
+    return new Sequence({ name, initial, formatter, aliases });
+}
+/**
+ * Collects declarations for one factory/trait block. Shared by factory blocks,
+ * trait blocks and the root registry-defaults block.
+ */
+class DeclarationCollector {
+    /** Builds a collector. */
+    constructor() {
+        /** @type {import("./declarations.js").Declaration[]} - Ordered declarations. */
+        this.declarations = [];
+    }
+    /**
+     * Records a literal/lazy attribute.
+     * @param {string} name - Attribute name.
+     * @param {?} value - Literal value or lazy function.
+     * @returns {void}
+     */
+    attribute(name, value) {
+        assertName(name, "Attribute");
+        this.declarations.push(attributeDeclaration(name, value, false));
+    }
+    /**
+     * Records a transient attribute.
+     * @param {string} name - Transient name.
+     * @param {?} value - Literal value or lazy function.
+     * @returns {void}
+     */
+    transient(name, value) {
+        assertName(name, "Transient");
+        this.declarations.push(attributeDeclaration(name, value, true));
+    }
+    /**
+     * Records an association.
+     * @param {string} name - Relationship name.
+     * @param {Array<?>} args - Traits and/or an options object.
+     * @returns {void}
+     */
+    association(name, ...args) {
+        assertName(name, "Association");
+        this.declarations.push(buildAssociationDeclaration(name, args));
+    }
+    /**
+     * Records a before-callback.
+     * @param {string} phase - Phase (all/build/create).
+     * @param {import("./declarations.js").CallbackDeclaration["fn"]} fn - Callback body.
+     * @returns {void}
+     */
+    before(phase, fn) {
+        this.declarations.push(callbackDeclaration(eventNameFor("before", phase), fn));
+    }
+    /**
+     * Records an after-callback.
+     * @param {string} phase - Phase (all/build/create).
+     * @param {import("./declarations.js").CallbackDeclaration["fn"]} fn - Callback body.
+     * @returns {void}
+     */
+    after(phase, fn) {
+        this.declarations.push(callbackDeclaration(eventNameFor("after", phase), fn));
+    }
+    /**
+     * Records a custom constructor.
+     * @param {import("./declarations.js").InitializeWithDeclaration["fn"]} fn - Constructor body.
+     * @returns {void}
+     */
+    initializeWith(fn) {
+        this.declarations.push(initializeWithDeclaration(fn));
+    }
+    /**
+     * Records a custom persistence hook.
+     * @param {import("./declarations.js").ToCreateDeclaration["fn"]} fn - Persistence body.
+     * @returns {void}
+     */
+    toCreate(fn) {
+        this.declarations.push(toCreateDeclaration(fn));
+    }
+    /**
+     * Records that persistence should be skipped for the create strategy.
+     * @returns {void}
+     */
+    skipCreate() {
+        this.declarations.push(skipCreateDeclaration());
+    }
+}
+/**
+ * Runs a trait block against a fresh collector and compiles it into a definition.
+ * @param {string} name - Trait name.
+ * @param {(builder: object) => void} callback - Trait builder callback.
+ * @returns {TraitDefinition} - Compiled trait.
+ */
+function compileTrait(name, callback) {
+    assertName(name, "Trait");
+    if (typeof callback !== "function") {
+        throw new InvalidDefinitionError(`Trait "${name}" requires a builder function`);
+    }
+    const collector = new DeclarationCollector();
+    const builder = {
+        attribute: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.attribute(attrName, value),
+        transient: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.transient(attrName, value),
+        association: (/** @type {string} */ assocName, /** @type {Array<?>} */ ...args) => collector.association(assocName, ...args),
+        before: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.before(phase, fn),
+        after: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.after(phase, fn),
+        initializeWith: (/** @type {?} */ fn) => collector.initializeWith(fn),
+        toCreate: (/** @type {?} */ fn) => collector.toCreate(fn),
+        skipCreate: () => collector.skipCreate(),
+        trait: (/** @type {string} */ includeName) => {
+            assertName(includeName, "Trait include");
+            collector.declarations.push(traitIncludeDeclaration(includeName));
+        }
+    };
+    callback(builder);
+    return new TraitDefinition({ name, declarations: collector.declarations });
+}
+/**
+ * A single `define`/`modify` session. It walks the builder callbacks, compiles
+ * immutable definitions and registers them into the target registry, throwing on
+ * duplicate or structurally invalid declarations at definition time.
+ */
+export default class DefinitionSession {
+    /**
+     * Builds a session.
+     * @param {import("./factory-registry.js").default} registry - Target registry.
+     */
+    constructor(registry) {
+        /** @type {import("./factory-registry.js").default} - Target registry. */
+        this.registry = registry;
+    }
+    /**
+     * Runs a root `define` callback.
+     * @param {(builder: object) => void} callback - Root builder callback.
+     * @returns {void}
+     */
+    run(callback) {
+        if (typeof callback !== "function") {
+            throw new InvalidDefinitionError("define requires a builder callback");
+        }
+        callback(this._rootBuilder());
+    }
+    /**
+     * Runs a `modify` callback that reopens existing factories to append/override
+     * declarations, recompiling each into a fresh immutable definition rather than
+     * mutating the original.
+     * @param {(builder: object) => void} callback - Modify builder callback.
+     * @returns {void}
+     */
+    runModify(callback) {
+        if (typeof callback !== "function") {
+            throw new InvalidDefinitionError("modify requires a builder callback");
+        }
+        callback(this._modifyBuilder());
+    }
+    /**
+     * Builds the builder object exposed to `modify`.
+     * @returns {object} - Modify builder.
+     */
+    _modifyBuilder() {
+        return {
+            factory: (/** @type {string} */ name, /** @type {(builder: object) => void} */ cb) => this._modifyFactory(name, cb),
+            trait: (/** @type {string} */ name, /** @type {(builder: object) => void} */ cb) => this.registry._registerGlobalTrait(compileTrait(name, cb)),
+            sequence: (/** @type {string} */ name, /** @type {Array<?>} */ ...args) => this.registry._registerSequence(buildSequence(name, args), null),
+            before: (/** @type {string} */ phase, /** @type {?} */ fn) => this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor("before", phase), fn)),
+            after: (/** @type {string} */ phase, /** @type {?} */ fn) => this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor("after", phase), fn)),
+            initializeWith: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(initializeWithDeclaration(fn)),
+            toCreate: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(toCreateDeclaration(fn)),
+            skipCreate: () => this.registry._addGlobalDeclaration(skipCreateDeclaration())
+        };
+    }
+    /**
+     * Recompiles an existing factory with appended declarations.
+     * @param {string} name - Existing factory name.
+     * @param {(builder: object) => void} cb - Factory builder callback.
+     * @returns {void}
+     */
+    _modifyFactory(name, cb) {
+        assertName(name, "Factory");
+        const existing = this.registry._factories.get(name);
+        if (!existing) {
+            throw new InvalidDefinitionError(`Cannot modify unknown factory "${name}"`);
+        }
+        const collector = new DeclarationCollector();
+        /** @type {Array<{name: string, modelOrOptions: ?, cb: ?}>} */
+        const nestedFactories = [];
+        const localTraits = new Map(existing.localTraits);
+        /** @type {Sequence[]} */
+        const scopedSequences = [];
+        if (typeof cb === "function") {
+            cb(this._factoryBuilder(collector, nestedFactories, localTraits, scopedSequences));
+        }
+        const merged = new FactoryDefinition({
+            name: existing.name,
+            modelClass: existing.modelClass,
+            parentName: existing.parentName,
+            aliases: [...existing.aliases],
+            declarations: [...existing.declarations, ...collector.declarations],
+            localTraits
+        });
+        this.registry._replaceFactoryDefinition(merged);
+        for (const sequence of scopedSequences) {
+            this.registry._registerSequence(sequence, name);
+        }
+        for (const nested of nestedFactories) {
+            this._defineFactory(nested.name, nested.modelOrOptions, nested.cb, name);
+        }
+    }
+    /**
+     * Builds the root builder object exposed to `define`.
+     * @returns {object} - Root builder.
+     */
+    _rootBuilder() {
+        return {
+            factory: (/** @type {string} */ name, /** @type {?} */ modelOrOptions, /** @type {?} */ cb) => this._defineFactory(name, modelOrOptions, cb, null),
+            trait: (/** @type {string} */ name, /** @type {(builder: object) => void} */ cb) => this.registry._registerGlobalTrait(compileTrait(name, cb)),
+            sequence: (/** @type {string} */ name, /** @type {Array<?>} */ ...args) => this.registry._registerSequence(buildSequence(name, args), null),
+            before: (/** @type {string} */ phase, /** @type {?} */ fn) => this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor("before", phase), fn)),
+            after: (/** @type {string} */ phase, /** @type {?} */ fn) => this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor("after", phase), fn)),
+            initializeWith: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(initializeWithDeclaration(fn)),
+            toCreate: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(toCreateDeclaration(fn)),
+            skipCreate: () => this.registry._addGlobalDeclaration(skipCreateDeclaration())
+        };
+    }
+    /**
+     * Compiles and registers a factory (and its nested children/local traits/scoped
+     * sequences).
+     * @param {string} name - Factory name.
+     * @param {?} modelOrOptions - Model class or options object.
+     * @param {?} cb - Factory builder callback.
+     * @param {string | null} inheritedParent - Parent name for nested factories.
+     * @returns {void}
+     */
+    _defineFactory(name, modelOrOptions, cb, inheritedParent) {
+        assertName(name, "Factory");
+        let modelClass = null;
+        let builderCallback = cb;
+        /** @type {Record<string, ?>} */
+        let options = {};
+        if (typeof cb === "function") {
+            // Three-argument form: the second argument is the model class or options.
+            if (typeof modelOrOptions === "function") {
+                modelClass = modelOrOptions;
+            }
+            else if (isPlainObject(modelOrOptions)) {
+                options = modelOrOptions;
+                modelClass = options.model || options.class || null;
+            }
+            else if (modelOrOptions !== undefined) {
+                throw new InvalidDefinitionError(`Factory "${name}" model must be a class or an options object`);
+            }
+        }
+        else if (typeof modelOrOptions === "function") {
+            // Two-argument form with a trailing function. A backend model class means
+            // "no builder"; any other function is the builder (child inherits its model).
+            if (modelOrOptions.prototype instanceof DatabaseRecord) {
+                modelClass = modelOrOptions;
+            }
+            else {
+                builderCallback = modelOrOptions;
+            }
+        }
+        else if (isPlainObject(modelOrOptions)) {
+            options = modelOrOptions;
+            modelClass = options.model || options.class || null;
+        }
+        else if (modelOrOptions !== undefined) {
+            throw new InvalidDefinitionError(`Factory "${name}" model must be a class or an options object`);
+        }
+        const parentName = options.parent || inheritedParent || null;
+        const aliases = Array.isArray(options.aliases) ? options.aliases : [];
+        const baseTraits = Array.isArray(options.traits) ? options.traits : [];
+        const collector = new DeclarationCollector();
+        /** @type {Array<{name: string, modelOrOptions: ?, cb: ?}>} */
+        const nestedFactories = [];
+        /** @type {Map<string, TraitDefinition>} */
+        const localTraits = new Map();
+        /** @type {Sequence[]} */
+        const scopedSequences = [];
+        if (typeof builderCallback === "function") {
+            builderCallback(this._factoryBuilder(collector, nestedFactories, localTraits, scopedSequences));
+        }
+        const declarations = [...baseTraits.map((traitName) => traitIncludeDeclaration(traitName)), ...collector.declarations];
+        const definition = new FactoryDefinition({ name, modelClass, parentName, aliases, declarations, localTraits });
+        this.registry._registerFactoryDefinition(definition);
+        for (const sequence of scopedSequences) {
+            this.registry._registerSequence(sequence, name);
+        }
+        for (const nested of nestedFactories) {
+            this._defineFactory(nested.name, nested.modelOrOptions, nested.cb, name);
+        }
+    }
+    /**
+     * Builds the factory builder object.
+     * @param {DeclarationCollector} collector - Declaration collector.
+     * @param {Array<{name: string, modelOrOptions: ?, cb: ?}>} nestedFactories - Nested factory sink.
+     * @param {Map<string, TraitDefinition>} localTraits - Local trait sink.
+     * @param {Sequence[]} scopedSequences - Scoped sequence sink.
+     * @returns {object} - Factory builder.
+     */
+    _factoryBuilder(collector, nestedFactories, localTraits, scopedSequences) {
+        return {
+            attribute: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.attribute(attrName, value),
+            transient: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.transient(attrName, value),
+            association: (/** @type {string} */ assocName, /** @type {Array<?>} */ ...args) => collector.association(assocName, ...args),
+            before: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.before(phase, fn),
+            after: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.after(phase, fn),
+            initializeWith: (/** @type {?} */ fn) => collector.initializeWith(fn),
+            toCreate: (/** @type {?} */ fn) => collector.toCreate(fn),
+            skipCreate: () => collector.skipCreate(),
+            sequence: (/** @type {string} */ seqName, /** @type {Array<?>} */ ...args) => scopedSequences.push(buildSequence(seqName, args)),
+            trait: (/** @type {string} */ traitName, /** @type {((builder: object) => void) | undefined} */ traitCb) => {
+                if (typeof traitCb === "function") {
+                    const compiled = compileTrait(traitName, traitCb);
+                    if (localTraits.has(traitName)) {
+                        throw new InvalidDefinitionError(`Local trait "${traitName}" is already defined on this factory`);
+                    }
+                    localTraits.set(traitName, compiled);
+                }
+                else {
+                    assertName(traitName, "Trait include");
+                    collector.declarations.push(traitIncludeDeclaration(traitName));
+                }
+            },
+            factory: (/** @type {string} */ childName, /** @type {?} */ childModelOrOptions, /** @type {?} */ childCb) => nestedFactories.push({ name: childName, modelOrOptions: childModelOrOptions, cb: childCb })
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition-builder.js","sourceRoot":"","sources":["../../../../src/testing/factory/definition-builder.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isPlainObject} from \"is-plain-object\"\nimport DatabaseRecord from \"../../database/record/index.js\"\nimport {\n  attributeDeclaration,\n  callbackDeclaration,\n  initializeWithDeclaration,\n  skipCreateDeclaration,\n  toCreateDeclaration,\n  traitIncludeDeclaration\n} from \"./declarations.js\"\nimport AssociationDeclaration from \"./association-declaration.js\"\nimport FactoryDefinition from \"./factory-definition.js\"\nimport Sequence from \"./sequence.js\"\nimport TraitDefinition from \"./trait-definition.js\"\nimport {InvalidDefinitionError} from \"./errors.js\"\n\n/** Callback phases accepted by `before`/`after` mapped to their event suffix. */\nconst CALLBACK_PHASES = {all: \"All\", build: \"Build\", create: \"Create\"}\n\n/**\n * Resolves a `before`/`after` phase into the concrete event name.\n * @param {\"before\" | \"after\"} prefix - Callback prefix.\n * @param {string} phase - Declared phase (all/build/create).\n * @returns {string} - Concrete event name (e.g. \"afterCreate\").\n */\nfunction eventNameFor(prefix, phase) {\n  const suffix = /** @type {Record<string, string>} */ (CALLBACK_PHASES)[phase]\n\n  if (!suffix) {\n    throw new InvalidDefinitionError(`Unknown callback phase \"${String(phase)}\". Use one of: ${Object.keys(CALLBACK_PHASES).join(\", \")}`)\n  }\n\n  return `${prefix}${suffix}`\n}\n\n/**\n * Validates a declared name is a non-empty string.\n * @param {string} name - Name to validate.\n * @param {string} what - What is being named (for the message).\n * @returns {void}\n */\nfunction assertName(name, what) {\n  if (!name || typeof name !== \"string\") {\n    throw new InvalidDefinitionError(`${what} name must be a non-empty string, got: ${String(name)}`)\n  }\n}\n\n/**\n * Builds an association declaration from the loose `association(name, ...)` args:\n * leading strings are traits and a trailing plain object supplies factory/strategy\n * plus overrides.\n * @param {string} name - Relationship name.\n * @param {Array<?>} args - Remaining arguments.\n * @returns {AssociationDeclaration} - The declaration.\n */\nfunction buildAssociationDeclaration(name, args) {\n  /** @type {string[]} */\n  const traits = []\n  /** @type {Record<string, ?>} */\n  let options = {}\n\n  for (const arg of args) {\n    if (typeof arg === \"string\") {\n      traits.push(arg)\n    } else if (isPlainObject(arg)) {\n      options = arg\n    } else {\n      throw new InvalidDefinitionError(`Invalid association argument for \"${name}\": ${String(arg)}`)\n    }\n  }\n\n  const {factory, strategy, ...overrides} = options\n\n  return new AssociationDeclaration({name, factory, strategy, traits, overrides})\n}\n\n/**\n * Parses the polymorphic `sequence(name, ...)` argument forms into a Sequence.\n * @param {string} name - Sequence name.\n * @param {Array<?>} args - Remaining arguments (initial/options and/or formatter).\n * @returns {Sequence} - The constructed sequence.\n */\nfunction buildSequence(name, args) {\n  assertName(name, \"Sequence\")\n\n  let initial = 1\n  /** @type {string[]} */\n  let aliases = []\n  /** @type {import(\"./sequence.js\").SequenceFormatter | undefined} */\n  let formatter\n\n  for (const arg of args) {\n    if (typeof arg === \"function\") {\n      formatter = arg\n    } else if (typeof arg === \"number\") {\n      initial = arg\n    } else if (isPlainObject(arg)) {\n      if (typeof arg.initial === \"number\") initial = arg.initial\n      if (Array.isArray(arg.aliases)) aliases = arg.aliases\n    } else if (arg !== undefined) {\n      throw new InvalidDefinitionError(`Invalid sequence argument for \"${name}\": ${String(arg)}`)\n    }\n  }\n\n  return new Sequence({name, initial, formatter, aliases})\n}\n\n/**\n * Collects declarations for one factory/trait block. Shared by factory blocks,\n * trait blocks and the root registry-defaults block.\n */\nclass DeclarationCollector {\n  /** Builds a collector. */\n  constructor() {\n    /** @type {import(\"./declarations.js\").Declaration[]} - Ordered declarations. */\n    this.declarations = []\n  }\n\n  /**\n   * Records a literal/lazy attribute.\n   * @param {string} name - Attribute name.\n   * @param {?} value - Literal value or lazy function.\n   * @returns {void}\n   */\n  attribute(name, value) {\n    assertName(name, \"Attribute\")\n    this.declarations.push(attributeDeclaration(name, value, false))\n  }\n\n  /**\n   * Records a transient attribute.\n   * @param {string} name - Transient name.\n   * @param {?} value - Literal value or lazy function.\n   * @returns {void}\n   */\n  transient(name, value) {\n    assertName(name, \"Transient\")\n    this.declarations.push(attributeDeclaration(name, value, true))\n  }\n\n  /**\n   * Records an association.\n   * @param {string} name - Relationship name.\n   * @param {Array<?>} args - Traits and/or an options object.\n   * @returns {void}\n   */\n  association(name, ...args) {\n    assertName(name, \"Association\")\n    this.declarations.push(buildAssociationDeclaration(name, args))\n  }\n\n  /**\n   * Records a before-callback.\n   * @param {string} phase - Phase (all/build/create).\n   * @param {import(\"./declarations.js\").CallbackDeclaration[\"fn\"]} fn - Callback body.\n   * @returns {void}\n   */\n  before(phase, fn) {\n    this.declarations.push(callbackDeclaration(eventNameFor(\"before\", phase), fn))\n  }\n\n  /**\n   * Records an after-callback.\n   * @param {string} phase - Phase (all/build/create).\n   * @param {import(\"./declarations.js\").CallbackDeclaration[\"fn\"]} fn - Callback body.\n   * @returns {void}\n   */\n  after(phase, fn) {\n    this.declarations.push(callbackDeclaration(eventNameFor(\"after\", phase), fn))\n  }\n\n  /**\n   * Records a custom constructor.\n   * @param {import(\"./declarations.js\").InitializeWithDeclaration[\"fn\"]} fn - Constructor body.\n   * @returns {void}\n   */\n  initializeWith(fn) {\n    this.declarations.push(initializeWithDeclaration(fn))\n  }\n\n  /**\n   * Records a custom persistence hook.\n   * @param {import(\"./declarations.js\").ToCreateDeclaration[\"fn\"]} fn - Persistence body.\n   * @returns {void}\n   */\n  toCreate(fn) {\n    this.declarations.push(toCreateDeclaration(fn))\n  }\n\n  /**\n   * Records that persistence should be skipped for the create strategy.\n   * @returns {void}\n   */\n  skipCreate() {\n    this.declarations.push(skipCreateDeclaration())\n  }\n}\n\n/**\n * Runs a trait block against a fresh collector and compiles it into a definition.\n * @param {string} name - Trait name.\n * @param {(builder: object) => void} callback - Trait builder callback.\n * @returns {TraitDefinition} - Compiled trait.\n */\nfunction compileTrait(name, callback) {\n  assertName(name, \"Trait\")\n\n  if (typeof callback !== \"function\") {\n    throw new InvalidDefinitionError(`Trait \"${name}\" requires a builder function`)\n  }\n\n  const collector = new DeclarationCollector()\n  const builder = {\n    attribute: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.attribute(attrName, value),\n    transient: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.transient(attrName, value),\n    association: (/** @type {string} */ assocName, /** @type {Array<?>} */ ...args) => collector.association(assocName, ...args),\n    before: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.before(phase, fn),\n    after: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.after(phase, fn),\n    initializeWith: (/** @type {?} */ fn) => collector.initializeWith(fn),\n    toCreate: (/** @type {?} */ fn) => collector.toCreate(fn),\n    skipCreate: () => collector.skipCreate(),\n    trait: (/** @type {string} */ includeName) => {\n      assertName(includeName, \"Trait include\")\n      collector.declarations.push(traitIncludeDeclaration(includeName))\n    }\n  }\n\n  callback(builder)\n\n  return new TraitDefinition({name, declarations: collector.declarations})\n}\n\n/**\n * A single `define`/`modify` session. It walks the builder callbacks, compiles\n * immutable definitions and registers them into the target registry, throwing on\n * duplicate or structurally invalid declarations at definition time.\n */\nexport default class DefinitionSession {\n  /**\n   * Builds a session.\n   * @param {import(\"./factory-registry.js\").default} registry - Target registry.\n   */\n  constructor(registry) {\n    /** @type {import(\"./factory-registry.js\").default} - Target registry. */\n    this.registry = registry\n  }\n\n  /**\n   * Runs a root `define` callback.\n   * @param {(builder: object) => void} callback - Root builder callback.\n   * @returns {void}\n   */\n  run(callback) {\n    if (typeof callback !== \"function\") {\n      throw new InvalidDefinitionError(\"define requires a builder callback\")\n    }\n\n    callback(this._rootBuilder())\n  }\n\n  /**\n   * Runs a `modify` callback that reopens existing factories to append/override\n   * declarations, recompiling each into a fresh immutable definition rather than\n   * mutating the original.\n   * @param {(builder: object) => void} callback - Modify builder callback.\n   * @returns {void}\n   */\n  runModify(callback) {\n    if (typeof callback !== \"function\") {\n      throw new InvalidDefinitionError(\"modify requires a builder callback\")\n    }\n\n    callback(this._modifyBuilder())\n  }\n\n  /**\n   * Builds the builder object exposed to `modify`.\n   * @returns {object} - Modify builder.\n   */\n  _modifyBuilder() {\n    return {\n      factory: (/** @type {string} */ name, /** @type {(builder: object) => void} */ cb) => this._modifyFactory(name, cb),\n      trait: (/** @type {string} */ name, /** @type {(builder: object) => void} */ cb) =>\n        this.registry._registerGlobalTrait(compileTrait(name, cb)),\n      sequence: (/** @type {string} */ name, /** @type {Array<?>} */ ...args) =>\n        this.registry._registerSequence(buildSequence(name, args), null),\n      before: (/** @type {string} */ phase, /** @type {?} */ fn) =>\n        this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor(\"before\", phase), fn)),\n      after: (/** @type {string} */ phase, /** @type {?} */ fn) =>\n        this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor(\"after\", phase), fn)),\n      initializeWith: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(initializeWithDeclaration(fn)),\n      toCreate: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(toCreateDeclaration(fn)),\n      skipCreate: () => this.registry._addGlobalDeclaration(skipCreateDeclaration())\n    }\n  }\n\n  /**\n   * Recompiles an existing factory with appended declarations.\n   * @param {string} name - Existing factory name.\n   * @param {(builder: object) => void} cb - Factory builder callback.\n   * @returns {void}\n   */\n  _modifyFactory(name, cb) {\n    assertName(name, \"Factory\")\n\n    const existing = this.registry._factories.get(name)\n\n    if (!existing) {\n      throw new InvalidDefinitionError(`Cannot modify unknown factory \"${name}\"`)\n    }\n\n    const collector = new DeclarationCollector()\n    /** @type {Array<{name: string, modelOrOptions: ?, cb: ?}>} */\n    const nestedFactories = []\n    const localTraits = new Map(existing.localTraits)\n    /** @type {Sequence[]} */\n    const scopedSequences = []\n\n    if (typeof cb === \"function\") {\n      cb(this._factoryBuilder(collector, nestedFactories, localTraits, scopedSequences))\n    }\n\n    const merged = new FactoryDefinition({\n      name: existing.name,\n      modelClass: existing.modelClass,\n      parentName: existing.parentName,\n      aliases: [...existing.aliases],\n      declarations: [...existing.declarations, ...collector.declarations],\n      localTraits\n    })\n\n    this.registry._replaceFactoryDefinition(merged)\n\n    for (const sequence of scopedSequences) {\n      this.registry._registerSequence(sequence, name)\n    }\n\n    for (const nested of nestedFactories) {\n      this._defineFactory(nested.name, nested.modelOrOptions, nested.cb, name)\n    }\n  }\n\n  /**\n   * Builds the root builder object exposed to `define`.\n   * @returns {object} - Root builder.\n   */\n  _rootBuilder() {\n    return {\n      factory: (/** @type {string} */ name, /** @type {?} */ modelOrOptions, /** @type {?} */ cb) =>\n        this._defineFactory(name, modelOrOptions, cb, null),\n      trait: (/** @type {string} */ name, /** @type {(builder: object) => void} */ cb) =>\n        this.registry._registerGlobalTrait(compileTrait(name, cb)),\n      sequence: (/** @type {string} */ name, /** @type {Array<?>} */ ...args) =>\n        this.registry._registerSequence(buildSequence(name, args), null),\n      before: (/** @type {string} */ phase, /** @type {?} */ fn) =>\n        this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor(\"before\", phase), fn)),\n      after: (/** @type {string} */ phase, /** @type {?} */ fn) =>\n        this.registry._addGlobalDeclaration(callbackDeclaration(eventNameFor(\"after\", phase), fn)),\n      initializeWith: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(initializeWithDeclaration(fn)),\n      toCreate: (/** @type {?} */ fn) => this.registry._addGlobalDeclaration(toCreateDeclaration(fn)),\n      skipCreate: () => this.registry._addGlobalDeclaration(skipCreateDeclaration())\n    }\n  }\n\n  /**\n   * Compiles and registers a factory (and its nested children/local traits/scoped\n   * sequences).\n   * @param {string} name - Factory name.\n   * @param {?} modelOrOptions - Model class or options object.\n   * @param {?} cb - Factory builder callback.\n   * @param {string | null} inheritedParent - Parent name for nested factories.\n   * @returns {void}\n   */\n  _defineFactory(name, modelOrOptions, cb, inheritedParent) {\n    assertName(name, \"Factory\")\n\n    let modelClass = null\n    let builderCallback = cb\n    /** @type {Record<string, ?>} */\n    let options = {}\n\n    if (typeof cb === \"function\") {\n      // Three-argument form: the second argument is the model class or options.\n      if (typeof modelOrOptions === \"function\") {\n        modelClass = modelOrOptions\n      } else if (isPlainObject(modelOrOptions)) {\n        options = modelOrOptions\n        modelClass = options.model || options.class || null\n      } else if (modelOrOptions !== undefined) {\n        throw new InvalidDefinitionError(`Factory \"${name}\" model must be a class or an options object`)\n      }\n    } else if (typeof modelOrOptions === \"function\") {\n      // Two-argument form with a trailing function. A backend model class means\n      // \"no builder\"; any other function is the builder (child inherits its model).\n      if (modelOrOptions.prototype instanceof DatabaseRecord) {\n        modelClass = modelOrOptions\n      } else {\n        builderCallback = modelOrOptions\n      }\n    } else if (isPlainObject(modelOrOptions)) {\n      options = modelOrOptions\n      modelClass = options.model || options.class || null\n    } else if (modelOrOptions !== undefined) {\n      throw new InvalidDefinitionError(`Factory \"${name}\" model must be a class or an options object`)\n    }\n\n    const parentName = options.parent || inheritedParent || null\n    const aliases = Array.isArray(options.aliases) ? options.aliases : []\n    const baseTraits = Array.isArray(options.traits) ? options.traits : []\n\n    const collector = new DeclarationCollector()\n    /** @type {Array<{name: string, modelOrOptions: ?, cb: ?}>} */\n    const nestedFactories = []\n    /** @type {Map<string, TraitDefinition>} */\n    const localTraits = new Map()\n    /** @type {Sequence[]} */\n    const scopedSequences = []\n\n    if (typeof builderCallback === \"function\") {\n      builderCallback(this._factoryBuilder(collector, nestedFactories, localTraits, scopedSequences))\n    }\n\n    const declarations = [...baseTraits.map((traitName) => traitIncludeDeclaration(traitName)), ...collector.declarations]\n    const definition = new FactoryDefinition({name, modelClass, parentName, aliases, declarations, localTraits})\n\n    this.registry._registerFactoryDefinition(definition)\n\n    for (const sequence of scopedSequences) {\n      this.registry._registerSequence(sequence, name)\n    }\n\n    for (const nested of nestedFactories) {\n      this._defineFactory(nested.name, nested.modelOrOptions, nested.cb, name)\n    }\n  }\n\n  /**\n   * Builds the factory builder object.\n   * @param {DeclarationCollector} collector - Declaration collector.\n   * @param {Array<{name: string, modelOrOptions: ?, cb: ?}>} nestedFactories - Nested factory sink.\n   * @param {Map<string, TraitDefinition>} localTraits - Local trait sink.\n   * @param {Sequence[]} scopedSequences - Scoped sequence sink.\n   * @returns {object} - Factory builder.\n   */\n  _factoryBuilder(collector, nestedFactories, localTraits, scopedSequences) {\n    return {\n      attribute: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.attribute(attrName, value),\n      transient: (/** @type {string} */ attrName, /** @type {?} */ value) => collector.transient(attrName, value),\n      association: (/** @type {string} */ assocName, /** @type {Array<?>} */ ...args) => collector.association(assocName, ...args),\n      before: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.before(phase, fn),\n      after: (/** @type {string} */ phase, /** @type {?} */ fn) => collector.after(phase, fn),\n      initializeWith: (/** @type {?} */ fn) => collector.initializeWith(fn),\n      toCreate: (/** @type {?} */ fn) => collector.toCreate(fn),\n      skipCreate: () => collector.skipCreate(),\n      sequence: (/** @type {string} */ seqName, /** @type {Array<?>} */ ...args) => scopedSequences.push(buildSequence(seqName, args)),\n      trait: (/** @type {string} */ traitName, /** @type {((builder: object) => void) | undefined} */ traitCb) => {\n        if (typeof traitCb === \"function\") {\n          const compiled = compileTrait(traitName, traitCb)\n\n          if (localTraits.has(traitName)) {\n            throw new InvalidDefinitionError(`Local trait \"${traitName}\" is already defined on this factory`)\n          }\n\n          localTraits.set(traitName, compiled)\n        } else {\n          assertName(traitName, \"Trait include\")\n          collector.declarations.push(traitIncludeDeclaration(traitName))\n        }\n      },\n      factory: (/** @type {string} */ childName, /** @type {?} */ childModelOrOptions, /** @type {?} */ childCb) =>\n        nestedFactories.push({name: childName, modelOrOptions: childModelOrOptions, cb: childCb})\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,62 @@
+/**
+ * Raised when a factory, trait or sequence is declared twice within the same
+ * registry, matching FactoryBot's duplicate-definition guard.
+ */
+export class DuplicateDefinitionError extends FactoryError {
+}
+/**
+ * Raised when attribute or factory/trait resolution forms a cycle. The message
+ * always contains the full offending path so the author can break it.
+ */
+export class FactoryCycleError extends FactoryError {
+}
+/**
+ * Base error for every Factory-framework failure so callers can catch the whole
+ * family with a single `instanceof FactoryError` check.
+ */
+export class FactoryError extends Error {
+    /**
+     * Builds a factory error.
+     * @param {string} message - Human readable description of the failure.
+     */
+    constructor(message: string);
+}
+/**
+ * Raised when a definition is structurally invalid at declaration time (bad
+ * names, option shapes, event names, or model references).
+ */
+export class InvalidDefinitionError extends FactoryError {
+}
+/**
+ * Raised when a build/create strategy is asked to construct a class that is not a
+ * supported, initialized Velocious backend record.
+ */
+export class ModelContractError extends FactoryError {
+}
+/**
+ * Raised when setup-time mutation (define/modify/reset/sequence set/rewind) is
+ * attempted while the registry has in-flight evaluations.
+ */
+export class RegistryBusyError extends FactoryError {
+}
+/**
+ * Raised when a lazy attribute references another attribute that does not exist.
+ */
+export class UndefinedAttributeError extends FactoryError {
+}
+/**
+ * Raised when a strategy references a factory name that was never registered.
+ */
+export class UndefinedFactoryError extends FactoryError {
+}
+/**
+ * Raised when a sequence name cannot be resolved in the factory-local or global scope.
+ */
+export class UndefinedSequenceError extends FactoryError {
+}
+/**
+ * Raised when a trait name cannot be resolved in the factory-local or global scope.
+ */
+export class UndefinedTraitError extends FactoryError {
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/errors.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH;CAAsD;AAsBtD;;;GAGG;AACH;CAA+C;AA7C/C;;;GAGG;AACH;IACE;;;OAGG;IACH,qBAFW,MAAM,EAKhB;CACF;AAkCD;;;GAGG;AACH;CAAoD;AAEpD;;;GAGG;AACH;CAAgD;AAEhD;;;GAGG;AACH;CAA+C;AA3B/C;;GAEG;AACH;CAAqD;AAlBrD;;GAEG;AACH;CAAmD;AAOnD;;GAEG;AACH;CAAoD;AARpD;;GAEG;AACH;CAAiD"}

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

@@ -0,0 +1,67 @@
+// @ts-check
+/**
+ * Base error for every Factory-framework failure so callers can catch the whole
+ * family with a single `instanceof FactoryError` check.
+ */
+class FactoryError extends Error {
+    /**
+     * Builds a factory error.
+     * @param {string} message - Human readable description of the failure.
+     */
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+/**
+ * Raised when a factory, trait or sequence is declared twice within the same
+ * registry, matching FactoryBot's duplicate-definition guard.
+ */
+class DuplicateDefinitionError extends FactoryError {
+}
+/**
+ * Raised when a strategy references a factory name that was never registered.
+ */
+class UndefinedFactoryError extends FactoryError {
+}
+/**
+ * Raised when a trait name cannot be resolved in the factory-local or global scope.
+ */
+class UndefinedTraitError extends FactoryError {
+}
+/**
+ * Raised when a sequence name cannot be resolved in the factory-local or global scope.
+ */
+class UndefinedSequenceError extends FactoryError {
+}
+/**
+ * Raised when a lazy attribute references another attribute that does not exist.
+ */
+class UndefinedAttributeError extends FactoryError {
+}
+/**
+ * Raised when attribute or factory/trait resolution forms a cycle. The message
+ * always contains the full offending path so the author can break it.
+ */
+class FactoryCycleError extends FactoryError {
+}
+/**
+ * Raised when a definition is structurally invalid at declaration time (bad
+ * names, option shapes, event names, or model references).
+ */
+class InvalidDefinitionError extends FactoryError {
+}
+/**
+ * Raised when a build/create strategy is asked to construct a class that is not a
+ * supported, initialized Velocious backend record.
+ */
+class ModelContractError extends FactoryError {
+}
+/**
+ * Raised when setup-time mutation (define/modify/reset/sequence set/rewind) is
+ * attempted while the registry has in-flight evaluations.
+ */
+class RegistryBusyError extends FactoryError {
+}
+export { DuplicateDefinitionError, FactoryCycleError, FactoryError, InvalidDefinitionError, ModelContractError, RegistryBusyError, UndefinedAttributeError, UndefinedFactoryError, UndefinedSequenceError, UndefinedTraitError };
+//# sourceMappingURL=data:application/json;base64,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