z-schema 8.4.0 → 8.5.0

package/README.md

@@ -67,12 +67,89 @@ var errors = validator.getLastErrors();
 ...
 ```
 
-### Async mode:
+### Async validation:
 
-```javascript
-validator.validate(json, schema, function (err, valid) {
-    ...
+ZSchema supports custom format validators that can perform both synchronous and asynchronous validation. This example shows how to validate a person payload with:
+
+- **Async validation**: User ID against a database
+- **Async validation**: Postcode against an external service
+- **Sync validation**: Phone number format
+
+```typescript
+import ZSchema from 'z-schema';
+import db from './db';
+
+// Initialize ZSchema
+const validator = new ZSchema();
+
+// Register async and sync format validators
+validator.registerFormat('user-exists', async (input: unknown): Promise<boolean> => {
+  if (typeof input !== 'number') return false;
+  const user = await db.getUserById(input);
+  return user != null;
 });
+validator.registerFormat('valid-postcode', async (input: unknown): Promise<boolean> => {
+  if (typeof input !== 'string') return false;
+  const postcode = await db.getPostcode(input);
+  return postcode != null;
+});
+validator.registerFormat('phone-number', (input: unknown): boolean => {
+  if (typeof input !== 'string') return false;
+  const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+  return phoneRegex.test(input);
+});
+
+// Define the JSON Schema
+const personSchema = {
+  $schema: 'http://json-schema.org/draft-04/schema#',
+  type: 'object',
+  required: ['personId', 'address'],
+  properties: {
+    personId: {
+      type: 'number',
+      format: 'user-exists',
+    },
+    address: {
+      type: 'object',
+      required: ['postcode', 'phone'],
+      properties: {
+        postcode: {
+          type: 'string',
+          format: 'valid-postcode',
+        },
+        phone: {
+          type: 'string',
+          format: 'phone-number',
+        },
+      },
+    },
+  },
+};
+
+// Example payload
+const payload = {
+  personId: 'user123',
+  address: {
+    postcode: 'SW1A 1AA',
+    phone: '+441234567890',
+  },
+};
+
+// Validate asynchronously
+try {
+  await validator.validateAsync(payload, personSchema);
+  console.log('✅ Validation successful!');
+} catch (err) {
+  console.log('❌ Validation failed:', err);
+}
+
+// or validate without try-catch
+const res = await validator.validateAsyncSafe(payload, personSchema);
+if (res.valid) {
+  console.log('✅ Validation successful!');
+} else {
+  console.log('❌ Validation failed:', res.errs);
+}
 ```
 
 ### Browser:

package/cjs/index.d.ts

@@ -200,7 +200,7 @@ declare class Report {
     addCustomError(errorCode: ErrorCode, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema, keyword?: keyof JsonSchema): void;
 }
 
-type FormatValidatorFn = (input: unknown) => boolean;
+type FormatValidatorFn = (input: unknown) => boolean | Promise<boolean>;
 interface FormatValidatorsOptions {
     strictUris?: boolean;
     customFormats?: Record<string, FormatValidatorFn | null>;
@@ -274,7 +274,7 @@ interface ValidateOptions {
     includeErrors?: Array<keyof typeof Errors>;
     excludeErrors?: Array<keyof typeof Errors>;
 }
-type ValidateCallback = (e: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
+type ValidateCallback = (err: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
 type SchemaReader = (uri: string) => JsonSchema;
 declare class ZSchema {
     static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
@@ -297,6 +297,11 @@ declare class ZSchema {
     validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
     validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): boolean;
     validate(json: unknown, schema: JsonSchema | string): boolean;
+    validateAsync(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<true>;
+    validateAsyncSafe(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<{
+        valid: boolean;
+        errs?: any[];
+    }>;
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */
@@ -312,10 +317,10 @@ declare class ZSchema {
     getMissingReferences(arr?: SchemaErrorDetail[]): string[];
     getMissingRemoteReferences(): string[];
     getResolvedSchema(schema: JsonSchema): JsonSchema;
-    static schemaReader: SchemaReader;
-    setSchemaReader(schemaReader: SchemaReader): void;
-    getSchemaReader(): SchemaReader;
-    static setSchemaReader(schemaReader: SchemaReader): void;
+    static schemaReader: SchemaReader | undefined;
+    setSchemaReader(schemaReader: SchemaReader | undefined): void;
+    getSchemaReader(): SchemaReader | undefined;
+    static setSchemaReader(schemaReader: SchemaReader | undefined): void;
     static schemaSymbol: symbol;
     static jsonSymbol: symbol;
 }

package/cjs/index.js

@@ -1877,34 +1877,106 @@ const JsonValidators = {
     anyOf: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.2
         const subReports = [];
-        let passed = false;
         let idx = schema.anyOf.length;
-        while (idx-- && passed === false) {
+        while (idx--) {
             const subReport = new Report(report);
             subReports.push(subReport);
-            passed = validate.call(this, subReport, schema.anyOf[idx], json);
+            validate.call(this, subReport, schema.anyOf[idx], json);
+        }
+        // Aggregate async tasks from sub-reports to the main report
+        const asyncTasksBefore = report.asyncTasks.length;
+        for (const subReport of subReports) {
+            report.asyncTasks.push(...subReport.asyncTasks);
+        }
+        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+        if (hasAsyncTasks) {
+            // Defer the decision until async tasks complete
+            const pathBeforeAsync = shallowClone(report.path);
+            report.addAsyncTask((callback) => {
+                setTimeout(() => callback(null), 0);
+            }, [], () => {
+                const backup = report.path;
+                report.path = pathBeforeAsync;
+                let passed = false;
+                for (const subReport of subReports) {
+                    if (subReport.errors.length === 0) {
+                        passed = true;
+                        break;
+                    }
+                }
+                if (passed === false) {
+                    report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+                }
+                report.path = backup;
+            });
         }
-        if (passed === false) {
-            report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+        else {
+            // No async tasks, decide immediately
+            let passed = false;
+            for (const subReport of subReports) {
+                if (subReport.errors.length === 0) {
+                    passed = true;
+                    break;
+                }
+            }
+            if (passed === false) {
+                report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+            }
         }
     },
     oneOf: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.2
-        let passes = 0;
         const subReports = [];
         let idx = schema.oneOf.length;
         while (idx--) {
             const subReport = new Report(report);
             subReports.push(subReport);
-            if (validate.call(this, subReport, schema.oneOf[idx], json) === true) {
-                passes++;
-            }
-        }
-        if (passes === 0) {
-            report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
+            validate.call(this, subReport, schema.oneOf[idx], json);
+        }
+        // Aggregate async tasks from sub-reports to the main report
+        const asyncTasksBefore = report.asyncTasks.length;
+        for (const subReport of subReports) {
+            report.asyncTasks.push(...subReport.asyncTasks);
+        }
+        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+        if (hasAsyncTasks) {
+            // Defer the decision until async tasks complete
+            const pathBeforeAsync = shallowClone(report.path);
+            report.addAsyncTask((callback) => {
+                // This task runs after all async tasks, so we can check final state
+                setTimeout(() => callback(null), 0);
+            }, [], () => {
+                const backup = report.path;
+                report.path = pathBeforeAsync;
+                let passes = 0;
+                for (const subReport of subReports) {
+                    if (subReport.errors.length === 0) {
+                        passes++;
+                    }
+                }
+                if (passes === 0) {
+                    report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
+                }
+                else if (passes > 1) {
+                    report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+                }
+                report.path = backup;
+            });
         }
-        else if (passes > 1) {
-            report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+        else {
+            // No async tasks, decide immediately
+            let passes = 0;
+            for (const subReport of subReports) {
+                if (subReport.errors.length === 0) {
+                    passes++;
+                }
+            }
+            if (passes === 0) {
+                report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
+            }
+            else if (passes > 1) {
+                report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+            }
         }
     },
     not: function (report, schema, json) {
@@ -1931,7 +2003,7 @@ const JsonValidators = {
                 return;
             }
             if (formatValidatorFn.length === 2) {
-                // async - need to clone the path here, because it will change by the time async function reports back
+                // callback-based async - need to clone the path here, because it will change by the time async function reports back
                 const pathBeforeAsync = shallowClone(report.path);
                 report.addAsyncTask(formatValidatorFn, [json], function (result) {
                     if (result !== true) {
@@ -1943,9 +2015,40 @@ const JsonValidators = {
                 });
             }
             else {
-                // sync
-                if (formatValidatorFn.call(this, json) !== true) {
-                    report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
+                const result = formatValidatorFn.call(this, json);
+                if (result instanceof Promise) {
+                    // Promise-based async
+                    const pathBeforeAsync = shallowClone(report.path);
+                    const timeoutMs = this.options.asyncTimeout || 2000;
+                    report.addAsyncTask(async (callback) => {
+                        try {
+                            const timeoutPromise = new Promise((_, reject) => {
+                                setTimeout(() => reject(new Error('Async timeout')), timeoutMs);
+                            });
+                            const resolved = await Promise.race([result, timeoutPromise]);
+                            callback(resolved);
+                        }
+                        catch (error) {
+                            if (error.message === 'Async timeout') {
+                                // Don't call callback, let global timeout handle it
+                                return;
+                            }
+                            callback(false);
+                        }
+                    }, [], function (resolvedResult) {
+                        if (resolvedResult !== true) {
+                            const backup = report.path;
+                            report.path = pathBeforeAsync;
+                            report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
+                            report.path = backup;
+                        }
+                    });
+                }
+                else {
+                    // sync
+                    if (result !== true) {
+                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
+                    }
                 }
             }
         }
@@ -5767,6 +5870,34 @@ class ZSchema {
         this.lastReport = report;
         return report.isValid();
     }
+    // validateAsync always returns true, implement using try-catch
+    validateAsync(json, schema, options) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.validate(json, schema, options || {}, (err, valid) => err || valid !== true ? reject(err) : resolve(valid));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    // validateAsyncSafe never throws, but returns complex object
+    validateAsyncSafe(json, schema, options) {
+        return new Promise((resolve) => {
+            try {
+                this.validate(json, schema, options || {}, (err, valid) => {
+                    let errs;
+                    if (err != null) {
+                        errs = Array.isArray(err) ? err : [err];
+                    }
+                    resolve({ valid, errs });
+                });
+            }
+            catch (err) {
+                resolve({ valid: false, errs: Array.isArray(err) ? err : [err] });
+            }
+        });
+    }
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */

package/dist/json-validation.js

@@ -371,34 +371,106 @@ export const JsonValidators = {
     anyOf: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.2
         const subReports = [];
-        let passed = false;
         let idx = schema.anyOf.length;
-        while (idx-- && passed === false) {
+        while (idx--) {
             const subReport = new Report(report);
             subReports.push(subReport);
-            passed = validate.call(this, subReport, schema.anyOf[idx], json);
+            validate.call(this, subReport, schema.anyOf[idx], json);
+        }
+        // Aggregate async tasks from sub-reports to the main report
+        const asyncTasksBefore = report.asyncTasks.length;
+        for (const subReport of subReports) {
+            report.asyncTasks.push(...subReport.asyncTasks);
+        }
+        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+        if (hasAsyncTasks) {
+            // Defer the decision until async tasks complete
+            const pathBeforeAsync = shallowClone(report.path);
+            report.addAsyncTask((callback) => {
+                setTimeout(() => callback(null), 0);
+            }, [], () => {
+                const backup = report.path;
+                report.path = pathBeforeAsync;
+                let passed = false;
+                for (const subReport of subReports) {
+                    if (subReport.errors.length === 0) {
+                        passed = true;
+                        break;
+                    }
+                }
+                if (passed === false) {
+                    report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+                }
+                report.path = backup;
+            });
         }
-        if (passed === false) {
-            report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+        else {
+            // No async tasks, decide immediately
+            let passed = false;
+            for (const subReport of subReports) {
+                if (subReport.errors.length === 0) {
+                    passed = true;
+                    break;
+                }
+            }
+            if (passed === false) {
+                report.addError('ANY_OF_MISSING', undefined, subReports, schema, 'anyOf');
+            }
         }
     },
     oneOf: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.2
-        let passes = 0;
         const subReports = [];
         let idx = schema.oneOf.length;
         while (idx--) {
             const subReport = new Report(report);
             subReports.push(subReport);
-            if (validate.call(this, subReport, schema.oneOf[idx], json) === true) {
-                passes++;
-            }
-        }
-        if (passes === 0) {
-            report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
+            validate.call(this, subReport, schema.oneOf[idx], json);
+        }
+        // Aggregate async tasks from sub-reports to the main report
+        const asyncTasksBefore = report.asyncTasks.length;
+        for (const subReport of subReports) {
+            report.asyncTasks.push(...subReport.asyncTasks);
+        }
+        const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
+        if (hasAsyncTasks) {
+            // Defer the decision until async tasks complete
+            const pathBeforeAsync = shallowClone(report.path);
+            report.addAsyncTask((callback) => {
+                // This task runs after all async tasks, so we can check final state
+                setTimeout(() => callback(null), 0);
+            }, [], () => {
+                const backup = report.path;
+                report.path = pathBeforeAsync;
+                let passes = 0;
+                for (const subReport of subReports) {
+                    if (subReport.errors.length === 0) {
+                        passes++;
+                    }
+                }
+                if (passes === 0) {
+                    report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
+                }
+                else if (passes > 1) {
+                    report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+                }
+                report.path = backup;
+            });
         }
-        else if (passes > 1) {
-            report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+        else {
+            // No async tasks, decide immediately
+            let passes = 0;
+            for (const subReport of subReports) {
+                if (subReport.errors.length === 0) {
+                    passes++;
+                }
+            }
+            if (passes === 0) {
+                report.addError('ONE_OF_MISSING', undefined, subReports, schema, 'oneOf');
+            }
+            else if (passes > 1) {
+                report.addError('ONE_OF_MULTIPLE', undefined, undefined, schema, 'oneOf');
+            }
         }
     },
     not: function (report, schema, json) {
@@ -425,7 +497,7 @@ export const JsonValidators = {
                 return;
             }
             if (formatValidatorFn.length === 2) {
-                // async - need to clone the path here, because it will change by the time async function reports back
+                // callback-based async - need to clone the path here, because it will change by the time async function reports back
                 const pathBeforeAsync = shallowClone(report.path);
                 report.addAsyncTask(formatValidatorFn, [json], function (result) {
                     if (result !== true) {
@@ -437,9 +509,40 @@ export const JsonValidators = {
                 });
             }
             else {
-                // sync
-                if (formatValidatorFn.call(this, json) !== true) {
-                    report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
+                const result = formatValidatorFn.call(this, json);
+                if (result instanceof Promise) {
+                    // Promise-based async
+                    const pathBeforeAsync = shallowClone(report.path);
+                    const timeoutMs = this.options.asyncTimeout || 2000;
+                    report.addAsyncTask(async (callback) => {
+                        try {
+                            const timeoutPromise = new Promise((_, reject) => {
+                                setTimeout(() => reject(new Error('Async timeout')), timeoutMs);
+                            });
+                            const resolved = await Promise.race([result, timeoutPromise]);
+                            callback(resolved);
+                        }
+                        catch (error) {
+                            if (error.message === 'Async timeout') {
+                                // Don't call callback, let global timeout handle it
+                                return;
+                            }
+                            callback(false);
+                        }
+                    }, [], function (resolvedResult) {
+                        if (resolvedResult !== true) {
+                            const backup = report.path;
+                            report.path = pathBeforeAsync;
+                            report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
+                            report.path = backup;
+                        }
+                    });
+                }
+                else {
+                    // sync
+                    if (result !== true) {
+                        report.addError('INVALID_FORMAT', [schema.format, JSON.stringify(json)], undefined, schema, 'format');
+                    }
                 }
             }
         }

package/dist/types/format-validators.d.ts

@@ -1,4 +1,4 @@
-export type FormatValidatorFn = (input: unknown) => boolean;
+export type FormatValidatorFn = (input: unknown) => boolean | Promise<boolean>;
 export interface FormatValidatorsOptions {
     strictUris?: boolean;
     customFormats?: Record<string, FormatValidatorFn | null>;

package/dist/types/z-schema.d.ts

@@ -37,7 +37,7 @@ export interface ValidateOptions {
     includeErrors?: Array<keyof typeof Errors>;
     excludeErrors?: Array<keyof typeof Errors>;
 }
-export type ValidateCallback = (e: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
+export type ValidateCallback = (err: Error | SchemaErrorDetail[] | null, valid: boolean) => void;
 export type SchemaReader = (uri: string) => JsonSchema;
 export declare class ZSchema {
     static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
@@ -60,6 +60,11 @@ export declare class ZSchema {
     validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
     validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): boolean;
     validate(json: unknown, schema: JsonSchema | string): boolean;
+    validateAsync(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<true>;
+    validateAsyncSafe(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<{
+        valid: boolean;
+        errs?: any[];
+    }>;
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */
@@ -75,10 +80,10 @@ export declare class ZSchema {
     getMissingReferences(arr?: SchemaErrorDetail[]): string[];
     getMissingRemoteReferences(): string[];
     getResolvedSchema(schema: JsonSchema): JsonSchema;
-    static schemaReader: SchemaReader;
-    setSchemaReader(schemaReader: SchemaReader): void;
-    getSchemaReader(): SchemaReader;
-    static setSchemaReader(schemaReader: SchemaReader): void;
+    static schemaReader: SchemaReader | undefined;
+    setSchemaReader(schemaReader: SchemaReader | undefined): void;
+    getSchemaReader(): SchemaReader | undefined;
+    static setSchemaReader(schemaReader: SchemaReader | undefined): void;
     static schemaSymbol: symbol;
     static jsonSymbol: symbol;
 }

package/dist/z-schema.js

@@ -240,6 +240,34 @@ export class ZSchema {
         this.lastReport = report;
         return report.isValid();
     }
+    // validateAsync always returns true, implement using try-catch
+    validateAsync(json, schema, options) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.validate(json, schema, options || {}, (err, valid) => err || valid !== true ? reject(err) : resolve(valid));
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    // validateAsyncSafe never throws, but returns complex object
+    validateAsyncSafe(json, schema, options) {
+        return new Promise((resolve) => {
+            try {
+                this.validate(json, schema, options || {}, (err, valid) => {
+                    let errs;
+                    if (err != null) {
+                        errs = Array.isArray(err) ? err : [err];
+                    }
+                    resolve({ valid, errs });
+                });
+            }
+            catch (err) {
+                resolve({ valid: false, errs: Array.isArray(err) ? err : [err] });
+            }
+        });
+    }
     /**
      * Returns an Error object for the most recent failed validation, or null if the validation was successful.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "engines": {
     "node": ">=22.0.0"
   },
@@ -50,7 +50,7 @@
   "scripts": {
     "prepare": "husky",
     "pre-commit": "npx lint-staged",
-    "pre-push": "npm run build",
+    "pre-push": "npm run build && npm run build:tests",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint --fix",
@@ -59,16 +59,15 @@
     "build": "npm run copy:schemas && tsc && npm run copy:module-json && rollup -c",
     "build:browser": "rollup -c --environment BROWSER",
     "build:watch": "rollup -c -w",
+    "build:tests": "tsc --noEmit --project test/tsconfig.json",
     "copy:module-json": "node -e \"fs.copyFileSync('./src/package.json', './dist/package.json')\"",
     "copy:schemas": "node ./scripts/copy-schemas.mts",
     "prepublishOnly": "npm run clean && npm run build && npm test",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "test:quick": "npm run build && npm run test:node",
-    "test:browser": "vitest run --project browser --silent=false",
     "test:node": "vitest run --project node --silent=false",
-    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\"",
-    "release:commit": "node -e \"const v=process.argv[1]; if(!v) throw new Error('Usage: npm run release:empty-commit -- <version>'); require('child_process').execSync(`git commit --allow-empty -m \\\"chore: release ${v}\\\" -m \\\"Release-As: ${v}\\\"`, {stdio:'inherit'});\" --"
+    "test:browser": "vitest run --project browser --silent=false",
+    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\""
   },
   "dependencies": {
     "lodash.isequal": "^4.5.0",

package/src/format-validators.ts

@@ -3,7 +3,7 @@ import isIPModule from 'validator/lib/isIP.js';
 import isURLModule from 'validator/lib/isURL.js';
 import { sortedKeys } from './utils/json.js';
 
-export type FormatValidatorFn = (input: unknown) => boolean;
+export type FormatValidatorFn = (input: unknown) => boolean | Promise<boolean>;
 
 const dateValidator: FormatValidatorFn = (date: unknown) => {
   if (typeof date !== 'string') {