velocious 1.0.552 → 1.0.555

package/build/src/testing/factory/strategies/base.js

@@ -0,0 +1,191 @@
+// @ts-check
+import * as inflection from "inflection";
+import { assertModelClass } from "../model-contract.js";
+import { ModelContractError } from "../errors.js";
+import EvaluationContext from "../evaluation-context.js";
+/**
+ * Shared behaviour for the build/create/attributesFor strategies: evaluation
+ * context creation, deterministic callback execution, guaranteed `afterAll`
+ * cleanup, record construction (default and `initializeWith`), and association
+ * wiring through public relationship reflection.
+ */
+export default class BaseStrategy {
+    /**
+     * Creates an evaluation context for a plan.
+     * @param {import("../factory-registry.js").default} registry - Owning registry.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {"attributesFor" | "build" | "create"} strategyName - Strategy name.
+     * @returns {EvaluationContext} - The context.
+     */
+    _newContext(registry, plan, strategyName) {
+        return new EvaluationContext({ registry, plan, strategy: strategyName });
+    }
+    /**
+     * Builds the callback `context` object: evaluated transients exposed as plain
+     * properties (no Proxy) plus the named evaluator methods.
+     * @param {EvaluationContext} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transient values.
+     * @returns {Record<string, ?>} - The callback context.
+     */
+    _callbackContext(context, transients) {
+        return Object.assign({}, transients, context.contextFor([]));
+    }
+    /**
+     * Runs every deduped callback for an event in declaration order.
+     * @param {EvaluationContext} context - Evaluation context.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {string} event - Event name (e.g. "afterCreate").
+     * @param {{record: ?, transients: Record<string, ?>, strategy: string}} state - Current record/transients/strategy.
+     * @returns {Promise<void>} - Resolves when all callbacks complete.
+     */
+    async _runCallbacks(context, plan, event, state) {
+        const callbacks = plan.callbacks.get(event);
+        if (!callbacks)
+            return;
+        const callbackContext = this._callbackContext(context, state.transients);
+        for (const callback of callbacks) {
+            await callback.fn({ record: state.record, context: callbackContext, strategy: state.strategy });
+        }
+    }
+    /**
+     * Runs `body`, then guarantees `afterAll` runs in `finally`. When both the body
+     * and cleanup fail, the body's primary error is preserved and the cleanup error
+     * is attached as a detail rather than masking it.
+     * @param {EvaluationContext} context - Evaluation context.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {() => {record: ?, transients: Record<string, ?>, strategy: string}} state - Late-bound state accessor.
+     * @param {() => Promise<?>} body - The strategy body.
+     * @returns {Promise<?>} - The body's result.
+     */
+    async _runWithAfterAll(context, plan, state, body) {
+        /** @type {?} */
+        let result;
+        /** @type {?} */
+        let primaryError;
+        let hasPrimaryError = false;
+        try {
+            result = await body();
+        }
+        catch (error) {
+            primaryError = error;
+            hasPrimaryError = true;
+        }
+        /** @type {?} */
+        let cleanupError;
+        let hasCleanupError = false;
+        try {
+            await this._runCallbacks(context, plan, "afterAll", state());
+        }
+        catch (error) {
+            cleanupError = error;
+            hasCleanupError = true;
+        }
+        if (hasPrimaryError) {
+            if (hasCleanupError)
+                this._attachCleanupFailure(primaryError, cleanupError);
+            throw primaryError;
+        }
+        if (hasCleanupError)
+            throw cleanupError;
+        return result;
+    }
+    /**
+     * Attaches an afterAll cleanup failure to the primary error without masking it.
+     * @param {?} primaryError - The original error that will propagate.
+     * @param {?} cleanupError - The afterAll cleanup failure.
+     * @returns {void}
+     */
+    _attachCleanupFailure(primaryError, cleanupError) {
+        if (!primaryError || typeof primaryError !== "object" || !Object.isExtensible(primaryError))
+            return;
+        if (!Array.isArray(primaryError.factoryCleanupErrors))
+            primaryError.factoryCleanupErrors = [];
+        primaryError.factoryCleanupErrors.push(cleanupError);
+    }
+    /**
+     * Constructs a record from evaluated public attributes, honouring a custom
+     * `initializeWith` constructor and never assigning constructor-consumed
+     * attributes twice.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.
+     * @param {EvaluationContext} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @returns {Promise<?>} - The constructed record.
+     */
+    async _constructRecord(plan, publicAttributes, context, transients) {
+        const ModelClass = assertModelClass(plan.modelClass, plan.factoryName);
+        if (plan.initializeWith) {
+            return await this._constructWithInitializer(plan, ModelClass, publicAttributes, context, transients);
+        }
+        return new ModelClass(publicAttributes);
+    }
+    /**
+     * Constructs a record via a custom `initializeWith`, tracking which attributes
+     * the constructor consumed through its `get(name)` accessor and assigning only
+     * the remaining public attributes afterwards.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {new (attributes?: Record<string, ?>) => import("../../../database/record/index.js").default} ModelClass - Validated declared model class.
+     * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.
+     * @param {EvaluationContext} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @returns {Promise<?>} - The constructed record.
+     */
+    async _constructWithInitializer(plan, ModelClass, publicAttributes, context, transients) {
+        /** @type {Set<string>} */
+        const consumed = new Set();
+        const get = (/** @type {string} */ name) => {
+            consumed.add(name);
+            return publicAttributes[name];
+        };
+        const initializeWith = /** @type {import("../declarations.js").InitializeWithDeclaration["fn"]} */ (plan.initializeWith);
+        const record = await initializeWith({ attributes: { ...publicAttributes }, get, context: this._callbackContext(context, transients) });
+        if (!(record instanceof ModelClass)) {
+            throw new ModelContractError(`Factory "${plan.factoryName}" initializeWith must return an instance of ${ModelClass.name}, got: ${String(record)}`);
+        }
+        /** @type {Record<string, ?>} */
+        const remaining = {};
+        for (const key of Object.keys(publicAttributes)) {
+            if (!consumed.has(key))
+                remaining[key] = publicAttributes[key];
+        }
+        if (Object.keys(remaining).length > 0) {
+            /** @type {?} */ (record).assign(remaining);
+        }
+        return record;
+    }
+    /**
+     * Wires evaluated associations onto a record through public relationship
+     * reflection and generated setters (never private caches or guessed keys).
+     * @param {?} record - The owning record.
+     * @param {Array<{name: string, record: ?}>} associations - Evaluated associations.
+     * @returns {void}
+     */
+    _assignAssociations(record, associations) {
+        for (const { name, record: associatedRecord } of associations) {
+            const instanceRelationship = record.getRelationshipByName(name);
+            const relationshipType = instanceRelationship.getType();
+            if (relationshipType === "belongsTo") {
+                record[`set${inflection.camelize(name)}`](associatedRecord || null);
+            }
+            else if (relationshipType === "hasOne") {
+                instanceRelationship.setLoaded(associatedRecord || undefined);
+            }
+            else if (relationshipType === "hasMany") {
+                instanceRelationship.setLoaded(this._toRecordArray(associatedRecord));
+            }
+        }
+    }
+    /**
+     * Normalizes a has-many association value into an array of records.
+     * @param {?} value - Association value (record, array, or null).
+     * @returns {Array<?>} - The normalized record array.
+     */
+    _toRecordArray(value) {
+        if (value == null)
+            return [];
+        if (Array.isArray(value))
+            return value;
+        return [value];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport * as inflection from \"inflection\"\nimport {assertModelClass} from \"../model-contract.js\"\nimport {ModelContractError} from \"../errors.js\"\nimport EvaluationContext from \"../evaluation-context.js\"\n\n/**\n * Shared behaviour for the build/create/attributesFor strategies: evaluation\n * context creation, deterministic callback execution, guaranteed `afterAll`\n * cleanup, record construction (default and `initializeWith`), and association\n * wiring through public relationship reflection.\n */\nexport default class BaseStrategy {\n  /**\n   * Creates an evaluation context for a plan.\n   * @param {import(\"../factory-registry.js\").default} registry - Owning registry.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {\"attributesFor\" | \"build\" | \"create\"} strategyName - Strategy name.\n   * @returns {EvaluationContext} - The context.\n   */\n  _newContext(registry, plan, strategyName) {\n    return new EvaluationContext({registry, plan, strategy: strategyName})\n  }\n\n  /**\n   * Builds the callback `context` object: evaluated transients exposed as plain\n   * properties (no Proxy) plus the named evaluator methods.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ?>} transients - Evaluated transient values.\n   * @returns {Record<string, ?>} - The callback context.\n   */\n  _callbackContext(context, transients) {\n    return Object.assign({}, transients, context.contextFor([]))\n  }\n\n  /**\n   * Runs every deduped callback for an event in declaration order.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {string} event - Event name (e.g. \"afterCreate\").\n   * @param {{record: ?, transients: Record<string, ?>, strategy: string}} state - Current record/transients/strategy.\n   * @returns {Promise<void>} - Resolves when all callbacks complete.\n   */\n  async _runCallbacks(context, plan, event, state) {\n    const callbacks = plan.callbacks.get(event)\n\n    if (!callbacks) return\n\n    const callbackContext = this._callbackContext(context, state.transients)\n\n    for (const callback of callbacks) {\n      await callback.fn({record: state.record, context: callbackContext, strategy: state.strategy})\n    }\n  }\n\n  /**\n   * Runs `body`, then guarantees `afterAll` runs in `finally`. When both the body\n   * and cleanup fail, the body's primary error is preserved and the cleanup error\n   * is attached as a detail rather than masking it.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {() => {record: ?, transients: Record<string, ?>, strategy: string}} state - Late-bound state accessor.\n   * @param {() => Promise<?>} body - The strategy body.\n   * @returns {Promise<?>} - The body's result.\n   */\n  async _runWithAfterAll(context, plan, state, body) {\n    /** @type {?} */\n    let result\n    /** @type {?} */\n    let primaryError\n    let hasPrimaryError = false\n\n    try {\n      result = await body()\n    } catch (error) {\n      primaryError = error\n      hasPrimaryError = true\n    }\n\n    /** @type {?} */\n    let cleanupError\n    let hasCleanupError = false\n\n    try {\n      await this._runCallbacks(context, plan, \"afterAll\", state())\n    } catch (error) {\n      cleanupError = error\n      hasCleanupError = true\n    }\n\n    if (hasPrimaryError) {\n      if (hasCleanupError) this._attachCleanupFailure(primaryError, cleanupError)\n\n      throw primaryError\n    }\n\n    if (hasCleanupError) throw cleanupError\n\n    return result\n  }\n\n  /**\n   * Attaches an afterAll cleanup failure to the primary error without masking it.\n   * @param {?} primaryError - The original error that will propagate.\n   * @param {?} cleanupError - The afterAll cleanup failure.\n   * @returns {void}\n   */\n  _attachCleanupFailure(primaryError, cleanupError) {\n    if (!primaryError || typeof primaryError !== \"object\" || !Object.isExtensible(primaryError)) return\n\n    if (!Array.isArray(primaryError.factoryCleanupErrors)) primaryError.factoryCleanupErrors = []\n    primaryError.factoryCleanupErrors.push(cleanupError)\n  }\n\n  /**\n   * Constructs a record from evaluated public attributes, honouring a custom\n   * `initializeWith` constructor and never assigning constructor-consumed\n   * attributes twice.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ?>} transients - Evaluated transients.\n   * @returns {Promise<?>} - The constructed record.\n   */\n  async _constructRecord(plan, publicAttributes, context, transients) {\n    const ModelClass = assertModelClass(plan.modelClass, plan.factoryName)\n\n    if (plan.initializeWith) {\n      return await this._constructWithInitializer(plan, ModelClass, publicAttributes, context, transients)\n    }\n\n    return new ModelClass(publicAttributes)\n  }\n\n  /**\n   * Constructs a record via a custom `initializeWith`, tracking which attributes\n   * the constructor consumed through its `get(name)` accessor and assigning only\n   * the remaining public attributes afterwards.\n   * @param {import(\"../factory-runner.js\").CompiledPlan} plan - Compiled plan.\n   * @param {new (attributes?: Record<string, ?>) => import(\"../../../database/record/index.js\").default} ModelClass - Validated declared model class.\n   * @param {Record<string, ?>} publicAttributes - Evaluated public attributes.\n   * @param {EvaluationContext} context - Evaluation context.\n   * @param {Record<string, ?>} transients - Evaluated transients.\n   * @returns {Promise<?>} - The constructed record.\n   */\n  async _constructWithInitializer(plan, ModelClass, publicAttributes, context, transients) {\n    /** @type {Set<string>} */\n    const consumed = new Set()\n    const get = (/** @type {string} */ name) => {\n      consumed.add(name)\n\n      return publicAttributes[name]\n    }\n    const initializeWith = /** @type {import(\"../declarations.js\").InitializeWithDeclaration[\"fn\"]} */ (plan.initializeWith)\n    const record = await initializeWith({attributes: {...publicAttributes}, get, context: this._callbackContext(context, transients)})\n\n    if (!(record instanceof ModelClass)) {\n      throw new ModelContractError(`Factory \"${plan.factoryName}\" initializeWith must return an instance of ${ModelClass.name}, got: ${String(record)}`)\n    }\n\n    /** @type {Record<string, ?>} */\n    const remaining = {}\n\n    for (const key of Object.keys(publicAttributes)) {\n      if (!consumed.has(key)) remaining[key] = publicAttributes[key]\n    }\n\n    if (Object.keys(remaining).length > 0) {\n      /** @type {?} */ (record).assign(remaining)\n    }\n\n    return record\n  }\n\n  /**\n   * Wires evaluated associations onto a record through public relationship\n   * reflection and generated setters (never private caches or guessed keys).\n   * @param {?} record - The owning record.\n   * @param {Array<{name: string, record: ?}>} associations - Evaluated associations.\n   * @returns {void}\n   */\n  _assignAssociations(record, associations) {\n    for (const {name, record: associatedRecord} of associations) {\n      const instanceRelationship = record.getRelationshipByName(name)\n      const relationshipType = instanceRelationship.getType()\n\n      if (relationshipType === \"belongsTo\") {\n        record[`set${inflection.camelize(name)}`](associatedRecord || null)\n      } else if (relationshipType === \"hasOne\") {\n        instanceRelationship.setLoaded(associatedRecord || undefined)\n      } else if (relationshipType === \"hasMany\") {\n        instanceRelationship.setLoaded(this._toRecordArray(associatedRecord))\n      }\n    }\n  }\n\n  /**\n   * Normalizes a has-many association value into an array of records.\n   * @param {?} value - Association value (record, array, or null).\n   * @returns {Array<?>} - The normalized record array.\n   */\n  _toRecordArray(value) {\n    if (value == null) return []\n    if (Array.isArray(value)) return value\n\n    return [value]\n  }\n}\n"]}

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

@@ -0,0 +1,20 @@
+/**
+ * The `build` strategy. It recursively builds associated models (using the parent
+ * strategy) and constructs the root record without persisting anything. Runs the
+ * beforeAll/beforeBuild/afterBuild callbacks and guarantees afterAll cleanup.
+ */
+export default class BuildStrategy extends BaseStrategy {
+    /**
+     * Runs the strategy.
+     * @param {object} args - Options.
+     * @param {import("../factory-registry.js").default} args.registry - Owning registry.
+     * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
+     * @returns {Promise<?>} - The built (unsaved) record.
+     */
+    run({ registry, plan }: {
+        registry: import("../factory-registry.js").default;
+        plan: import("../factory-runner.js").CompiledPlan;
+    }): Promise<unknown>;
+}
+import BaseStrategy from "./base.js";
+//# sourceMappingURL=build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/build.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,wBAJG;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO;QACU,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY;KACnD,GAAU,OAAO,CAAC,OAAC,CAAC,CAyBtB;CACF;yBAvCwB,WAAW"}

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

@@ -0,0 +1,34 @@
+// @ts-check
+import BaseStrategy from "./base.js";
+/**
+ * The `build` strategy. It recursively builds associated models (using the parent
+ * strategy) and constructs the root record without persisting anything. Runs the
+ * beforeAll/beforeBuild/afterBuild callbacks and guarantees afterAll cleanup.
+ */
+export default class BuildStrategy extends BaseStrategy {
+    /**
+     * Runs the strategy.
+     * @param {object} args - Options.
+     * @param {import("../factory-registry.js").default} args.registry - Owning registry.
+     * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
+     * @returns {Promise<?>} - The built (unsaved) record.
+     */
+    async run({ registry, plan }) {
+        const context = this._newContext(registry, plan, "build");
+        /** @type {{record: ?, transients: Record<string, ?>}} */
+        const runState = { record: undefined, transients: {} };
+        const state = () => ({ record: runState.record, transients: runState.transients, strategy: "build" });
+        return await this._runWithAfterAll(context, plan, state, async () => {
+            runState.transients = await context.resolveTransients();
+            await this._runCallbacks(context, plan, "beforeAll", state());
+            await this._runCallbacks(context, plan, "beforeBuild", state());
+            const { publicAttributes, transients, associations } = await context.resolveForConstruction();
+            const record = await this._constructRecord(plan, publicAttributes, context, transients);
+            this._assignAssociations(record, associations);
+            runState.record = record;
+            await this._runCallbacks(context, plan, "afterBuild", state());
+            return record;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/factory/strategies/create.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The `create` strategy. It builds the object graph (associations use the parent
+ * create strategy by default), runs beforeAll/beforeBuild/afterBuild, persists the
+ * root record through its native `save()` (letting Velocious own association
+ * autosave order and validation) or a custom `toCreate`, then runs
+ * beforeCreate/afterCreate and guarantees afterAll cleanup.
+ */
+export default class CreateStrategy extends BaseStrategy {
+    /**
+     * Runs the strategy.
+     * @param {object} args - Options.
+     * @param {import("../factory-registry.js").default} args.registry - Owning registry.
+     * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
+     * @returns {Promise<?>} - The persisted record.
+     */
+    run({ registry, plan }: {
+        registry: import("../factory-registry.js").default;
+        plan: import("../factory-runner.js").CompiledPlan;
+    }): Promise<unknown>;
+    /**
+     * Persists the record via a custom `toCreate`, native `save()`, or not at all
+     * when `skipCreate` is declared.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {?} record - The record to persist.
+     * @param {import("../evaluation-context.js").default} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @returns {Promise<void>} - Resolves when persistence completes.
+     */
+    _persist(plan: import("../factory-runner.js").CompiledPlan, record: unknown, context: import("../evaluation-context.js").default, transients: Record<string, unknown>): Promise<void>;
+}
+import BaseStrategy from "./base.js";
+//# sourceMappingURL=create.d.ts.map

package/build/src/testing/factory/strategies/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../../../src/testing/factory/strategies/create.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH;IACE;;;;;;OAMG;IACH,wBAJG;QAAuD,QAAQ,EAAvD,OAAO,wBAAwB,EAAE,OAAO;QACU,IAAI,EAAtD,OAAO,sBAAsB,EAAE,YAAY;KACnD,GAAU,OAAO,CAAC,OAAC,CAAC,CA4BtB;IAED;;;;;;;;OAQG;IACH,eANW,OAAO,sBAAsB,EAAE,YAAY,UAC3C,OAAC,WACD,OAAO,0BAA0B,EAAE,OAAO,cAC1C,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,OAAO,CAAC,IAAI,CAAC,CAYzB;CACF;yBAjEwB,WAAW"}

package/build/src/testing/factory/strategies/create.js

@@ -0,0 +1,57 @@
+// @ts-check
+import BaseStrategy from "./base.js";
+/**
+ * The `create` strategy. It builds the object graph (associations use the parent
+ * create strategy by default), runs beforeAll/beforeBuild/afterBuild, persists the
+ * root record through its native `save()` (letting Velocious own association
+ * autosave order and validation) or a custom `toCreate`, then runs
+ * beforeCreate/afterCreate and guarantees afterAll cleanup.
+ */
+export default class CreateStrategy extends BaseStrategy {
+    /**
+     * Runs the strategy.
+     * @param {object} args - Options.
+     * @param {import("../factory-registry.js").default} args.registry - Owning registry.
+     * @param {import("../factory-runner.js").CompiledPlan} args.plan - Compiled plan.
+     * @returns {Promise<?>} - The persisted record.
+     */
+    async run({ registry, plan }) {
+        const context = this._newContext(registry, plan, "create");
+        /** @type {{record: ?, transients: Record<string, ?>}} */
+        const runState = { record: undefined, transients: {} };
+        const state = () => ({ record: runState.record, transients: runState.transients, strategy: "create" });
+        return await this._runWithAfterAll(context, plan, state, async () => {
+            runState.transients = await context.resolveTransients();
+            await this._runCallbacks(context, plan, "beforeAll", state());
+            await this._runCallbacks(context, plan, "beforeBuild", state());
+            const { publicAttributes, transients, associations } = await context.resolveForConstruction();
+            const record = await this._constructRecord(plan, publicAttributes, context, transients);
+            this._assignAssociations(record, associations);
+            runState.record = record;
+            await this._runCallbacks(context, plan, "afterBuild", state());
+            await this._runCallbacks(context, plan, "beforeCreate", state());
+            await this._persist(plan, record, context, transients);
+            await this._runCallbacks(context, plan, "afterCreate", state());
+            return record;
+        });
+    }
+    /**
+     * Persists the record via a custom `toCreate`, native `save()`, or not at all
+     * when `skipCreate` is declared.
+     * @param {import("../factory-runner.js").CompiledPlan} plan - Compiled plan.
+     * @param {?} record - The record to persist.
+     * @param {import("../evaluation-context.js").default} context - Evaluation context.
+     * @param {Record<string, ?>} transients - Evaluated transients.
+     * @returns {Promise<void>} - Resolves when persistence completes.
+     */
+    async _persist(plan, record, context, transients) {
+        if (plan.skipCreate)
+            return;
+        if (plan.toCreate) {
+            await plan.toCreate({ record, context: this._callbackContext(context, transients) });
+            return;
+        }
+        await record.save();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/factory/trait-definition.d.ts

@@ -0,0 +1,22 @@
+/**
+ * An immutable compiled trait. A trait carries an ordered list of declarations
+ * (attributes, transients, associations, callbacks, custom construction, and
+ * base-trait inclusions) that are mixed into a factory run.
+ */
+export default class TraitDefinition {
+    /**
+     * Builds a trait definition.
+     * @param {object} args - Options.
+     * @param {string} args.name - Trait name.
+     * @param {import("./declarations.js").Declaration[]} args.declarations - Ordered declarations.
+     */
+    constructor({ name, declarations }: {
+        name: string;
+        declarations: import("./declarations.js").Declaration[];
+    });
+    /** @type {string} - Trait name. */
+    name: string;
+    /** @type {Array<import("./declarations.js").Declaration>} - Ordered declarations. */
+    declarations: Array<import("./declarations.js").Declaration>;
+}
+//# sourceMappingURL=trait-definition.d.ts.map

package/build/src/testing/factory/trait-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trait-definition.d.ts","sourceRoot":"","sources":["../../../../src/testing/factory/trait-definition.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;IACE;;;;;OAKG;IACH,oCAHG;QAAqB,IAAI,EAAjB,MAAM;QAC0C,YAAY,EAA5D,OAAO,mBAAmB,EAAE,WAAW,EAAE;KACnD,EASA;IAPC,mCAAmC;IACnC,MADW,MAAM,CACD;IAEhB,qFAAqF;IACrF,cADW,KAAK,CAAC,OAAO,mBAAmB,EAAE,WAAW,CAAC,CAC2D;CAIvH"}

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

@@ -0,0 +1,22 @@
+// @ts-check
+/**
+ * An immutable compiled trait. A trait carries an ordered list of declarations
+ * (attributes, transients, associations, callbacks, custom construction, and
+ * base-trait inclusions) that are mixed into a factory run.
+ */
+export default class TraitDefinition {
+    /**
+     * Builds a trait definition.
+     * @param {object} args - Options.
+     * @param {string} args.name - Trait name.
+     * @param {import("./declarations.js").Declaration[]} args.declarations - Ordered declarations.
+     */
+    constructor({ name, declarations }) {
+        /** @type {string} - Trait name. */
+        this.name = name;
+        /** @type {Array<import("./declarations.js").Declaration>} - Ordered declarations. */
+        this.declarations = /** @type {Array<import("./declarations.js").Declaration>} */ (Object.freeze([...declarations]));
+        Object.freeze(this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhaXQtZGVmaW5pdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90ZXN0aW5nL2ZhY3RvcnkvdHJhaXQtZGVmaW5pdGlvbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVo7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sZUFBZTtJQUNsQzs7Ozs7T0FLRztJQUNILFlBQVksRUFBQyxJQUFJLEVBQUUsWUFBWSxFQUFDO1FBQzlCLG1DQUFtQztRQUNuQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQTtRQUVoQixxRkFBcUY7UUFDckYsSUFBSSxDQUFDLFlBQVksR0FBRyw2REFBNkQsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUVwSCxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFBO0lBQ3JCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG4vKipcbiAqIEFuIGltbXV0YWJsZSBjb21waWxlZCB0cmFpdC4gQSB0cmFpdCBjYXJyaWVzIGFuIG9yZGVyZWQgbGlzdCBvZiBkZWNsYXJhdGlvbnNcbiAqIChhdHRyaWJ1dGVzLCB0cmFuc2llbnRzLCBhc3NvY2lhdGlvbnMsIGNhbGxiYWNrcywgY3VzdG9tIGNvbnN0cnVjdGlvbiwgYW5kXG4gKiBiYXNlLXRyYWl0IGluY2x1c2lvbnMpIHRoYXQgYXJlIG1peGVkIGludG8gYSBmYWN0b3J5IHJ1bi5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgVHJhaXREZWZpbml0aW9uIHtcbiAgLyoqXG4gICAqIEJ1aWxkcyBhIHRyYWl0IGRlZmluaXRpb24uXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gT3B0aW9ucy5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MubmFtZSAtIFRyYWl0IG5hbWUuXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi9kZWNsYXJhdGlvbnMuanNcIikuRGVjbGFyYXRpb25bXX0gYXJncy5kZWNsYXJhdGlvbnMgLSBPcmRlcmVkIGRlY2xhcmF0aW9ucy5cbiAgICovXG4gIGNvbnN0cnVjdG9yKHtuYW1lLCBkZWNsYXJhdGlvbnN9KSB7XG4gICAgLyoqIEB0eXBlIHtzdHJpbmd9IC0gVHJhaXQgbmFtZS4gKi9cbiAgICB0aGlzLm5hbWUgPSBuYW1lXG5cbiAgICAvKiogQHR5cGUge0FycmF5PGltcG9ydChcIi4vZGVjbGFyYXRpb25zLmpzXCIpLkRlY2xhcmF0aW9uPn0gLSBPcmRlcmVkIGRlY2xhcmF0aW9ucy4gKi9cbiAgICB0aGlzLmRlY2xhcmF0aW9ucyA9IC8qKiBAdHlwZSB7QXJyYXk8aW1wb3J0KFwiLi9kZWNsYXJhdGlvbnMuanNcIikuRGVjbGFyYXRpb24+fSAqLyAoT2JqZWN0LmZyZWV6ZShbLi4uZGVjbGFyYXRpb25zXSkpXG5cbiAgICBPYmplY3QuZnJlZXplKHRoaXMpXG4gIH1cbn1cbiJdfQ==

package/build/testing/factory/association-declaration.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+import {InvalidDefinitionError} from "./errors.js"
+
+/**
+ * A declared association. It records the relationship name, the factory to run
+ * (defaulting to the relationship name), any traits/overrides passed to that
+ * factory, and an optional explicit strategy. When no strategy is given the
+ * association follows the parent strategy at evaluation time.
+ */
+export default class AssociationDeclaration {
+  /**
+   * Builds an association declaration.
+   * @param {object} args - Options.
+   * @param {string} args.name - Relationship name on the owning model.
+   * @param {string} [args.factory] - Factory name to run. Defaults to the relationship name.
+   * @param {string[]} [args.traits] - Traits passed to the association factory.
+   * @param {Record<string, ?>} [args.overrides] - Overrides passed to the association factory.
+   * @param {"build" | "create" | undefined} [args.strategy] - Explicit strategy override.
+   */
+  constructor({name, factory, traits = [], overrides = {}, strategy}) {
+    if (!name || typeof name !== "string") {
+      throw new InvalidDefinitionError(`Association name must be a non-empty string, got: ${String(name)}`)
+    }
+
+    if (strategy !== undefined && strategy !== "build" && strategy !== "create") {
+      throw new InvalidDefinitionError(`Association strategy must be "build" or "create", got: ${String(strategy)}`)
+    }
+
+    /** @type {"association"} - Discriminant. */
+    this.kind = "association"
+
+    /** @type {string} - Relationship name on the owning model. */
+    this.name = name
+
+    /** @type {string} - Factory name to run for the association. */
+    this.factory = factory || name
+
+    /** @type {string[]} - Traits passed to the association factory. */
+    this.traits = traits
+
+    /** @type {Record<string, ?>} - Overrides passed to the association factory. */
+    this.overrides = overrides
+
+    /** @type {"build" | "create" | undefined} - Explicit strategy override. */
+    this.strategy = strategy
+
+    Object.freeze(this)
+  }
+}

package/build/testing/factory/declarations.js

@@ -0,0 +1,110 @@
+// @ts-check
+
+/**
+ * A literal or lazy attribute (or transient) declaration. A function value is the
+ * lazy form and receives the evaluator context; any other value is a literal.
+ * @typedef {object} AttributeDeclaration
+ * @property {"attribute"} kind - Discriminant.
+ * @property {string} name - Attribute name.
+ * @property {boolean} isTransient - Whether the value is transient (never assigned/returned).
+ * @property {?} value - Literal value or lazy `(context) => value` function.
+ */
+
+/**
+ * A lifecycle callback declaration. The same declaration object reached through
+ * multiple trait paths runs once per record (dedup is by object identity).
+ * @typedef {object} CallbackDeclaration
+ * @property {"callback"} kind - Discriminant.
+ * @property {string} event - One of the supported callback events.
+ * @property {(args: {record: ?, context: ?, strategy: string}) => (void | Promise<void>)} fn - Callback body.
+ */
+
+/**
+ * A base-trait inclusion declaration (a trait applied by default within a factory
+ * or composed inside another trait).
+ * @typedef {object} TraitIncludeDeclaration
+ * @property {"traitInclude"} kind - Discriminant.
+ * @property {string} name - Referenced trait name.
+ */
+
+/**
+ * A custom-constructor declaration.
+ * @typedef {object} InitializeWithDeclaration
+ * @property {"initializeWith"} kind - Discriminant.
+ * @property {(args: {attributes: Record<string, ?>, context: ?, get: (name: string) => ?}) => (? | Promise<?>)} fn - Constructor body.
+ */
+
+/**
+ * A custom-persistence declaration.
+ * @typedef {object} ToCreateDeclaration
+ * @property {"toCreate"} kind - Discriminant.
+ * @property {(args: {record: ?, context: ?}) => (void | Promise<void>)} fn - Persistence body.
+ */
+
+/**
+ * A declaration that disables persistence entirely for the create strategy.
+ * @typedef {object} SkipCreateDeclaration
+ * @property {"skipCreate"} kind - Discriminant.
+ */
+
+/**
+ * Union of every declaration kind stored on a factory/trait definition. Includes
+ * association declarations imported from their own module.
+ * @typedef {AttributeDeclaration | CallbackDeclaration | TraitIncludeDeclaration | InitializeWithDeclaration | ToCreateDeclaration | SkipCreateDeclaration | import("./association-declaration.js").default} Declaration
+ */
+
+/**
+ * Creates a literal/lazy attribute declaration.
+ * @param {string} name - Attribute name.
+ * @param {?} value - Literal value or lazy function.
+ * @param {boolean} isTransient - Whether the declaration is transient.
+ * @returns {AttributeDeclaration} - The frozen declaration.
+ */
+export function attributeDeclaration(name, value, isTransient) {
+  return Object.freeze({kind: "attribute", name, isTransient, value})
+}
+
+/**
+ * Creates a lifecycle callback declaration.
+ * @param {string} event - Callback event name.
+ * @param {CallbackDeclaration["fn"]} fn - Callback body.
+ * @returns {CallbackDeclaration} - The frozen declaration.
+ */
+export function callbackDeclaration(event, fn) {
+  return Object.freeze({kind: "callback", event, fn})
+}
+
+/**
+ * Creates a base-trait inclusion declaration.
+ * @param {string} name - Referenced trait name.
+ * @returns {TraitIncludeDeclaration} - The frozen declaration.
+ */
+export function traitIncludeDeclaration(name) {
+  return Object.freeze({kind: "traitInclude", name})
+}
+
+/**
+ * Creates a custom-constructor declaration.
+ * @param {InitializeWithDeclaration["fn"]} fn - Constructor body.
+ * @returns {InitializeWithDeclaration} - The frozen declaration.
+ */
+export function initializeWithDeclaration(fn) {
+  return Object.freeze({kind: "initializeWith", fn})
+}
+
+/**
+ * Creates a custom-persistence declaration.
+ * @param {ToCreateDeclaration["fn"]} fn - Persistence body.
+ * @returns {ToCreateDeclaration} - The frozen declaration.
+ */
+export function toCreateDeclaration(fn) {
+  return Object.freeze({kind: "toCreate", fn})
+}
+
+/**
+ * Creates a skip-create declaration.
+ * @returns {SkipCreateDeclaration} - The frozen declaration.
+ */
+export function skipCreateDeclaration() {
+  return Object.freeze({kind: "skipCreate"})
+}