@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
117 lines • 15.6 kB
JavaScript
import { DEFAULT_ERROR_MESSAGES } from "./constants.js";
import { sf } from "./../../utils/strings.js";
import { Reflection } from "@decaf-ts/reflection";
/**
* @description Abstract base class for all validators in the validation framework.
* @summary The BaseValidator class provides the foundation for all synchronous and asynchronous validator implementations.
* It handles type checking, error message formatting, and defines the interface that all validators must implement.
* This class is designed to be extended by specific validator classes that define their own validation logic.
*
* @template V - Validator options type
* @template IsAsync - Whether the validator is async (true) or sync (false). Default `false`.
*
* @param {boolean} async - Defines if the validator is async (must match the subclass signature)
* @param {string} message - Default error message to display when validation fails (defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT})
* @param {string[]} acceptedTypes - Type names that this validator accepts (used for runtime type checking)
*
* @class BaseValidator
* @abstract
*
* @example
* // Example of a synchronous validator
* class SyncValidator extends BaseValidator<SomeOptions, false> {
* constructor() {
* super(false, "Sync validation failed", String.name);
* }
*
* public hasErrors(value: any, options?: SomeOptions): string | undefined {
* if (typeof value !== "string") return this.getMessage(this.message);
* return undefined;
* }
* }
*
* @example
* // Example of an asynchronous custom validator
* class AsyncValidator extends BaseValidator<SomeOptions, true> {
* constructor() {
* super(true, "Async validation failed", String.name);
* }
*
* public async hasErrors(value: any, options?: SomeOptions): Promise<string | undefined> {
* const result = await someAsyncCheck(value);
* if (!result) return this.getMessage(this.message);
* return undefined;
* }
* }
*
* @mermaid
* sequenceDiagram
* participant C as Client
* participant V as Validator Subclass
* participant B as BaseValidator
*
* C->>V: new CustomValidator(async, message)
* V->>B: super(async, message, acceptedTypes)
* B->>B: Store message, async flag, and accepted types
* B->>B: Optionally 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 BaseValidator {
constructor(async, message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
this.async = async;
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 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, options, proxy, ...args) {
if (value === undefined || !this.acceptedTypes)
return unbound(value, options, proxy, ...args);
if (!Reflection.checkTypes(value, this.acceptedTypes))
return this.getMessage(DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
return unbound(value, options, proxy, ...args);
}.bind(this);
}
/**
* @summary Duck typing for Validators
* @param val
*/
static isValidator(val) {
return val.constructor && !!val["hasErrors"];
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BaseValidator.js","sourceRoot":"","sources":["../../../../src/validation/Validators/BaseValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,uBAAoB;AACrD,OAAO,EAAE,EAAE,EAAE,iCAA4B;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAKlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,OAAgB,aAAa;IAQjC,YACE,KAAY,EACZ,UAAkB,sBAAsB,CAAC,OAAO,EAChD,GAAG,aAAuB;QAE1B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,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,CACzC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAQ,CAC1B,CAAC;IACb,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,OAKgD;QAEhD,OAAO,UAEL,KAAU,EACV,OAAU,EACV,KAAsB,EACtB,GAAG,IAAW;YAEd,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa;gBAC5C,OAAO,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;YACjD,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,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;QACjD,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\";\nimport type { PathProxy } from \"../../utils\";\nimport type { ConditionalAsync } from \"../../types\";\n\n/**\n * @description Abstract base class for all validators in the validation framework.\n * @summary The BaseValidator class provides the foundation for all synchronous and asynchronous validator implementations.\n * It handles type checking, error message formatting, and defines the interface that all validators must implement.\n * This class is designed to be extended by specific validator classes that define their own validation logic.\n *\n * @template V - Validator options type\n * @template IsAsync - Whether the validator is async (true) or sync (false). Default `false`.\n *\n * @param {boolean} async - Defines if the validator is async (must match the subclass signature)\n * @param {string} message - Default error message to display when validation fails (defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT})\n * @param {string[]} acceptedTypes - Type names that this validator accepts (used for runtime type checking)\n *\n * @class BaseValidator\n * @abstract\n *\n * @example\n * // Example of a synchronous validator\n * class SyncValidator extends BaseValidator<SomeOptions, false> {\n *   constructor() {\n *     super(false, \"Sync validation failed\", String.name);\n *   }\n *\n *   public hasErrors(value: any, options?: SomeOptions): string | undefined {\n *     if (typeof value !== \"string\") return this.getMessage(this.message);\n *     return undefined;\n *   }\n * }\n *\n * @example\n * // Example of an asynchronous custom validator\n * class AsyncValidator extends BaseValidator<SomeOptions, true> {\n *   constructor() {\n *     super(true, \"Async validation failed\", String.name);\n *   }\n *\n *   public async hasErrors(value: any, options?: SomeOptions): Promise<string | undefined> {\n *     const result = await someAsyncCheck(value);\n *     if (!result) return this.getMessage(this.message);\n *     return undefined;\n *   }\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as Validator Subclass\n *   participant B as BaseValidator\n *\n *   C->>V: new CustomValidator(async, message)\n *   V->>B: super(async, message, acceptedTypes)\n *   B->>B: Store message, async flag, and accepted types\n *   B->>B: Optionally 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 BaseValidator<\n  V extends ValidatorOptions = ValidatorOptions,\n  Async extends boolean = false,\n> {\n  readonly message: string;\n  readonly acceptedTypes?: string[];\n  readonly async?: Async;\n\n  protected constructor(\n    async: Async,\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    this.async = async;\n    this.message = message;\n\n    if (acceptedTypes.length) this.acceptedTypes = acceptedTypes;\n    if (this.acceptedTypes)\n      this.hasErrors = this.checkTypeAndHasErrors(\n        this.hasErrors.bind(this) as any\n      ) as any;\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: (\n      value: any,\n      options?: V,\n      proxy?: PathProxy<any>,\n      ...args: any[]\n    ) => ConditionalAsync<Async, string | undefined>\n  ) {\n    return function (\n      this: BaseValidator,\n      value: any,\n      options: V,\n      proxy?: PathProxy<any>,\n      ...args: any[]\n    ) {\n      if (value === undefined || !this.acceptedTypes)\n        return unbound(value, options, proxy, ...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, options, proxy, ...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  ): ConditionalAsync<Async, 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"]}