json-schema-library 11.6.0 → 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/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];