From 5463c5c6d2cb35a7b7948dffc37c899a41d1775f Mon Sep 17 00:00:00 2001
From: "Nicholas C. Zakas" <nicholas@humanwhocodes.com>
Date: Tue, 2 Nov 2021 11:24:22 -0700
Subject: [PATCH] fix: Never return original object from individual config

---
 src/object-schema.js   |  8 +---
 tests/object-schema.js | 83 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+), 6 deletions(-)

diff --git a/src/object-schema.js b/src/object-schema.js
index 25864f5..b663236 100644
--- a/src/object-schema.js
+++ b/src/object-schema.js
@@ -104,12 +104,8 @@ class ObjectSchema {
                 const schema = new ObjectSchema(definitions[key].schema);
                 definitions[key] = {
                     ...definitions[key],
-                    merge(first, second) {
-                        if (first && second) {
-                            return schema.merge(first, second);
-                        }
-                        
-                        return MergeStrategy.assign(first, second);
+                    merge(first = {}, second = {}) {
+                        return schema.merge(first, second);
                     },
                     validate(value) {
                         ValidationStrategy.object(value);
diff --git a/tests/object-schema.js b/tests/object-schema.js
index bff0060..d86ef6e 100644
--- a/tests/object-schema.js
+++ b/tests/object-schema.js
@@ -266,6 +266,53 @@ describe("ObjectSchema", () => {
             assert.strictEqual(result.name.last, "z");
         });
 
+        it("should return separate objects when using subschema", () => {
+
+            schema = new ObjectSchema({
+                age: {
+                    merge: "replace",
+                    validate: "number"
+                },
+                address: {
+                    schema: {
+                        street: {
+                            schema: {
+                                number: {
+                                    merge: "replace",
+                                    validate: "number"
+                                },
+                                streetName: {
+                                    merge: "replace",
+                                    validate: "string"
+                                }
+                            }
+                        },
+                        state: {
+                            merge: "replace",
+                            validate: "string"
+                        }
+                    }
+                }
+            });
+
+            const baseObject = {
+                address: {
+                    street: {
+                        number: 100,
+                        streetName: "Foo St"
+                    },
+                    state: "HA"
+                }
+            };
+
+            const result = schema.merge(baseObject, {
+                age: 29
+            });
+
+            assert.notStrictEqual(result.address.street, baseObject.address.street);
+            assert.deepStrictEqual(result.address, baseObject.address);
+        });
+
         it("should not error when calling the merge strategy when there's a subschema and no matching key in second object", () => {
 
             schema = new ObjectSchema({
@@ -295,6 +342,42 @@ describe("ObjectSchema", () => {
             assert.strictEqual(result.name.last, "z");
         });
 
+        it("should not error when calling the merge strategy when there's multiple subschemas and no matching key in second object", () => {
+
+            schema = new ObjectSchema({
+                user: {
+                    schema: {
+                        name: {
+                            schema: {
+                                first: {
+                                    merge: "replace",
+                                    validate: "string"
+                                },
+                                last: {
+                                    merge: "replace",
+                                    validate: "string"
+                                }
+                            }
+                        }
+
+                    }
+                }
+            });
+
+            const result = schema.merge({
+                user: {
+                    name: {
+                        first: "n",
+                        last: "z"
+                    }
+                }
+            }, {
+            });
+
+            assert.strictEqual(result.user.name.first, "n");
+            assert.strictEqual(result.user.name.last, "z");
+        });
+
 
     });