@decaf-ts/decorator-validation 1.6.1 → 1.6.3

package/lib/validation/Validators/Validator.d.ts

@@ -1,14 +1,54 @@
 import { ValidatorOptions } from "../types";
 /**
- * @summary Base Implementation for Validators
- * @description Provides the underlying functionality for {@link Validator}s
+ * @description Abstract base class for all validators in the validation framework
+ * @summary The Validator class provides the foundation for all validator implementations.
+ * It handles type checking, error message formatting, and defines the common interface
+ * that all validators must implement. This class is designed to be extended by specific
+ * validator implementations that provide concrete validation logic.
  *
- * @param {string} validationKey the key to register the validator under
- * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
- * @param {string[]} [acceptedTypes] defines the value types this validator can validate
+ * @param {string} message - Default error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
+ * @param {string[]} acceptedTypes - Array of type names that this validator can validate
  *
  * @class Validator
  * @abstract
+ *
+ * @example
+ * ```typescript
+ * // Example of extending the Validator class to create a custom validator
+ * class CustomValidator extends Validator<CustomValidatorOptions> {
+ *   constructor(message: string = "Custom validation failed") {
+ *     // Specify that this validator accepts String and Number types
+ *     super(message, String.name, Number.name);
+ *   }
+ *
+ *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {
+ *     // Implement custom validation logic
+ *     if (someCondition) {
+ *       return this.getMessage(options?.message || this.message);
+ *     }
+ *     return undefined; // No errors
+ *   }
+ * }
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as Validator Subclass
+ *   participant B as Base Validator
+ *
+ *   C->>V: new CustomValidator(message)
+ *   V->>B: super(message, acceptedTypes)
+ *   B->>B: Store message and types
+ *   B->>B: Wrap hasErrors with type checking
+ *   C->>V: hasErrors(value, options)
+ *   alt value type not in acceptedTypes
+ *     B-->>C: Type error message
+ *   else value type is accepted
+ *     V->>V: Custom validation logic
+ *     V-->>C: Validation result
+ *   end
+ *
  * @category Validators
  */
 export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> {
@@ -16,26 +56,49 @@ export declare abstract class Validator<V extends ValidatorOptions = ValidatorOp
     readonly acceptedTypes?: string[];
     protected constructor(message?: string, ...acceptedTypes: string[]);
     /**
-     * @summary builds the error message
-     * @param {string} message
-     * @param {any[]} args
+     * @description Formats an error message with optional arguments
+     * @summary Creates a formatted error message by replacing placeholders with provided arguments.
+     * This method uses the string formatting utility to generate consistent error messages
+     * across all validators.
+     *
+     * @param {string} message - The message template with placeholders
+     * @param {...any} args - Values to insert into the message template
+     * @return {string} The formatted error message
      * @protected
      */
     protected getMessage(message: string, ...args: any[]): string;
     /**
-     * @summary Validates type
-     * @param {any} unbound
+     * @description Creates a type-checking wrapper around the hasErrors method
+     * @summary Wraps the hasErrors method with type validation logic to ensure that
+     * the value being validated is of an accepted type before performing specific validation.
+     * This method is called during construction if acceptedTypes are provided.
+     *
+     * @param {Function} unbound - The original hasErrors method to be wrapped
+     * @return {Function} A new function that performs type checking before calling the original method
      * @private
      */
     private checkTypeAndHasErrors;
     /**
-     * @summary Validates an attribute
-     * @param {any} value
-     * @param {ValidatorOptions} [options] Validate options for customizing the model validation behavior
+     * @description Validates a value against specific validation rules
+     * @summary Abstract method that must be implemented by all validator subclasses.
+     * This method contains the core validation logic that determines whether a value
+     * is valid according to the specific rules of the validator. If the value is valid,
+     * the method returns undefined; otherwise, it returns an error message.
+     *
+     * @template V - Type of the options object that can be passed to the validator
+     * @param {any} value - The value to validate
+     * @param {V} [options] - Optional configuration options for customizing validation behavior
+     *
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @abstract
      *
-     * @see Model#hasErrors
+     * @see Model#validate
      */
     abstract hasErrors(value: any, options?: V): string | undefined;
+    /**
+     * @summary Duck typing for Validators
+     * @param val
+     */
+    static isValidator(val: any): boolean;
 }

package/lib/validation/Validators/ValidatorRegistry.cjs

@@ -1,15 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidatorRegistry = void 0;
-exports.isValidator = isValidator;
-/**
- * @summary Duck typing for Validators
- * @function isValidator
- * @param val
- */
-function isValidator(val) {
-    return val.constructor && val["hasErrors"];
-}
+const Validator_1 = require("./Validator.cjs");
 /**
  * @summary Base Implementation of a Validator Registry
  *
@@ -48,7 +40,7 @@ class ValidatorRegistry {
         if (!(validatorKey in this.cache))
             return undefined;
         const classOrInstance = this.cache[validatorKey];
-        if (isValidator(classOrInstance))
+        if (Validator_1.Validator.isValidator(classOrInstance))
             return classOrInstance;
         const constructor = classOrInstance.default || classOrInstance;
         const instance = new constructor();
@@ -62,7 +54,7 @@ class ValidatorRegistry {
      */
     register(...validator) {
         validator.forEach((v) => {
-            if (isValidator(v)) {
+            if (Validator_1.Validator.isValidator(v)) {
                 // const k =
                 if (v.validationKey in this.cache)
                     return;
@@ -83,4 +75,4 @@ class ValidatorRegistry {
     }
 }
 exports.ValidatorRegistry = ValidatorRegistry;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validation/Validators/ValidatorRegistry.d.ts

@@ -1,12 +1,6 @@
 import { ValidatorDefinition } from "../types";
 import { IValidatorRegistry } from "../types";
-import type { Validator } from "./Validator";
-/**
- * @summary Duck typing for Validators
- * @function isValidator
- * @param val
- */
-export declare function isValidator(val: any): any;
+import { Validator } from "./Validator";
 /**
  * @summary Base Implementation of a Validator Registry
  *