react-native-onyx 2.0.26 → 2.0.27

package/dist/Onyx.js

@@ -271,38 +271,34 @@ function merge(key, changes) {
         }
         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_1.default.applyMerge(undefined, mergeQueue[key], false);
-            // The presence of a `null` in the merge queue instructs us to drop the existing value.
+            // We don't want to remove null values from the "batchedDeltaChanges", because SQLite uses them to remove keys from storage natively.
+            const batchedDeltaChanges = OnyxUtils_1.default.applyMerge(undefined, mergeQueue[key], false);
+            // 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_1.default.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_1.default.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_1.default.applyMerge(undefined, [batchedChanges], true);
-            }
-            const hasChanged = OnyxCache_1.default.hasValueChanged(key, modifiedData);
+            const { wasRemoved } = OnyxUtils_1.default.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_1.default.applyMerge(shouldSetValue ? undefined : existingValue, [batchedDeltaChanges], true);
+            // 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 = OnyxCache_1.default.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}${underscore_1.default.isObject(batchedChanges) ? ` properties: ${underscore_1.default.keys(batchedChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
+            Logger.logInfo(`merge called for key: ${key}${underscore_1.default.isObject(batchedDeltaChanges) ? ` properties: ${underscore_1.default.keys(batchedDeltaChanges).join(',')}` : ''} hasChanged: ${hasChanged}`);
             // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
-            const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, modifiedData, hasChanged, wasRemoved);
+            const updatePromise = OnyxUtils_1.default.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_1.default.mergeItem(key, batchedChanges, modifiedData).then(() => {
-                OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, modifiedData);
+            return storage_1.default.mergeItem(key, batchedDeltaChanges, preMergedValue, shouldSetValue).then(() => {
+                OnyxUtils_1.default.sendActionToDevTools(OnyxUtils_1.default.METHOD.MERGE, key, changes, preMergedValue);
                 return updatePromise;
             });
         }

package/dist/storage/__mocks__/index.d.ts

@@ -5,7 +5,7 @@ declare const StorageMock: {
     multiGet: jest.Mock<Promise<import("../providers/types").KeyValuePairList>, [keys: import("../providers/types").KeyList]>;
     setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: any, value: unknown]>;
     multiSet: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [pairs: import("../providers/types").KeyValuePairList]>;
-    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: any, changes: unknown, modifiedData: unknown]>;
+    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: any, deltaChanges: unknown, preMergedValue: unknown, shouldSetValue?: boolean | undefined]>;
     multiMerge: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: import("../providers/types").KeyValuePairList]>;
     removeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string]>;
     removeItems: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [keys: import("../providers/types").KeyList]>;

package/dist/storage/index.js

@@ -118,8 +118,8 @@ const Storage = {
     /**
      * Merging an existing value with a new one
      */
-    mergeItem: (key, changes, modifiedData) => tryOrDegradePerformance(() => {
-        const promise = provider.mergeItem(key, changes, modifiedData);
+    mergeItem: (key, deltaChanges, preMergedValue, shouldSetValue = false) => tryOrDegradePerformance(() => {
+        const promise = provider.mergeItem(key, deltaChanges, preMergedValue, shouldSetValue);
         if (shouldKeepInstancesSync) {
             return promise.then(() => InstanceSync_1.default.mergeItem(key));
         }

package/dist/storage/providers/IDBKeyValProvider.js

@@ -37,9 +37,9 @@ const provider = {
             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) => (0, idb_keyval_1.setMany)(pairs, idbKeyValStore),
     clear: () => (0, idb_keyval_1.clear)(idbKeyValStore),

package/dist/storage/providers/MemoryOnlyProvider.js

@@ -64,9 +64,9 @@ const provider = {
     /**
      * 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);
     },
     /**
      * Multiple merging of existing and new values in a batch

package/dist/storage/providers/SQLiteProvider.js

@@ -68,8 +68,11 @@ const provider = {
         });
         return db.executeBatchAsync([[query, queryArguments]]);
     },
-    mergeItem(key, changes) {
-        return this.multiMerge([[key, changes]]);
+    mergeItem(key, deltaChanges, preMergedValue, shouldSetValue) {
+        if (shouldSetValue) {
+            return this.setItem(key, preMergedValue);
+        }
+        return this.multiMerge([[key, deltaChanges]]);
     },
     getAllKeys: () => db.executeAsync('SELECT record_key FROM keyvaluepairs;').then(({ rows }) => {
         // eslint-disable-next-line no-underscore-dangle

package/dist/storage/providers/types.d.ts

@@ -35,10 +35,11 @@ type StorageProvider = {
     multiMerge: (pairs: KeyValuePairList) => Promise<BatchQueryResult | IDBValidKey[] | void>;
     /**
      * 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`
+     * @param shouldSetValue - whether the data should be set instead of merged
      */
-    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
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "2.0.26",
+  "version": "2.0.27",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",