json-schema-library 11.5.1 → 11.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.5.1",
+  "version": "11.6.1",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "types": "./dist/index.d.cts",
   "exports": {

package/src/SchemaNode.ts

@@ -551,7 +551,7 @@ export const SchemaNodeMethods = {
             schema.$id = resolveUri(schema.$id || url);
         }
 
-        const node = this as SchemaNode;
+        const node = this as SchemaNode & { schemaErrors?: JsonError[]; schemaAnnotations: JsonAnnotation[] };
         const { context } = node;
         const schemaId = isJsonSchema(schema) ? (node.context.draft ?? schema.$schema) : undefined;
         const draft = getDraft(context.drafts, schemaId ?? context.rootNode.schema?.$schema);
@@ -576,7 +576,22 @@ export const SchemaNodeMethods = {
 
         remoteNode.context.rootNode = remoteNode;
         remoteNode.context.remotes[resolveUri(url)] = remoteNode;
-        addKeywords(remoteNode);
+
+        // parse and validate schema
+        // @todo this is a duplicated to compileSchema
+        let schemaValidation = addKeywords(remoteNode).filter((err) => err != null);
+        schemaValidation = sanitizeErrors(schemaValidation);
+        const schemaErrors: JsonError[] = [];
+        const schemaAnnotations: JsonAnnotation[] = [];
+        schemaValidation.forEach((error) => {
+            if (isJsonError(error)) {
+                schemaErrors.push(error);
+            } else if (isJsonAnnotation(error)) {
+                schemaAnnotations.push(error);
+            }
+        });
+        node.schemaErrors = schemaErrors;
+        node.schemaAnnotations = schemaAnnotations;
 
         return node;
     },
@@ -631,6 +646,7 @@ export function addKeywords(node: SchemaNode) {
     ).forEach((keyword) => {
         errors.push(
             node.createAnnotation("unknown-keyword-warning", {
+                $id: node.$id,
                 pointer: `${node.schemaLocation}/${keyword}`,
                 schema: node.schema,
                 value: keyword,

package/src/compileSchema.test.ts

@@ -1,7 +1,6 @@
 import { compileSchema } from "./compileSchema";
 import { strict as assert } from "assert";
-import { draftEditor } from "./draftEditor";
-import { SchemaNode } from "./SchemaNode";
+import { isSchemaNode, SchemaNode } from "./SchemaNode";
 import { draft04 } from "./draft04";
 import { draft07 } from "./draft07";
 import { draft2020 } from "./draft2020";
@@ -106,6 +105,42 @@ describe("compileSchema remotes", () => {
         const data = node.getData();
         assert.deepEqual(data, { string: "a", number: 9 });
     });
+
+    it("should resolve definition of remote schema", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                required: ["value"],
+                properties: {
+                    value: { $ref: "https://remote.com/definitions.json#/$defs/property" }
+                }
+            },
+            {
+                drafts: [draft2020],
+                remotes: [
+                    {
+                        $id: "https://remote.com/definitions.json",
+                        $defs: {
+                            property: {
+                                title: "remote boolean definition",
+                                type: "boolean"
+                            }
+                        }
+                    }
+                ]
+            }
+        );
+
+        const data = node.getData();
+        assert.deepEqual(data, { value: false });
+
+        const { node: valueNode } = node.getNode("#/value");
+        assert(isSchemaNode(valueNode), "expected returned node to be a valid SchemaNode");
+        assert.deepEqual(valueNode.schema, {
+            title: "remote boolean definition",
+            type: "boolean"
+        });
+    });
 });
 
 describe("compileSchema vocabulary", () => {
@@ -250,17 +285,3 @@ describe("compileSchema `schemaLocation`", () => {
         assert.deepEqual(node?.schemaLocation, "#");
     });
 });
-
-describe("compileSchema `errors`", () => {
-    it("draftEditor come with custom minLengthOneError", () => {
-        const { errors } = compileSchema(
-            {
-                type: "string",
-                minLength: 1
-            },
-            { drafts: [draftEditor] }
-        ).validate("");
-        assert.equal(errors.length, 1);
-        assert.deepEqual(errors[0].code, "min-length-one-error");
-    });
-});

package/src/compileSchema.ts

@@ -66,7 +66,7 @@ export type CompileOptions = {
     /**
      * Set node and its remote schemata as remote schemata for this node and schema to resolve $ref
      */
-    remote?: SchemaNode;
+    remote?: SchemaNode & { schemaErrors?: JsonError[]; schemaAnnotations: JsonAnnotation[] };
     /**
      * a list of remotes to add, requires a unique $id for each schema. Will be ignored if `remote` is set
      */
@@ -180,11 +180,19 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
     const schemaAnnotations: JsonAnnotation[] = [];
     schemaValidation.forEach((error) => {
         if (isJsonError(error)) {
+            error.data.schemaId = node.context.rootNode.$id ?? "#";
             schemaErrors.push(error);
         } else if (isJsonAnnotation(error)) {
+            error.data.schemaId = node.context.rootNode.$id ?? "#";
             schemaAnnotations.push(error);
         }
     });
+    if (Array.isArray(remote?.schemaErrors)) {
+        schemaErrors.push(...remote.schemaErrors);
+    }
+    if (Array.isArray(remote?.schemaAnnotations)) {
+        schemaAnnotations.push(...remote.schemaAnnotations);
+    }
 
     if (options.throwOnInvalidSchema && schemaErrors.length > 0) {
         const error = new Error("Invalid schema passed to compileSchema");