@decaf-ts/decorator-validation 1.6.2 → 1.6.4

package/lib/validation/Validators/URLValidator.cjs

@@ -14,43 +14,12 @@ const constants_1 = require("./constants.cjs");
 const PatternValidator_1 = require("./PatternValidator.cjs");
 const decorators_1 = require("./decorators.cjs");
 /**
- * @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}
+ * @summary URL Validator
+ * @description Pattern from {@link https://gist.github.com/dperini/729294}
  *
  * @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_1.PatternValidator {
@@ -58,19 +27,16 @@ let URLValidator = class URLValidator extends PatternValidator_1.PatternValidato
         super(message);
     }
     /**
-     * @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.
+     * @summary Validates a model
      *
-     * @param {string} value - The string to validate as a URL
-     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
+     * @param {string} value
+     * @param {PatternValidatorOptions} [options={}]
      *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     * @return {string | undefined}
      *
      * @override
      *
-     * @see PatternValidator#hasErrors
+     * @see Validator#hasErrors
      */
     hasErrors(value, options = {}) {
         return super.hasErrors(value, {
@@ -84,4 +50,4 @@ exports.URLValidator = URLValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.URL),
     __metadata("design:paramtypes", [String])
 ], URLValidator);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,61 +1,27 @@
 import { PatternValidator } from "./PatternValidator";
 import { PatternValidatorOptions } from "../types";
 /**
- * @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}
+ * @summary URL Validator
+ * @description Pattern from {@link https://gist.github.com/dperini/729294}
  *
  * @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
  */
 export declare class URLValidator extends PatternValidator {
     constructor(message?: string);
     /**
-     * @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.
+     * @summary Validates a model
      *
-     * @param {string} value - The string to validate as a URL
-     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
+     * @param {string} value
+     * @param {PatternValidatorOptions} [options={}]
      *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     * @return {string | undefined}
      *
      * @override
      *
-     * @see PatternValidator#hasErrors
+     * @see Validator#hasErrors
      */
     hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
 }

package/lib/validation/Validators/Validator.cjs

@@ -5,55 +5,15 @@ const constants_1 = require("./constants.cjs");
 const strings_1 = require("../../utils/strings.cjs");
 const reflection_1 = require("@decaf-ts/reflection");
 /**
- * @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.
+ * @summary Base Implementation for Validators
+ * @description Provides the underlying functionality for {@link Validator}s
  *
- * @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
+ * @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
  *
  * @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
  */
 class Validator {
@@ -65,27 +25,17 @@ class Validator {
             this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
     }
     /**
-     * @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
+     * @summary builds the error message
+     * @param {string} message
+     * @param {any[]} args
      * @protected
      */
     getMessage(message, ...args) {
         return (0, strings_1.sf)(message, ...args);
     }
     /**
-     * @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
+     * @summary Validates type
+     * @param {any} unbound
      * @private
      */
     checkTypeAndHasErrors(unbound) {
@@ -97,13 +47,6 @@ class Validator {
             return unbound(value, ...args);
         }.bind(this);
     }
-    /**
-     * @summary Duck typing for Validators
-     * @param val
-     */
-    static isValidator(val) {
-        return val.constructor && !!val["hasErrors"];
-    }
 }
 exports.Validator = Validator;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../../../src/validation/Validators/Validator.ts"],"names":[],"mappings":";;;AAAA,2CAAqD;AACrD,iDAAyC;AACzC,qDAAkD;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAsB,SAAS;IAI7B,YACE,UAAkB,kCAAsB,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,IAAA,YAAE,EAAC,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,uBAAU,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC;gBACnD,OAAO,IAAI,CAAC,UAAU,CACpB,kCAAsB,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;IAqBD;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,GAAQ;QACzB,OAAO,GAAG,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC;CACF;AAtFD,8BAsFC","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(value: any, options?: V): 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"]}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,54 +1,14 @@
 import { ValidatorOptions } from "../types";
 /**
- * @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.
+ * @summary Base Implementation for Validators
+ * @description Provides the underlying functionality for {@link Validator}s
  *
- * @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
+ * @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
  *
  * @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> {
@@ -56,49 +16,29 @@ export declare abstract class Validator<V extends ValidatorOptions = ValidatorOp
     readonly acceptedTypes?: string[];
     protected constructor(message?: string, ...acceptedTypes: string[]);
     /**
-     * @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
+     * @summary builds the error message
+     * @param {string} message
+     * @param {any[]} args
      * @protected
      */
     protected getMessage(message: string, ...args: any[]): string;
     /**
-     * @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
+     * @summary Validates type
+     * @param {any} unbound
      * @private
      */
     private checkTypeAndHasErrors;
     /**
-     * @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
+     * @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.
      *
-     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     * @returns An error message string if validation fails; otherwise, `undefined`.
      *
      * @abstract
      *
-     * @see Model#validate
-     */
-    abstract hasErrors(value: any, options?: V): string | undefined;
-    /**
-     * @summary Duck typing for Validators
-     * @param val
+     * @see Model#hasErrors
      */
-    static isValidator(val: any): boolean;
+    abstract hasErrors(value: any, options?: V, instanceObj?: any): string | undefined;
 }

package/lib/validation/Validators/ValidatorRegistry.cjs

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

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

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

package/lib/validation/Validators/constants.cjs

@@ -1,7 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PATTERNS = exports.DEFAULT_ERROR_MESSAGES = exports.DAYS_OF_WEEK_NAMES = exports.MONTH_NAMES = exports.ValidationKeys = void 0;
+exports.DEFAULT_PATTERNS = exports.COMPARISON_ERROR_MESSAGES = exports.DEFAULT_ERROR_MESSAGES = exports.DAYS_OF_WEEK_NAMES = exports.MONTH_NAMES = exports.ValidationKeys = exports.ComparisonValidationKeys = void 0;
 const constants_1 = require("../../utils/constants.cjs");
+/**
+ * @summary Keys used for comparison-based validations.
+ *
+ * @property {string} EQUALS - Validates if two values are equal.
+ * @property {string} DIFF - Validates if two values are different.
+ * @property {string} LESS_THAN - Validates if a value is less than another.
+ * @property {string} LESS_THAN_OR_EQUAL - Validates if a value is less than or equal to another.
+ * @property {string} GREATER_THAN - Validates if a value is greater than another.
+ * @property {string} GREATER_THAN_OR_EQUAL - Validates if a value is greater than or equal to another.
+ *
+ * @constant ComparisonValidationKeys
+ * @memberof module:decorator-validation.Validation
+ * @category Validation
+ */
+exports.ComparisonValidationKeys = {
+    EQUALS: "equals",
+    DIFF: "different",
+    LESS_THAN: "lessThan",
+    LESS_THAN_OR_EQUAL: "lessThanOrEqual",
+    GREATER_THAN: "greaterThan",
+    GREATER_THAN_OR_EQUAL: "greaterThanOrEqual",
+};
 /**
  * @summary The keys used for validation
  *
@@ -41,6 +63,7 @@ exports.ValidationKeys = {
     PASSWORD: "password",
     LIST: "list",
     FORMAT: "format",
+    ...exports.ComparisonValidationKeys,
 };
 /**
  * @summary list of month names
@@ -121,6 +144,25 @@ exports.DEFAULT_ERROR_MESSAGES = {
     PASSWORD: "Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)",
     LIST: "Invalid list of {0}",
     MODEL_NOT_FOUND: "No model registered under {0}",
+    EQUALS: "This field must be equal to field {0}",
+    DIFF: "This field must be different from field {0}",
+    LESS_THAN: "This field must be less than field {0}",
+    LESS_THAN_OR_EQUAL: "This field must be less than or equal to field {0}",
+    GREATER_THAN: "This field must be greater than field {0}",
+    GREATER_THAN_OR_EQUAL: "This field must be greater than or equal to field {0}",
+};
+exports.COMPARISON_ERROR_MESSAGES = {
+    INVALID_PATH: "Invalid path argument. Expected non-empty string but received: '{0}'",
+    CONTEXT_NOT_OBJECT_COMPARISON: "Unable to access parent at level {0} for path '{1}': current context is not an object",
+    NO_PARENT_COMPARISON: "Unable to access parent at level {0} for path '{1}': no parent available",
+    PROPERTY_NOT_FOUND: "Failed to resolve path {0}: property '{1}' does not exist.",
+    PROPERTY_NOT_FOUND_ON_PARENT: "Failed to resolve path {0}: property '{1}' does not exist on parent.",
+    PROPERTY_NOT_FOUND_AFTER_PARENT: "Failed to resolve path {0}: property '{1}' does not exist after {2} parent level(s).",
+    UNSUPPORTED_TYPES_COMPARISON: "Unsupported types for comparison: '{0}' and '{1}'",
+    NULL_OR_UNDEFINED_COMPARISON: "Comparison failed due to null or undefined value",
+    INVALID_DATE_COMPARISON: "Invalid Date objects are not comparable",
+    TYPE_MISMATCH_COMPARISON: "Cannot compare values of different types: {0} and {1}.",
+    NAN_COMPARISON: "Comparison not supported for NaN values",
 };
 /**
  * @summary Defines the various default regexp patterns used
@@ -136,4 +178,4 @@ exports.DEFAULT_PATTERNS = {
         CHAR8_ONE_OF_EACH: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&_\-.,])[A-Za-z\d@$!%*?&_\-.,]{8,}$/g,
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/validation/Validators/constants.ts"],"names":[],"mappings":";;;AAAA,qDAAkD;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACU,QAAA,cAAc,GAAG;IAC5B,OAAO,EAAE,GAAG,qBAAS,CAAC,OAAO,aAAa;IAC1C,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE,WAAW;IACvB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;CACR,CAAC;AAEX;;;;;;;GAOG;AACU,QAAA,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;;GAOG;AACU,QAAA,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;CACjD,CAAC;AAEF;;;;;;GAMG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;CACF,CAAC","sourcesContent":["import { ModelKeys } from \"../../utils/constants\";\n\n/**\n * @summary The keys used for validation\n *\n * @property {string} REFLECT prefixes others\n * @property {string} REQUIRED sets as required\n * @property {string} MIN defines min value\n * @property {string} MAX defines max value\n * @property {string} STEP defines step\n * @property {string} MIN_LENGTH defines min length\n * @property {string} MAX_LENGTH defines max length\n * @property {string} PATTERN defines pattern\n * @property {string} EMAIL defines email\n * @property {string} URL defines url\n * @property {string} DATE defines date\n * @property {string} TYPE defines type\n * @property {string} PASSWORD defines password\n * @property {string} LIST defines list\n *\n * @constant ValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const ValidationKeys = {\n  REFLECT: `${ModelKeys.REFLECT}validation.`,\n  VALIDATOR: \"validator\",\n  REQUIRED: \"required\",\n  MIN: \"min\",\n  MAX: \"max\",\n  STEP: \"step\",\n  MIN_LENGTH: \"minlength\",\n  MAX_LENGTH: \"maxlength\",\n  PATTERN: \"pattern\",\n  EMAIL: \"email\",\n  URL: \"url\",\n  DATE: \"date\",\n  TYPE: \"type\",\n  PASSWORD: \"password\",\n  LIST: \"list\",\n  FORMAT: \"format\",\n} as const;\n\n/**\n * @summary list of month names\n * @description Stores month names. Can be changed for localization purposes\n *\n * @constant MONTH_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const MONTH_NAMES = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\n/**\n * @summary list of names of days of the week\n * @description Stores names for days of the week. Can be changed for localization purposes\n *\n * @constant DAYS_OF_WEEK_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DAYS_OF_WEEK_NAMES = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\n/**\n * @summary Defines the default error messages\n *\n * @property {string} REQUIRED default error message\n * @property {string} MIN default error message\n * @property {string} MAX default error message\n * @property {string} MIN_LENGTH default error message\n * @property {string} MAX_LENGTH default error message\n * @property {string} PATTERN default error message\n * @property {string} EMAIL default error message\n * @property {string} URL default error message\n * @property {string} TYPE default error message\n * @property {string} STEP default error message\n * @property {string} DATE default error message\n * @property {string} DEFAULT default error message\n * @property {string} PASSWORD default error message\n * @property {string} LIST default error message\n * @property {string} LIST_INSIDE default error message\n * @property {string} MODEL_NOT_FOUND default error message\n *\n * @constant DEFAULT_ERROR_MESSAGES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_ERROR_MESSAGES: Record<string, string> = {\n  REQUIRED: \"This field is required\",\n  MIN: \"The minimum value is {0}\",\n  MAX: \"The maximum value is {0}\",\n  MIN_LENGTH: \"The minimum length is {0}\",\n  MAX_LENGTH: \"The maximum length is {0}\",\n  PATTERN: \"The value does not match the pattern\",\n  EMAIL: \"The value is not a valid email\",\n  URL: \"The value is not a valid URL\",\n  TYPE: \"Invalid type. Expected {0}, received {1}\",\n  STEP: \"Invalid value. Not a step of {0}\",\n  DATE: \"Invalid value. not a valid Date\",\n  DEFAULT: \"There is an Error\",\n  PASSWORD:\n    \"Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)\",\n  LIST: \"Invalid list of {0}\",\n  MODEL_NOT_FOUND: \"No model registered under {0}\",\n};\n\n/**\n * @summary Defines the various default regexp patterns used\n *\n * @enum DEFAULT_PATTERNS\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_PATTERNS = {\n  EMAIL:\n    /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,\n  URL: /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i,\n  PASSWORD: {\n    CHAR8_ONE_OF_EACH:\n      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&_\\-.,])[A-Za-z\\d@$!%*?&_\\-.,]{8,}$/g,\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/validation/Validators/constants.ts"],"names":[],"mappings":";;;AAAA,qDAAkD;AAElD;;;;;;;;;;;;;GAaG;AACU,QAAA,wBAAwB,GAAG;IACtC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,UAAU;IACrB,kBAAkB,EAAE,iBAAiB;IACrC,YAAY,EAAE,aAAa;IAC3B,qBAAqB,EAAE,oBAAoB;CACnC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AACU,QAAA,cAAc,GAAG;IAC5B,OAAO,EAAE,GAAG,qBAAS,CAAC,OAAO,aAAa;IAC1C,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE,WAAW;IACvB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,GAAG,gCAAwB;CACnB,CAAC;AAEX;;;;;;;GAOG;AACU,QAAA,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;;GAOG;AACU,QAAA,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACU,QAAA,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;IAChD,MAAM,EAAE,uCAAuC;IAC/C,IAAI,EAAE,6CAA6C;IACnD,SAAS,EAAE,wCAAwC;IACnD,kBAAkB,EAAE,oDAAoD;IACxE,YAAY,EAAE,2CAA2C;IACzD,qBAAqB,EACnB,uDAAuD;CAC1D,CAAC;AAEW,QAAA,yBAAyB,GAAG;IACvC,YAAY,EACV,sEAAsE;IACxE,6BAA6B,EAC3B,uFAAuF;IACzF,oBAAoB,EAClB,0EAA0E;IAC5E,kBAAkB,EAChB,4DAA4D;IAC9D,4BAA4B,EAC1B,sEAAsE;IACxE,+BAA+B,EAC7B,sFAAsF;IACxF,4BAA4B,EAC1B,mDAAmD;IACrD,4BAA4B,EAC1B,kDAAkD;IACpD,uBAAuB,EAAE,yCAAyC;IAClE,wBAAwB,EACtB,wDAAwD;IAC1D,cAAc,EAAE,yCAAyC;CAC1D,CAAC;AAEF;;;;;;GAMG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;CACF,CAAC","sourcesContent":["import { ModelKeys } from \"../../utils/constants\";\n\n/**\n * @summary Keys used for comparison-based validations.\n *\n * @property {string} EQUALS - Validates if two values are equal.\n * @property {string} DIFF - Validates if two values are different.\n * @property {string} LESS_THAN - Validates if a value is less than another.\n * @property {string} LESS_THAN_OR_EQUAL - Validates if a value is less than or equal to another.\n * @property {string} GREATER_THAN - Validates if a value is greater than another.\n * @property {string} GREATER_THAN_OR_EQUAL - Validates if a value is greater than or equal to another.\n *\n * @constant ComparisonValidationKeys\n * @memberof module:decorator-validation.Validation\n * @category Validation\n */\nexport const ComparisonValidationKeys = {\n  EQUALS: \"equals\",\n  DIFF: \"different\",\n  LESS_THAN: \"lessThan\",\n  LESS_THAN_OR_EQUAL: \"lessThanOrEqual\",\n  GREATER_THAN: \"greaterThan\",\n  GREATER_THAN_OR_EQUAL: \"greaterThanOrEqual\",\n} as const;\n\n/**\n * @summary The keys used for validation\n *\n * @property {string} REFLECT prefixes others\n * @property {string} REQUIRED sets as required\n * @property {string} MIN defines min value\n * @property {string} MAX defines max value\n * @property {string} STEP defines step\n * @property {string} MIN_LENGTH defines min length\n * @property {string} MAX_LENGTH defines max length\n * @property {string} PATTERN defines pattern\n * @property {string} EMAIL defines email\n * @property {string} URL defines url\n * @property {string} DATE defines date\n * @property {string} TYPE defines type\n * @property {string} PASSWORD defines password\n * @property {string} LIST defines list\n *\n * @constant ValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const ValidationKeys = {\n  REFLECT: `${ModelKeys.REFLECT}validation.`,\n  VALIDATOR: \"validator\",\n  REQUIRED: \"required\",\n  MIN: \"min\",\n  MAX: \"max\",\n  STEP: \"step\",\n  MIN_LENGTH: \"minlength\",\n  MAX_LENGTH: \"maxlength\",\n  PATTERN: \"pattern\",\n  EMAIL: \"email\",\n  URL: \"url\",\n  DATE: \"date\",\n  TYPE: \"type\",\n  PASSWORD: \"password\",\n  LIST: \"list\",\n  FORMAT: \"format\",\n  ...ComparisonValidationKeys,\n} as const;\n\n/**\n * @summary list of month names\n * @description Stores month names. Can be changed for localization purposes\n *\n * @constant MONTH_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const MONTH_NAMES = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\n/**\n * @summary list of names of days of the week\n * @description Stores names for days of the week. Can be changed for localization purposes\n *\n * @constant DAYS_OF_WEEK_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DAYS_OF_WEEK_NAMES = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\n/**\n * @summary Defines the default error messages\n *\n * @property {string} REQUIRED default error message\n * @property {string} MIN default error message\n * @property {string} MAX default error message\n * @property {string} MIN_LENGTH default error message\n * @property {string} MAX_LENGTH default error message\n * @property {string} PATTERN default error message\n * @property {string} EMAIL default error message\n * @property {string} URL default error message\n * @property {string} TYPE default error message\n * @property {string} STEP default error message\n * @property {string} DATE default error message\n * @property {string} DEFAULT default error message\n * @property {string} PASSWORD default error message\n * @property {string} LIST default error message\n * @property {string} LIST_INSIDE default error message\n * @property {string} MODEL_NOT_FOUND default error message\n *\n * @constant DEFAULT_ERROR_MESSAGES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_ERROR_MESSAGES: Record<string, string> = {\n  REQUIRED: \"This field is required\",\n  MIN: \"The minimum value is {0}\",\n  MAX: \"The maximum value is {0}\",\n  MIN_LENGTH: \"The minimum length is {0}\",\n  MAX_LENGTH: \"The maximum length is {0}\",\n  PATTERN: \"The value does not match the pattern\",\n  EMAIL: \"The value is not a valid email\",\n  URL: \"The value is not a valid URL\",\n  TYPE: \"Invalid type. Expected {0}, received {1}\",\n  STEP: \"Invalid value. Not a step of {0}\",\n  DATE: \"Invalid value. not a valid Date\",\n  DEFAULT: \"There is an Error\",\n  PASSWORD:\n    \"Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)\",\n  LIST: \"Invalid list of {0}\",\n  MODEL_NOT_FOUND: \"No model registered under {0}\",\n  EQUALS: \"This field must be equal to field {0}\",\n  DIFF: \"This field must be different from field {0}\",\n  LESS_THAN: \"This field must be less than field {0}\",\n  LESS_THAN_OR_EQUAL: \"This field must be less than or equal to field {0}\",\n  GREATER_THAN: \"This field must be greater than field {0}\",\n  GREATER_THAN_OR_EQUAL:\n    \"This field must be greater than or equal to field {0}\",\n};\n\nexport const COMPARISON_ERROR_MESSAGES = {\n  INVALID_PATH:\n    \"Invalid path argument. Expected non-empty string but received: '{0}'\",\n  CONTEXT_NOT_OBJECT_COMPARISON:\n    \"Unable to access parent at level {0} for path '{1}': current context is not an object\",\n  NO_PARENT_COMPARISON:\n    \"Unable to access parent at level {0} for path '{1}': no parent available\",\n  PROPERTY_NOT_FOUND:\n    \"Failed to resolve path {0}: property '{1}' does not exist.\",\n  PROPERTY_NOT_FOUND_ON_PARENT:\n    \"Failed to resolve path {0}: property '{1}' does not exist on parent.\",\n  PROPERTY_NOT_FOUND_AFTER_PARENT:\n    \"Failed to resolve path {0}: property '{1}' does not exist after {2} parent level(s).\",\n  UNSUPPORTED_TYPES_COMPARISON:\n    \"Unsupported types for comparison: '{0}' and '{1}'\",\n  NULL_OR_UNDEFINED_COMPARISON:\n    \"Comparison failed due to null or undefined value\",\n  INVALID_DATE_COMPARISON: \"Invalid Date objects are not comparable\",\n  TYPE_MISMATCH_COMPARISON:\n    \"Cannot compare values of different types: {0} and {1}.\",\n  NAN_COMPARISON: \"Comparison not supported for NaN values\",\n};\n\n/**\n * @summary Defines the various default regexp patterns used\n *\n * @enum DEFAULT_PATTERNS\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_PATTERNS = {\n  EMAIL:\n    /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,\n  URL: /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i,\n  PASSWORD: {\n    CHAR8_ONE_OF_EACH:\n      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&_\\-.,])[A-Za-z\\d@$!%*?&_\\-.,]{8,}$/g,\n  },\n};\n"]}