velocious 1.0.577 → 1.0.579

package/build/src/database/record/relationships/base.d.ts

@@ -1,7 +1,71 @@
+export type RelationshipScopeCallback = (query: import("../../query/model-class-query.js").default<typeof import("../index.js").default>) => (import("../../query/model-class-query.js").default<typeof import("../index.js").default> | void);
+export type RelationshipRecordResolver = (record: import("../index.js").default) => VelociousDatabaseRecordBaseRelationship;
+export type RelationshipBaseArgsType = {
+    /**
+     * - Whether to auto-batch-preload siblings when this relationship is lazy-loaded. Default true.
+     */
+    autoload?: boolean;
+    /**
+     * - Name of the related model class.
+     */
+    className?: string;
+    /**
+     * - Auto-sync parent count column on create/update/destroy.
+     */
+    counterCache?: boolean;
+    /**
+     * - Dependent action when parent is destroyed.
+     */
+    dependent?: string;
+    /**
+     * - Explicit foreign key column name.
+     */
+    foreignKey?: string | undefined;
+    /**
+     * - Inverse relationship name on the related model.
+     */
+    inverseOf?: string;
+    /**
+     * - Related model class.
+     */
+    klass?: typeof import("../index.js").default;
+    /**
+     * - Owning model class.
+     */
+    modelClass: typeof import("../index.js").default;
+    /**
+     * - Primary key column on the owning model.
+     */
+    primaryKey?: string;
+    /**
+     * - Whether the relationship is polymorphic.
+     */
+    polymorphic?: boolean;
+    /**
+     * - Name of the relationship on the model.
+     */
+    relationshipName: string;
+    /**
+     * - Optional scope callback for the relationship.
+     */
+    scope?: RelationshipScopeCallback;
+    /**
+     * - Name of the through association.
+     */
+    through?: string;
+    /**
+     * - Relationship type (e.g. "hasMany").
+     */
+    type: string;
+};
 /**
  * RelationshipScopeCallback type.
  * @typedef {(query: import("../../query/model-class-query.js").default<typeof import("../index.js").default>) => (import("../../query/model-class-query.js").default<typeof import("../index.js").default> | void)} RelationshipScopeCallback
  */
+/**
+ * RelationshipRecordResolver type.
+ * @typedef {(record: import("../index.js").default) => VelociousDatabaseRecordBaseRelationship} RelationshipRecordResolver
+ */
 /**
  * RelationshipBaseArgsType type.
  * @typedef {object} RelationshipBaseArgsType
@@ -21,11 +85,6 @@
  * @property {string} type - Relationship type (e.g. "hasMany").
  */
 export default class VelociousDatabaseRecordBaseRelationship {
-    /**
-     * Runs constructor.
-     * @param {RelationshipBaseArgsType} args - Relationship definition arguments.
-     */
-    constructor({ autoload, className, counterCache, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey, polymorphic, relationshipName, scope, through, type, ...restArgs }: RelationshipBaseArgsType);
     _autoload: boolean;
     className: string | undefined;
     _counterCache: boolean;
@@ -41,6 +100,25 @@ export default class VelociousDatabaseRecordBaseRelationship {
     _scope: RelationshipScopeCallback | undefined;
     through: string | undefined;
     type: string;
+    _recordResolver: RelationshipRecordResolver | undefined;
+    _polymorphicTypeColumn: string | undefined;
+    /**
+     * Runs constructor.
+     * @param {RelationshipBaseArgsType} args - Relationship definition arguments.
+     */
+    constructor({ autoload, className, counterCache, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey, polymorphic, relationshipName, scope, through, type, ...restArgs }: RelationshipBaseArgsType);
+    /**
+     * Installs metadata selection for relationships whose physical definition varies by record operation.
+     * @param {RelationshipRecordResolver} resolver - Record-owned relationship resolver.
+     * @returns {void}
+     */
+    setRecordResolver(resolver: RelationshipRecordResolver): void;
+    /**
+     * Resolves this relationship for a record's captured physical database identity.
+     * @param {import("../index.js").default} record - Record owning the relationship access.
+     * @returns {VelociousDatabaseRecordBaseRelationship} - Physical relationship metadata.
+     */
+    resolveForRecord(record: import("../index.js").default): VelociousDatabaseRecordBaseRelationship;
     /**
      * Runs get autoload.
      * @returns {boolean} Whether this relationship auto-batch-preloads siblings on lazy access.
@@ -108,7 +186,6 @@ export default class VelociousDatabaseRecordBaseRelationship {
      * @returns {string} - The polymorphic type column.
      */
     getPolymorphicTypeColumn(): string;
-    _polymorphicTypeColumn: string | undefined;
     /**
      * Runs get primary key.
      * @returns {string} The name of the foreign key, e.g. "id" etc.
@@ -125,69 +202,4 @@ export default class VelociousDatabaseRecordBaseRelationship {
      */
     getTargetModelClass(): typeof import("../index.js").default | undefined;
 }
-/**
- * RelationshipScopeCallback type.
- */
-export type RelationshipScopeCallback = (query: import("../../query/model-class-query.js").default<typeof import("../index.js").default>) => (import("../../query/model-class-query.js").default<typeof import("../index.js").default> | void);
-/**
- * RelationshipBaseArgsType type.
- */
-export type RelationshipBaseArgsType = {
-    /**
-     * - Whether to auto-batch-preload siblings when this relationship is lazy-loaded. Default true.
-     */
-    autoload?: boolean | undefined;
-    /**
-     * - Name of the related model class.
-     */
-    className?: string | undefined;
-    /**
-     * - Auto-sync parent count column on create/update/destroy.
-     */
-    counterCache?: boolean | undefined;
-    /**
-     * - Dependent action when parent is destroyed.
-     */
-    dependent?: string | undefined;
-    /**
-     * - Explicit foreign key column name.
-     */
-    foreignKey?: string | undefined;
-    /**
-     * - Inverse relationship name on the related model.
-     */
-    inverseOf?: string | undefined;
-    /**
-     * - Related model class.
-     */
-    klass?: typeof import("../index.js").default | undefined;
-    /**
-     * - Owning model class.
-     */
-    modelClass: typeof import("../index.js").default;
-    /**
-     * - Primary key column on the owning model.
-     */
-    primaryKey?: string | undefined;
-    /**
-     * - Whether the relationship is polymorphic.
-     */
-    polymorphic?: boolean | undefined;
-    /**
-     * - Name of the relationship on the model.
-     */
-    relationshipName: string;
-    /**
-     * - Optional scope callback for the relationship.
-     */
-    scope?: RelationshipScopeCallback | undefined;
-    /**
-     * - Name of the through association.
-     */
-    through?: string | undefined;
-    /**
-     * - Relationship type (e.g. "hasMany").
-     */
-    type: string;
-};
 //# sourceMappingURL=base.d.ts.map

package/build/src/database/record/relationships/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/base.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH;;;;;;;;;;;;;;;;;GAiBG;AAEH;IACE;;;OAGG;IACH,sLAFW,wBAAwB,EA2BlC;IAfC,mBAAmC;IACnC,8BAA0B;IAC1B,uBAA0C;IAC1C,+BAA2B;IAC3B,+BAA4B;IAC5B,wCAAqC;IACrC,+BAA2B;IAC3B,wDAAkB;IAClB,iDAA4B;IAC5B,kCAA+B;IAC/B,oBAA6B;IAC7B,yBAAwC;IACxC,8CAAmB;IACnB,4BAAsB;IACtB,aAAgB;IAGlB;;;OAGG;IACH,eAFa,OAAO,CAEmB;IAEvC,gEAAiE;IAEjE;;;OAGG;IACH,mBAFa,OAAO,CAE2B;IAE/C;;;OAGG;IACH,gBAFa,MAAM,GAAG,SAAS,CAEU;IAEzC;;;;;OAKG;IACH,yBAFa,MAAM,GAAG,SAAS,CAE4B;IAE3D;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAFa,MAAM,GAAG,SAAS,CAI9B;IAED;;;OAGG;IACH,iBAFa,cAAc,aAAa,EAAE,OAAO,CAEP;IAE1C;;;OAGG;IACH,uBAFa,MAAM,CAEmC;IAEtD;;;OAGG;IACH,YAFa,yBAAyB,GAAG,SAAS,CAEjB;IAEjC;;;;;OAKG;IACH,WAJa,CAAC,SACH,CAAC,GACC,CAAC,CAUb;IAED;;;OAGG;IACH,kBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,4BAFa,MAAM,CAoBlB;IATK,2CAAiE;IAWvE;;;OAGG;IACH,iBAFa,MAAM,CAEwB;IAE3C;;;OAGG;IACH,WAFa,MAAM,CAEW;IAE9B;;;OAGG;IACH,uBAFa,cAAc,aAAa,EAAE,OAAO,GAAG,SAAS,CAY5D;CACF;;;;wCAhMY,CAAC,KAAK,EAAE,OAAO,kCAAkC,EAAE,OAAO,CAAC,cAAc,aAAa,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,kCAAkC,EAAE,OAAO,CAAC,cAAc,aAAa,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;iBASrM,MAAM,GAAG,SAAS;;;;;;;;;;;;gBAGlB,cAAc,aAAa,EAAE,OAAO;;;;;;;;;;;;sBAGpC,MAAM;;;;;;;;;;;;UAGN,MAAM"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/base.js"],"names":[],"mappings":"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"}

package/build/src/database/record/relationships/base.js

@@ -5,6 +5,10 @@ import * as inflection from "inflection";
  * RelationshipScopeCallback type.
  * @typedef {(query: import("../../query/model-class-query.js").default<typeof import("../index.js").default>) => (import("../../query/model-class-query.js").default<typeof import("../index.js").default> | void)} RelationshipScopeCallback
  */
+/**
+ * RelationshipRecordResolver type.
+ * @typedef {(record: import("../index.js").default) => VelociousDatabaseRecordBaseRelationship} RelationshipRecordResolver
+ */
 /**
  * RelationshipBaseArgsType type.
  * @typedef {object} RelationshipBaseArgsType
@@ -53,6 +57,22 @@ export default class VelociousDatabaseRecordBaseRelationship {
         this.through = through;
         this.type = type;
     }
+    /**
+     * Installs metadata selection for relationships whose physical definition varies by record operation.
+     * @param {RelationshipRecordResolver} resolver - Record-owned relationship resolver.
+     * @returns {void}
+     */
+    setRecordResolver(resolver) {
+        this._recordResolver = resolver;
+    }
+    /**
+     * Resolves this relationship for a record's captured physical database identity.
+     * @param {import("../index.js").default} record - Record owning the relationship access.
+     * @returns {VelociousDatabaseRecordBaseRelationship} - Physical relationship metadata.
+     */
+    resolveForRecord(record) {
+        return this._recordResolver ? this._recordResolver(record) : this;
+    }
     /**
      * Runs get autoload.
      * @returns {boolean} Whether this relationship auto-batch-preloads siblings on lazy access.
@@ -174,4 +194,4 @@ export default class VelociousDatabaseRecordBaseRelationship {
         throw new Error("Couldn't figure out the target model class");
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/database/record/relationships/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../../utils/rest-args-error.js\"\nimport * as inflection from \"inflection\"\n\n/**\n * RelationshipScopeCallback type.\n * @typedef {(query: import(\"../../query/model-class-query.js\").default<typeof import(\"../index.js\").default>) => (import(\"../../query/model-class-query.js\").default<typeof import(\"../index.js\").default> | void)} RelationshipScopeCallback\n */\n/**\n * RelationshipBaseArgsType type.\n * @typedef {object} RelationshipBaseArgsType\n * @property {boolean} [autoload] - Whether to auto-batch-preload siblings when this relationship is lazy-loaded. Default true.\n * @property {string} [className] - Name of the related model class.\n * @property {boolean} [counterCache] - Auto-sync parent count column on create/update/destroy.\n * @property {string} [dependent] - Dependent action when parent is destroyed.\n * @property {string | undefined} [foreignKey] - Explicit foreign key column name.\n * @property {string} [inverseOf] - Inverse relationship name on the related model.\n * @property {typeof import(\"../index.js\").default} [klass] - Related model class.\n * @property {typeof import(\"../index.js\").default} modelClass - Owning model class.\n * @property {string} [primaryKey] - Primary key column on the owning model.\n * @property {boolean} [polymorphic] - Whether the relationship is polymorphic.\n * @property {string} relationshipName - Name of the relationship on the model.\n * @property {RelationshipScopeCallback} [scope] - Optional scope callback for the relationship.\n * @property {string} [through] - Name of the through association.\n * @property {string} type - Relationship type (e.g. \"hasMany\").\n */\n\nexport default class VelociousDatabaseRecordBaseRelationship {\n  /**\n   * Runs constructor.\n   * @param {RelationshipBaseArgsType} args - Relationship definition arguments.\n   */\n  constructor({autoload, className, counterCache, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = \"id\", polymorphic, relationshipName, scope, through, type, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)\n    if (!className && !klass && !polymorphic) throw new Error(`Neither 'className' or 'klass' was given for ${modelClass.name}#${relationshipName}`)\n\n    if (className == \"EventSery\") {\n      throw new Error(`Invalid model name: ${className}`)\n    }\n\n    this._autoload = autoload !== false\n    this.className = className\n    this._counterCache = counterCache || false\n    this._dependent = dependent\n    this.foreignKey = foreignKey\n    this._explicitForeignKey = foreignKey\n    this._inverseOf = inverseOf\n    this.klass = klass\n    this.modelClass = modelClass\n    this._polymorphic = polymorphic\n    this._primaryKey = primaryKey\n    this.relationshipName = relationshipName\n    this._scope = scope\n    this.through = through\n    this.type = type\n  }\n\n  /**\n   * Runs get autoload.\n   * @returns {boolean} Whether this relationship auto-batch-preloads siblings on lazy access.\n   */\n  getAutoload() { return this._autoload }\n\n  getConfiguration() { return this.modelClass._getConfiguration() }\n\n  /**\n   * Runs get counter cache.\n   * @returns {boolean} Whether a counter cache column is synced on the parent.\n   */\n  getCounterCache() { return this._counterCache }\n\n  /**\n   * Runs get dependent.\n   * @returns {string | undefined} What will be done when the parent record is destroyed. E.g. \"destroy\", \"nullify\", \"restrict\" etc.\n   */\n  getDependent() { return this._dependent }\n\n  /**\n   * The foreign key explicitly passed when the relationship was declared, if any. Unlike\n   * `getForeignKey()` this never falls back to a computed default, so callers can tell whether the\n   * developer named a specific column (e.g. to disambiguate multiple belongs-to on a through target).\n   * @returns {string | undefined} - The explicitly declared foreign key, or undefined.\n   */\n  getExplicitForeignKey() { return this._explicitForeignKey }\n\n  /**\n   * Runs get foreign key.\n   * @abstract\n   * @returns {string} The name of the foreign key, e.g. \"user_id\", \"post_id\" etc.\n   */\n  getForeignKey() {\n    throw new Error(\"getForeignKey not implemented\")\n  }\n\n  /**\n   * Runs get inverse of.\n   * @abstract\n   * @returns {string | undefined} The name of the inverse relationship, e.g. \"posts\", \"comments\" etc.\n   */\n  getInverseOf() {\n    throw new Error(\"getInverseOf not implemented\")\n  }\n\n  /**\n   * Runs get model class.\n   * @returns {typeof import(\"../index.js\").default} - The model class.\n   */\n  getModelClass() { return this.modelClass }\n\n  /**\n   * Runs get relationship name.\n   * @returns {string} The name of the relationship, e.g. \"posts\", \"user\", \"comments\" etc.\n   */\n  getRelationshipName() { return this.relationshipName }\n\n  /**\n   * Runs get scope.\n   * @returns {RelationshipScopeCallback | undefined} - The scope callback.\n   */\n  getScope() { return this._scope }\n\n  /**\n   * Runs apply scope.\n   * @template T\n   * @param {T} query - Query instance.\n   * @returns {T} - Scoped query.\n   */\n  applyScope(query) {\n    const scope = this.getScope()\n\n    if (!scope) return query\n\n    const scopedQuery = /** @type {T | void} */ (scope.call(query, /** @type {import(\"../../query/model-class-query.js\").default<typeof import(\"../index.js\").default>} */ (query)))\n\n    return scopedQuery || query\n  }\n\n  /**\n   * Runs get polymorphic.\n   * @returns {boolean} - Whether polymorphic.\n   */\n  getPolymorphic() {\n    return this._polymorphic || false\n  }\n\n  /**\n   * Runs get polymorphic type column.\n   * @returns {string} - The polymorphic type column.\n   */\n  getPolymorphicTypeColumn() {\n    if (!this.getPolymorphic()) {\n      throw new Error(`${this.modelClass.name}#${this.relationshipName} isn't polymorphic`)\n    }\n\n    if (!this._polymorphicTypeColumn) {\n      const foreignKey = this.getForeignKey()\n\n      if (foreignKey && foreignKey.endsWith(\"_id\")) {\n        this._polymorphicTypeColumn = foreignKey.replace(/_id$/, \"_type\")\n      } else {\n        const underscoredName = inflection.underscore(this.getRelationshipName())\n\n        this._polymorphicTypeColumn = `${underscoredName}_type`\n      }\n    }\n\n    return this._polymorphicTypeColumn\n  }\n\n  /**\n   * Runs get primary key.\n   * @returns {string} The name of the foreign key, e.g. \"id\" etc.\n   */\n  getPrimaryKey() { return this._primaryKey }\n\n  /**\n   * Runs get type.\n   * @returns {string} The type of the relationship, e.g. \"has_many\", \"belongs_to\", \"has_one\", \"has_and_belongs_to_many\" etc.\n   */\n  getType() { return this.type }\n\n  /**\n   * Runs get target model class.\n   * @returns {typeof import(\"../index.js\").default | undefined} The target model class for this relationship, e.g. if the relationship is \"posts\" then the target model class is the Post class.\n   */\n  getTargetModelClass() {\n    if (this.getPolymorphic() && this.type == \"belongsTo\") {\n      return undefined\n    } else if (this.className) {\n      return this.getConfiguration().getModelClass(this.className)\n    } else if (this.klass) {\n      return this.klass\n    }\n\n    throw new Error(\"Couldn't figure out the target model class\")\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../src/database/record/relationships/base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../../utils/rest-args-error.js\"\nimport * as inflection from \"inflection\"\n\n/**\n * RelationshipScopeCallback type.\n * @typedef {(query: import(\"../../query/model-class-query.js\").default<typeof import(\"../index.js\").default>) => (import(\"../../query/model-class-query.js\").default<typeof import(\"../index.js\").default> | void)} RelationshipScopeCallback\n */\n/**\n * RelationshipRecordResolver type.\n * @typedef {(record: import(\"../index.js\").default) => VelociousDatabaseRecordBaseRelationship} RelationshipRecordResolver\n */\n/**\n * RelationshipBaseArgsType type.\n * @typedef {object} RelationshipBaseArgsType\n * @property {boolean} [autoload] - Whether to auto-batch-preload siblings when this relationship is lazy-loaded. Default true.\n * @property {string} [className] - Name of the related model class.\n * @property {boolean} [counterCache] - Auto-sync parent count column on create/update/destroy.\n * @property {string} [dependent] - Dependent action when parent is destroyed.\n * @property {string | undefined} [foreignKey] - Explicit foreign key column name.\n * @property {string} [inverseOf] - Inverse relationship name on the related model.\n * @property {typeof import(\"../index.js\").default} [klass] - Related model class.\n * @property {typeof import(\"../index.js\").default} modelClass - Owning model class.\n * @property {string} [primaryKey] - Primary key column on the owning model.\n * @property {boolean} [polymorphic] - Whether the relationship is polymorphic.\n * @property {string} relationshipName - Name of the relationship on the model.\n * @property {RelationshipScopeCallback} [scope] - Optional scope callback for the relationship.\n * @property {string} [through] - Name of the through association.\n * @property {string} type - Relationship type (e.g. \"hasMany\").\n */\n\nexport default class VelociousDatabaseRecordBaseRelationship {\n  /**\n   * Runs constructor.\n   * @param {RelationshipBaseArgsType} args - Relationship definition arguments.\n   */\n  constructor({autoload, className, counterCache, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = \"id\", polymorphic, relationshipName, scope, through, type, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)\n    if (!className && !klass && !polymorphic) throw new Error(`Neither 'className' or 'klass' was given for ${modelClass.name}#${relationshipName}`)\n\n    if (className == \"EventSery\") {\n      throw new Error(`Invalid model name: ${className}`)\n    }\n\n    this._autoload = autoload !== false\n    this.className = className\n    this._counterCache = counterCache || false\n    this._dependent = dependent\n    this.foreignKey = foreignKey\n    this._explicitForeignKey = foreignKey\n    this._inverseOf = inverseOf\n    this.klass = klass\n    this.modelClass = modelClass\n    this._polymorphic = polymorphic\n    this._primaryKey = primaryKey\n    this.relationshipName = relationshipName\n    this._scope = scope\n    this.through = through\n    this.type = type\n  }\n\n  /**\n   * Installs metadata selection for relationships whose physical definition varies by record operation.\n   * @param {RelationshipRecordResolver} resolver - Record-owned relationship resolver.\n   * @returns {void}\n   */\n  setRecordResolver(resolver) {\n    this._recordResolver = resolver\n  }\n\n  /**\n   * Resolves this relationship for a record's captured physical database identity.\n   * @param {import(\"../index.js\").default} record - Record owning the relationship access.\n   * @returns {VelociousDatabaseRecordBaseRelationship} - Physical relationship metadata.\n   */\n  resolveForRecord(record) {\n    return this._recordResolver ? this._recordResolver(record) : this\n  }\n\n  /**\n   * Runs get autoload.\n   * @returns {boolean} Whether this relationship auto-batch-preloads siblings on lazy access.\n   */\n  getAutoload() { return this._autoload }\n\n  getConfiguration() { return this.modelClass._getConfiguration() }\n\n  /**\n   * Runs get counter cache.\n   * @returns {boolean} Whether a counter cache column is synced on the parent.\n   */\n  getCounterCache() { return this._counterCache }\n\n  /**\n   * Runs get dependent.\n   * @returns {string | undefined} What will be done when the parent record is destroyed. E.g. \"destroy\", \"nullify\", \"restrict\" etc.\n   */\n  getDependent() { return this._dependent }\n\n  /**\n   * The foreign key explicitly passed when the relationship was declared, if any. Unlike\n   * `getForeignKey()` this never falls back to a computed default, so callers can tell whether the\n   * developer named a specific column (e.g. to disambiguate multiple belongs-to on a through target).\n   * @returns {string | undefined} - The explicitly declared foreign key, or undefined.\n   */\n  getExplicitForeignKey() { return this._explicitForeignKey }\n\n  /**\n   * Runs get foreign key.\n   * @abstract\n   * @returns {string} The name of the foreign key, e.g. \"user_id\", \"post_id\" etc.\n   */\n  getForeignKey() {\n    throw new Error(\"getForeignKey not implemented\")\n  }\n\n  /**\n   * Runs get inverse of.\n   * @abstract\n   * @returns {string | undefined} The name of the inverse relationship, e.g. \"posts\", \"comments\" etc.\n   */\n  getInverseOf() {\n    throw new Error(\"getInverseOf not implemented\")\n  }\n\n  /**\n   * Runs get model class.\n   * @returns {typeof import(\"../index.js\").default} - The model class.\n   */\n  getModelClass() { return this.modelClass }\n\n  /**\n   * Runs get relationship name.\n   * @returns {string} The name of the relationship, e.g. \"posts\", \"user\", \"comments\" etc.\n   */\n  getRelationshipName() { return this.relationshipName }\n\n  /**\n   * Runs get scope.\n   * @returns {RelationshipScopeCallback | undefined} - The scope callback.\n   */\n  getScope() { return this._scope }\n\n  /**\n   * Runs apply scope.\n   * @template T\n   * @param {T} query - Query instance.\n   * @returns {T} - Scoped query.\n   */\n  applyScope(query) {\n    const scope = this.getScope()\n\n    if (!scope) return query\n\n    const scopedQuery = /** @type {T | void} */ (scope.call(query, /** @type {import(\"../../query/model-class-query.js\").default<typeof import(\"../index.js\").default>} */ (query)))\n\n    return scopedQuery || query\n  }\n\n  /**\n   * Runs get polymorphic.\n   * @returns {boolean} - Whether polymorphic.\n   */\n  getPolymorphic() {\n    return this._polymorphic || false\n  }\n\n  /**\n   * Runs get polymorphic type column.\n   * @returns {string} - The polymorphic type column.\n   */\n  getPolymorphicTypeColumn() {\n    if (!this.getPolymorphic()) {\n      throw new Error(`${this.modelClass.name}#${this.relationshipName} isn't polymorphic`)\n    }\n\n    if (!this._polymorphicTypeColumn) {\n      const foreignKey = this.getForeignKey()\n\n      if (foreignKey && foreignKey.endsWith(\"_id\")) {\n        this._polymorphicTypeColumn = foreignKey.replace(/_id$/, \"_type\")\n      } else {\n        const underscoredName = inflection.underscore(this.getRelationshipName())\n\n        this._polymorphicTypeColumn = `${underscoredName}_type`\n      }\n    }\n\n    return this._polymorphicTypeColumn\n  }\n\n  /**\n   * Runs get primary key.\n   * @returns {string} The name of the foreign key, e.g. \"id\" etc.\n   */\n  getPrimaryKey() { return this._primaryKey }\n\n  /**\n   * Runs get type.\n   * @returns {string} The type of the relationship, e.g. \"has_many\", \"belongs_to\", \"has_one\", \"has_and_belongs_to_many\" etc.\n   */\n  getType() { return this.type }\n\n  /**\n   * Runs get target model class.\n   * @returns {typeof import(\"../index.js\").default | undefined} The target model class for this relationship, e.g. if the relationship is \"posts\" then the target model class is the Post class.\n   */\n  getTargetModelClass() {\n    if (this.getPolymorphic() && this.type == \"belongsTo\") {\n      return undefined\n    } else if (this.className) {\n      return this.getConfiguration().getModelClass(this.className)\n    } else if (this.klass) {\n      return this.klass\n    }\n\n    throw new Error(\"Couldn't figure out the target model class\")\n  }\n}\n"]}

package/build/src/database/record/relationships/belongs-to.d.ts

@@ -1,5 +1,15 @@
+import BaseRelationship from "./base.js";
 export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRelationship {
     _autoGenerateInverseOfAttempted: boolean | undefined;
+    /**
+     * Runs get foreign key.
+     * @returns {string} - The foreign key.
+     */
+    getForeignKey(): string;
+    /**
+     * Runs get inverse of.
+     * @returns {string | undefined} - The inverse of.
+     */
+    getInverseOf(): string | undefined;
 }
-import BaseRelationship from "./base.js";
 //# sourceMappingURL=belongs-to.d.ts.map

package/build/src/database/record/relationships/belongs-to.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"belongs-to.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/belongs-to.js"],"names":[],"mappings":"AAKA;IA2BM,qDAA2C;CAwBhD;6BAtD4B,WAAW"}
+{"version":3,"file":"belongs-to.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/belongs-to.js"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,WAAW,CAAA;AAGxC,MAAM,CAAC,OAAO,OAAO,4CAA6C,SAAQ,gBAAgB;IA2B/E,+BAA+B;IA1BxC;;;OAGG;IACH,aAAa,IAFA,MAAM,CAgBlB;IAED;;;OAGG;IACH,YAAY,IAFC,MAAM,GAAG,SAAS,CA2B9B;CACF"}

package/build/src/database/record/relationships/has-many.d.ts

@@ -1,5 +1,15 @@
+import BaseRelationship from "./base.js";
 export default class VelociousDatabaseRecordHasManyRelationship extends BaseRelationship {
     _autoGenerateInverseOfAttempted: boolean | undefined;
+    /**
+     * Runs get foreign key.
+     * @returns {string} - The foreign key.
+     */
+    getForeignKey(): string;
+    /**
+     * Runs get inverse of.
+     * @returns {string | undefined} - The inverse of.
+     */
+    getInverseOf(): string | undefined;
 }
-import BaseRelationship from "./base.js";
 //# sourceMappingURL=has-many.d.ts.map

package/build/src/database/record/relationships/has-many.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/has-many.js"],"names":[],"mappings":"AAKA;IAqBM,qDAA2C;CAqBhD;6BA7C4B,WAAW"}
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/has-many.js"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,WAAW,CAAA;AAGxC,MAAM,CAAC,OAAO,OAAO,0CAA2C,SAAQ,gBAAgB;IAqB7E,+BAA+B;IApBxC;;;OAGG;IACH,aAAa,IAFA,MAAM,CAUlB;IAED;;;OAGG;IACH,YAAY,IAFC,MAAM,GAAG,SAAS,CAwB9B;CACF"}

package/build/src/database/record/relationships/has-one.d.ts

@@ -1,5 +1,15 @@
+import BaseRelationship from "./base.js";
 export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelationship {
     _autoGenerateInverseOfAttempted: boolean | undefined;
+    /**
+     * Runs get foreign key.
+     * @returns {string} - The foreign key.
+     */
+    getForeignKey(): string;
+    /**
+     * Runs get inverse of.
+     * @returns {string | undefined} - The inverse of.
+     */
+    getInverseOf(): string | undefined;
 }
-import BaseRelationship from "./base.js";
 //# sourceMappingURL=has-one.d.ts.map

package/build/src/database/record/relationships/has-one.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"has-one.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/has-one.js"],"names":[],"mappings":"AAKA;IAqBM,qDAA2C;CAqBhD;6BA7C4B,WAAW"}
+{"version":3,"file":"has-one.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/relationships/has-one.js"],"names":[],"mappings":"AAEA,OAAO,gBAAgB,MAAM,WAAW,CAAA;AAGxC,MAAM,CAAC,OAAO,OAAO,yCAA0C,SAAQ,gBAAgB;IAqB5E,+BAA+B;IApBxC;;;OAGG;IACH,aAAa,IAFA,MAAM,CAUlB;IAED;;;OAGG;IACH,YAAY,IAFC,MAAM,GAAG,SAAS,CAwB9B;CACF"}

package/build/src/database/record/state-machine.d.ts

@@ -1,3 +1,22 @@
+export type StateMachineDefinition = {
+    column?: string;
+    initial: string;
+    states: Record<string, StateDefinition>;
+    events: Record<string, EventDefinition>;
+};
+export type StateDefinition = {
+    beforeEnter?: (model: import("./index.js").default) => void | Promise<void>;
+    afterEnter?: (model: import("./index.js").default) => void | Promise<void>;
+    beforeExit?: (model: import("./index.js").default) => void | Promise<void>;
+    afterExit?: (model: import("./index.js").default) => void | Promise<void>;
+};
+export type EventDefinition = {
+    from: string | string[];
+    to: string;
+    guard?: (model: import("./index.js").default) => boolean | Promise<boolean>;
+    before?: (model: import("./index.js").default) => void | Promise<void>;
+    after?: (model: import("./index.js").default) => void | Promise<void>;
+};
 /**
  * Registers a state machine on a Velocious model class.
  *
@@ -30,33 +49,5 @@
  * @param {StateMachineDefinition} definition - The state machine definition.
  * @returns {void}
  */
-export function stateMachine(ModelClass: typeof import("./index.js").default, definition: StateMachineDefinition): void;
-/**
- * Defines this typedef.
- */
-export type StateMachineDefinition = {
-    column?: string;
-    initial: string;
-    states: Record<string, StateDefinition>;
-    events: Record<string, EventDefinition>;
-};
-/**
- * Defines this typedef.
- */
-export type StateDefinition = {
-    beforeEnter?: (model: import("./index.js").default) => void | Promise<void>;
-    afterEnter?: (model: import("./index.js").default) => void | Promise<void>;
-    beforeExit?: (model: import("./index.js").default) => void | Promise<void>;
-    afterExit?: (model: import("./index.js").default) => void | Promise<void>;
-};
-/**
- * Defines this typedef.
- */
-export type EventDefinition = {
-    from: string | string[];
-    to: string;
-    guard?: (model: import("./index.js").default) => boolean | Promise<boolean>;
-    before?: (model: import("./index.js").default) => void | Promise<void>;
-    after?: (model: import("./index.js").default) => void | Promise<void>;
-};
+export declare function stateMachine(ModelClass: typeof import("./index.js").default, definition: StateMachineDefinition): void;
 //# sourceMappingURL=state-machine.d.ts.map

package/build/src/database/record/state-machine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../../../../src/database/record/state-machine.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAJW,cAAc,YAAY,EAAE,OAAO,cACnC,sBAAsB,GACpB,IAAI,CAsOhB;;;;qCA9RY;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;CACxC;;;;8BACS;IACR,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1E;;;;8BACS;IACR,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5E,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE"}
+{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../../../../src/database/record/state-machine.js"],"names":[],"mappings":"AAIG,YAKG,sBAAsB,GALf;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;CACxC,CAAwB;AACzB,YAKG,eAAe,GALR;IACR,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3E,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1E,CAAiB;AAClB,YAMG,eAAe,GANR;IACR,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5E,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE,CAAiB;AAQrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAJ5B,cAAc,YAAY,EAAE,OAIA,EAAE,UAAU,EAHxC,sBAGwC,GAFtC,IAAI,CAsOhB"}

package/build/src/database/record/state-machine.js

@@ -63,7 +63,7 @@ export function stateMachine(ModelClass, definition) {
     // Store definition on the model class for introspection
     /**
      * Dynamic class.
-     * @type {?} */
+     * @type {ReturnType<typeof JSON.parse>} */
     const dynamicClass = ModelClass;
     // Idempotent: re-declaring on the same class (or a re-evaluated module) must not
     // register the before/after-save transition hooks twice. Guard on an own property
@@ -98,7 +98,7 @@ export function stateMachine(ModelClass, definition) {
     // Register event methods and guard methods on the prototype
     /**
      * Proto.
-     * @type {?} */
+     * @type {ReturnType<typeof JSON.parse>} */
     const proto = ModelClass.prototype;
     for (const [eventName, eventDef] of Object.entries(definition.events)) {
         const fromStates = Array.isArray(eventDef.from) ? eventDef.from : [eventDef.from];
@@ -135,7 +135,7 @@ export function stateMachine(ModelClass, definition) {
         proto[eventName] = function () {
             /**
              * Self.
-             * @type {?} */
+             * @type {ReturnType<typeof JSON.parse>} */
             const self = this;
             const currentState = self.readAttribute(column);
             if (!fromStates.includes(currentState)) {
@@ -160,7 +160,7 @@ export function stateMachine(ModelClass, definition) {
         proto[`${eventName}AndSave`] = async function () {
             /**
              * Self.
-             * @type {?} */
+             * @type {ReturnType<typeof JSON.parse>} */
             const self = this;
             const currentState = self.readAttribute(column);
             if (!fromStates.includes(currentState)) {
@@ -183,7 +183,7 @@ export function stateMachine(ModelClass, definition) {
     ModelClass.beforeSave(async function (model) {
         /**
          * Dynamic model.
-         * @type {?} */
+         * @type {ReturnType<typeof JSON.parse>} */
         const dynamicModel = model;
         const pending = dynamicModel[PENDING_TRANSITION_KEY];
         if (!pending) {
@@ -208,7 +208,7 @@ export function stateMachine(ModelClass, definition) {
     ModelClass.afterSave(async function (model) {
         /**
          * Dynamic model.
-         * @type {?} */
+         * @type {ReturnType<typeof JSON.parse>} */
         const dynamicModel = model;
         const pending = dynamicModel[PENDING_TRANSITION_KEY];
         if (!pending) {
@@ -240,4 +240,4 @@ export function stateMachine(ModelClass, definition) {
 function columnSetterName(column) {
     return `set${column.charAt(0).toUpperCase()}${column.slice(1)}`;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-machine.js","sourceRoot":"","sources":["../../../../src/database/record/state-machine.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Defines this typedef.\n * @typedef {{\n *   column?: string,\n *   initial: string,\n *   states: Record<string, StateDefinition>,\n *   events: Record<string, EventDefinition>\n * }} StateMachineDefinition\n * @typedef {{\n *   beforeEnter?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   afterEnter?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   beforeExit?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   afterExit?: (model: import(\"./index.js\").default) => void | Promise<void>\n * }} StateDefinition\n * @typedef {{\n *   from: string | string[],\n *   to: string,\n *   guard?: (model: import(\"./index.js\").default) => boolean | Promise<boolean>,\n *   before?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   after?: (model: import(\"./index.js\").default) => void | Promise<void>\n * }} EventDefinition\n */\n\n/**\n * Pending transition key.\n * @type {string} */\nconst PENDING_TRANSITION_KEY = \"_stateMachinePendingTransition\"\n\n/**\n * Registers a state machine on a Velocious model class.\n *\n * Usage:\n * ```js\n * import {stateMachine} from \"velocious/build/src/database/record/state-machine.js\"\n *\n * class Build extends BuildBase {}\n *\n * stateMachine(Build, {\n *   column: \"status\",\n *   initial: \"new\",\n *   states: {\n *     new: {},\n *     queued: {beforeEnter: (build) => { build.setQueuedAt(new Date()) }},\n *     running: {beforeEnter: (build) => { build.setStartedAt(new Date()) }},\n *     failed: {beforeEnter: (build) => { build.setEndedAt(new Date()) }},\n *     succeeded: {beforeEnter: (build) => { build.setEndedAt(new Date()) }}\n *   },\n *   events: {\n *     queue: {from: \"new\", to: \"queued\"},\n *     run: {from: [\"new\", \"queued\", \"crashed\"], to: \"running\"},\n *     fail: {from: [\"new\", \"queued\", \"running\"], to: \"failed\"},\n *     succeed: {from: \"running\", to: \"succeeded\"},\n *     cancel: {from: [\"new\", \"queued\", \"running\"], to: \"cancelled\", guard: (build) => !build.isNewRecord()}\n *   }\n * })\n * ```\n * @param {typeof import(\"./index.js\").default} ModelClass - The model class to add state machine behavior to.\n * @param {StateMachineDefinition} definition - The state machine definition.\n * @returns {void}\n */\nexport function stateMachine(ModelClass, definition) {\n  const column = definition.column || \"state\"\n  const stateNames = Object.keys(definition.states)\n\n  // Store definition on the model class for introspection\n  /**\n   * Dynamic class.\n   * @type {?} */\n  const dynamicClass = ModelClass\n\n  // Idempotent: re-declaring on the same class (or a re-evaluated module) must not\n  // register the before/after-save transition hooks twice. Guard on an own property\n  // so a subclass declaring its own machine is unaffected by the parent's flag.\n  if (Object.prototype.hasOwnProperty.call(dynamicClass, \"_stateMachineRegistered\") && dynamicClass._stateMachineRegistered) {\n    return\n  }\n\n  dynamicClass._stateMachineRegistered = true\n  dynamicClass._stateMachineDefinition = definition\n  dynamicClass._stateMachineColumn = column\n\n  /**\n   * Returns the registered state machine definition.\n   * @returns {StateMachineDefinition} - The registered state machine definition.\n   */\n  dynamicClass.getStateMachineDefinition = function () {\n    return dynamicClass._stateMachineDefinition\n  }\n\n  /**\n   * Returns the state column name.\n   * @returns {string} - The column name used for state storage.\n   */\n  dynamicClass.getStateMachineColumn = function () {\n    return dynamicClass._stateMachineColumn\n  }\n\n  /**\n   * Returns all declared state names.\n   * @returns {string[]} - All declared state names.\n   */\n  dynamicClass.getStateMachineStateNames = function () {\n    return stateNames\n  }\n\n  // Register event methods and guard methods on the prototype\n  /**\n   * Proto.\n   * @type {?} */\n  const proto = ModelClass.prototype\n\n  for (const [eventName, eventDef] of Object.entries(definition.events)) {\n    const fromStates = Array.isArray(eventDef.from) ? eventDef.from : [eventDef.from]\n    const capitalizedEvent = eventName.charAt(0).toUpperCase() + eventName.slice(1)\n    const canMethodName = `can${capitalizedEvent}`\n    const setterName = columnSetterName(column)\n\n    // Guard method: canQueue(), canRun(), etc.\n    proto[canMethodName] = function () {\n      const currentState = this.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        return false\n      }\n\n      if (eventDef.guard) {\n        const guardResult = eventDef.guard(this)\n\n        if (guardResult instanceof Promise) {\n          throw new Error(`Guard for event \"${eventName}\" returned a Promise. Use await model.can${capitalizedEvent}Async() instead.`)\n        }\n\n        return guardResult\n      }\n\n      return true\n    }\n\n    // Async guard method: canQueueAsync(), canRunAsync(), etc.\n    proto[`${canMethodName}Async`] = async function () {\n      const currentState = this.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        return false\n      }\n\n      if (eventDef.guard) {\n        return await eventDef.guard(this)\n      }\n\n      return true\n    }\n\n    // Transition method: queue(), run(), etc. — checks guard, sets the state, stashes event name\n    proto[eventName] = function () {\n      /**\n       * Self.\n       * @type {?} */\n      const self = this\n      const currentState = self.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        throw new Error(\n          `Cannot transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}. ` +\n          `Allowed source states: ${fromStates.join(\", \")}`\n        )\n      }\n\n      // Enforce synchronous guard before mutating state\n      if (eventDef.guard) {\n        const guardResult = eventDef.guard(self)\n\n        if (guardResult instanceof Promise) {\n          throw new Error(`Guard for event \"${eventName}\" returned a Promise. Use await model.${eventName}AndSave() for async guards.`)\n        }\n\n        if (!guardResult) {\n          throw new Error(\n            `Guard rejected transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}.`\n          )\n        }\n      }\n\n      // Stash the transition so beforeSave/afterSave know which event was invoked\n      self[PENDING_TRANSITION_KEY] = {eventName, from: currentState, to: eventDef.to}\n      self[setterName](eventDef.to)\n    }\n\n    // Bang method: queueAndSave(), runAndSave(), etc. — transitions AND saves (supports async guards)\n    proto[`${eventName}AndSave`] = async function () {\n      /**\n       * Self.\n       * @type {?} */\n      const self = this\n      const currentState = self.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        throw new Error(\n          `Cannot transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}. ` +\n          `Allowed source states: ${fromStates.join(\", \")}`\n        )\n      }\n\n      // Enforce async guard before mutating state\n      if (eventDef.guard) {\n        const allowed = await eventDef.guard(self)\n\n        if (!allowed) {\n          throw new Error(\n            `Guard rejected transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}.`\n          )\n        }\n      }\n\n      self[PENDING_TRANSITION_KEY] = {eventName, from: currentState, to: eventDef.to}\n      self[setterName](eventDef.to)\n      await self.save()\n    }\n  }\n\n  // Register a beforeSave callback that fires state-enter hooks\n  ModelClass.beforeSave(async function (model) {\n    /**\n     * Dynamic model.\n     * @type {?} */\n    const dynamicModel = model\n    const pending = dynamicModel[PENDING_TRANSITION_KEY]\n\n    if (!pending) {\n      return\n    }\n\n    const eventDef = definition.events[pending.eventName]\n\n    // Run event-level before callback\n    if (eventDef?.before) {\n      await eventDef.before(model)\n    }\n\n    // Run the exited state's beforeExit, then the entered state's beforeEnter\n    const fromStateDefinition = definition.states[pending.from]\n\n    if (fromStateDefinition?.beforeExit) {\n      await fromStateDefinition.beforeExit(model)\n    }\n\n    const stateDefinition = definition.states[pending.to]\n\n    if (stateDefinition?.beforeEnter) {\n      await stateDefinition.beforeEnter(model)\n    }\n  })\n\n  // Register an afterSave callback for afterEnter hooks\n  ModelClass.afterSave(async function (model) {\n    /**\n     * Dynamic model.\n     * @type {?} */\n    const dynamicModel = model\n    const pending = dynamicModel[PENDING_TRANSITION_KEY]\n\n    if (!pending) {\n      return\n    }\n\n    // Clear the pending transition now that save is complete\n    dynamicModel[PENDING_TRANSITION_KEY] = null\n\n    // Run the entered state's afterEnter, then the exited state's afterExit\n    const stateDefinition = definition.states[pending.to]\n\n    if (stateDefinition?.afterEnter) {\n      await stateDefinition.afterEnter(model)\n    }\n\n    const fromStateDefinition = definition.states[pending.from]\n\n    if (fromStateDefinition?.afterExit) {\n      await fromStateDefinition.afterExit(model)\n    }\n\n    // Run event-level after callback\n    const eventDef = definition.events[pending.eventName]\n\n    if (eventDef?.after) {\n      await eventDef.after(model)\n    }\n  })\n}\n\n/**\n * Returns the setter method name for a column (e.g., \"status\" → \"setStatus\", \"state\" → \"setState\").\n * @param {string} column - The column name.\n * @returns {string} - The setter method name.\n */\nfunction columnSetterName(column) {\n  return `set${column.charAt(0).toUpperCase()}${column.slice(1)}`\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-machine.js","sourceRoot":"","sources":["../../../../src/database/record/state-machine.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Defines this typedef.\n * @typedef {{\n *   column?: string,\n *   initial: string,\n *   states: Record<string, StateDefinition>,\n *   events: Record<string, EventDefinition>\n * }} StateMachineDefinition\n * @typedef {{\n *   beforeEnter?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   afterEnter?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   beforeExit?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   afterExit?: (model: import(\"./index.js\").default) => void | Promise<void>\n * }} StateDefinition\n * @typedef {{\n *   from: string | string[],\n *   to: string,\n *   guard?: (model: import(\"./index.js\").default) => boolean | Promise<boolean>,\n *   before?: (model: import(\"./index.js\").default) => void | Promise<void>,\n *   after?: (model: import(\"./index.js\").default) => void | Promise<void>\n * }} EventDefinition\n */\n\n/**\n * Pending transition key.\n * @type {string} */\nconst PENDING_TRANSITION_KEY = \"_stateMachinePendingTransition\"\n\n/**\n * Registers a state machine on a Velocious model class.\n *\n * Usage:\n * ```js\n * import {stateMachine} from \"velocious/build/src/database/record/state-machine.js\"\n *\n * class Build extends BuildBase {}\n *\n * stateMachine(Build, {\n *   column: \"status\",\n *   initial: \"new\",\n *   states: {\n *     new: {},\n *     queued: {beforeEnter: (build) => { build.setQueuedAt(new Date()) }},\n *     running: {beforeEnter: (build) => { build.setStartedAt(new Date()) }},\n *     failed: {beforeEnter: (build) => { build.setEndedAt(new Date()) }},\n *     succeeded: {beforeEnter: (build) => { build.setEndedAt(new Date()) }}\n *   },\n *   events: {\n *     queue: {from: \"new\", to: \"queued\"},\n *     run: {from: [\"new\", \"queued\", \"crashed\"], to: \"running\"},\n *     fail: {from: [\"new\", \"queued\", \"running\"], to: \"failed\"},\n *     succeed: {from: \"running\", to: \"succeeded\"},\n *     cancel: {from: [\"new\", \"queued\", \"running\"], to: \"cancelled\", guard: (build) => !build.isNewRecord()}\n *   }\n * })\n * ```\n * @param {typeof import(\"./index.js\").default} ModelClass - The model class to add state machine behavior to.\n * @param {StateMachineDefinition} definition - The state machine definition.\n * @returns {void}\n */\nexport function stateMachine(ModelClass, definition) {\n  const column = definition.column || \"state\"\n  const stateNames = Object.keys(definition.states)\n\n  // Store definition on the model class for introspection\n  /**\n   * Dynamic class.\n   * @type {ReturnType<typeof JSON.parse>} */\n  const dynamicClass = ModelClass\n\n  // Idempotent: re-declaring on the same class (or a re-evaluated module) must not\n  // register the before/after-save transition hooks twice. Guard on an own property\n  // so a subclass declaring its own machine is unaffected by the parent's flag.\n  if (Object.prototype.hasOwnProperty.call(dynamicClass, \"_stateMachineRegistered\") && dynamicClass._stateMachineRegistered) {\n    return\n  }\n\n  dynamicClass._stateMachineRegistered = true\n  dynamicClass._stateMachineDefinition = definition\n  dynamicClass._stateMachineColumn = column\n\n  /**\n   * Returns the registered state machine definition.\n   * @returns {StateMachineDefinition} - The registered state machine definition.\n   */\n  dynamicClass.getStateMachineDefinition = function () {\n    return dynamicClass._stateMachineDefinition\n  }\n\n  /**\n   * Returns the state column name.\n   * @returns {string} - The column name used for state storage.\n   */\n  dynamicClass.getStateMachineColumn = function () {\n    return dynamicClass._stateMachineColumn\n  }\n\n  /**\n   * Returns all declared state names.\n   * @returns {string[]} - All declared state names.\n   */\n  dynamicClass.getStateMachineStateNames = function () {\n    return stateNames\n  }\n\n  // Register event methods and guard methods on the prototype\n  /**\n   * Proto.\n   * @type {ReturnType<typeof JSON.parse>} */\n  const proto = ModelClass.prototype\n\n  for (const [eventName, eventDef] of Object.entries(definition.events)) {\n    const fromStates = Array.isArray(eventDef.from) ? eventDef.from : [eventDef.from]\n    const capitalizedEvent = eventName.charAt(0).toUpperCase() + eventName.slice(1)\n    const canMethodName = `can${capitalizedEvent}`\n    const setterName = columnSetterName(column)\n\n    // Guard method: canQueue(), canRun(), etc.\n    proto[canMethodName] = function () {\n      const currentState = this.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        return false\n      }\n\n      if (eventDef.guard) {\n        const guardResult = eventDef.guard(this)\n\n        if (guardResult instanceof Promise) {\n          throw new Error(`Guard for event \"${eventName}\" returned a Promise. Use await model.can${capitalizedEvent}Async() instead.`)\n        }\n\n        return guardResult\n      }\n\n      return true\n    }\n\n    // Async guard method: canQueueAsync(), canRunAsync(), etc.\n    proto[`${canMethodName}Async`] = async function () {\n      const currentState = this.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        return false\n      }\n\n      if (eventDef.guard) {\n        return await eventDef.guard(this)\n      }\n\n      return true\n    }\n\n    // Transition method: queue(), run(), etc. — checks guard, sets the state, stashes event name\n    proto[eventName] = function () {\n      /**\n       * Self.\n       * @type {ReturnType<typeof JSON.parse>} */\n      const self = this\n      const currentState = self.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        throw new Error(\n          `Cannot transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}. ` +\n          `Allowed source states: ${fromStates.join(\", \")}`\n        )\n      }\n\n      // Enforce synchronous guard before mutating state\n      if (eventDef.guard) {\n        const guardResult = eventDef.guard(self)\n\n        if (guardResult instanceof Promise) {\n          throw new Error(`Guard for event \"${eventName}\" returned a Promise. Use await model.${eventName}AndSave() for async guards.`)\n        }\n\n        if (!guardResult) {\n          throw new Error(\n            `Guard rejected transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}.`\n          )\n        }\n      }\n\n      // Stash the transition so beforeSave/afterSave know which event was invoked\n      self[PENDING_TRANSITION_KEY] = {eventName, from: currentState, to: eventDef.to}\n      self[setterName](eventDef.to)\n    }\n\n    // Bang method: queueAndSave(), runAndSave(), etc. — transitions AND saves (supports async guards)\n    proto[`${eventName}AndSave`] = async function () {\n      /**\n       * Self.\n       * @type {ReturnType<typeof JSON.parse>} */\n      const self = this\n      const currentState = self.readAttribute(column)\n\n      if (!fromStates.includes(currentState)) {\n        throw new Error(\n          `Cannot transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}. ` +\n          `Allowed source states: ${fromStates.join(\", \")}`\n        )\n      }\n\n      // Enforce async guard before mutating state\n      if (eventDef.guard) {\n        const allowed = await eventDef.guard(self)\n\n        if (!allowed) {\n          throw new Error(\n            `Guard rejected transition \"${eventName}\" from \"${currentState}\" on ${self.getModelClass().name}.`\n          )\n        }\n      }\n\n      self[PENDING_TRANSITION_KEY] = {eventName, from: currentState, to: eventDef.to}\n      self[setterName](eventDef.to)\n      await self.save()\n    }\n  }\n\n  // Register a beforeSave callback that fires state-enter hooks\n  ModelClass.beforeSave(async function (model) {\n    /**\n     * Dynamic model.\n     * @type {ReturnType<typeof JSON.parse>} */\n    const dynamicModel = model\n    const pending = dynamicModel[PENDING_TRANSITION_KEY]\n\n    if (!pending) {\n      return\n    }\n\n    const eventDef = definition.events[pending.eventName]\n\n    // Run event-level before callback\n    if (eventDef?.before) {\n      await eventDef.before(model)\n    }\n\n    // Run the exited state's beforeExit, then the entered state's beforeEnter\n    const fromStateDefinition = definition.states[pending.from]\n\n    if (fromStateDefinition?.beforeExit) {\n      await fromStateDefinition.beforeExit(model)\n    }\n\n    const stateDefinition = definition.states[pending.to]\n\n    if (stateDefinition?.beforeEnter) {\n      await stateDefinition.beforeEnter(model)\n    }\n  })\n\n  // Register an afterSave callback for afterEnter hooks\n  ModelClass.afterSave(async function (model) {\n    /**\n     * Dynamic model.\n     * @type {ReturnType<typeof JSON.parse>} */\n    const dynamicModel = model\n    const pending = dynamicModel[PENDING_TRANSITION_KEY]\n\n    if (!pending) {\n      return\n    }\n\n    // Clear the pending transition now that save is complete\n    dynamicModel[PENDING_TRANSITION_KEY] = null\n\n    // Run the entered state's afterEnter, then the exited state's afterExit\n    const stateDefinition = definition.states[pending.to]\n\n    if (stateDefinition?.afterEnter) {\n      await stateDefinition.afterEnter(model)\n    }\n\n    const fromStateDefinition = definition.states[pending.from]\n\n    if (fromStateDefinition?.afterExit) {\n      await fromStateDefinition.afterExit(model)\n    }\n\n    // Run event-level after callback\n    const eventDef = definition.events[pending.eventName]\n\n    if (eventDef?.after) {\n      await eventDef.after(model)\n    }\n  })\n}\n\n/**\n * Returns the setter method name for a column (e.g., \"status\" → \"setStatus\", \"state\" → \"setState\").\n * @param {string} column - The column name.\n * @returns {string} - The setter method name.\n */\nfunction columnSetterName(column) {\n  return `set${column.charAt(0).toUpperCase()}${column.slice(1)}`\n}\n"]}

package/build/src/database/record/user-module.d.ts

@@ -1,4 +1,5 @@
 export default class UserModule {
+    secretKey: string;
     /**
      * Runs constructor.
      * @param {object} args - Options object.
@@ -7,7 +8,6 @@ export default class UserModule {
     constructor({ secretKey, ...restArgs }: {
         secretKey: string;
     });
-    secretKey: string;
     /**
      * Runs attach to.
      * @param {typeof import("./index.js").default} UserClass - User class.

package/build/src/database/record/user-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-module.d.ts","sourceRoot":"","sources":["../../../../src/database/record/user-module.js"],"names":[],"mappings":"AAKA;IACE;;;;OAIG;IACH,wCAFG;QAAqB,SAAS,EAAtB,MAAM;KAChB,EAOA;IADC,kBAA0B;IAG5B;;;OAGG;IACH,oBAFW,cAAc,YAAY,EAAE,OAAO,QAoB7C;CACF"}
+{"version":3,"file":"user-module.d.ts","sourceRoot":"","sources":["../../../../src/database/record/user-module.js"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,OAAO,UAAU;IAWtB,SAAS;IAVhB;;;;OAIG;IACH,YAAY,EAAC,SAAS,EAAE,GAAG,QAAQ,EAAC,EAFjC;QAAqB,SAAS,EAAtB,MAAM,CAChB;KACmC,EAMnC;IAED;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAFP,cAAc,YAAY,EAAE,OAErB,QAkBjB;CACF"}