json-schema-library 11.5.0 → 11.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.5.0",
+  "version": "11.6.0",
   "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,10 @@ 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
+     */
     remotes?: JsonSchema[];
     /**
      * Enables `format`-keyword assertions when this is set tor `true` or sets assertion as defined by
@@ -177,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");

package/src/keywords/allOf.ts

@@ -1,11 +1,5 @@
 import { mergeSchema } from "../utils/mergeSchema";
-import {
-    Keyword,
-    JsonSchemaReducerParams,
-    JsonSchemaValidatorParams,
-    ValidationReturnType,
-    ValidationAnnotation
-} from "../Keyword";
+import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
 import { collectValidationErrors } from "src/utils/collectValidationErrors";

package/src/keywords/oneOf.test.ts

@@ -160,6 +160,17 @@ describe("keyword : oneof-fuzzy : reduce", () => {
         assert.equal(res.oneOfIndex, 1, "should have exposed correct resolved oneOfIndex");
     });
 
+    it("should resolve to best matching oneOf", () => {
+        const node = compileSchema({
+            oneOf: [
+                { type: "array", items: { oneOf: [{ type: "string" }] } },
+                { type: "array", items: { oneOf: [{ type: "number" }] } }
+            ]
+        });
+        const res = reduceOneOfFuzzy({ node, data: [1, 2, "3"], pointer: "#", path: [] });
+        assert.deepEqual(res?.schema, { type: "array", items: { oneOf: [{ type: "number" }] } });
+    });
+
     describe("object", () => {
         it("should return schema with matching properties", () => {
             const node = compileSchema({

package/src/keywords/oneOf.ts

@@ -257,6 +257,38 @@ export function reduceOneOfFuzzy({ node, data, pointer, path }: Omit<JsonSchemaR
             });
         }
 
+        const { node: reducedNode, error } = nodeOfItem.reduceNode(data, { pointer, path });
+        if (reducedNode) {
+            reducedNode.oneOfIndex = schemaOfIndex; // @evaluation-info
+            return reducedNode;
+        }
+        return error;
+    } else if (Array.isArray(data)) {
+        let nodeOfItem: SchemaNode | undefined;
+        let schemaOfIndex = -1;
+        let errorCount = Infinity;
+
+        for (let i = 0; i < node.oneOf.length; i += 1) {
+            const oneNode = node.oneOf[i];
+            const { errors } = oneNode.validate(data);
+            const nextErrorCount = errors.length;
+
+            if (nextErrorCount < errorCount) {
+                errorCount = nextErrorCount;
+                nodeOfItem = oneNode;
+                schemaOfIndex = i;
+            }
+        }
+
+        if (nodeOfItem === undefined) {
+            return node.createError("one-of-error", {
+                value: JSON.stringify(data),
+                pointer,
+                schema: node.schema,
+                oneOf: node.schema.oneOf
+            });
+        }
+
         const { node: reducedNode, error } = nodeOfItem.reduceNode(data, { pointer, path });
         if (reducedNode) {
             reducedNode.oneOfIndex = schemaOfIndex; // @evaluation-info

package/src/keywords/propertyDependencies.test.ts

@@ -139,6 +139,27 @@ describe("keyword : propertyDependencies : validate", () => {
         const { errors } = node.validate([{ propertyName: "propertyValue", type: "headline", test: 123 }]);
         assert.equal(errors.length, 0);
     });
+
+    it("should safely support __proto__ as property dependency key", () => {
+        const schema = JSON.parse(`{
+            "type": "array",
+            "items": {
+                "propertyDependencies": {
+                    "__proto__": {
+                        "polluted": {
+                            "type": "object",
+                            "required": ["safe"]
+                        }
+                    }
+                }
+            }
+        }`);
+        const node = compileSchema(schema, { drafts });
+        const data = JSON.parse(`[{ "__proto__": "polluted" }]`);
+
+        const { errors } = node.validate(data);
+        assert.equal(errors.length, 1);
+    });
 });
 
 describe("keyword : propertyDependencies : validate", () => {

package/src/keywords/propertyDependencies.ts

@@ -24,12 +24,13 @@ function findMatchingSchemata(node: SchemaNode, data: Record<string, unknown>) {
     const matchingSchemata: { property: string; value: string; node: SchemaNode }[] = [];
     for (const propertyName of dependentPropertyNames) {
         if (hasProperty(data, propertyName)) {
-            const value = data[propertyName];
-            if (dependentProperties[propertyName][value as string]) {
+            const dependentValues = dependentProperties[propertyName];
+            const value = `${data[propertyName]}`;
+            if (hasProperty(dependentValues, value)) {
                 matchingSchemata.push({
                     property: propertyName,
-                    value: `${value}`,
-                    node: dependentProperties[propertyName][value as string]
+                    value,
+                    node: dependentValues[value]
                 });
             }
         }
@@ -82,7 +83,7 @@ function parsePropertyDependencies(node: SchemaNode) {
             message: `Keyword '${KEYWORD}' must be an object - received '${typeof propertyDependencies}'`
         });
     }
-    const parsed: Record<string, Record<string, SchemaNode>> = {};
+    const parsed: Record<string, Record<string, SchemaNode>> = Object.create(null);
     const errors: ValidationAnnotation[] = [];
     Object.keys(propertyDependencies).map((propertyName) => {
         const values = propertyDependencies[propertyName];
@@ -110,7 +111,7 @@ function parsePropertyDependencies(node: SchemaNode) {
                 );
                 return;
             }
-            parsed[propertyName] = parsed[propertyName] ?? {};
+            parsed[propertyName] = parsed[propertyName] ?? Object.create(null);
             parsed[propertyName][value] = node.compileSchema(
                 schema,
                 `${node.evaluationPath}/${KEYWORD}/${propertyName}/${value}`,

package/src/keywords/unevaluatedProperties.test.ts

@@ -1,4 +1,5 @@
 import { compileSchema } from "../compileSchema";
+import { draft2020 } from "../draft2020";
 import { strict as assert } from "assert";
 
 describe("keyword : unevaluatedProperties : validation", () => {
@@ -13,4 +14,60 @@ describe("keyword : unevaluatedProperties : validation", () => {
         });
         assert.equal(errors.length, 0);
     });
+
+    it("should not return unevaluated-property-error for a property that fails format validation", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    email: { type: "string", format: "email" }
+                },
+                unevaluatedProperties: false
+            },
+            { drafts: [draft2020] }
+        );
+
+        const { errors } = node.validate({ name: "Alice", email: "not-an-email" });
+
+        const unevaluatedErrors = errors.filter((e) => e.code === "unevaluated-property-error");
+        assert.equal(unevaluatedErrors.length, 0, "should not flag email as unevaluated");
+    });
+
+    it("should not return unevaluated-property-error for a property that fails type validation", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    age: { type: "number" }
+                },
+                unevaluatedProperties: false
+            },
+            { drafts: [draft2020] }
+        );
+
+        const { errors } = node.validate({ name: "Alice", age: "not-a-number" });
+
+        const unevaluatedErrors = errors.filter((e) => e.code === "unevaluated-property-error");
+        assert.equal(unevaluatedErrors.length, 0, "should not flag age as unevaluated");
+    });
+
+    it("should still return unevaluated-property-error for truly unknown properties", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" }
+                },
+                unevaluatedProperties: false
+            },
+            { drafts: [draft2020] }
+        );
+
+        const { errors } = node.validate({ name: "Alice", unknown: "value" });
+
+        const unevaluatedErrors = errors.filter((e) => e.code === "unevaluated-property-error");
+        assert.equal(unevaluatedErrors.length, 1, "should flag unknown as unevaluated");
+    });
 });

package/src/keywords/unevaluatedProperties.ts

@@ -56,6 +56,13 @@ function validateUnevaluatedProperties({ node, data, pointer, path }: JsonSchema
 
     const errors: ValidationReturnType = [];
     for (const propertyName of unevaluated) {
+        // Properties defined directly on this schema object are always
+        // evaluated by the "properties" keyword, regardless of whether the
+        // value passes validation (per JSON Schema spec, annotations from
+        // adjacent keywords are always collected)
+        if (node.properties?.[propertyName]) {
+            continue;
+        }
         if (isPropertyEvaluated({ node, data, key: propertyName, pointer, path })) {
             continue;
         }

package/src/methods/getChildSelection.test.ts

@@ -88,7 +88,30 @@ describe("getChildSelection", () => {
                 number: { type: "number" },
                 string: { type: "string" }
             }
-        }).getChildSelection("b");
+        }).getChildSelection(1);
+
+        assert(!isJsonError(result));
+        assert.deepEqual(result.length, 2);
+        assert.deepEqual(
+            result.map((n) => n.schema),
+            [{ type: "string" }, { type: "number" }]
+        );
+    });
+
+    it("should resolve items $ref", () => {
+        const result = compileSchema({
+            type: "array",
+            items: {
+                $ref: "#/$defs/oneOfRef"
+            },
+            $defs: {
+                oneOfRef: {
+                    oneOf: [{ $ref: "#/$defs/string" }, { $ref: "#/$defs/number" }]
+                },
+                number: { type: "number" },
+                string: { type: "string" }
+            }
+        }).getChildSelection(1);
 
         assert(!isJsonError(result));
         assert.deepEqual(result.length, 2);

package/src/methods/getChildSelection.ts

@@ -6,12 +6,17 @@ import { isSchemaNode, JsonError, SchemaNode } from "../types";
  * a list with a single item will be returned
  */
 export function getChildSelection(node: SchemaNode, property: string | number) {
+    if (node.items) {
+        const items = node.items.resolveRef();
+        if (items?.oneOf) {
+            return items.oneOf.map((childNode: SchemaNode) => childNode.resolveRef());
+        }
+    }
+
     if (node.oneOf) {
         return node.oneOf.map((childNode: SchemaNode) => childNode.resolveRef());
     }
-    if (node.items?.oneOf) {
-        return node.items.oneOf.map((childNode: SchemaNode) => childNode.resolveRef());
-    }
+
     // array.items[] found
     if (node.prefixItems && node.prefixItems.length > +property) {
         const { node: childNode, error } = node.getNodeChild(property);

package/src/settings.ts

@@ -19,7 +19,7 @@ export default {
     ],
     REGEX_FLAGS: "u",
     /** additional keywords that should not produce an unknown-keyword-warning */
-    VALID_ANNOTATION_KEYWORDS: ["title", "description", "default"],
+    VALID_ANNOTATION_KEYWORDS: ["$id", "$schema", "title", "description", "default", "oneOfProperty"],
     /**
      * properties to keep from a $ref-schema when resolving a $ref (recursively)
      * this allows to overwrite specified properties locally on a $ref-definition
@@ -45,5 +45,5 @@ export default {
      *   type: "object"
      * }
      */
-    PROPERTIES_TO_MERGE: ["title", "description", "options", "x-options", "readOnly", "writeOnly"]
+    PROPERTIES_TO_MERGE: ["title", "description", "default", "options", "x-options", "readOnly", "writeOnly"]
 };

package/src/validateSchema.test.ts

@@ -250,6 +250,18 @@ describe("validateSchema", () => {
         assert.equal(schemaErrors[0].data.pointer, "#/uniqueItems");
     });
 
+    describe("remotes", () => {
+        it("should return errors of remotes", () => {
+            const { schemaErrors } = compileSchema(
+                {},
+                { remotes: [{ $id: "https://remote.com/error.json", anyOf: [999] }] }
+            );
+            assert.equal(schemaErrors?.length, 1);
+            assert.equal(schemaErrors[0].data.pointer, "#/anyOf/0");
+            assert.equal(schemaErrors[0].data.schemaId, "https://remote.com/error.json");
+        });
+    });
+
     describe("annotations", () => {
         it("should return unknown keywords as annotation", () => {
             const { schemaAnnotations } = compileSchema({