fix: handle probe promise rejection to avoid unhandled rejection

The visibilitychange probe adds a separate .then branch off the cached
open promise. If the tab becomes visible while dbp is still a pending
indexedDB.open() that later rejects, that branch rejected with no handler,
surfacing an unhandled rejection on foregrounding. Add a .catch on the
probe chain (cacheOpenPromise already clears dbp on its own branch).

Addresses PR Expensify#788 review (chatgpt-codex-connector).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: elirangoshen

lib/storage/providers/IDBKeyValProvider/createStore.ts

@@ -157,24 +157,29 @@ function createStore(dbName: string, storeName: string): UseStore {
             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);
-            }
-        });
+        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:

tests/unit/storage/providers/createStoreTest.ts

@@ -666,5 +666,50 @@ describe('createStore', () => {
             expect(result).toBe('value');
             expect(logAlertSpy).toHaveBeenCalledWith(expect.stringContaining('IDB visibilitychange probe: stale connection detected'), expect.objectContaining({dbName: expect.any(String)}));
         });
+
+        it('should not surface an unhandled rejection when the probe runs while the open promise rejects', async () => {
+            const store = createStore(uniqueDBName(), STORE_NAME);
+
+            // Keep the initial open pending until we reject it manually, so the probe attaches to a pending dbp.
+            let rejectOpen: () => void = () => {
+                /* assigned inside the indexedDB.open mock below */
+            };
+            jest.spyOn(indexedDB, 'open').mockImplementation(() => {
+                const req = {} as IDBOpenDBRequest;
+                rejectOpen = () => {
+                    Object.defineProperty(req, 'error', {value: new DOMException('probe open failed', 'AbortError'), configurable: true});
+                    req.onerror?.(new Event('error') as Event & {target: IDBOpenDBRequest});
+                };
+                return req;
+            });
+
+            const unhandled = jest.fn();
+            process.on('unhandledRejection', unhandled);
+
+            try {
+                // Start an op so dbp becomes a pending open promise; keep its rejection handled.
+                const opAssertion = expect(store('readonly', (s) => IDB.promisifyRequest(s.get('key1')))).rejects.toThrow('probe open failed');
+
+                // Tab becomes visible while the open is still pending — probe attaches to the pending dbp.
+                simulateVisibilityChange('hidden');
+                simulateVisibilityChange('visible');
+
+                // Now the open rejects — both the op chain and the probe chain see it.
+                rejectOpen();
+
+                await opAssertion;
+                // Give the probe's separate branch a couple of ticks to (not) surface an unhandled rejection.
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 0);
+                });
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 0);
+                });
+
+                expect(unhandled).not.toHaveBeenCalled();
+            } finally {
+                process.off('unhandledRejection', unhandled);
+            }
+        });
     });
 });