@decaf-ts/decorator-validation 1.6.4 → 1.7.0

package/lib/esm/validation/Validators/URLValidator.js

@@ -11,12 +11,43 @@ import { ValidationKeys, DEFAULT_ERROR_MESSAGES, DEFAULT_PATTERNS, } from "./con
 import { PatternValidator } from "./PatternValidator";
 import { validator } from "./decorators";
 /**
- * @summary URL Validator
- * @description Pattern from {@link https://gist.github.com/dperini/729294}
+ * @description Validator for checking if a string is a valid URL
+ * @summary The URLValidator checks if a string matches a standard URL pattern.
+ * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
+ * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
+ * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
  *
  * @class URLValidator
  * @extends PatternValidator
  *
+ * @example
+ * ```typescript
+ * // Create a URL validator with default error message
+ * const urlValidator = new URLValidator();
+ *
+ * // Create a URL validator with custom error message
+ * const customUrlValidator = new URLValidator("Please enter a valid web address");
+ *
+ * // Validate a URL
+ * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
+ * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant U as URLValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>U: new URLValidator(message)
+ *   U->>P: super(message)
+ *   C->>U: hasErrors(value, options)
+ *   U->>P: super.hasErrors(value, options with URL pattern)
+ *   P-->>U: validation result
+ *   U-->>C: validation result
+ *
  * @category Validators
  */
 let URLValidator = class URLValidator extends PatternValidator {
@@ -24,16 +55,19 @@ let URLValidator = class URLValidator extends PatternValidator {
         super(message);
     }
     /**
-     * @summary Validates a model
+     * @description Checks if a string is a valid URL
+     * @summary Validates that the provided string matches the URL pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the URL pattern is used, even if not explicitly provided in the options.
      *
-     * @param {string} value
-     * @param {PatternValidatorOptions} [options={}]
+     * @param {string} value - The string to validate as a URL
+     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
-     * @see Validator#hasErrors
+     * @see PatternValidator#hasErrors
      */
     hasErrors(value, options = {}) {
         return super.hasErrors(value, {
@@ -47,4 +81,4 @@ URLValidator = __decorate([
     __metadata("design:paramtypes", [String])
 ], URLValidator);
 export { URLValidator };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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,29 +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 - The value to be validated.
-     * @param {ValidatorOptions} [options] Validate options for customizing the model validation behavior
-     * @param {any} [instanceObj] - The object instance that contains the key-value being validated. Used for cross-field validation. Defaults to an empty object.
+     * @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
      *
-     * @returns An error message string if validation fails; otherwise, `undefined`.
+     * @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, instanceObj?: any): string | undefined;
+    /**
+     * @summary Duck typing for Validators
+     * @param val
+     */
+    static isValidator(val: any): boolean;
 }

package/lib/esm/validation/Validators/Validator.js

@@ -2,15 +2,55 @@ import { DEFAULT_ERROR_MESSAGES } from "./constants";
 import { sf } from "../../utils/strings";
 import { Reflection } from "@decaf-ts/reflection";
 /**
- * @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 class Validator {
@@ -22,17 +62,27 @@ export class Validator {
             this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
     }
     /**
-     * @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
      */
     getMessage(message, ...args) {
         return sf(message, ...args);
     }
     /**
-     * @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
      */
     checkTypeAndHasErrors(unbound) {
@@ -44,5 +94,12 @@ export class Validator {
             return unbound(value, ...args);
         }.bind(this);
     }
+    /**
+     * @summary Duck typing for Validators
+     * @param val
+     */
+    static isValidator(val) {
+        return val.constructor && !!val["hasErrors"];
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../../../../src/validation/Validators/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,EAAE,EAAE,MAAM,qBAAqB,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,OAAgB,SAAS;IAI7B,YACE,UAAkB,sBAAsB,CAAC,OAAO,EAChD,GAAG,aAAuB;QAE1B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,IAAI,aAAa,CAAC,MAAM;YAAE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QAC7D,IAAI,IAAI,CAAC,aAAa;YACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;;;;;OAUG;IACO,UAAU,CAAC,OAAe,EAAE,GAAG,IAAW;QAClD,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;OASG;IACK,qBAAqB,CAC3B,OAA2D;QAE3D,OAAO,UAEL,KAAU,EACV,GAAG,IAAW;YAEd,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa;gBAC5C,OAAO,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;YACjC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC;gBACnD,OAAO,IAAI,CAAC,UAAU,CACpB,sBAAsB,CAAC,IAAI,EAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAC7B,OAAO,KAAK,CACb,CAAC;YACJ,OAAO,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;QACjC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACf,CAAC;IAyBD;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,GAAQ;QACzB,OAAO,GAAG,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC;CACF","sourcesContent":["import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { sf } from \"../../utils/strings\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidatorOptions } from \"../types\";\n\n/**\n * @description Abstract base class for all validators in the validation framework\n * @summary The Validator class provides the foundation for all validator implementations.\n * It handles type checking, error message formatting, and defines the common interface\n * that all validators must implement. This class is designed to be extended by specific\n * validator implementations that provide concrete validation logic.\n *\n * @param {string} message - Default error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}\n * @param {string[]} acceptedTypes - Array of type names that this validator can validate\n *\n * @class Validator\n * @abstract\n *\n * @example\n * ```typescript\n * // Example of extending the Validator class to create a custom validator\n * class CustomValidator extends Validator<CustomValidatorOptions> {\n *   constructor(message: string = \"Custom validation failed\") {\n *     // Specify that this validator accepts String and Number types\n *     super(message, String.name, Number.name);\n *   }\n *\n *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {\n *     // Implement custom validation logic\n *     if (someCondition) {\n *       return this.getMessage(options?.message || this.message);\n *     }\n *     return undefined; // No errors\n *   }\n * }\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as Validator Subclass\n *   participant B as Base Validator\n *\n *   C->>V: new CustomValidator(message)\n *   V->>B: super(message, acceptedTypes)\n *   B->>B: Store message and types\n *   B->>B: Wrap hasErrors with type checking\n *   C->>V: hasErrors(value, options)\n *   alt value type not in acceptedTypes\n *     B-->>C: Type error message\n *   else value type is accepted\n *     V->>V: Custom validation logic\n *     V-->>C: Validation result\n *   end\n *\n * @category Validators\n */\nexport abstract class Validator<V extends ValidatorOptions = ValidatorOptions> {\n  readonly message: string;\n  readonly acceptedTypes?: string[];\n\n  protected constructor(\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    this.message = message;\n\n    if (acceptedTypes.length) this.acceptedTypes = acceptedTypes;\n    if (this.acceptedTypes)\n      this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));\n  }\n\n  /**\n   * @description Formats an error message with optional arguments\n   * @summary Creates a formatted error message by replacing placeholders with provided arguments.\n   * This method uses the string formatting utility to generate consistent error messages\n   * across all validators.\n   *\n   * @param {string} message - The message template with placeholders\n   * @param {...any} args - Values to insert into the message template\n   * @return {string} The formatted error message\n   * @protected\n   */\n  protected getMessage(message: string, ...args: any[]) {\n    return sf(message, ...args);\n  }\n\n  /**\n   * @description Creates a type-checking wrapper around the hasErrors method\n   * @summary Wraps the hasErrors method with type validation logic to ensure that\n   * the value being validated is of an accepted type before performing specific validation.\n   * This method is called during construction if acceptedTypes are provided.\n   *\n   * @param {Function} unbound - The original hasErrors method to be wrapped\n   * @return {Function} A new function that performs type checking before calling the original method\n   * @private\n   */\n  private checkTypeAndHasErrors(\n    unbound: (value: any, ...args: any[]) => string | undefined\n  ) {\n    return function (\n      this: Validator,\n      value: any,\n      ...args: any[]\n    ): string | undefined {\n      if (value === undefined || !this.acceptedTypes)\n        return unbound(value, ...args);\n      if (!Reflection.checkTypes(value, this.acceptedTypes))\n        return this.getMessage(\n          DEFAULT_ERROR_MESSAGES.TYPE,\n          this.acceptedTypes.join(\", \"),\n          typeof value\n        );\n      return unbound(value, ...args);\n    }.bind(this);\n  }\n\n  /**\n   * @description Validates a value against specific validation rules\n   * @summary Abstract method that must be implemented by all validator subclasses.\n   * This method contains the core validation logic that determines whether a value\n   * is valid according to the specific rules of the validator. If the value is valid,\n   * the method returns undefined; otherwise, it returns an error message.\n   *\n   * @template V - Type of the options object that can be passed to the validator\n   * @param {any} value - The value to validate\n   * @param {V} [options] - Optional configuration options for customizing validation behavior\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @abstract\n   *\n   * @see Model#validate\n   */\n  public abstract hasErrors(\n    value: any,\n    options?: V,\n    instanceObj?: any\n  ): string | undefined;\n\n  /**\n   * @summary Duck typing for Validators\n   * @param val\n   */\n  static isValidator(val: any): boolean {\n    return val.constructor && !!val[\"hasErrors\"];\n  }\n}\n"]}

package/lib/esm/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
  *

package/lib/esm/validation/Validators/ValidatorRegistry.js

@@ -1,11 +1,4 @@
-/**
- * @summary Duck typing for Validators
- * @function isValidator
- * @param val
- */
-export function isValidator(val) {
-    return val.constructor && val["hasErrors"];
-}
+import { Validator } from "./Validator";
 /**
  * @summary Base Implementation of a Validator Registry
  *
@@ -44,7 +37,7 @@ export class ValidatorRegistry {
         if (!(validatorKey in this.cache))
             return undefined;
         const classOrInstance = this.cache[validatorKey];
-        if (isValidator(classOrInstance))
+        if (Validator.isValidator(classOrInstance))
             return classOrInstance;
         const constructor = classOrInstance.default || classOrInstance;
         const instance = new constructor();
@@ -58,7 +51,7 @@ export class ValidatorRegistry {
      */
     register(...validator) {
         validator.forEach((v) => {
-            if (isValidator(v)) {
+            if (Validator.isValidator(v)) {
                 // const k =
                 if (v.validationKey in this.cache)
                     return;
@@ -78,4 +71,4 @@ export class ValidatorRegistry {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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