@decaf-ts/decorator-validation/lib/validation/Validators/AsyncValidator.cjs

simple decorator based validation engine

"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,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