fix(object-opt-null): support for optional and nullable for inner obj fields

packages/schema/src/schema.ts

@@ -101,7 +101,7 @@ export function validateAndMap<T extends Schema<any, any>>(
   );
   const validationResult = schema.validateBeforeMap(value, contextCreator);
   if (validationResult.length === 0) {
-    if (isOptionalNullable(schema.type())) {
+    if (isOptionalNullable(schema.type(), value)) {
       return { errors: false, result: value };
     }
     return { errors: false, result: schema.map(value, contextCreator) };

packages/schema/src/types/object.ts

@@ -7,6 +7,8 @@ import {
 } from '../schema';
 import { OptionalizeObject } from '../typeUtils';
 import {
+  isOptional,
+  isOptionalNullable,
   literalToString,
   objectEntries,
   objectKeyEncode,
@@ -456,24 +458,33 @@ function mapObject<T extends AnyObjectSchema>(
 
     // Map known properties using the schema
     for (const key in objectSchema) {
-      /* istanbul ignore else */
-      if (Object.prototype.hasOwnProperty.call(objectSchema, key)) {
-        const element = objectSchema[key];
-        const propName = element[0];
-        const propValue = objectValue[propName];
-        unknownKeys.delete(propName);
-
-        // Skip mapping for optional properties to avoid creating properties with value 'undefined'
-        if (
-          element[1].type().indexOf('Optional<') !== 0 ||
-          propValue !== undefined
-        ) {
-          output[key] = element[1][mappingFn](
-            propValue,
-            ctxt.createChild(propName, propValue, element[1])
-          );
+      if (!Object.prototype.hasOwnProperty.call(objectSchema, key)) {
+        continue;
+      }
+
+      const element = objectSchema[key];
+      const propName = element[0];
+      const propValue = objectValue[propName];
+      unknownKeys.delete(propName);
+
+      if (isOptionalNullable(element[1].type(), propValue)) {
+        if (typeof propValue === 'undefined') {
+          // Skip mapping to avoid creating properties with value 'undefined'
+          continue;
         }
+        output[key] = null;
+        continue;
       }
+
+      if (isOptional(element[1].type(), propValue)) {
+        // Skip mapping to avoid creating properties with value 'undefined'
+        continue;
+      }
+
+      output[key] = element[1][mappingFn](
+        propValue,
+        ctxt.createChild(propName, propValue, element[1])
+      );
     }
 
     // Copy unknown properties over if additional properties flag is set

packages/schema/src/utils.ts

@@ -156,9 +156,14 @@ export function isNullOrMissing(value: unknown): value is null | undefined {
   return value === null || typeof value === 'undefined';
 }
 
-export function isOptionalNullable(type: string): boolean {
+export function isOptional(type: string, value: unknown): boolean {
+  return type.startsWith('Optional<') && typeof value === 'undefined';
+}
+
+export function isOptionalNullable(type: string, value: unknown): boolean {
   return (
-    type.startsWith('Optional<Nullable<') ||
-    type.startsWith('Nullable<Optional<')
+    (type.startsWith('Optional<Nullable<') ||
+      type.startsWith('Nullable<Optional<')) &&
+    isNullOrMissing(value)
   );
 }

packages/schema/test/types/object.test.ts

@@ -1,4 +1,6 @@
 import {
+  lazy,
+  nullable,
   number,
   object,
   optional,
@@ -14,6 +16,65 @@ describe('Object', () => {
     const userSchema = object({
       id: ['user_id', string()],
       age: ['user_age', number()],
+      work: ['user_work', optional(nullable(lazy(() => workSchema)))],
+    });
+
+    const workSchema = object({
+      id: ['work_id', optional(nullable(number()))],
+      name: ['work_name', optional(nullable(string()))],
+      address: ['work_address', optional(nullable(string()))],
+    });
+
+    it('should map valid object with lazy loaded sub object', () => {
+      const input = {
+        user_id: 'John Smith',
+        user_age: 50,
+        user_work: {
+          work_id: null,
+          work_name: undefined,
+        },
+      };
+      const output = validateAndMap(input, userSchema);
+      const expected: SchemaType<typeof userSchema> = {
+        id: 'John Smith',
+        age: 50,
+        work: {
+          id: null,
+        },
+      };
+      expect(output.errors).toBeFalsy();
+      expect((output as any).result).toStrictEqual(expected);
+    });
+
+    it('should map valid object with missing lazy loaded sub object', () => {
+      const input = {
+        user_id: 'John Smith',
+        user_age: 50,
+        user_work: undefined,
+      };
+      const output = validateAndMap(input, userSchema);
+      const expected: SchemaType<typeof userSchema> = {
+        id: 'John Smith',
+        age: 50
+      };
+      expect(output.errors).toBeFalsy();
+      expect((output as any).result).toStrictEqual(expected);
+    });
+
+    it('should map valid object with null lazy loaded sub object', () => {
+      const input = {
+        user_id: 'John Smith',
+        user_age: 50,
+        user_work: null,
+      };
+      const output = validateAndMap(input, userSchema);
+      const expected: SchemaType<typeof userSchema> = {
+        id: 'John Smith',
+        age: 50,
+        work: null
+      };
+      expect(output.errors).toBeFalsy();
+      expect((output as any).result).toStrictEqual(expected);
     });
 
     it('should map valid object', () => {
@@ -69,13 +130,13 @@ describe('Object', () => {
             "branch": Array [
               "not an object",
             ],
-            "message": "Expected value to be of type 'Object<{id,age}>' but found 'string'.
+            "message": "Expected value to be of type 'Object<{id,age,work}>' but found 'string'.
 
         Given value: \\"not an object\\"
         Type: 'string'
-        Expected type: 'Object<{id,age}>'",
+        Expected type: 'Object<{id,age,work}>'",
             "path": Array [],
-            "type": "Object<{id,age}>",
+            "type": "Object<{id,age,work}>",
             "value": "not an object",
           },
         ]
@@ -135,9 +196,9 @@ describe('Object', () => {
 
         Given value: {\\"user_id\\":\\"John Smith\\"}
         Type: 'object'
-        Expected type: 'Object<{id,age}>'",
+        Expected type: 'Object<{id,age,work}>'",
             "path": Array [],
-            "type": "Object<{id,age}>",
+            "type": "Object<{id,age,work}>",
             "value": Object {
               "user_id": "John Smith",
             },