@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
109 lines • 13.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Validator = void 0;
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.
*
* @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
*/
class Validator {
constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
this.message = message;
if (acceptedTypes.length)
this.acceptedTypes = acceptedTypes;
if (this.acceptedTypes)
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
* @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
* @private
*/
checkTypeAndHasErrors(unbound) {
return function (value, ...args) {
if (value === undefined || !this.acceptedTypes)
return unbound(value, ...args);
if (!reflection_1.Reflection.checkTypes(value, this.acceptedTypes))
return this.getMessage(constants_1.DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
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,+CAAqD;AACrD,uDAAyC;AACzC,qDAAkD;AAIlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;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;AA1FD,8BA0FC","sourcesContent":["import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { sf } from \"../../utils/strings\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidatorOptions } from \"../types\";\nimport type { PathProxy } from \"../../utils\";\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   * @param {PathProxy<any>} proxy -\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    proxy?: PathProxy<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"]}