react-native-onyx 3.0.85 → 3.0.87

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/createStore.js

@@ -69,6 +69,10 @@ function getBudgetedHealErrorLabel(error) {
         return 'connection lost';
     return 'unknown';
 }
+/** Union of all error types indicating a stale/dead IDB connection. Used by the visibilitychange probe. */
+function isStaleConnectionError(error) {
+    return isInvalidStateError(error) || isBackingStoreError(error) || isConnectionLostError(error);
+}
 // This is a copy of the createStore function from idb-keyval, we need a custom implementation
 // because we need to create the database manually in order to ensure that the store exists before we use it.
 // If the store does not exist, idb-keyval will throw an error
@@ -146,6 +150,52 @@ function createStore(dbName, storeName) {
         healAttemptsRemaining = HEAL_ATTEMPTS_MAX;
         return result;
     }
+    // Proactive IDB health check when tab returns to foreground.
+    // Safari kills IDB connections for backgrounded tabs. By probing as soon as
+    // the tab becomes visible, we drop the stale dbp early so the first real
+    // operation opens a fresh connection instead of failing.
+    document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState !== 'visible' || !dbp) {
+            return;
+        }
+        Logger.logInfo('IDB visibilitychange probe: tab became visible, checking connection health', { dbName, storeName });
+        const probePromise = dbp;
+        const dropCacheIfStale = (error) => {
+            if (dbp !== probePromise || !isStaleConnectionError(error)) {
+                return;
+            }
+            Logger.logAlert('IDB visibilitychange probe: stale connection detected, dropping cached connection', {
+                dbName,
+                storeName,
+                errorMessage: error instanceof Error ? error.message : String(error),
+            });
+            dbp = undefined;
+        };
+        probePromise
+            .then((db) => {
+            if (dbp !== probePromise) {
+                return;
+            }
+            try {
+                const tx = db.transaction(storeName, 'readonly');
+                const probeStore = tx.objectStore(storeName);
+                const req = probeStore.count();
+                req.onsuccess = () => {
+                    Logger.logInfo('IDB visibilitychange probe: connection is healthy', { dbName, storeName });
+                };
+                req.onerror = () => {
+                    dropCacheIfStale(req.error);
+                };
+            }
+            catch (error) {
+                dropCacheIfStale(error);
+            }
+        })
+            .catch(() => {
+            // The cached open promise rejected; cacheOpenPromise already cleared dbp on its own
+            // branch. Swallow here so the probe's separate branch doesn't surface an unhandled rejection.
+        });
+    });
     // Handles three recoverable error classes:
     // 1. InvalidStateError — connection closed between getDB() resolving and db.transaction().
     //    Retry once with a fresh connection. No budget limit (transient, always worth one reopen).

package/package.json

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