react-native-onyx 3.0.115 → 3.0.116

package/dist/Onyx.js

@@ -239,16 +239,18 @@ function merge(key, changes) {
             mergeQueue[key].push(changes);
             return mergeQueuePromise[key];
         }
-        mergeQueue[key] = [changes];
+        const queuedChanges = [changes];
+        mergeQueue[key] = queuedChanges;
         mergeQueuePromise[key] = OnyxUtils_1.default.get(key).then((valueFromGet) => {
             // Calls to Onyx.set after a merge will terminate the current merge process and clear the merge queue
-            if (mergeQueue[key] == null) {
+            if (mergeQueue[key] !== queuedChanges) {
                 return Promise.resolve();
             }
             // Other writers (notably Onyx.update's mergeCollection path, which doesn't participate in mergeQueue)
             // can land between get() resolving and this callback running. Applying the delta on top of the value
             // captured back then and broadcasting it would overwrite those writes wholesale, so re-read the cache.
-            const existingValue = OnyxCache_1.default.hasCacheForKey(key) ? OnyxCache_1.default.get(key) : valueFromGet;
+            const baseValue = OnyxUtils_1.default.hasStaleMergeRead(queuedChanges) ? undefined : valueFromGet;
+            const existingValue = OnyxCache_1.default.hasCacheForKey(key) ? OnyxCache_1.default.get(key) : baseValue;
             try {
                 const validChanges = mergeQueue[key].filter((change) => {
                     const { isCompatible, existingValueType, newValueType, isEmptyArrayCoercion } = utils_1.default.checkCompatibilityWithExistingValue(change, existingValue);
@@ -327,6 +329,7 @@ function mergeCollection(collectionKey, collection) {
  */
 function clear(keysToPreserve = []) {
     return OnyxUtils_1.default.afterInit(() => {
+        const pendingMergeEntries = OnyxUtils_1.default.getPendingMergeEntries(keysToPreserve);
         const defaultKeyStates = OnyxUtils_1.default.getDefaultKeyStates();
         const initialKeys = Object.keys(defaultKeyStates);
         const promise = OnyxUtils_1.default.getAllKeys()
@@ -339,6 +342,7 @@ function clear(keysToPreserve = []) {
             // because the notification process needs the old values in cache but at that point they will be already removed from it.
             const keyValuesToResetAsCollection = {};
             const allKeys = new Set([...cachedKeys, ...initialKeys]);
+            OnyxUtils_1.default.cancelPendingMerges(pendingMergeEntries);
             // The only keys that should not be cleared are:
             // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
             //      status, or activeClients need to remain in Onyx even when signed out)

package/dist/OnyxUtils.d.ts

@@ -164,6 +164,10 @@ declare function retryOperation<TMethod extends RetriableOnyxOperation>(error: E
  */
 declare function broadcastUpdate<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TKey>, hasChanged?: boolean): void;
 declare function hasPendingMergeForKey(key: OnyxKey): boolean;
+type PendingMergeEntry = [OnyxKey, Array<OnyxValue<OnyxKey>>, number];
+declare function getPendingMergeEntries(keysToPreserve: OnyxKey[]): PendingMergeEntry[];
+declare function cancelPendingMerges(entries: PendingMergeEntry[]): void;
+declare function hasStaleMergeRead(queuedChanges: Array<OnyxValue<OnyxKey>>): boolean;
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
@@ -305,6 +309,9 @@ declare const OnyxUtils: {
     retryOperation: typeof retryOperation;
     broadcastUpdate: typeof broadcastUpdate;
     hasPendingMergeForKey: typeof hasPendingMergeForKey;
+    getPendingMergeEntries: typeof getPendingMergeEntries;
+    cancelPendingMerges: typeof cancelPendingMerges;
+    hasStaleMergeRead: typeof hasStaleMergeRead;
     prepareKeyValuePairsForStorage: typeof prepareKeyValuePairsForStorage;
     mergeChanges: typeof mergeChanges;
     mergeAndMarkChanges: typeof mergeAndMarkChanges;

package/dist/OnyxUtils.js

@@ -74,6 +74,7 @@ function formatCaughtError(error) {
 // Key/value store of Onyx key and arrays of values to merge
 let mergeQueue = {};
 let mergeQueuePromise = {};
+const mergeQueuesWithStaleRead = new WeakSet();
 // Holds a mapping of all the React components that want their state subscribed to a store key
 let callbackToStateMapping = {};
 // Holds a mapping of the connected key to the subscriptionID for faster lookups
@@ -773,6 +774,52 @@ function broadcastUpdate(key, value, hasChanged) {
 function hasPendingMergeForKey(key) {
     return !!mergeQueue[key];
 }
+function cancelPendingMergesForKey(key) {
+    delete mergeQueue[key];
+    delete mergeQueuePromise[key];
+}
+function cancelPendingMergesForCollection(collectionKey) {
+    for (const key of Object.keys(mergeQueue)) {
+        if (!OnyxKeys_1.default.isCollectionMemberKey(collectionKey, key)) {
+            continue;
+        }
+        cancelPendingMergesForKey(key);
+    }
+}
+function getPendingMergeEntries(keysToPreserve) {
+    return Object.entries(mergeQueue)
+        .filter(([key]) => !keysToPreserve.some((preserveKey) => OnyxKeys_1.default.isKeyMatch(preserveKey, key)))
+        .map(([key, queuedChanges]) => [key, queuedChanges, queuedChanges.length]);
+}
+function cancelPendingMerges(entries) {
+    for (const [key, queuedChanges, capturedLength] of entries) {
+        if (mergeQueue[key] !== queuedChanges) {
+            continue;
+        }
+        if (queuedChanges.length === capturedLength) {
+            cancelPendingMergesForKey(key);
+            continue;
+        }
+        queuedChanges.splice(0, capturedLength);
+        mergeQueuesWithStaleRead.add(queuedChanges);
+    }
+}
+function hasStaleMergeRead(queuedChanges) {
+    return mergeQueuesWithStaleRead.has(queuedChanges);
+}
+function cancelPendingMergesForKeys(keys) {
+    for (const key of keys) {
+        cancelPendingMergesForKey(key);
+    }
+}
+function cancelPendingMergesForNullMembers(collection) {
+    for (const [key, value] of Object.entries(collection)) {
+        if (value !== null) {
+            continue;
+        }
+        cancelPendingMergesForKey(key);
+    }
+}
 /**
  * Storage expects array like: [["@MyApp_user", value_1], ["@MyApp_key", value_2]]
  * This method transforms an object like {'@MyApp_user': myUserValue, '@MyApp_key': myKeyValue}
@@ -1197,6 +1244,9 @@ function multiSetWithRetry(data, retryAttempt) {
         }, {});
     }
     const { pairs: keyValuePairsToSet, keysToRemove: removalCandidates } = OnyxUtils.prepareKeyValuePairsForStorage(newData, true);
+    if (!retryAttempt) {
+        cancelPendingMergesForKeys(removalCandidates);
+    }
     // Removals of keys that are neither cached nor persisted are no-ops and skipped. When the key
     // index has not been loaded yet (empty set), keep the removal to be safe.
     const persistedKeys = OnyxCache_1.default.getAllKeys();
@@ -1321,6 +1371,9 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         }, {});
     }
     resultCollectionKeys = Object.keys(resultCollection);
+    if (!retryAttempt) {
+        cancelPendingMergesForCollection(collectionKey);
+    }
     return OnyxUtils.getAllKeys().then((persistedKeys) => {
         const mutableCollection = Object.assign({}, resultCollection);
         for (const key of persistedKeys) {
@@ -1408,6 +1461,9 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         }, {});
     }
     resultCollectionKeys = Object.keys(resultCollection);
+    if (!retryAttempt) {
+        cancelPendingMergesForNullMembers(resultCollection);
+    }
     return getAllKeys()
         .then((persistedKeys) => {
         // Split to keys that exist in storage and keys that don't. Null members are collected
@@ -1561,6 +1617,9 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         }, {});
     }
     resultCollectionKeys = Object.keys(resultCollection);
+    if (!retryAttempt) {
+        cancelPendingMergesForKeys(resultCollectionKeys);
+    }
     return getAllKeys().then((persistedKeys) => {
         const mutableCollection = Object.assign({}, resultCollection);
         const existingKeys = resultCollectionKeys.filter((key) => persistedKeys.has(key));
@@ -1638,6 +1697,9 @@ const OnyxUtils = {
     retryOperation,
     broadcastUpdate,
     hasPendingMergeForKey,
+    getPendingMergeEntries,
+    cancelPendingMerges,
+    hasStaleMergeRead,
     prepareKeyValuePairsForStorage,
     mergeChanges,
     mergeAndMarkChanges,

package/package.json

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