@decaf-ts/decorator-validation/lib/esm/validation/Validators/AsyncValidator.d.ts

simple decorator based validation engine

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>;
}