change: replace method validateAsync with validate.errorsAsync

Author: sagold

README.md

@@ -1,4 +1,4 @@
-[![Npm package version](https://badgen.net/npm/v/json-schema-library)](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml) [![CI](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml/badge.svg)](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml) ![Types](https://badgen.net/npm/types/json-schema-library)
+injectWorkspacePackages: true[![Npm package version](https://badgen.net/npm/v/json-schema-library)](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml) [![CI](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml/badge.svg)](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml) ![Types](https://badgen.net/npm/types/json-schema-library)
 
 <h1 align="center">
     <img src="./docs/json-schema-library-10.png" width="192" alt="json-schema-library">
@@ -180,8 +180,7 @@ Please note that these benchmarks refer to validation only. _json-schema-library
 [**reduceNode**](#reducenode) ·
 [**toDataNodes**](#todatanodes) ·
 [**toSchemaNodes**](#toschemanodes) ·
-[**validate**](#validate) ·
-[**validateAsync**](#validateasync)
+[**validate**](#validate)
 
 </details>
 
@@ -862,18 +861,70 @@ expect(errors).to.deep.equal([
 
 </details>
 
-### validateAsync
+You can also use async validators to validate data with json-schema. For this, another property asyncErrors is exposed on validate:
 
-Per default all _json-schema-library_ validators are sync, but adding custom async validators is supported. To resolve async validators use `validateAsync`:
+```ts
+const { isValid, errors, errorsAsync } = compileSchema(myJsonSchema).validate(myData);
+
+if (errorsAsync.length > 0) {
+    const additionalErrors = (await Promise.all(errorsAsync)).filter((err) => err != null);
+}
+```
+
+Per default _json-schema-library_ does not have async validators, so `errorsAsync` is always empty. If you add async validators, a list of `Promise<JsonError|undefined>` is return and you need to resolve and filter non-errors (undefined) yourself.
 
-~~Optional support for `onError` helper, which is invoked for each error (after being resolved)~~
+> **Note** `isValid` only refers to errors. `errorsAsync` has to be evaluated separately
+
+<details><summary>Example Async Validation</summary>
+
+```ts
+import { JsonSchemaValidator, draft2020 } from "json-schema-library";
+// return Promise<JsonError>
+const customValidator: JsonSchemaValidator = async ({ node, pointer, data }) => {
+    return node.createError("type-error", {
+        schema: {},
+        pointer,
+        value: data
+    });
+};
+
+const draftList = [
+    extendDraft(jsonEditorDraft, {
+        keywords: {
+            custom: customValidator
+        }
+    })
+];
+
+const { isValid, errorsAsync } = compileSchema({ custom: true }).validate("data");
+console.log(isValid, errors.length); // true, 0
+
+const errors = await Promise.all(errorsAsync);
+console.log(errors); /// [{ code: "type-error", value: "data", pointer: "#", ... }]
+```
+
+</details>
 
 ```ts
-compileSchema(mySchema)
-    .validateAsync(myData)
-    .then(({ valid, error }) => console.log(errors));
+const myJsonSchema: JsonSchema = {
+    type: "object",
+    additionalProperties: false
+};
+
+const { errors } = compileSchema(myJsonSchema).validate({ name: "my-data" });
+
+expect(errors).to.deep.equal([
+    {
+        type: "error",
+        code: "no-additional-properties-error",
+        message: "Additional property `name` in `#` is not allowed",
+        data: { property: "name", properties: [], pointer: "#" }
+    }
+]);
 ```
 
+</details>
+
 ## Draft Customization
 
 [**Extending a Draft**](#extending-a-draft) · [**Keyword**](#keyword)

src/Draft.ts

@@ -1,9 +1,8 @@
-import type { Keyword } from "./Keyword";
+import type { JsonSchemaValidator, Keyword } from "./Keyword";
 import { copyDraft } from "./utils/copyDraft";
 import { createSchema } from "./methods/createSchema";
 import { toDataNodes } from "./methods/toDataNodes";
 import { ErrorConfig } from "./types";
-import { formats } from "./formats/formats";
 import { getChildSelection } from "./methods/getChildSelection";
 import { getData } from "./methods/getData";
 
@@ -27,7 +26,7 @@ export interface Draft {
     $schema?: string;
     /** draft errors (this can still be global) */
     errors: ErrorConfig;
-    formats: typeof formats;
+    formats: Record<string, JsonSchemaValidator>;
 }
 
 type PartialDraft = Partial<Omit<Draft, "errors" | "formats">> & {

src/Keyword.ts

@@ -36,7 +36,7 @@ export type JsonSchemaValidatorParams = { pointer?: string; data: unknown; node:
 export interface JsonSchemaValidator {
     toJSON?: () => string;
     order?: number;
-    (options: JsonSchemaValidatorParams): undefined | JsonError | ValidationResult[];
+    (options: JsonSchemaValidatorParams): undefined | ValidationResult | ValidationResult[];
 }
 
 export type Keyword = {

src/SchemaNode.ts

@@ -1,7 +1,14 @@
 import copy from "fast-copy";
 import sanitizeErrors from "./utils/sanitizeErrors";
 import settings from "./settings";
-import type { JsonSchemaReducer, JsonSchemaResolver, JsonSchemaValidator, Keyword, ValidationPath } from "./Keyword";
+import type {
+    JsonSchemaReducer,
+    JsonSchemaResolver,
+    JsonSchemaValidator,
+    Keyword,
+    ValidationPath,
+    ValidationResult
+} from "./Keyword";
 import { createSchema } from "./methods/createSchema";
 import { Draft } from "./Draft";
 import { toSchemaNodes } from "./methods/toSchemaNodes";
@@ -299,30 +306,27 @@ export const SchemaNodeMethods = {
     /**
      * @returns validation result of data validated by this node's JSON Schema
      */
-    validate(data: unknown, pointer = "#", path: ValidationPath = []): { valid: boolean; errors: JsonError[] } {
+    validate(data: unknown, pointer = "#", path: ValidationPath = []) {
         const errors = validateNode(this, data, pointer, path) ?? [];
+        const syncErrors: JsonError[] = [];
         const flatErrorList = sanitizeErrors(Array.isArray(errors) ? errors : [errors]).filter(isJsonError);
-        return {
+
+        const errorsAsync: Promise<JsonError | undefined>[] = [];
+        sanitizeErrors(Array.isArray(errors) ? errors : [errors]).forEach((error) => {
+            if (isJsonError(error)) {
+                syncErrors.push(error);
+            } else if (error instanceof Promise) {
+                errorsAsync.push(error);
+            }
+        });
+
+        const result: { valid: boolean; errors: JsonError[]; errorsAsync: Promise<JsonError | undefined>[] } = {
             valid: flatErrorList.length === 0,
-            errors: flatErrorList
+            errors: syncErrors,
+            errorsAsync
         };
-    },
 
-    /**
-     * @returns a promise which resolves to validation-result
-     */
-    async validateAsync(
-        data: unknown,
-        pointer = "#",
-        path: ValidationPath = []
-    ): Promise<{ valid: boolean; errors: JsonError[] }> {
-        const errors = validateNode(this, data, pointer, path) ?? [];
-        let resolvedErrors = await Promise.all(sanitizeErrors(Array.isArray(errors) ? errors : [errors]));
-        resolvedErrors = sanitizeErrors(resolvedErrors) as JsonError[];
-        return {
-            valid: resolvedErrors.length === 0,
-            errors: resolvedErrors
-        };
+        return result;
     },
 
     /**

src/compileSchema.reduceSchema.test.ts

@@ -128,7 +128,6 @@ describe("compileSchema : reduceNode", () => {
                 dependencies: { one: ["two"], two: { type: "number" } }
             });
             const { node: reduced } = node.reduceNode({});
-            console.log("reudced schema", reduced.schema);
             assert.deepEqual(reduced.schema, {
                 type: "object",
                 properties: { one: { type: "string" } }

src/compileSchema.ts

@@ -11,9 +11,9 @@ import { TemplateOptions } from "./methods/getData";
 import { SchemaNode, SchemaNodeMethods, addKeywords, isSchemaNode } from "./SchemaNode";
 
 export type CompileOptions = {
-    drafts: Draft[];
-    remote: SchemaNode;
-    formatAssertion: boolean | "meta-schema";
+    drafts?: Draft[];
+    remote?: SchemaNode;
+    formatAssertion?: boolean | "meta-schema";
     getDataDefaultOptions?: TemplateOptions;
 };
 
@@ -28,7 +28,7 @@ function getDraft(drafts: Draft[], $schema: string) {
  * wrapping each schema with utilities and as much preevaluation is possible. Each
  * node will be reused for each task, but will create a compiledNode for bound data.
  */
-export function compileSchema(schema: JsonSchema, options: Partial<CompileOptions> = {}) {
+export function compileSchema(schema: JsonSchema, options: CompileOptions = {}) {
     /** @todo this option has to be passed to all drafts (remotes) */
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;

src/compileSchema.validate.test.ts

@@ -2,6 +2,7 @@ import { compileSchema } from "./compileSchema";
 import { strict as assert } from "assert";
 import { Draft, JsonError, SchemaNode } from "./types";
 import { draft2020 } from "./draft2020";
+import { ValidationResult } from "./Keyword";
 
 describe("compileSchema.validate", () => {
     describe("integer", () => {
@@ -948,29 +949,13 @@ describe("compileSchema.validate : format", () => {
     });
 });
 
-describe("compileSchema.validateAsync", () => {
-    it("should return a promise", () => {
-        const promise = compileSchema({
-            type: "number"
-        }).validateAsync(4);
-        assert(promise instanceof Promise);
-    });
-
+describe("compileSchema.validate - errorsAsync", () => {
     it("should resolve successfull with an empty error", async () => {
-        const promise = compileSchema({
+        const { errorsAsync } = compileSchema({
             type: "number"
-        }).validateAsync(4);
-        const { errors } = await promise;
-        assert.deepEqual(errors.length, 0);
-    });
-
-    it("should resolve with errors for a failed validation", async () => {
-        const promise = compileSchema({
-            type: "number"
-        }).validateAsync("4");
-        const { errors } = await promise;
-        assert.deepEqual(errors.length, 1);
-        assert.deepEqual(errors[0].code, "type-error");
+        }).validate(4);
+        const asyncErrors = await Promise.all(errorsAsync);
+        assert.deepEqual(asyncErrors.length, 0);
     });
 
     describe("async validation", () => {
@@ -979,92 +964,44 @@ describe("compileSchema.validateAsync", () => {
             draft = {
                 ...draft2020,
                 keywords: [
-                    // @ts-expect-error asd
                     ...draft2020.keywords,
                     {
                         id: "async",
                         keyword: "async-error",
                         addValidate: (node) => node.schema.asyncError != null,
-                        // @ts-expect-error asd
-                        validate: ({ node }) => {
+                        validate: async ({ node }): Promise<JsonError> => {
                             if (node.schema.asyncError === false) {
-                                return;
+                                return undefined;
                             }
-                            return new Promise((resolve) =>
-                                resolve([
-                                    node.createError("type-error", {
-                                        schema: {},
-                                        pointer: "",
-                                        value: ""
-                                    })
-                                ])
-                            ) as Promise<JsonError[]>;
+                            return node.createError("type-error", {
+                                schema: {},
+                                pointer: "",
+                                value: ""
+                            });
                         }
                     }
                 ]
             };
 
             it("should resolve async validation returning no error", async () => {
-                const { errors } = await compileSchema(
+                const { errors, errorsAsync } = compileSchema(
                     { type: "number", asyncError: false },
                     { drafts: [draft] }
-                ).validateAsync(4);
+                ).validate(4);
+                const asyncErrors = await Promise.all(errorsAsync);
                 assert.deepEqual(errors.length, 0);
+                assert.deepEqual(asyncErrors.length, 0);
             });
 
             it("should resolve async validation errors", async () => {
-                const { errors } = await compileSchema(
+                const { errorsAsync } = compileSchema(
                     { type: "number", asyncError: true },
                     { drafts: [draft] }
-                ).validateAsync(4);
-                assert.deepEqual(errors.length, 1);
-                assert.deepEqual(errors[0].code, "type-error");
+                ).validate(4);
+                const asyncErrors = await Promise.all(errorsAsync);
+                assert.deepEqual(asyncErrors.length, 1);
+                assert.deepEqual(asyncErrors[0].code, "type-error");
             });
         });
     });
-
-    // describe("on-error", () => {
-    //     before(() => {
-    //         // adds an async validation helper to { type: 'string', asyncError: true }
-    //         // @ts-expect-error type mismatch of vladation function
-    //         addValidator.keyword(draft, "string", "async-error", (node) => {
-    //             return node.schema.asyncError
-    //                 ? new Promise((resolve) =>
-    //                       // eslint-disable-next-line max-nested-callbacks
-    //                       resolve({
-    //                           type: "error",
-    //                           name: "async-error",
-    //                           code: "test-async-error",
-    //                           message: "custom test error"
-    //                       })
-    //                   )
-    //                 : Promise.resolve();
-    //         });
-    //     });
-
-    //     it("should call onProgress immediately with error", async () => {
-    //         const errors: JsonError[] = [];
-    //         return validateAsync(
-    //             draft,
-    //             {
-    //                 async: "test async progres",
-    //                 anotherError: 44
-    //             },
-    //             {
-    //                 schema: {
-    //                     type: "object",
-    //                     properties: {
-    //                         async: { type: "string", asyncError: true },
-    //                         anotherError: { type: "string" }
-    //                     }
-    //                 },
-    //                 onError: (err) => errors.push(err)
-    //             }
-    //         ).then(() => {
-    //             assert.deepEqual(errors.length, 2);
-    //             assert.deepEqual(errors[0].name).to.eq("type-error");
-    //             assert.deepEqual(errors[1].name).to.eq("async-error");
-    //         });
-    //     });
-    // });
 });