react-native-onyx 3.0.84 → 3.0.86

package/dist/OnyxCache.d.ts

@@ -122,8 +122,10 @@ declare class OnyxCache {
     addEvictableKeysToRecentlyAccessedList(isCollectionKeyFn: (key: OnyxKey) => boolean, getAllKeysFn: () => Promise<Set<OnyxKey>>): Promise<void>;
     /**
      * Finds the least recently accessed key that can be safely evicted from storage.
+     * `excludeKeys` skips keys that must not be evicted (e.g. the in-flight write's own keys,
+     * whose cache value is the merge base the retry depends on).
      */
-    getKeyForEviction(): OnyxKey | undefined;
+    getKeyForEviction(excludeKeys?: Set<OnyxKey>): OnyxKey | undefined;
     /**
      * Set the collection keys for optimized storage
      */

package/dist/OnyxCache.js

@@ -265,11 +265,18 @@ class OnyxCache {
     }
     /**
      * Finds the least recently accessed key that can be safely evicted from storage.
+     * `excludeKeys` skips keys that must not be evicted (e.g. the in-flight write's own keys,
+     * whose cache value is the merge base the retry depends on).
      */
-    getKeyForEviction() {
+    getKeyForEviction(excludeKeys) {
         // recentlyAccessedKeys is ordered from least to most recently accessed,
-        // so the first element is the best candidate for eviction.
-        return this.recentlyAccessedKeys.values().next().value;
+        // so the first non-excluded key is the best candidate for eviction.
+        for (const key of this.recentlyAccessedKeys) {
+            if (!(excludeKeys === null || excludeKeys === void 0 ? void 0 : excludeKeys.has(key))) {
+                return key;
+            }
+        }
+        return undefined;
     }
     /**
      * Set the collection keys for optimized storage

package/dist/OnyxUtils.d.ts

@@ -140,7 +140,7 @@ declare function reportStorageQuota(error?: Error): Promise<void>;
  * - Non-retriable errors: logs an alert and resolves without retrying
  * - Other errors: retries the operation
  */
-declare function retryOperation<TMethod extends RetriableOnyxOperation>(error: Error, onyxMethod: TMethod, defaultParams: Parameters<TMethod>[0], retryAttempt: number | undefined): Promise<void>;
+declare function retryOperation<TMethod extends RetriableOnyxOperation>(error: Error, onyxMethod: TMethod, defaultParams: Parameters<TMethod>[0], retryAttempt: number | undefined, inFlightKeys?: Set<OnyxKey>): Promise<void>;
 /**
  * Notifies subscribers and writes current value to cache
  */

package/dist/OnyxUtils.js

@@ -679,7 +679,7 @@ function reportStorageQuota(error) {
  * - Non-retriable errors: logs an alert and resolves without retrying
  * - Other errors: retries the operation
  */
-function retryOperation(error, onyxMethod, defaultParams, retryAttempt) {
+function retryOperation(error, onyxMethod, defaultParams, retryAttempt, inFlightKeys) {
     var _a, _b, _c, _d;
     const currentRetryAttempt = retryAttempt !== null && retryAttempt !== void 0 ? retryAttempt : 0;
     const nextRetryAttempt = currentRetryAttempt + 1;
@@ -704,8 +704,10 @@ function retryOperation(error, onyxMethod, defaultParams, retryAttempt) {
         // @ts-expect-error No overload matches this call.
         return onyxMethod(defaultParams, nextRetryAttempt);
     }
-    // Find the least recently accessed evictable key that we can remove
-    const keyForRemoval = OnyxCache_1.default.getKeyForEviction();
+    // Find the least recently accessed evictable key that we can remove. Never evict an in-flight
+    // key — its cache value is the merge base this retry depends on, so dropping it would truncate
+    // the write to just the delta and diverge cache from storage.
+    const keyForRemoval = OnyxCache_1.default.getKeyForEviction(inFlightKeys);
     if (!keyForRemoval) {
         // If we have no acceptable keys to remove then we are possibly trying to save mission critical data. If this is the case,
         // then we should stop retrying as there is not much the user can do to fix this. Instead of getting them stuck in an infinite loop we
@@ -1177,21 +1179,29 @@ function multiSetWithRetry(data, retryAttempt) {
             // so re-entrant callbacks (e.g. Onyx.set inside a callback) see consistent cache
             // and subscriber state, matching the original per-key notification semantics.
             OnyxCache_1.default.set(key, value);
-            keyChanged(key, value);
+            // Skip subscriber notification on retry — already notified on attempt 0.
+            // waitForCollectionCallback subscribers re-fire on every keyChanged by contract.
+            if (!retryAttempt) {
+                keyChanged(key, value);
+            }
         }
     }
     // One keysChanged() per collection — fires each collection-level subscriber once and lets
     // keysChanged() internally decide which individual member subscribers need notification.
-    for (const [collectionKey, batch] of collectionBatches) {
-        keysChanged(collectionKey, batch.partial, batch.previous);
+    // Skip on retry — already notified on attempt 0 (see same-reason comment above).
+    if (!retryAttempt) {
+        for (const [collectionKey, batch] of collectionBatches) {
+            keysChanged(collectionKey, batch.partial, batch.previous);
+        }
     }
     const keyValuePairsToStore = keyValuePairsToSet.filter((keyValuePair) => {
         const [key] = keyValuePair;
         // Filter out the RAM-only key value pairs, as they should not be saved to storage
         return !OnyxKeys_1.default.isRamOnlyKey(key);
     });
+    const inFlightKeys = new Set(keyValuePairsToSet.map(([key]) => key));
     return storage_1.default.multiSet(keyValuePairsToStore)
-        .catch((error) => OnyxUtils.retryOperation(error, multiSetWithRetry, newData, retryAttempt))
+        .catch((error) => OnyxUtils.retryOperation(error, multiSetWithRetry, newData, retryAttempt, inFlightKeys))
         .then(() => {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.MULTI_SET, undefined, newData);
     });
@@ -1247,14 +1257,19 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
         const previousCollection = OnyxUtils.getCachedCollection(collectionKey);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        keysChanged(collectionKey, mutableCollection, previousCollection);
+        // Skip subscriber notification on retry — already notified on attempt 0.
+        // waitForCollectionCallback subscribers re-fire on every keysChanged by contract.
+        if (!retryAttempt) {
+            keysChanged(collectionKey, mutableCollection, previousCollection);
+        }
         // RAM-only keys are not supposed to be saved to storage
         if (OnyxKeys_1.default.isRamOnlyKey(collectionKey)) {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
             return;
         }
+        const inFlightKeys = new Set(keyValuePairs.map(([key]) => key));
         return storage_1.default.multiSet(keyValuePairs)
-            .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt))
+            .catch((error) => OnyxUtils.retryOperation(error, setCollectionWithRetry, { collectionKey, collection }, retryAttempt, inFlightKeys))
             .then(() => {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
         });
@@ -1364,10 +1379,15 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
             // write fails.
             const previousCollection = getCachedCollection(collectionKey, existingKeys);
             OnyxCache_1.default.merge(finalMergedCollection);
-            keysChanged(collectionKey, finalMergedCollection, previousCollection);
+            // Skip subscriber notification on retry — already notified on attempt 0.
+            // waitForCollectionCallback subscribers re-fire on every keysChanged by contract.
+            if (!retryAttempt) {
+                keysChanged(collectionKey, finalMergedCollection, previousCollection);
+            }
             const promises = [];
-            // New keys will be added via multiSet while existing keys will be updated using multiMerge
-            // This is because setting a key that doesn't exist yet with multiMerge will throw errors
+            // New keys go through multiSet and existing keys through multiMerge. multiMerge on a
+            // missing key stores the value just like multiSet across all backends; splitting them lets
+            // multiSet strip nested nulls (the merge layer keeps them to delete nested storage keys).
             // We can skip this step for RAM-only keys as they should never be saved to storage
             if (!OnyxKeys_1.default.isRamOnlyKey(collectionKey) && keyValuePairsForExistingCollection.length > 0) {
                 promises.push(storage_1.default.multiMerge(keyValuePairsForExistingCollection));
@@ -1376,8 +1396,9 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
             if (!OnyxKeys_1.default.isRamOnlyKey(collectionKey) && keyValuePairsForNewCollection.length > 0) {
                 promises.push(storage_1.default.multiSet(keyValuePairsForNewCollection));
             }
+            const inFlightKeys = new Set(Object.keys(finalMergedCollection));
             return Promise.all(promises)
-                .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt))
+                .catch((error) => retryOperation(error, mergeCollectionWithPatches, { collectionKey, collection: resultCollection, mergeReplaceNullPatches, isProcessingCollectionUpdate }, retryAttempt, inFlightKeys))
                 .then(() => {
                 sendActionToDevTools(METHOD.MERGE_COLLECTION, undefined, resultCollection);
             });
@@ -1427,13 +1448,18 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         const keyValuePairs = prepareKeyValuePairsForStorage(mutableCollection, true, undefined, true);
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
-        keysChanged(collectionKey, mutableCollection, previousCollection);
+        // Skip subscriber notification on retry — already notified on attempt 0.
+        // waitForCollectionCallback subscribers re-fire on every keysChanged by contract.
+        if (!retryAttempt) {
+            keysChanged(collectionKey, mutableCollection, previousCollection);
+        }
         if (OnyxKeys_1.default.isRamOnlyKey(collectionKey)) {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
             return;
         }
+        const inFlightKeys = new Set(keyValuePairs.map(([key]) => key));
         return storage_1.default.multiSet(keyValuePairs)
-            .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt))
+            .catch((error) => retryOperation(error, partialSetCollection, { collectionKey, collection }, retryAttempt, inFlightKeys))
             .then(() => {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
         });

package/dist/storage/providers/IDBKeyValProvider/index.js

@@ -41,6 +41,17 @@ const utils_1 = __importDefault(require("../../../utils"));
 const createStore_1 = __importDefault(require("./createStore"));
 const DB_NAME = 'OnyxDB';
 const STORE_NAME = 'keyvaluepairs';
+/**
+ * Awaits an IndexedDB write transaction. idb-keyval's promisifyRequest rejects with
+ * `transaction.error`, which is `null` for an abort not caused by its own request
+ * (connection close / versionchange / a sibling transaction aborting). Normalize that
+ * `null` into a tagged AbortError.
+ */
+function promisifyWriteTransaction(transaction) {
+    return IDB.promisifyRequest(transaction).catch((error) => {
+        throw error !== null && error !== void 0 ? error : new DOMException('IDB write transaction aborted without an error', 'AbortError');
+    });
+}
 const provider = {
     // We don't want to initialize the store while the JS bundle loads as idb-keyval will try to use global.indexedDB
     // which might not be available in certain environments that load the bundle (e.g. electron main process).
@@ -66,7 +77,13 @@ const provider = {
         if (value === null) {
             return provider.removeItem(key);
         }
-        return IDB.set(key, value, provider.store);
+        // Drive the write through the manual store transaction so promisifyWriteTransaction can
+        // normalize a null abort error — idb-keyval's IDB.set() awaits the raw transaction and
+        // would propagate the unclassifiable "Error: null".
+        return provider.store('readwrite', (store) => {
+            store.put(value, key);
+            return promisifyWriteTransaction(store.transaction);
+        });
     },
     multiGet(keysParam) {
         if (!provider.store) {
@@ -95,7 +112,7 @@ const provider = {
                         store.put(newValue, key);
                     }
                 }
-                return IDB.promisifyRequest(store.transaction);
+                return promisifyWriteTransaction(store.transaction);
             });
         });
     },
@@ -116,7 +133,7 @@ const provider = {
                     store.put(value, key);
                 }
             }
-            return IDB.promisifyRequest(store.transaction);
+            return promisifyWriteTransaction(store.transaction);
         });
     },
     clear() {
@@ -149,13 +166,21 @@ const provider = {
         if (!provider.store) {
             throw new Error('Store not initialized!');
         }
-        return IDB.del(key, provider.store);
+        return provider.store('readwrite', (store) => {
+            store.delete(key);
+            return promisifyWriteTransaction(store.transaction);
+        });
     },
     removeItems(keysParam) {
         if (!provider.store) {
             throw new Error('Store not initialized!');
         }
-        return IDB.delMany(keysParam, provider.store);
+        return provider.store('readwrite', (store) => {
+            for (const key of keysParam) {
+                store.delete(key);
+            }
+            return promisifyWriteTransaction(store.transaction);
+        });
     },
     getDatabaseSize() {
         if (!provider.store) {

package/package.json

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