velocious 1.0.431 → 1.0.433

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

@@ -1,5 +1,4 @@
 // @ts-check
-
 /**
  * Defines this typedef.
  * @typedef {{
@@ -20,12 +19,10 @@
  *   after?: (model: import("./index.js").default) => void | Promise<void>
  * }} EventDefinition
  */
-
 /**
  * Pending transition key.
   @type {string} */
-const PENDING_TRANSITION_KEY = "_stateMachinePendingTransition"
-
+const PENDING_TRANSITION_KEY = "_stateMachinePendingTransition";
 /**
  * Registers a state machine on a Velocious model class.
  *
@@ -59,220 +56,171 @@ const PENDING_TRANSITION_KEY = "_stateMachinePendingTransition"
  * @returns {void}
  */
 export function stateMachine(ModelClass, definition) {
-  const column = definition.column || "state"
-  const stateNames = Object.keys(definition.states)
-
-  // Store definition on the model class for introspection
-  /**
-   * Dynamic class.
-    @type {?} */
-  const dynamicClass = ModelClass
-
-  dynamicClass._stateMachineDefinition = definition
-  dynamicClass._stateMachineColumn = column
-
-  /**
-   * Returns the registered state machine definition.
-   * @returns {StateMachineDefinition} - The registered state machine definition.
-   */
-  dynamicClass.getStateMachineDefinition = function () {
-    return dynamicClass._stateMachineDefinition
-  }
-
-  /**
-   * Returns the state column name.
-   * @returns {string} - The column name used for state storage.
-   */
-  dynamicClass.getStateMachineColumn = function () {
-    return dynamicClass._stateMachineColumn
-  }
-
-  /**
-   * Returns all declared state names.
-   * @returns {string[]} - All declared state names.
-   */
-  dynamicClass.getStateMachineStateNames = function () {
-    return stateNames
-  }
-
-  // Register event methods and guard methods on the prototype
-  /**
-   * Proto.
-    @type {?} */
-  const proto = ModelClass.prototype
-
-  for (const [eventName, eventDef] of Object.entries(definition.events)) {
-    const fromStates = Array.isArray(eventDef.from) ? eventDef.from : [eventDef.from]
-    const capitalizedEvent = eventName.charAt(0).toUpperCase() + eventName.slice(1)
-    const canMethodName = `can${capitalizedEvent}`
-    const setterName = columnSetterName(column)
-
-    // Guard method: canQueue(), canRun(), etc.
-    proto[canMethodName] = function () {
-      const currentState = this.readAttribute(column)
-
-      if (!fromStates.includes(currentState)) {
-        return false
-      }
-
-      if (eventDef.guard) {
-        const guardResult = eventDef.guard(this)
-
-        if (guardResult instanceof Promise) {
-          throw new Error(`Guard for event "${eventName}" returned a Promise. Use await model.can${capitalizedEvent}Async() instead.`)
-        }
-
-        return guardResult
-      }
-
-      return true
-    }
-
-    // Async guard method: canQueueAsync(), canRunAsync(), etc.
-    proto[`${canMethodName}Async`] = async function () {
-      const currentState = this.readAttribute(column)
-
-      if (!fromStates.includes(currentState)) {
-        return false
-      }
-
-      if (eventDef.guard) {
-        return await eventDef.guard(this)
-      }
-
-      return true
-    }
-
-    // Transition method: queue(), run(), etc. — checks guard, sets the state, stashes event name
-    proto[eventName] = function () {
-      /**
-       * Self.
-        @type {?} */
-      const self = this
-      const currentState = self.readAttribute(column)
-
-      if (!fromStates.includes(currentState)) {
-        throw new Error(
-          `Cannot transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}. ` +
-          `Allowed source states: ${fromStates.join(", ")}`
-        )
-      }
-
-      // Enforce synchronous guard before mutating state
-      if (eventDef.guard) {
-        const guardResult = eventDef.guard(self)
-
-        if (guardResult instanceof Promise) {
-          throw new Error(`Guard for event "${eventName}" returned a Promise. Use await model.${eventName}AndSave() for async guards.`)
-        }
-
-        if (!guardResult) {
-          throw new Error(
-            `Guard rejected transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}.`
-          )
-        }
-      }
-
-      // Stash the transition so beforeSave/afterSave know which event was invoked
-      self[PENDING_TRANSITION_KEY] = {eventName, from: currentState, to: eventDef.to}
-      self[setterName](eventDef.to)
-    }
-
-    // Bang method: queueAndSave(), runAndSave(), etc. — transitions AND saves (supports async guards)
-    proto[`${eventName}AndSave`] = async function () {
-      /**
-       * Self.
-        @type {?} */
-      const self = this
-      const currentState = self.readAttribute(column)
-
-      if (!fromStates.includes(currentState)) {
-        throw new Error(
-          `Cannot transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}. ` +
-          `Allowed source states: ${fromStates.join(", ")}`
-        )
-      }
-
-      // Enforce async guard before mutating state
-      if (eventDef.guard) {
-        const allowed = await eventDef.guard(self)
-
-        if (!allowed) {
-          throw new Error(
-            `Guard rejected transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}.`
-          )
-        }
-      }
-
-      self[PENDING_TRANSITION_KEY] = {eventName, from: currentState, to: eventDef.to}
-      self[setterName](eventDef.to)
-      await self.save()
-    }
-  }
-
-  // Register a beforeSave callback that fires state-enter hooks
-  ModelClass.beforeSave(async function (model) {
+    const column = definition.column || "state";
+    const stateNames = Object.keys(definition.states);
+    // Store definition on the model class for introspection
     /**
-     * Dynamic model.
+     * Dynamic class.
       @type {?} */
-    const dynamicModel = model
-    const pending = dynamicModel[PENDING_TRANSITION_KEY]
-
-    if (!pending) {
-      return
-    }
-
-    const eventDef = definition.events[pending.eventName]
-
-    // Run event-level before callback
-    if (eventDef?.before) {
-      await eventDef.before(model)
-    }
-
-    // Run state-level beforeEnter callback
-    const stateDefinition = definition.states[pending.to]
-
-    if (stateDefinition?.beforeEnter) {
-      await stateDefinition.beforeEnter(model)
-    }
-  })
-
-  // Register an afterSave callback for afterEnter hooks
-  ModelClass.afterSave(async function (model) {
+    const dynamicClass = ModelClass;
+    dynamicClass._stateMachineDefinition = definition;
+    dynamicClass._stateMachineColumn = column;
     /**
-     * Dynamic model.
+     * Returns the registered state machine definition.
+     * @returns {StateMachineDefinition} - The registered state machine definition.
+     */
+    dynamicClass.getStateMachineDefinition = function () {
+        return dynamicClass._stateMachineDefinition;
+    };
+    /**
+     * Returns the state column name.
+     * @returns {string} - The column name used for state storage.
+     */
+    dynamicClass.getStateMachineColumn = function () {
+        return dynamicClass._stateMachineColumn;
+    };
+    /**
+     * Returns all declared state names.
+     * @returns {string[]} - All declared state names.
+     */
+    dynamicClass.getStateMachineStateNames = function () {
+        return stateNames;
+    };
+    // Register event methods and guard methods on the prototype
+    /**
+     * Proto.
       @type {?} */
-    const dynamicModel = model
-    const pending = dynamicModel[PENDING_TRANSITION_KEY]
-
-    if (!pending) {
-      return
+    const proto = ModelClass.prototype;
+    for (const [eventName, eventDef] of Object.entries(definition.events)) {
+        const fromStates = Array.isArray(eventDef.from) ? eventDef.from : [eventDef.from];
+        const capitalizedEvent = eventName.charAt(0).toUpperCase() + eventName.slice(1);
+        const canMethodName = `can${capitalizedEvent}`;
+        const setterName = columnSetterName(column);
+        // Guard method: canQueue(), canRun(), etc.
+        proto[canMethodName] = function () {
+            const currentState = this.readAttribute(column);
+            if (!fromStates.includes(currentState)) {
+                return false;
+            }
+            if (eventDef.guard) {
+                const guardResult = eventDef.guard(this);
+                if (guardResult instanceof Promise) {
+                    throw new Error(`Guard for event "${eventName}" returned a Promise. Use await model.can${capitalizedEvent}Async() instead.`);
+                }
+                return guardResult;
+            }
+            return true;
+        };
+        // Async guard method: canQueueAsync(), canRunAsync(), etc.
+        proto[`${canMethodName}Async`] = async function () {
+            const currentState = this.readAttribute(column);
+            if (!fromStates.includes(currentState)) {
+                return false;
+            }
+            if (eventDef.guard) {
+                return await eventDef.guard(this);
+            }
+            return true;
+        };
+        // Transition method: queue(), run(), etc. — checks guard, sets the state, stashes event name
+        proto[eventName] = function () {
+            /**
+             * Self.
+              @type {?} */
+            const self = this;
+            const currentState = self.readAttribute(column);
+            if (!fromStates.includes(currentState)) {
+                throw new Error(`Cannot transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}. ` +
+                    `Allowed source states: ${fromStates.join(", ")}`);
+            }
+            // Enforce synchronous guard before mutating state
+            if (eventDef.guard) {
+                const guardResult = eventDef.guard(self);
+                if (guardResult instanceof Promise) {
+                    throw new Error(`Guard for event "${eventName}" returned a Promise. Use await model.${eventName}AndSave() for async guards.`);
+                }
+                if (!guardResult) {
+                    throw new Error(`Guard rejected transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}.`);
+                }
+            }
+            // Stash the transition so beforeSave/afterSave know which event was invoked
+            self[PENDING_TRANSITION_KEY] = { eventName, from: currentState, to: eventDef.to };
+            self[setterName](eventDef.to);
+        };
+        // Bang method: queueAndSave(), runAndSave(), etc. — transitions AND saves (supports async guards)
+        proto[`${eventName}AndSave`] = async function () {
+            /**
+             * Self.
+              @type {?} */
+            const self = this;
+            const currentState = self.readAttribute(column);
+            if (!fromStates.includes(currentState)) {
+                throw new Error(`Cannot transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}. ` +
+                    `Allowed source states: ${fromStates.join(", ")}`);
+            }
+            // Enforce async guard before mutating state
+            if (eventDef.guard) {
+                const allowed = await eventDef.guard(self);
+                if (!allowed) {
+                    throw new Error(`Guard rejected transition "${eventName}" from "${currentState}" on ${self.getModelClass().name}.`);
+                }
+            }
+            self[PENDING_TRANSITION_KEY] = { eventName, from: currentState, to: eventDef.to };
+            self[setterName](eventDef.to);
+            await self.save();
+        };
     }
-
-    // Clear the pending transition now that save is complete
-    dynamicModel[PENDING_TRANSITION_KEY] = null
-
-    // Run state-level afterEnter callback
-    const stateDefinition = definition.states[pending.to]
-
-    if (stateDefinition?.afterEnter) {
-      await stateDefinition.afterEnter(model)
-    }
-
-    // Run event-level after callback
-    const eventDef = definition.events[pending.eventName]
-
-    if (eventDef?.after) {
-      await eventDef.after(model)
-    }
-  })
+    // Register a beforeSave callback that fires state-enter hooks
+    ModelClass.beforeSave(async function (model) {
+        /**
+         * Dynamic model.
+          @type {?} */
+        const dynamicModel = model;
+        const pending = dynamicModel[PENDING_TRANSITION_KEY];
+        if (!pending) {
+            return;
+        }
+        const eventDef = definition.events[pending.eventName];
+        // Run event-level before callback
+        if (eventDef?.before) {
+            await eventDef.before(model);
+        }
+        // Run state-level beforeEnter callback
+        const stateDefinition = definition.states[pending.to];
+        if (stateDefinition?.beforeEnter) {
+            await stateDefinition.beforeEnter(model);
+        }
+    });
+    // Register an afterSave callback for afterEnter hooks
+    ModelClass.afterSave(async function (model) {
+        /**
+         * Dynamic model.
+          @type {?} */
+        const dynamicModel = model;
+        const pending = dynamicModel[PENDING_TRANSITION_KEY];
+        if (!pending) {
+            return;
+        }
+        // Clear the pending transition now that save is complete
+        dynamicModel[PENDING_TRANSITION_KEY] = null;
+        // Run state-level afterEnter callback
+        const stateDefinition = definition.states[pending.to];
+        if (stateDefinition?.afterEnter) {
+            await stateDefinition.afterEnter(model);
+        }
+        // Run event-level after callback
+        const eventDef = definition.events[pending.eventName];
+        if (eventDef?.after) {
+            await eventDef.after(model);
+        }
+    });
 }
-
 /**
  * Returns the setter method name for a column (e.g., "status" → "setStatus", "state" → "setState").
  * @param {string} column - The column name.
  * @returns {string} - The setter method name.
  */
 function columnSetterName(column) {
-  return `set${column.charAt(0).toUpperCase()}${column.slice(1)}`
+    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 * }} 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  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 state-level beforeEnter callback\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 state-level afterEnter callback\n    const stateDefinition = definition.states[pending.to]\n\n    if (stateDefinition?.afterEnter) {\n      await stateDefinition.afterEnter(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.js

@@ -1,43 +1,37 @@
 // @ts-check
-
-import bcryptjs from "bcryptjs"
-import restArgsError from "../../utils/rest-args-error.js"
-
+import bcryptjs from "bcryptjs";
+import restArgsError from "../../utils/rest-args-error.js";
 export default class UserModule {
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {string} args.secretKey - Secret key.
-   */
-  constructor({secretKey, ...restArgs}) {
-    restArgsError(restArgs)
-
-    if (!secretKey) throw new Error(`Invalid secret key given: ${secretKey}`)
-
-    this.secretKey = secretKey
-  }
-
-  /**
-   * Runs attach to.
-   * @param {typeof import("./index.js").default} UserClass - User class.
-   */
-  attachTo(UserClass) {
-    // @ts-expect-error
-    UserClass.prototype.setPassword = function(newPassword) {
-      const salt = bcryptjs.genSaltSync(10)
-      const encryptedPassword = bcryptjs.hashSync(newPassword, salt)
-
-      // @ts-expect-error
-      this.setEncryptedPassword(encryptedPassword)
+    /**
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {string} args.secretKey - Secret key.
+     */
+    constructor({ secretKey, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!secretKey)
+            throw new Error(`Invalid secret key given: ${secretKey}`);
+        this.secretKey = secretKey;
     }
-
-    // @ts-expect-error
-    UserClass.prototype.setPasswordConfirmation = function(newPasswordConfirmation) {
-      const salt = bcryptjs.genSaltSync(10)
-      const encryptedPassword = bcryptjs.hashSync(newPasswordConfirmation, salt)
-
-      // @ts-expect-error
-      this._encryptedPasswordConfirmation = encryptedPassword
+    /**
+     * Runs attach to.
+     * @param {typeof import("./index.js").default} UserClass - User class.
+     */
+    attachTo(UserClass) {
+        // @ts-expect-error
+        UserClass.prototype.setPassword = function (newPassword) {
+            const salt = bcryptjs.genSaltSync(10);
+            const encryptedPassword = bcryptjs.hashSync(newPassword, salt);
+            // @ts-expect-error
+            this.setEncryptedPassword(encryptedPassword);
+        };
+        // @ts-expect-error
+        UserClass.prototype.setPasswordConfirmation = function (newPasswordConfirmation) {
+            const salt = bcryptjs.genSaltSync(10);
+            const encryptedPassword = bcryptjs.hashSync(newPasswordConfirmation, salt);
+            // @ts-expect-error
+            this._encryptedPasswordConfirmation = encryptedPassword;
+        };
     }
-  }
 }
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,27 +1,25 @@
 // @ts-check
-
 export default class VelociousDatabaseRecordValidatorsBase {
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {string} args.attributeName - Attribute name.
-   * @param {Record<string, ?>} args.args - Options object.
-   */
-  constructor({attributeName, args}) {
-    this.attributeName = attributeName
-    this.args = args
-  }
-
-  /**
-   * Runs validate.
-   * @abstract
-   * @param {object} args - Options object.
-   * @param {import("../index.js").default} args.model - Model instance.
-   * @param {string} args.attributeName - Attribute name.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async validate({model, attributeName}) { // eslint-disable-line no-unused-vars
-    throw new Error("validate not implemented")
-  }
+    /**
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {string} args.attributeName - Attribute name.
+     * @param {Record<string, ?>} args.args - Options object.
+     */
+    constructor({ attributeName, args }) {
+        this.attributeName = attributeName;
+        this.args = args;
+    }
+    /**
+     * Runs validate.
+     * @abstract
+     * @param {object} args - Options object.
+     * @param {import("../index.js").default} args.model - Model instance.
+     * @param {string} args.attributeName - Attribute name.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async validate({ model, attributeName }) {
+        throw new Error("validate not implemented");
+    }
 }
-
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9kYXRhYmFzZS9yZWNvcmQvdmFsaWRhdG9ycy9iYXNlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixNQUFNLENBQUMsT0FBTyxPQUFPLHFDQUFxQztJQUN4RDs7Ozs7T0FLRztJQUNILFlBQVksRUFBQyxhQUFhLEVBQUUsSUFBSSxFQUFDO1FBQy9CLElBQUksQ0FBQyxhQUFhLEdBQUcsYUFBYSxDQUFBO1FBQ2xDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO0lBQ2xCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsS0FBSyxDQUFDLFFBQVEsQ0FBQyxFQUFDLEtBQUssRUFBRSxhQUFhLEVBQUM7UUFDbkMsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFBO0lBQzdDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNEYXRhYmFzZVJlY29yZFZhbGlkYXRvcnNCYXNlIHtcbiAgLyoqXG4gICAqIFJ1bnMgY29uc3RydWN0b3IuXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gT3B0aW9ucyBvYmplY3QuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBhcmdzLmF0dHJpYnV0ZU5hbWUgLSBBdHRyaWJ1dGUgbmFtZS5cbiAgICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCA/Pn0gYXJncy5hcmdzIC0gT3B0aW9ucyBvYmplY3QuXG4gICAqL1xuICBjb25zdHJ1Y3Rvcih7YXR0cmlidXRlTmFtZSwgYXJnc30pIHtcbiAgICB0aGlzLmF0dHJpYnV0ZU5hbWUgPSBhdHRyaWJ1dGVOYW1lXG4gICAgdGhpcy5hcmdzID0gYXJnc1xuICB9XG5cbiAgLyoqXG4gICAqIFJ1bnMgdmFsaWRhdGUuXG4gICAqIEBhYnN0cmFjdFxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMgb2JqZWN0LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4uL2luZGV4LmpzXCIpLmRlZmF1bHR9IGFyZ3MubW9kZWwgLSBNb2RlbCBpbnN0YW5jZS5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuYXR0cmlidXRlTmFtZSAtIEF0dHJpYnV0ZSBuYW1lLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gLSBSZXNvbHZlcyB3aGVuIGNvbXBsZXRlLlxuICAgKi9cbiAgYXN5bmMgdmFsaWRhdGUoe21vZGVsLCBhdHRyaWJ1dGVOYW1lfSkgeyAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIG5vLXVudXNlZC12YXJzXG4gICAgdGhyb3cgbmV3IEVycm9yKFwidmFsaWRhdGUgbm90IGltcGxlbWVudGVkXCIpXG4gIH1cbn1cblxuIl19

package/build/src/database/record/validators/format.js

@@ -1,50 +1,40 @@
 // @ts-check
-
-import Base from "./base.js"
-
+import Base from "./base.js";
 export default class VelociousDatabaseRecordValidatorsFormat extends Base {
-  /**
-   * Runs validate.
-   * @param {object} args - Options object.
-   * @param {import("../index.js").default} args.model - Model instance.
-   * @param {string} args.attributeName - Attribute name.
-   * @returns {Promise<void>}
-   */
-  async validate({model, attributeName}) {
-    const value = model.readAttribute(attributeName)
-
-    // Rails parity: `allow_blank: true` skips the format check for
-    // blank/null/undefined values. Default to false (same as Rails).
-    const allowBlank = this.args?.allowBlank === true
-
-    if (value == null || (typeof value === "string" && value.trim() === "")) {
-      if (allowBlank) return
-
-      if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []
-
-      model._validationErrors[attributeName].push({type: "format", message: "is invalid"})
-
-      return
+    /**
+     * Runs validate.
+     * @param {object} args - Options object.
+     * @param {import("../index.js").default} args.model - Model instance.
+     * @param {string} args.attributeName - Attribute name.
+     * @returns {Promise<void>}
+     */
+    async validate({ model, attributeName }) {
+        const value = model.readAttribute(attributeName);
+        // Rails parity: `allow_blank: true` skips the format check for
+        // blank/null/undefined values. Default to false (same as Rails).
+        const allowBlank = this.args?.allowBlank === true;
+        if (value == null || (typeof value === "string" && value.trim() === "")) {
+            if (allowBlank)
+                return;
+            if (!(attributeName in model._validationErrors))
+                model._validationErrors[attributeName] = [];
+            model._validationErrors[attributeName].push({ type: "format", message: "is invalid" });
+            return;
+        }
+        const pattern = this.args?.with;
+        if (!(pattern instanceof RegExp)) {
+            throw new Error(`validates format requires a 'with' option that is a RegExp, got: ${typeof pattern}`);
+        }
+        const stringValue = String(value);
+        // Reset lastIndex so stateful flags (g, y) on a shared RegExp
+        // instance don't cause nondeterministic pass/fail across calls.
+        pattern.lastIndex = 0;
+        if (!pattern.test(stringValue)) {
+            const message = typeof this.args?.message === "string" ? this.args.message : "is invalid";
+            if (!(attributeName in model._validationErrors))
+                model._validationErrors[attributeName] = [];
+            model._validationErrors[attributeName].push({ type: "format", message });
+        }
     }
-
-    const pattern = this.args?.with
-
-    if (!(pattern instanceof RegExp)) {
-      throw new Error(`validates format requires a 'with' option that is a RegExp, got: ${typeof pattern}`)
-    }
-
-    const stringValue = String(value)
-
-    // Reset lastIndex so stateful flags (g, y) on a shared RegExp
-    // instance don't cause nondeterministic pass/fail across calls.
-    pattern.lastIndex = 0
-
-    if (!pattern.test(stringValue)) {
-      const message = typeof this.args?.message === "string" ? this.args.message : "is invalid"
-
-      if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []
-
-      model._validationErrors[attributeName].push({type: "format", message})
-    }
-  }
 }
+//# sourceMappingURL=data:application/json;base64,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