velocious 1.0.430 → 1.0.431

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

@@ -1,4 +1,5 @@
 // @ts-check
+
 /**
  * Defines this typedef.
  * @typedef {{
@@ -19,10 +20,12 @@
  *   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.
  *
@@ -56,171 +59,220 @@ 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
+  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) {
     /**
-     * Dynamic class.
+     * Dynamic model.
       @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
+    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) {
     /**
-     * Proto.
+     * Dynamic model.
       @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();
-        };
+    const dynamicModel = model
+    const pending = dynamicModel[PENDING_TRANSITION_KEY]
+
+    if (!pending) {
+      return
     }
-    // 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);
-        }
-    });
+
+    // 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,37 +1,43 @@
 // @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 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 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;
-        };
+
+    // @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,25 +1,27 @@
 // @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 }) {
-        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}) { // eslint-disable-line no-unused-vars
+    throw new Error("validate not implemented")
+  }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9kYXRhYmFzZS9yZWNvcmQvdmFsaWRhdG9ycy9iYXNlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixNQUFNLENBQUMsT0FBTyxPQUFPLHFDQUFxQztJQUN4RDs7Ozs7T0FLRztJQUNILFlBQVksRUFBQyxhQUFhLEVBQUUsSUFBSSxFQUFDO1FBQy9CLElBQUksQ0FBQyxhQUFhLEdBQUcsYUFBYSxDQUFBO1FBQ2xDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO0lBQ2xCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsS0FBSyxDQUFDLFFBQVEsQ0FBQyxFQUFDLEtBQUssRUFBRSxhQUFhLEVBQUM7UUFDbkMsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFBO0lBQzdDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNEYXRhYmFzZVJlY29yZFZhbGlkYXRvcnNCYXNlIHtcbiAgLyoqXG4gICAqIFJ1bnMgY29uc3RydWN0b3IuXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gT3B0aW9ucyBvYmplY3QuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBhcmdzLmF0dHJpYnV0ZU5hbWUgLSBBdHRyaWJ1dGUgbmFtZS5cbiAgICogQHBhcmFtIHtSZWNvcmQ8c3RyaW5nLCA/Pn0gYXJncy5hcmdzIC0gT3B0aW9ucyBvYmplY3QuXG4gICAqL1xuICBjb25zdHJ1Y3Rvcih7YXR0cmlidXRlTmFtZSwgYXJnc30pIHtcbiAgICB0aGlzLmF0dHJpYnV0ZU5hbWUgPSBhdHRyaWJ1dGVOYW1lXG4gICAgdGhpcy5hcmdzID0gYXJnc1xuICB9XG5cbiAgLyoqXG4gICAqIFJ1bnMgdmFsaWRhdGUuXG4gICAqIEBhYnN0cmFjdFxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMgb2JqZWN0LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4uL2luZGV4LmpzXCIpLmRlZmF1bHR9IGFyZ3MubW9kZWwgLSBNb2RlbCBpbnN0YW5jZS5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuYXR0cmlidXRlTmFtZSAtIEF0dHJpYnV0ZSBuYW1lLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gLSBSZXNvbHZlcyB3aGVuIGNvbXBsZXRlLlxuICAgKi9cbiAgYXN5bmMgdmFsaWRhdGUoe21vZGVsLCBhdHRyaWJ1dGVOYW1lfSkgeyAvLyBlc2xpbnQtZGlzYWJsZS1saW5lIG5vLXVudXNlZC12YXJzXG4gICAgdGhyb3cgbmV3IEVycm9yKFwidmFsaWRhdGUgbm90IGltcGxlbWVudGVkXCIpXG4gIH1cbn1cblxuIl19
+