@decaf-ts/decorator-validation 1.7.7 → 1.7.8

package/lib/model/validation.d.ts

@@ -1,14 +1,116 @@
 import { ModelErrorDefinition } from "./ModelErrorDefinition";
 import { Model } from "./Model";
+import { ValidationPropertyDecoratorDefinition } from "../validation";
+import { ConditionalAsync, DecoratorMetadataAsync } from "../types";
 /**
- * @summary Analyses the decorations of the properties and validates the obj according to them
+ * Retrieves the validation metadata decorators associated with a specific property of a model,
+ * using the reflective metadata key.
  *
- * @typedef M extends Model
- * @prop {M} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ * @param model - The model instance or class containing the decorated property.
+ * @param {string} prop - The name of the property whose decorators should be retrieved.
+ * @param {string} reflectKey - The metadata key used to retrieve the decorators.
+ *                     Defaults to `ValidationKeys.REFLECT`.
  *
+ * @returns The validation decorators applied to the property
+ */
+export declare function getValidationDecorators(model: Record<string, any>, prop: string, reflectKey?: string): ValidationPropertyDecoratorDefinition;
+/**
+ * @description
+ * Retrieves all validatable property decorators from a given model, excluding specified properties.
+ *
+ * @summary
+ * Iterates through the own enumerable properties of a model instance, filtering out any properties
+ * listed in the `propsToIgnore` array. For each remaining property, it checks whether validation
+ * decorators are present using `getValidationDecorators`, and if so, collects them in the result array.
+ *
+ * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
+ *
+ * @param {M} model - An instance of a class extending `Model` from which validatable properties will be extracted.
+ * @param {string[]} propsToIgnore - An array of property names that should be excluded from validation inspection.
+ *
+ * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions
+ * associated with the model's properties, excluding those listed in `propsToIgnore`.
+ *
+ * @function getValidatableProperties
+ */
+export declare function getValidatableProperties<M extends Model>(model: M, propsToIgnore: string[]): ValidationPropertyDecoratorDefinition[];
+export declare function validateDecorator<M extends Model, Async extends boolean = false>(model: M, value: any, decorator: DecoratorMetadataAsync, async?: Async): ConditionalAsync<Async, string | undefined>;
+/**
+ * @description
+ * Executes validation logic for a set of decorators applied to a model's property, handling both
+ * synchronous and asynchronous validations, including support for nested validations and lists.
+ *
+ * @summary
+ * Iterates over an array of decorator metadata objects and applies each validation rule to the
+ * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,
+ * supporting nested model validation and type checks. If the `async` flag is set, asynchronous
+ * validation is supported using `Promise.all`. The result is a record mapping validation keys to
+ * error messages, or `undefined` if no errors are found.
+ *
+ * @template M - A type parameter extending `Model`, representing the model type being validated.
+ * @template Async - A boolean indicating whether validation should be performed asynchronously.
+ *
+ * @param {M} model - The model instance that the validation is associated with.
+ * @param {any} value - The value to be validated against the provided decorators.
+ * @param {DecoratorMetadataAsync[]} decorators - An array of metadata objects representing validation decorators.
+ * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.
+ *
+ * @return {ConditionalAsync<Async, Record<string, string>> | undefined}
+ * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.
+ * If `async` is true, the return value is a Promise resolving to the same structure.
+ *
+ * @function validateDecorators
+ */
+export declare function validateDecorators<M extends Model, Async extends boolean = false>(model: M, value: any, decorators: DecoratorMetadataAsync[], async?: Async): ConditionalAsync<Async, Record<string, string> | undefined>;
+/**
  * @function validate
+ * @template M
+ * @template Async
  * @memberOf module:decorator-validation
  * @category Model
+ *
+ * @description
+ * Validates the properties of a {@link Model} instance using registered decorators.
+ * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.
+ *
+ * @summary
+ * This function inspects a given model object, identifies decorated properties that require validation,
+ * and applies the corresponding validation rules. It also supports nested model validation and gracefully
+ * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator
+ * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten
+ * the nested error keys using dot notation.
+ *
+ * @param {M} model - The model instance to be validated. Must extend from {@link Model}.
+ * @param {Async} [async] - A flag indicating whether validation should be asynchronous.
+ * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.
+ *
+ * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}
+ * Returns either a {@link ModelErrorDefinition} containing validation errors,
+ * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.
+ *
+ * @see {@link Model}
+ * @see {@link ModelErrorDefinition}
+ * @see {@link validateDecorators}
+ * @see {@link getValidatableProperties}
+ *
+ * @mermaid
+ * sequenceDiagram
+ *     participant Caller
+ *     participant validate
+ *     participant getValidatableProperties
+ *     participant validateDecorators
+ *     participant ModelInstance
+ *     Caller->>validate: call with obj, async, propsToIgnore
+ *     validate->>getValidatableProperties: retrieve decorated props
+ *     loop for each property
+ *         validate->>validateDecorators: validate using decorators
+ *         alt is nested model
+ *             validate->>ModelInstance: call hasErrors()
+ *         end
+ *     end
+ *     alt async
+ *         validate->>validate: Promise.allSettled for errors
+ *     end
+ *     validate-->>Caller: return ModelErrorDefinition | undefined
  */
-export declare function validate<M extends Model>(obj: M, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+export declare function validate<M extends Model<boolean>, Async extends boolean = false>(model: M, async: Async, ...propsToIgnore: string[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;

package/lib/types/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./validation.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3ZhbGlkYXRpb25cIjtcbiJdfQ==

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./validation";

package/lib/types/validation.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy92YWxpZGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEZWNvcmF0b3JNZXRhZGF0YSB9IGZyb20gXCJAZGVjYWYtdHMvcmVmbGVjdGlvblwiO1xuaW1wb3J0IHsgTW9kZWwsIE1vZGVsRXJyb3JEZWZpbml0aW9uIH0gZnJvbSBcIi4uL21vZGVsXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIENvbmRpdGlvbmFsbHkgd3JhcHMgYSB0eXBlIGluIGEgYFByb21pc2VgIGJhc2VkIG9uIHRoZSBgQXN5bmNgIGZsYWcuXG4gKiBAc3VtbWFyeSBVdGlsaXR5IHR5cGUgdGhhdCByZXNvbHZlcyB0byBgVGAgaWYgYEFzeW5jYCBpcyBgZmFsc2VgLCBvciB0byBgUHJvbWlzZTxUPmAgaWYgYEFzeW5jYCBpcyBgdHJ1ZWAuXG4gKiBVc2VkIHRvIGFic3RyYWN0IHRoZSByZXR1cm4gdHlwZSBvZiBmdW5jdGlvbnMgdGhhdCBtYXkgYmUgZWl0aGVyIHN5bmNocm9ub3VzIG9yIGFzeW5jaHJvbm91cyBkZXBlbmRpbmcgb24gYSBmbGFnLlxuICpcbiAqIEB0ZW1wbGF0ZSBBc3luYyBBIGJvb2xlYW4gZmxhZyBpbmRpY2F0aW5nIHdoZXRoZXIgdGhlIHJlc3VsdCBzaG91bGQgYmUgYXN5bmNocm9ub3VzIChgdHJ1ZWApIG9yIHN5bmNocm9ub3VzIChgZmFsc2VgKS5cbiAqIEB0ZW1wbGF0ZSBUIFRoZSBiYXNlIHR5cGUgdG8gcmV0dXJuIGRpcmVjdGx5IG9yIHRvIHdyYXAgaW4gYSBgUHJvbWlzZWAuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIC8vIFN5bmNocm9ub3VzIHJlc3VsdFxuICogdHlwZSBTeW5jUmVzdWx0OiBzdHJpbmcgfCBudW1iZXIgPSBDb25kaXRpb25hbEFzeW5jPGZhbHNlLCBzdHJpbmcgfCBudW1iZXI+O1xuICpcbiAqIC8vIEFzeW5jaHJvbm91cyByZXN1bHRcbiAqIHR5cGUgQXN5bmNSZXN1bHQ6IFByb21pc2U8c3RyaW5nIHwgbnVtYmVyPiA9IENvbmRpdGlvbmFsQXN5bmM8dHJ1ZSwgc3RyaW5nIHwgbnVtYmVyPjtcbiAqIGBgYFxuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0b3ItdmFsaWRhdGlvblxuICovXG5leHBvcnQgdHlwZSBDb25kaXRpb25hbEFzeW5jPEFzeW5jIGV4dGVuZHMgYm9vbGVhbiwgVD4gPSBBc3luYyBleHRlbmRzIHRydWVcbiAgPyBQcm9taXNlPFQ+XG4gIDogVDtcblxuZXhwb3J0IHR5cGUgRGVjb3JhdG9yTWV0YWRhdGFBc3luYyA9IERlY29yYXRvck1ldGFkYXRhICYgeyBhc3luYz86IGJvb2xlYW4gfTtcblxuZXhwb3J0IHR5cGUgTW9kZWxDb25kaXRpb25hbEFzeW5jPE0+ID1cbiAgTSBleHRlbmRzIE1vZGVsPHRydWU+XG4gICAgPyBQcm9taXNlPE1vZGVsRXJyb3JEZWZpbml0aW9uIHwgdW5kZWZpbmVkPlxuICAgIDogTW9kZWxFcnJvckRlZmluaXRpb24gfCB1bmRlZmluZWQ7XG4iXX0=

package/lib/types/validation.d.ts

@@ -0,0 +1,25 @@
+import { DecoratorMetadata } from "@decaf-ts/reflection";
+import { Model, ModelErrorDefinition } from "../model";
+/**
+ * @description Conditionally wraps a type in a `Promise` based on the `Async` flag.
+ * @summary Utility type that resolves to `T` if `Async` is `false`, or to `Promise<T>` if `Async` is `true`.
+ * Used to abstract the return type of functions that may be either synchronous or asynchronous depending on a flag.
+ *
+ * @template Async A boolean flag indicating whether the result should be asynchronous (`true`) or synchronous (`false`).
+ * @template T The base type to return directly or to wrap in a `Promise`.
+ *
+ * @example
+ * ```typescript
+ * // Synchronous result
+ * type SyncResult: string | number = ConditionalAsync<false, string | number>;
+ *
+ * // Asynchronous result
+ * type AsyncResult: Promise<string | number> = ConditionalAsync<true, string | number>;
+ * ```
+ * @memberOf module:decorator-validation
+ */
+export type ConditionalAsync<Async extends boolean, T> = Async extends true ? Promise<T> : T;
+export type DecoratorMetadataAsync = DecoratorMetadata & {
+    async?: boolean;
+};
+export type ModelConditionalAsync<M> = M extends Model<true> ? Promise<ModelErrorDefinition | undefined> : ModelErrorDefinition | undefined;

package/lib/validation/Validators/AsyncValidator.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncValidator = void 0;
+const BaseValidator_1 = require("./BaseValidator.cjs");
+const constants_1 = require("./constants.cjs");
+/**
+ * @description
+ * Abstract class for defining asynchronous validators.
+ *
+ * This class extends the base `Validator` and enforces that any implementation
+ * of `hasErrors` must be asynchronous, always returning a Promise.
+ *
+ * Use this when the validation process involves asynchronous operations,
+ * such as API calls, database lookups, or time-based checks (e.g., timeouts).
+ *
+ * @example
+ * ```typescript
+ * // Example of an asynchronous validator that compares value against a timeout
+ * class TimeoutValidator extends AsyncValidator<{ timeout?: number }> {
+ *   constructor(message: string = "Validation failed due to timeout") {
+ *     super(message);
+ *   }
+ *
+ *   async hasErrors(value: number, options?: { timeout?: number }) {
+ *     const delay = options?.timeout ?? 100;
+ *
+ *     // async call
+ *     await new Promise(res => setTimeout(res, delay));
+ *
+ *     if (value > delay) {
+ *       // Rejects the validation after waiting the delay if value is greater
+ *       return Promise.resolve(this.getMessage());
+ *     }
+ *
+ *     // Passes the validation after waiting the delay
+ *     return Promise.resolve(undefined);
+ *   }
+ * }
+ *
+ * // Example usage:
+ * const validator = new TimeoutValidator();
+ *
+ * async function runValidation() {
+ *  const error = await validator.hasErrors(50, { timeout: 100 });
+ *  if (error) {
+ *    return console.error('Validation error:', error);
+ *  }
+ *  console.log('Value is valid');
+ * }
+ *
+ * await runValidation();
+ * ```
+ *
+ * - If `value > timeout`, the validator waits for the delay and then rejects with an error.
+ * - If `value <= timeout`, the validator waits for the delay and resolves successfully with `undefined`.
+ *
+ * @see {@link Validator} For the base synchronous validator.
+ */
+class AsyncValidator extends BaseValidator_1.BaseValidator {
+    constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+        super(true, message, ...acceptedTypes);
+    }
+}
+exports.AsyncValidator = AsyncValidator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXN5bmNWYWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdmFsaWRhdGlvbi9WYWxpZGF0b3JzL0FzeW5jVmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLHVEQUFnRDtBQUNoRCwrQ0FBcUQ7QUFFckQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FvREc7QUFDSCxNQUFzQixjQUVwQixTQUFRLDZCQUFzQjtJQUM5QixZQUNFLFVBQWtCLGtDQUFzQixDQUFDLE9BQU8sRUFDaEQsR0FBRyxhQUF1QjtRQUUxQixLQUFLLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLGFBQWEsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7Q0FtQkY7QUEzQkQsd0NBMkJDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBWYWxpZGF0b3JPcHRpb25zIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgdHlwZSB7IFBhdGhQcm94eSB9IGZyb20gXCIuLi8uLi91dGlsc1wiO1xuaW1wb3J0IHsgQmFzZVZhbGlkYXRvciB9IGZyb20gXCIuL0Jhc2VWYWxpZGF0b3JcIjtcbmltcG9ydCB7IERFRkFVTFRfRVJST1JfTUVTU0FHRVMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb25cbiAqIEFic3RyYWN0IGNsYXNzIGZvciBkZWZpbmluZyBhc3luY2hyb25vdXMgdmFsaWRhdG9ycy5cbiAqXG4gKiBUaGlzIGNsYXNzIGV4dGVuZHMgdGhlIGJhc2UgYFZhbGlkYXRvcmAgYW5kIGVuZm9yY2VzIHRoYXQgYW55IGltcGxlbWVudGF0aW9uXG4gKiBvZiBgaGFzRXJyb3JzYCBtdXN0IGJlIGFzeW5jaHJvbm91cywgYWx3YXlzIHJldHVybmluZyBhIFByb21pc2UuXG4gKlxuICogVXNlIHRoaXMgd2hlbiB0aGUgdmFsaWRhdGlvbiBwcm9jZXNzIGludm9sdmVzIGFzeW5jaHJvbm91cyBvcGVyYXRpb25zLFxuICogc3VjaCBhcyBBUEkgY2FsbHMsIGRhdGFiYXNlIGxvb2t1cHMsIG9yIHRpbWUtYmFzZWQgY2hlY2tzIChlLmcuLCB0aW1lb3V0cykuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIC8vIEV4YW1wbGUgb2YgYW4gYXN5bmNocm9ub3VzIHZhbGlkYXRvciB0aGF0IGNvbXBhcmVzIHZhbHVlIGFnYWluc3QgYSB0aW1lb3V0XG4gKiBjbGFzcyBUaW1lb3V0VmFsaWRhdG9yIGV4dGVuZHMgQXN5bmNWYWxpZGF0b3I8eyB0aW1lb3V0PzogbnVtYmVyIH0+IHtcbiAqICAgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nID0gXCJWYWxpZGF0aW9uIGZhaWxlZCBkdWUgdG8gdGltZW91dFwiKSB7XG4gKiAgICAgc3VwZXIobWVzc2FnZSk7XG4gKiAgIH1cbiAqXG4gKiAgIGFzeW5jIGhhc0Vycm9ycyh2YWx1ZTogbnVtYmVyLCBvcHRpb25zPzogeyB0aW1lb3V0PzogbnVtYmVyIH0pIHtcbiAqICAgICBjb25zdCBkZWxheSA9IG9wdGlvbnM/LnRpbWVvdXQgPz8gMTAwO1xuICpcbiAqICAgICAvLyBhc3luYyBjYWxsXG4gKiAgICAgYXdhaXQgbmV3IFByb21pc2UocmVzID0+IHNldFRpbWVvdXQocmVzLCBkZWxheSkpO1xuICpcbiAqICAgICBpZiAodmFsdWUgPiBkZWxheSkge1xuICogICAgICAgLy8gUmVqZWN0cyB0aGUgdmFsaWRhdGlvbiBhZnRlciB3YWl0aW5nIHRoZSBkZWxheSBpZiB2YWx1ZSBpcyBncmVhdGVyXG4gKiAgICAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHRoaXMuZ2V0TWVzc2FnZSgpKTtcbiAqICAgICB9XG4gKlxuICogICAgIC8vIFBhc3NlcyB0aGUgdmFsaWRhdGlvbiBhZnRlciB3YWl0aW5nIHRoZSBkZWxheVxuICogICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUodW5kZWZpbmVkKTtcbiAqICAgfVxuICogfVxuICpcbiAqIC8vIEV4YW1wbGUgdXNhZ2U6XG4gKiBjb25zdCB2YWxpZGF0b3IgPSBuZXcgVGltZW91dFZhbGlkYXRvcigpO1xuICpcbiAqIGFzeW5jIGZ1bmN0aW9uIHJ1blZhbGlkYXRpb24oKSB7XG4gKiAgY29uc3QgZXJyb3IgPSBhd2FpdCB2YWxpZGF0b3IuaGFzRXJyb3JzKDUwLCB7IHRpbWVvdXQ6IDEwMCB9KTtcbiAqICBpZiAoZXJyb3IpIHtcbiAqICAgIHJldHVybiBjb25zb2xlLmVycm9yKCdWYWxpZGF0aW9uIGVycm9yOicsIGVycm9yKTtcbiAqICB9XG4gKiAgY29uc29sZS5sb2coJ1ZhbHVlIGlzIHZhbGlkJyk7XG4gKiB9XG4gKlxuICogYXdhaXQgcnVuVmFsaWRhdGlvbigpO1xuICogYGBgXG4gKlxuICogLSBJZiBgdmFsdWUgPiB0aW1lb3V0YCwgdGhlIHZhbGlkYXRvciB3YWl0cyBmb3IgdGhlIGRlbGF5IGFuZCB0aGVuIHJlamVjdHMgd2l0aCBhbiBlcnJvci5cbiAqIC0gSWYgYHZhbHVlIDw9IHRpbWVvdXRgLCB0aGUgdmFsaWRhdG9yIHdhaXRzIGZvciB0aGUgZGVsYXkgYW5kIHJlc29sdmVzIHN1Y2Nlc3NmdWxseSB3aXRoIGB1bmRlZmluZWRgLlxuICpcbiAqIEBzZWUge0BsaW5rIFZhbGlkYXRvcn0gRm9yIHRoZSBiYXNlIHN5bmNocm9ub3VzIHZhbGlkYXRvci5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEFzeW5jVmFsaWRhdG9yPFxuICBWIGV4dGVuZHMgVmFsaWRhdG9yT3B0aW9ucyxcbj4gZXh0ZW5kcyBCYXNlVmFsaWRhdG9yPFYsIHRydWU+IHtcbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKFxuICAgIG1lc3NhZ2U6IHN0cmluZyA9IERFRkFVTFRfRVJST1JfTUVTU0FHRVMuREVGQVVMVCxcbiAgICAuLi5hY2NlcHRlZFR5cGVzOiBzdHJpbmdbXVxuICApIHtcbiAgICBzdXBlcih0cnVlLCBtZXNzYWdlLCAuLi5hY2NlcHRlZFR5cGVzKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb25cbiAgICogQXN5bmNocm9ub3VzbHkgdmFsaWRhdGVzIGEgdmFsdWUuXG4gICAqXG4gICAqIEB0ZW1wbGF0ZSBWIC0gVHlwZSBvZiB0aGUgb3B0aW9uIG9iamVjdCB0aGF0IGNhbiBiZSBwYXNzZWQgdG8gdGhlIHZhbGlkYXRvclxuICAgKiBAcGFyYW0ge2FueX0gdmFsdWUgLSBUaGUgdmFsdWUgdG8gdmFsaWRhdGVcbiAgICogQHBhcmFtIHtWfSBbb3B0aW9uc10gLSBPcHRpb25hbCBjb25maWd1cmF0aW9uIG9wdGlvbnMgZm9yIGN1c3RvbWl6aW5nIHZhbGlkYXRpb24gYmVoYXZpb3JcbiAgICogQHBhcmFtIHtQYXRoUHJveHk8YW55Pn0gcHJveHkgLVxuICAgKiBAcmV0dXJuIFByb21pc2U8c3RyaW5nIHwgdW5kZWZpbmVkPiBFcnJvciBtZXNzYWdlIGlmIHZhbGlkYXRpb24gZmFpbHMsIHVuZGVmaW5lZCBpZiB2YWxpZGF0aW9uIHBhc3Nlc1xuICAgKlxuICAgKiBAc2VlIHtAbGluayBWYWxpZGF0b3J9XG4gICAqL1xuICBwdWJsaWMgYWJzdHJhY3Qgb3ZlcnJpZGUgaGFzRXJyb3JzKFxuICAgIHZhbHVlOiBhbnksXG4gICAgb3B0aW9ucz86IFYsXG4gICAgcHJveHk/OiBQYXRoUHJveHk8YW55PlxuICApOiBQcm9taXNlPHN0cmluZyB8IHVuZGVmaW5lZD47XG59XG4iXX0=

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

@@ -0,0 +1,72 @@
+import type { ValidatorOptions } from "../types";
+import type { PathProxy } from "../../utils";
+import { BaseValidator } from "./BaseValidator";
+/**
+ * @description
+ * Abstract class for defining asynchronous validators.
+ *
+ * This class extends the base `Validator` and enforces that any implementation
+ * of `hasErrors` must be asynchronous, always returning a Promise.
+ *
+ * Use this when the validation process involves asynchronous operations,
+ * such as API calls, database lookups, or time-based checks (e.g., timeouts).
+ *
+ * @example
+ * ```typescript
+ * // Example of an asynchronous validator that compares value against a timeout
+ * class TimeoutValidator extends AsyncValidator<{ timeout?: number }> {
+ *   constructor(message: string = "Validation failed due to timeout") {
+ *     super(message);
+ *   }
+ *
+ *   async hasErrors(value: number, options?: { timeout?: number }) {
+ *     const delay = options?.timeout ?? 100;
+ *
+ *     // async call
+ *     await new Promise(res => setTimeout(res, delay));
+ *
+ *     if (value > delay) {
+ *       // Rejects the validation after waiting the delay if value is greater
+ *       return Promise.resolve(this.getMessage());
+ *     }
+ *
+ *     // Passes the validation after waiting the delay
+ *     return Promise.resolve(undefined);
+ *   }
+ * }
+ *
+ * // Example usage:
+ * const validator = new TimeoutValidator();
+ *
+ * async function runValidation() {
+ *  const error = await validator.hasErrors(50, { timeout: 100 });
+ *  if (error) {
+ *    return console.error('Validation error:', error);
+ *  }
+ *  console.log('Value is valid');
+ * }
+ *
+ * await runValidation();
+ * ```
+ *
+ * - If `value > timeout`, the validator waits for the delay and then rejects with an error.
+ * - If `value <= timeout`, the validator waits for the delay and resolves successfully with `undefined`.
+ *
+ * @see {@link Validator} For the base synchronous validator.
+ */
+export declare abstract class AsyncValidator<V extends ValidatorOptions> extends BaseValidator<V, true> {
+    protected constructor(message?: string, ...acceptedTypes: string[]);
+    /**
+     * @description
+     * Asynchronously validates a value.
+     *
+     * @template V - Type of the option 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
+     * @param {PathProxy<any>} proxy -
+     * @return Promise<string | undefined> Error message if validation fails, undefined if validation passes
+     *
+     * @see {@link Validator}
+     */
+    abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): Promise<string | undefined>;
+}

package/lib/validation/Validators/BaseValidator.cjs

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseValidator = 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 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
+ */
+class BaseValidator {
+    constructor(async, message = constants_1.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 (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, options, proxy, ...args) {
+            if (value === undefined || !this.acceptedTypes)
+                return unbound(value, options, proxy, ...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, options, proxy, ...args);
+        }.bind(this);
+    }
+    /**
+     * @summary Duck typing for Validators
+     * @param val
+     */
+    static isValidator(val) {
+        return val.constructor && !!val["hasErrors"];
+    }
+}
+exports.BaseValidator = BaseValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BaseValidator.js","sourceRoot":"","sources":["../../../src/validation/Validators/BaseValidator.ts"],"names":[],"mappings":";;;AAAA,+CAAqD;AACrD,uDAAyC;AACzC,qDAAkD;AAKlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAsB,aAAa;IAQjC,YACE,KAAY,EACZ,UAAkB,kCAAsB,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,IAAA,YAAE,EAAC,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,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,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;AAzGD,sCAyGC","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"]}

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

@@ -0,0 +1,118 @@
+import { ValidatorOptions } from "../types";
+import type { PathProxy } from "../../utils";
+import type { ConditionalAsync } from "../../types";
+/**
+ * @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 declare abstract class BaseValidator<V extends ValidatorOptions = ValidatorOptions, Async extends boolean = false> {
+    readonly message: string;
+    readonly acceptedTypes?: string[];
+    readonly async?: Async;
+    protected constructor(async: Async, 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
+     * @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
+     * @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
+     * @param {PathProxy<any>} proxy -
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @abstract
+     *
+     * @see Model#validate
+     */
+    abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): ConditionalAsync<Async, string | undefined>;
+    /**
+     * @summary Duck typing for Validators
+     * @param val
+     */
+    static isValidator(val: any): boolean;
+}

package/lib/validation/Validators/ListValidator.cjs

@@ -89,7 +89,7 @@ let ListValidator = class ListValidator extends Validator_1.Validator {
             switch (typeof val) {
                 case "object":
                 case "function":
-                    isValid = clazz.includes(val.constructor?.name);
+                    isValid = clazz.includes((val ?? {}).constructor?.name); // null is an object
                     break;
                 default:
                     isValid = clazz.some((c) => typeof val === c.toLowerCase());
@@ -106,4 +106,4 @@ exports.ListValidator = ListValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.LIST),
     __metadata("design:paramtypes", [String])
 ], ListValidator);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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