json-schema-library 11.5.1 → 11.6.1

package/src/draft2019-09/methods/getData.ts

@@ -191,8 +191,19 @@ const TYPE: Record<string, (node: SchemaNode, data: unknown, opts: TemplateOptio
                 const input = getValue(data, propertyName);
                 const value = data === undefined || input === undefined ? getValue(template, propertyName) : input;
                 // Omit adding a property if it is not required or optional props should be added
-                if (value != null || isRequired || opts.addOptionalProps) {
+                if (value !== undefined || isRequired || opts.addOptionalProps) {
                     const propertyValue = propertyNode.getData(value, opts);
+                    const dataType = getTypeOf(propertyValue);
+                    if (
+                        opts.removeInvalidData &&
+                        // @attention we do not remove values that might have valid nested values
+                        dataType !== "object" &&
+                        dataType !== "array" &&
+                        !propertyNode.validate(propertyValue).valid
+                    ) {
+                        return;
+                    }
+
                     if (propertyValue !== undefined || opts.useTypeDefaults !== false) {
                         d[propertyName] = propertyValue;
                     }
@@ -250,7 +261,28 @@ const TYPE: Record<string, (node: SchemaNode, data: unknown, opts: TemplateOptio
                 }
             } else {
                 // merge any missing data (additionals) to resulting object
-                Object.keys(data).forEach((key) => d[key] == null && (d[key] = getValue(data, key)));
+                Object.keys(data).forEach((key) => {
+                    // if we allow additionalProperties, but the current value has a schema that invalidates
+                    // do not add this value
+                    const dataType = getTypeOf(key);
+                    if (
+                        opts.removeInvalidData &&
+                        node.properties &&
+                        node.properties[key] &&
+                        dataType !== "object" &&
+                        dataType !== "array"
+                    ) {
+                        const propertyNode = node.properties[key];
+                        const propertyValue = propertyNode.getData(getValue(data, key), opts);
+                        if (!propertyNode.validate(propertyValue).valid) {
+                            return;
+                        }
+                    }
+
+                    if (d[key] == null) {
+                        d[key] = getValue(data, key);
+                    }
+                });
             }
         }
 

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/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/methods/getData.test.ts

@@ -1450,6 +1450,79 @@ describe("getData", () => {
             assert.deepEqual(res, {});
         });
 
+        it("should not remove 'null' values if specified in enum", () => {
+            const node = compileSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    keepA: {
+                        type: ["string", "null"],
+                        enum: ["Chicago", "Rome", null]
+                    },
+                    keepB: {
+                        type: ["null", "string"],
+                        enum: ["Chicago", null, "Rome"]
+                    },
+                    removeA: {
+                        type: ["string"],
+                        enum: ["Chicago", "Rome", null]
+                    },
+                    removeB: {
+                        type: ["string", "null"],
+                        enum: ["Chicago", "Rome"]
+                    }
+                }
+            });
+
+            const res = node.getData(
+                { keepA: null, keepB: null, removeA: null, removeB: null },
+                { removeInvalidData: true }
+            );
+
+            assert.deepEqual(res, { keepA: null, keepB: null });
+        });
+
+        it("should not remove full object when a nested value fails validation", () => {
+            const node = compileSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    keep: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            keep: { type: "number" },
+                            remove: { type: "number" }
+                        }
+                    }
+                }
+            });
+
+            const res = node.getData({ keep: { keep: 9, remove: "a" } }, { removeInvalidData: true });
+
+            assert.deepEqual(res, { keep: { keep: 9 } });
+        });
+
+        it("should remove nested properties that fail validation", () => {
+            const node = compileSchema({
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    keep: {
+                        type: "object",
+                        properties: {
+                            keep: { type: "number" },
+                            remove: { type: "number" }
+                        }
+                    }
+                }
+            });
+
+            const res = node.getData({ keep: { keep: 9, remove: "a" } }, { removeInvalidData: true });
+
+            assert.deepEqual(res, { keep: { keep: 9 } });
+        });
+
         it("should not add optional properties", () => {
             const schema = {
                 type: "object",

package/src/methods/getData.ts

@@ -190,8 +190,19 @@ const TYPE: Record<string, (node: SchemaNode, data: unknown, opts: TemplateOptio
                 const input = getValue(data, propertyName);
                 const value = data === undefined || input === undefined ? getValue(template, propertyName) : input;
                 // Omit adding a property if it is not required or optional props should be added
-                if (value != null || isRequired || opts.addOptionalProps) {
+                if (value !== undefined || isRequired || opts.addOptionalProps) {
                     const propertyValue = propertyNode.getData(value, opts);
+                    const dataType = getTypeOf(propertyValue);
+                    if (
+                        opts.removeInvalidData &&
+                        // @attention we do not remove values that might have valid nested values
+                        dataType !== "object" &&
+                        dataType !== "array" &&
+                        !propertyNode.validate(propertyValue).valid
+                    ) {
+                        return;
+                    }
+
                     if (propertyValue !== undefined || opts.useTypeDefaults !== false) {
                         d[propertyName] = propertyValue;
                     }
@@ -229,7 +240,6 @@ const TYPE: Record<string, (node: SchemaNode, data: unknown, opts: TemplateOptio
             });
         }
 
-        // console.log("getData object", data, opts);
         if (data) {
             if (
                 opts.removeInvalidData === true &&
@@ -248,7 +258,28 @@ const TYPE: Record<string, (node: SchemaNode, data: unknown, opts: TemplateOptio
                 }
             } else {
                 // merge any missing data (additionals) to resulting object
-                Object.keys(data).forEach((key) => d[key] == null && (d[key] = getValue(data, key)));
+                Object.keys(data).forEach((key) => {
+                    // if we allow additionalProperties, but the current value has a schema that invalidates
+                    // do not add this value
+                    const dataType = getTypeOf(key);
+                    if (
+                        opts.removeInvalidData &&
+                        node.properties &&
+                        node.properties[key] &&
+                        dataType !== "object" &&
+                        dataType !== "array"
+                    ) {
+                        const propertyNode = node.properties[key];
+                        const propertyValue = propertyNode.getData(getValue(data, key), opts);
+                        if (!propertyNode.validate(propertyValue).valid) {
+                            return;
+                        }
+                    }
+
+                    if (d[key] == null) {
+                        d[key] = getValue(data, key);
+                    }
+                });
             }
         }
 

package/src/utils/getValue.ts

@@ -1,7 +1,8 @@
 import { isObject } from "../utils/isObject";
+import { hasProperty } from "./hasProperty";
 
 export function getValue(data: unknown, key: string | number) {
-    if (isObject(data)) {
+    if (isObject(data) && hasProperty(data, `${key}`)) {
         return data[key];
     } else if (Array.isArray(data)) {
         return data[key as number];

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({