From 418b8d589245446ff0408eaaec0994159339d39c Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.io>
Date: Thu, 28 Mar 2024 18:47:27 +0100
Subject: [PATCH 1/6] add failing test

---
 tests/unit/onyxTest.js | 59 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/tests/unit/onyxTest.js b/tests/unit/onyxTest.js
index a75fd6bb1..ff8ed1e56 100644
--- a/tests/unit/onyxTest.js
+++ b/tests/unit/onyxTest.js
@@ -2,6 +2,7 @@ import _ from 'underscore';
 import Onyx from '../../lib';
 import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
 import OnyxUtils from '../../lib/OnyxUtils';
+import StorageMock from '../../lib/storage/__mocks__';
 
 const ONYX_KEYS = {
     TEST_KEY: 'test',
@@ -1071,4 +1072,62 @@ describe('Onyx', () => {
                 expect(testKeyValue).toEqual(null);
             });
     });
+
+    it('(nested) nullish values should be removed when changes are batched during merge (SQLite)', () => {
+        let result;
+
+        const initialData = {
+            a: 'a',
+            b: 'b',
+            c: {
+                d: 'd',
+                e: 'e',
+            },
+        };
+        const change1 = null;
+        const change2 = {
+            f: 'f',
+            c: {
+                g: 'g',
+            },
+        };
+        const changes = [change1, change2];
+
+        const batchedChanges = OnyxUtils.applyMerge(undefined, changes, false);
+
+        console.log('Batched changes\n', JSON.stringify(batchedChanges, null, 2));
+
+        connectionID = Onyx.connect({
+            key: ONYX_KEYS.TEST_KEY,
+            initWithStoredValues: false,
+            callback: (value) => (result = value),
+        });
+
+        return Onyx.set(ONYX_KEYS.TEST_KEY, initialData)
+            .then(() => {
+                expect(result).toEqual(initialData);
+                Onyx.merge(ONYX_KEYS.TEST_KEY, changes[0]);
+                Onyx.merge(ONYX_KEYS.TEST_KEY, changes[1]);
+            })
+            .then(waitForPromisesToResolve)
+            .then(() => {
+                expect(result).toEqual({
+                    f: 'f',
+                    c: {
+                        g: 'g',
+                    },
+                });
+
+                console.log('Result in storage\n', JSON.stringify(result, null, 2));
+
+                // We would need to mock SQLite here to actually see what happens
+                // The current storage mock will just use the "modifiedData" from Onyx and just set it instead of actually applying the delta change.
+                expect(StorageMock.getItem(ONYX_KEYS.TEST_KEY)).toEqual({
+                    f: 'f',
+                    c: {
+                        g: 'g',
+                    },
+                });
+            });
+    });
 });

From 1538e885bcee92cb8cdc229dec040b7ad43658fc Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.io>
Date: Fri, 29 Mar 2024 11:40:44 +0100
Subject: [PATCH 2/6] update test

---
 tests/unit/onyxTest.js | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/tests/unit/onyxTest.js b/tests/unit/onyxTest.js
index ff8ed1e56..617a237b5 100644
--- a/tests/unit/onyxTest.js
+++ b/tests/unit/onyxTest.js
@@ -1089,9 +1089,15 @@ describe('Onyx', () => {
             f: 'f',
             c: {
                 g: 'g',
+                h: 'h',
             },
         };
-        const changes = [change1, change2];
+        const change3 = {
+            c: {
+                g: null,
+            },
+        };
+        const changes = [change1, change2, change3];
 
         const batchedChanges = OnyxUtils.applyMerge(undefined, changes, false);
 
@@ -1106,26 +1112,29 @@ describe('Onyx', () => {
         return Onyx.set(ONYX_KEYS.TEST_KEY, initialData)
             .then(() => {
                 expect(result).toEqual(initialData);
-                Onyx.merge(ONYX_KEYS.TEST_KEY, changes[0]);
-                Onyx.merge(ONYX_KEYS.TEST_KEY, changes[1]);
+
+                _.map(changes, (change) => Onyx.merge(ONYX_KEYS.TEST_KEY, change));
             })
             .then(waitForPromisesToResolve)
             .then(() => {
+                const valueInStorage = StorageMock.getItem(ONYX_KEYS.TEST_KEY);
+
+                console.log('Result from Onyx (most likely from cache)\n', JSON.stringify(result, null, 2));
+                console.log('Result in storage\n', JSON.stringify(valueInStorage, null, 2));
+
                 expect(result).toEqual({
                     f: 'f',
                     c: {
-                        g: 'g',
+                        h: 'h',
                     },
                 });
 
-                console.log('Result in storage\n', JSON.stringify(result, null, 2));
-
                 // We would need to mock SQLite here to actually see what happens
                 // The current storage mock will just use the "modifiedData" from Onyx and just set it instead of actually applying the delta change.
-                expect(StorageMock.getItem(ONYX_KEYS.TEST_KEY)).toEqual({
+                expect(valueInStorage).toEqual({
                     f: 'f',
                     c: {
-                        g: 'g',
+                        h: 'h',
                     },
                 });
             });

From b0365a693ec2e9ca2c23e5be3789065064a0d6b5 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.io>
Date: Fri, 29 Mar 2024 12:27:28 +0100
Subject: [PATCH 3/6] fix: batched changes

---
 lib/Onyx.ts                                 | 41 +++++++++------------
 lib/storage/providers/IDBKeyValProvider.ts  |  4 +-
 lib/storage/providers/MemoryOnlyProvider.ts |  4 +-
 lib/storage/providers/SQLiteProvider.ts     |  8 +++-
 lib/storage/providers/types.ts              |  6 +--
 tests/unit/onyxTest.js                      | 19 ++++++----
 6 files changed, 43 insertions(+), 39 deletions(-)

diff --git a/lib/Onyx.ts b/lib/Onyx.ts
index 98b9413c2..075f81741 100644
--- a/lib/Onyx.ts
+++ b/lib/Onyx.ts
@@ -303,48 +303,43 @@ function merge<TKey extends OnyxKey>(key: TKey, changes: OnyxEntry<NullishDeep<K
 
         try {
             // We first only merge the changes, so we can provide these to the native implementation (SQLite uses only delta changes in "JSON_PATCH" to merge)
-            // We don't want to remove null values from the "batchedChanges", because SQLite uses them to remove keys from storage natively.
-            let batchedChanges = OnyxUtils.applyMerge(undefined, mergeQueue[key], false);
+            // We don't want to remove null values from the "batchedDeltaChanges", because SQLite uses them to remove keys from storage natively.
+            const batchedDeltaChanges = OnyxUtils.applyMerge(undefined, mergeQueue[key], false);
 
-            // The presence of a `null` in the merge queue instructs us to drop the existing value.
+            // Case (1): When there is no existing value in storage, we want to set the value instead of merge it.
+            // Case (2): The presence of a top-level`null` in the merge queue instructs us to drop the whole existing value.
             // In this case, we can't simply merge the batched changes with the existing value, because then the null in the merge queue would have no effect
-            const shouldOverwriteExistingValue = mergeQueue[key].includes(null);
+            const shouldSetValue = !existingValue || mergeQueue[key].includes(null);
 
             // Clean up the write queue, so we don't apply these changes again
             delete mergeQueue[key];
             delete mergeQueuePromise[key];
 
             // If the batched changes equal null, we want to remove the key from storage, to reduce storage size
-            const {wasRemoved} = OnyxUtils.removeNullValues(key, batchedChanges);
-
-            // After that we merge the batched changes with the existing value
-            // We can remove null values from the "modifiedData", because "null" implicates that the user wants to remove a value from storage.
-            // The "modifiedData" will be directly "set" in storage instead of being merged
-            const modifiedData = shouldOverwriteExistingValue ? batchedChanges : OnyxUtils.applyMerge(existingValue, [batchedChanges], true);
-
-            // On native platforms we use SQLite which utilises JSON_PATCH to merge changes.
-            // JSON_PATCH generally removes null values from the stored object.
-            // When there is no existing value though, SQLite will just insert the changes as a new value and thus the null values won't be removed.
-            // Therefore we need to remove null values from the `batchedChanges` which are sent to the SQLite, if no existing value is present.
-            if (!existingValue) {
-                batchedChanges = OnyxUtils.applyMerge(undefined, [batchedChanges], true);
-            }
+            const {wasRemoved} = OnyxUtils.removeNullValues(key, batchedDeltaChanges);
+
+            // For providers that can't handle delta changes, we need to merge the batched changes with the existing value beforehand.
+            // The "preMergedValue" will be directly "set" in storage instead of being merged
+            // Therefore we merge the batched changes with the existing value to get the final merged value that will be stored.
+            // We can remove null values from the "preMergedValue", because "null" implicates that the user wants to remove a value from storage.
+            const preMergedValue = OnyxUtils.applyMerge(shouldSetValue ? undefined : existingValue, [batchedDeltaChanges], true);
 
-            const hasChanged = cache.hasValueChanged(key, modifiedData);
+            // In cache, we don't want to remove the key if it's null to improve performance and speed up the next merge.
+            const hasChanged = cache.hasValueChanged(key, preMergedValue);
 
             // Logging properties only since values could be sensitive things we don't want to log
-            Logger.logInfo(`merge called for key: ${key}${_.isObject(batchedChanges) ? ` properties: ${_.keys(batchedChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
+            Logger.logInfo(`merge called for key: ${key}${_.isObject(batchedDeltaChanges) ? ` properties: ${_.keys(batchedDeltaChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
 
             // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-            const updatePromise = OnyxUtils.broadcastUpdate(key, modifiedData, hasChanged, wasRemoved);
+            const updatePromise = OnyxUtils.broadcastUpdate(key, preMergedValue, hasChanged, wasRemoved);
 
             // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
             if (!hasChanged || wasRemoved) {
                 return updatePromise;
             }
 
-            return Storage.mergeItem(key, batchedChanges, modifiedData).then(() => {
-                OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MERGE, key, changes, modifiedData);
+            return Storage.mergeItem(key, batchedDeltaChanges, preMergedValue, shouldSetValue).then(() => {
+                OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MERGE, key, changes, preMergedValue);
                 return updatePromise;
             });
         } catch (error) {
diff --git a/lib/storage/providers/IDBKeyValProvider.ts b/lib/storage/providers/IDBKeyValProvider.ts
index 3a385d228..f3539b500 100644
--- a/lib/storage/providers/IDBKeyValProvider.ts
+++ b/lib/storage/providers/IDBKeyValProvider.ts
@@ -40,9 +40,9 @@ const provider: StorageProvider = {
                 return Promise.all(upsertMany);
             });
         }),
-    mergeItem(key, _changes, modifiedData) {
+    mergeItem(key, _deltaChanges, preMergedValue) {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
-        return provider.setItem(key, modifiedData);
+        return provider.setItem(key, preMergedValue);
     },
     multiSet: (pairs) => setMany(pairs, idbKeyValStore),
     clear: () => clear(idbKeyValStore),
diff --git a/lib/storage/providers/MemoryOnlyProvider.ts b/lib/storage/providers/MemoryOnlyProvider.ts
index 74d9e3a84..00583a55a 100644
--- a/lib/storage/providers/MemoryOnlyProvider.ts
+++ b/lib/storage/providers/MemoryOnlyProvider.ts
@@ -78,9 +78,9 @@ const provider: StorageProvider = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem(key, _changes, modifiedData) {
+    mergeItem(key, _deltaChanges, preMergedValue) {
         // Since Onyx already merged the existing value with the changes, we can just set the value directly
-        return this.setItem(key, modifiedData);
+        return this.setItem(key, preMergedValue);
     },
 
     /**
diff --git a/lib/storage/providers/SQLiteProvider.ts b/lib/storage/providers/SQLiteProvider.ts
index ad5324ea9..a4771a34c 100644
--- a/lib/storage/providers/SQLiteProvider.ts
+++ b/lib/storage/providers/SQLiteProvider.ts
@@ -76,8 +76,12 @@ const provider: StorageProvider = {
 
         return db.executeBatchAsync([[query, queryArguments]]);
     },
-    mergeItem(key, changes) {
-        return this.multiMerge([[key, changes]]) as Promise<BatchQueryResult>;
+    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue = false) {
+        if (shouldSetValue) {
+            return this.setItem(key, preMergedValue) as Promise<BatchQueryResult>;
+        }
+
+        return this.multiMerge([[key, deltaChanges]]) as Promise<BatchQueryResult>;
     },
     getAllKeys: () =>
         db.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({rows}) => {
diff --git a/lib/storage/providers/types.ts b/lib/storage/providers/types.ts
index 80cf88ba7..969118004 100644
--- a/lib/storage/providers/types.ts
+++ b/lib/storage/providers/types.ts
@@ -43,10 +43,10 @@ type StorageProvider = {
 
     /**
      * Merges an existing value with a new one by leveraging JSON_PATCH
-     * @param changes - the delta for a specific key
-     * @param modifiedData - the pre-merged data from `Onyx.applyMerge`
+     * @param deltaChanges - the delta for a specific key
+     * @param preMergedValue - the pre-merged data from `Onyx.applyMerge`
      */
-    mergeItem: <TKey extends OnyxKey>(key: TKey, changes: OnyxValue<TKey>, modifiedData: OnyxValue<TKey>) => Promise<BatchQueryResult | void>;
+    mergeItem: <TKey extends OnyxKey>(key: TKey, deltaChanges: OnyxValue<TKey>, preMergedValue: OnyxValue<TKey>, shouldSetValue?: boolean) => Promise<BatchQueryResult | void>;
 
     /**
      * Returns all keys available in storage
diff --git a/tests/unit/onyxTest.js b/tests/unit/onyxTest.js
index 617a237b5..b5fbe5a06 100644
--- a/tests/unit/onyxTest.js
+++ b/tests/unit/onyxTest.js
@@ -1075,6 +1075,7 @@ describe('Onyx', () => {
 
     it('(nested) nullish values should be removed when changes are batched during merge (SQLite)', () => {
         let result;
+        let valueInStorage;
 
         const initialData = {
             a: 'a',
@@ -1084,20 +1085,23 @@ describe('Onyx', () => {
                 e: 'e',
             },
         };
-        const change1 = null;
-        const change2 = {
+        const change1 = {
+            b: null,
+        };
+        const change2 = null;
+        const change3 = {
             f: 'f',
             c: {
                 g: 'g',
                 h: 'h',
             },
         };
-        const change3 = {
+        const change4 = {
             c: {
                 g: null,
             },
         };
-        const changes = [change1, change2, change3];
+        const changes = [change1, change2, change3, change4];
 
         const batchedChanges = OnyxUtils.applyMerge(undefined, changes, false);
 
@@ -1113,12 +1117,13 @@ describe('Onyx', () => {
             .then(() => {
                 expect(result).toEqual(initialData);
 
-                _.map(changes, (change) => Onyx.merge(ONYX_KEYS.TEST_KEY, change));
+                return Promise.all(_.map(changes, (change) => Onyx.merge(ONYX_KEYS.TEST_KEY, change)));
             })
             .then(waitForPromisesToResolve)
             .then(() => {
-                const valueInStorage = StorageMock.getItem(ONYX_KEYS.TEST_KEY);
-
+                StorageMock.getItem(ONYX_KEYS.TEST_KEY).then((v) => (valueInStorage = v));
+            })
+            .then(() => {
                 console.log('Result from Onyx (most likely from cache)\n', JSON.stringify(result, null, 2));
                 console.log('Result in storage\n', JSON.stringify(valueInStorage, null, 2));
 

From efa02509812a99dbc0860749fb899f7087382284 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.io>
Date: Sun, 7 Apr 2024 13:30:32 +0200
Subject: [PATCH 4/6] fix: pass new param through storage layer

---
 lib/storage/index.ts                       | 4 ++--
 lib/storage/providers/IDBKeyValProvider.ts | 2 +-
 lib/storage/providers/SQLiteProvider.ts    | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/storage/index.ts b/lib/storage/index.ts
index cf8c575bc..c9b797b10 100644
--- a/lib/storage/index.ts
+++ b/lib/storage/index.ts
@@ -114,9 +114,9 @@ const Storage: Storage = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem: (key, changes, modifiedData) =>
+    mergeItem: (key, deltaChanges, preMergedValue, shouldSetValue = false) =>
         tryOrDegradePerformance(() => {
-            const promise = provider.mergeItem(key, changes, modifiedData);
+            const promise = provider.mergeItem(key, deltaChanges, preMergedValue, shouldSetValue);
 
             if (shouldKeepInstancesSync) {
                 return promise.then(() => InstanceSync.mergeItem(key));
diff --git a/lib/storage/providers/IDBKeyValProvider.ts b/lib/storage/providers/IDBKeyValProvider.ts
index f3539b500..f13657800 100644
--- a/lib/storage/providers/IDBKeyValProvider.ts
+++ b/lib/storage/providers/IDBKeyValProvider.ts
@@ -40,7 +40,7 @@ const provider: StorageProvider = {
                 return Promise.all(upsertMany);
             });
         }),
-    mergeItem(key, _deltaChanges, preMergedValue) {
+    mergeItem(key, _deltaChanges, preMergedValue, _shouldSetValue) {
         // Since Onyx also merged the existing value with the changes, we can just set the value directly
         return provider.setItem(key, preMergedValue);
     },
diff --git a/lib/storage/providers/SQLiteProvider.ts b/lib/storage/providers/SQLiteProvider.ts
index a4771a34c..461c4b8ca 100644
--- a/lib/storage/providers/SQLiteProvider.ts
+++ b/lib/storage/providers/SQLiteProvider.ts
@@ -76,7 +76,7 @@ const provider: StorageProvider = {
 
         return db.executeBatchAsync([[query, queryArguments]]);
     },
-    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue = false) {
+    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue) {
         if (shouldSetValue) {
             return this.setItem(key, preMergedValue) as Promise<BatchQueryResult>;
         }

From 9778ebebf7a4a3413166ed44dc16a2b66fd50a52 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.io>
Date: Sun, 7 Apr 2024 13:38:33 +0200
Subject: [PATCH 5/6] remove test

---
 tests/unit/onyxTest.js | 72 ------------------------------------------
 1 file changed, 72 deletions(-)

diff --git a/tests/unit/onyxTest.js b/tests/unit/onyxTest.js
index b5fbe5a06..b8199087a 100644
--- a/tests/unit/onyxTest.js
+++ b/tests/unit/onyxTest.js
@@ -1072,76 +1072,4 @@ describe('Onyx', () => {
                 expect(testKeyValue).toEqual(null);
             });
     });
-
-    it('(nested) nullish values should be removed when changes are batched during merge (SQLite)', () => {
-        let result;
-        let valueInStorage;
-
-        const initialData = {
-            a: 'a',
-            b: 'b',
-            c: {
-                d: 'd',
-                e: 'e',
-            },
-        };
-        const change1 = {
-            b: null,
-        };
-        const change2 = null;
-        const change3 = {
-            f: 'f',
-            c: {
-                g: 'g',
-                h: 'h',
-            },
-        };
-        const change4 = {
-            c: {
-                g: null,
-            },
-        };
-        const changes = [change1, change2, change3, change4];
-
-        const batchedChanges = OnyxUtils.applyMerge(undefined, changes, false);
-
-        console.log('Batched changes\n', JSON.stringify(batchedChanges, null, 2));
-
-        connectionID = Onyx.connect({
-            key: ONYX_KEYS.TEST_KEY,
-            initWithStoredValues: false,
-            callback: (value) => (result = value),
-        });
-
-        return Onyx.set(ONYX_KEYS.TEST_KEY, initialData)
-            .then(() => {
-                expect(result).toEqual(initialData);
-
-                return Promise.all(_.map(changes, (change) => Onyx.merge(ONYX_KEYS.TEST_KEY, change)));
-            })
-            .then(waitForPromisesToResolve)
-            .then(() => {
-                StorageMock.getItem(ONYX_KEYS.TEST_KEY).then((v) => (valueInStorage = v));
-            })
-            .then(() => {
-                console.log('Result from Onyx (most likely from cache)\n', JSON.stringify(result, null, 2));
-                console.log('Result in storage\n', JSON.stringify(valueInStorage, null, 2));
-
-                expect(result).toEqual({
-                    f: 'f',
-                    c: {
-                        h: 'h',
-                    },
-                });
-
-                // We would need to mock SQLite here to actually see what happens
-                // The current storage mock will just use the "modifiedData" from Onyx and just set it instead of actually applying the delta change.
-                expect(valueInStorage).toEqual({
-                    f: 'f',
-                    c: {
-                        h: 'h',
-                    },
-                });
-            });
-    });
 });

From ef2201eed3263e3bc2f47e8044b1c5a38bdd0e38 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.io>
Date: Sun, 7 Apr 2024 13:39:08 +0200
Subject: [PATCH 6/6] add test for SQLite batched changes

---
 tests/unit/onyxTest.js | 72 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)

diff --git a/tests/unit/onyxTest.js b/tests/unit/onyxTest.js
index b8199087a..b5fbe5a06 100644
--- a/tests/unit/onyxTest.js
+++ b/tests/unit/onyxTest.js
@@ -1072,4 +1072,76 @@ describe('Onyx', () => {
                 expect(testKeyValue).toEqual(null);
             });
     });
+
+    it('(nested) nullish values should be removed when changes are batched during merge (SQLite)', () => {
+        let result;
+        let valueInStorage;
+
+        const initialData = {
+            a: 'a',
+            b: 'b',
+            c: {
+                d: 'd',
+                e: 'e',
+            },
+        };
+        const change1 = {
+            b: null,
+        };
+        const change2 = null;
+        const change3 = {
+            f: 'f',
+            c: {
+                g: 'g',
+                h: 'h',
+            },
+        };
+        const change4 = {
+            c: {
+                g: null,
+            },
+        };
+        const changes = [change1, change2, change3, change4];
+
+        const batchedChanges = OnyxUtils.applyMerge(undefined, changes, false);
+
+        console.log('Batched changes\n', JSON.stringify(batchedChanges, null, 2));
+
+        connectionID = Onyx.connect({
+            key: ONYX_KEYS.TEST_KEY,
+            initWithStoredValues: false,
+            callback: (value) => (result = value),
+        });
+
+        return Onyx.set(ONYX_KEYS.TEST_KEY, initialData)
+            .then(() => {
+                expect(result).toEqual(initialData);
+
+                return Promise.all(_.map(changes, (change) => Onyx.merge(ONYX_KEYS.TEST_KEY, change)));
+            })
+            .then(waitForPromisesToResolve)
+            .then(() => {
+                StorageMock.getItem(ONYX_KEYS.TEST_KEY).then((v) => (valueInStorage = v));
+            })
+            .then(() => {
+                console.log('Result from Onyx (most likely from cache)\n', JSON.stringify(result, null, 2));
+                console.log('Result in storage\n', JSON.stringify(valueInStorage, null, 2));
+
+                expect(result).toEqual({
+                    f: 'f',
+                    c: {
+                        h: 'h',
+                    },
+                });
+
+                // We would need to mock SQLite here to actually see what happens
+                // The current storage mock will just use the "modifiedData" from Onyx and just set it instead of actually applying the delta change.
+                expect(valueInStorage).toEqual({
+                    f: 'f',
+                    c: {
+                        h: 'h',
+                    },
+                });
+            });
+    });
 });