Compat: Ensure undefined/null values are filtered out

src/schemas/Array.js

@@ -23,6 +23,7 @@ export default class ArraySchema extends PolymorphicSchema {
   normalize(input, parent, key, visit, addEntity) {
     const values = Array.isArray(input) ? input : Object.values(input);
 
-    return values.map((value, index) => this.normalizeValue(value, parent, key, visit, addEntity));
+    return values.map((value, index) => this.normalizeValue(value, parent, key, visit, addEntity))
+      .filter((value) => value !== undefined && value !== null);
   }
 }

src/schemas/Object.js

@@ -2,7 +2,12 @@ export const normalize = (schema, input, parent, key, visit, addEntity) => {
   const object = { ...input };
   Object.keys(schema).forEach((key) => {
     const localSchema = schema[key];
-    object[key] = visit(input[key], input, key, localSchema, addEntity);
+    const value = visit(input[key], input, key, localSchema, addEntity);
+    if (value === undefined || value === null) {
+      delete object[key];
+    } else {
+      object[key] = value;
+    }
   });
   return object;
 };

src/schemas/Polymorphic.js

@@ -36,7 +36,7 @@ export default class PolymorphicSchema {
   normalizeValue(value, parent, key, visit, addEntity) {
     const schema = this.inferSchema(value, parent, key);
     const normalizedValue = visit(value, parent, key, schema, addEntity);
-    return this.isSingleSchema ?
+    return this.isSingleSchema || normalizedValue === undefined || normalizedValue === null ?
       normalizedValue :
       { id: normalizedValue, schema: this.getSchemaAttribute(value, parent, key) };
   }

src/schemas/Values.js

@@ -4,10 +4,10 @@ export default class ValuesSchema extends PolymorphicSchema {
   normalize(input, parent, key, visit, addEntity) {
     return Object.keys(input).reduce((output, key, index) => {
       const value = input[key];
-      return {
+      return value !== undefined && value !== null ? {
         ...output,
         [key]: this.normalizeValue(value, input, key, visit, addEntity)
-      };
+      } : output;
     }, {});
   }
 }

src/schemas/__tests__/Array.test.js

@@ -65,5 +65,11 @@ describe(schema.Array.name, () => {
       const users = new schema.Array(userSchema);
       expect(normalize({ foo: { id: 1 }, bar: { id: 2 } }, users)).toMatchSnapshot();
     });
+
+    it('filters out undefined and null normalized values', () => {
+      const userSchema = new schema.Entity('user');
+      const users = new schema.Array(userSchema);
+      expect(normalize([ undefined, { id: 123 }, null ], users)).toMatchSnapshot();
+    });
   });
 });

src/schemas/__tests__/Object.test.js

@@ -14,4 +14,10 @@ describe(schema.Object.name, () => {
     const userSchema = new schema.Entity('user');
     expect(normalize({ user: { id: 1 } }, { user: userSchema })).toMatchSnapshot();
   });
+
+  it('filters out undefined and null values', () => {
+    const userSchema = new schema.Entity('user');
+    const users = { foo: userSchema, bar: userSchema, baz: userSchema };
+    expect(normalize({ foo: {}, bar: { id: '1' } }, users)).toMatchSnapshot();
+  });
 });

src/schemas/__tests__/Values.test.js

@@ -38,4 +38,19 @@ describe(schema.Values.name, () => {
 
     expect(() => normalize({ fluffy: { id: 1, type: 'cat' } }, valuesSchema)).toThrow();
   });
+
+  it('filters out null and undefined values', () => {
+    const cat = new schema.Entity('cats');
+    const dog = new schema.Entity('dogs');
+    const valuesSchema = new schema.Values({
+      dogs: dog,
+      cats: cat
+    }, (entity, key) => entity.type);
+
+    expect(normalize({
+      fido: undefined,
+      milo: null,
+      fluffy: { id: 1, type: 'cats' }
+    }, valuesSchema)).toMatchSnapshot();
+  });
 });

src/schemas/__tests__/__snapshots__/Array.test.js.snap

@@ -1,3 +1,18 @@
+exports[`ArraySchema Class filters out undefined and null normalized values 1`] = `
+Object {
+  "entities": Object {
+    "user": Object {
+      "123": Object {
+        "id": 123,
+      },
+    },
+  },
+  "result": Array [
+    123,
+  ],
+}
+`;
+
 exports[`ArraySchema Class normalizes Objects using their values 1`] = `
 Object {
   "entities": Object {

src/schemas/__tests__/__snapshots__/Object.test.js.snap

@@ -1,3 +1,19 @@
+exports[`ObjectSchema filters out undefined and null values 1`] = `
+Object {
+  "entities": Object {
+    "user": Object {
+      "1": Object {
+        "id": "1",
+      },
+      "undefined": Object {},
+    },
+  },
+  "result": Object {
+    "bar": "1",
+  },
+}
+`;
+
 exports[`ObjectSchema normalizes an object 1`] = `
 Object {
   "entities": Object {

src/schemas/__tests__/__snapshots__/Values.test.js.snap

@@ -27,6 +27,25 @@ Object {
 }
 `;
 
+exports[`ValuesSchema filters out null and undefined values 1`] = `
+Object {
+  "entities": Object {
+    "cats": Object {
+      "1": Object {
+        "id": 1,
+        "type": "cats",
+      },
+    },
+  },
+  "result": Object {
+    "fluffy": Object {
+      "id": 1,
+      "schema": "cats",
+    },
+  },
+}
+`;
+
 exports[`ValuesSchema normalizes the values of an object with the given schema 1`] = `
 Object {
   "entities": Object {