SequentialQueue: don't block the queue when a persist write fails

The conflict-resolution persist paths (update / deleteRequestsByIndices)
returned a raw Onyx.set that could reject. Awaiting that in push() before
flush() stranded isReadyPromise on a disk-write failure, hanging every
READ parked on waitForIdle() and never flushing the request.

These paths now swallow the rejection like save() already did — the
in-memory queue stays the source of truth for retry — and surface it via
Log.alert so a disk-write failure is observable rather than silent.
push() keeps a defensive try/catch so a persist rejection can never wedge
the queue; on failure it flushes best-effort, matching pre-async behavior.

Adds a regression test that fails on the pre-fix code.

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

Author: adhorodyski

src/libs/Network/SequentialQueue.ts

@@ -584,7 +584,13 @@ async function push<TKey extends OnyxKey>(newRequest: OnyxRequest<TKey>): Promis
 
     // Block until the Onyx disk commit lands so flush() → XHR cannot race the disk write —
     // a process kill in that window would lose the request on next launch.
-    await persistencePromise;
+    try {
+        await persistencePromise;
+    } catch {
+        // Backstop: persistence alerts+swallows on failure, so this shouldn't reject. If it ever does,
+        // flush anyway (the request is already in the in-memory queue) rather than stranding isReadyPromise.
+        Log.info('[SequentialQueue] Persist rejected — flushing anyway', false, {command: newRequest.command});
+    }
 
     // The network may have flipped offline while we awaited the disk write. flush() would
     // early-return on its offline check without resolving isReadyPromise, leaving READs parked

src/libs/actions/PersistedRequests.ts

@@ -260,10 +260,12 @@ function save<TKey extends OnyxKey>(requestToPersist: Request<TKey>): Promise<vo
                 queueLength: getLength(),
             });
         })
-        .catch(() => {
-            Log.info('[PersistedRequests] ERROR: Failed to persist request to disk', false, {
+        .catch((error) => {
+            // Disk-write failure risks losing this request on a crash — alert as a storage emergency.
+            Log.alert('[PersistedRequests] ERROR: Failed to persist request to disk', {
                 command: requestToPersist.command,
                 queueLength: getLength(),
+                error,
             });
         });
 }
@@ -334,9 +336,18 @@ function deleteRequestsByIndices(indices: number[]): Promise<void> {
     persistedRequests = persistedRequests.filter((_, index) => !indicesSet.has(index));
 
     // Update the persisted requests in storage or state as necessary
-    return trackOnyxWrite(Onyx.set(ONYXKEYS.PERSISTED_REQUESTS, persistedRequests)).then(() => {
-        Log.info(`Multiple (${indices.length}) requests removed from the queue. Queue length is ${persistedRequests.length}`);
-    });
+    return trackOnyxWrite(Onyx.set(ONYXKEYS.PERSISTED_REQUESTS, persistedRequests))
+        .then(() => {
+            Log.info(`Multiple (${indices.length}) requests removed from the queue. Queue length is ${persistedRequests.length}`);
+        })
+        .catch((error) => {
+            // Swallow so the conflict promise resolves (in-memory queue is the source of truth); alert as a storage emergency.
+            Log.alert('[PersistedRequests] ERROR: Failed to persist request deletion to disk', {
+                indicesCount: indices.length,
+                queueLength: getLength(),
+                error,
+            });
+        });
 }
 
 function update<TKey extends OnyxKey>(oldRequestIndex: number, newRequest: Request<TKey>): Promise<void> {
@@ -349,7 +360,14 @@ function update<TKey extends OnyxKey>(oldRequestIndex: number, newRequest: Reque
     if (requestIndex != null) {
         knownRequestIDs.add(requestIndex);
     }
-    return trackOnyxWrite(Onyx.set(ONYXKEYS.PERSISTED_REQUESTS, requests));
+    return trackOnyxWrite(Onyx.set(ONYXKEYS.PERSISTED_REQUESTS, requests)).catch((error) => {
+        // Swallow so the conflict promise resolves (in-memory queue is the source of truth); alert as a storage emergency.
+        Log.alert('[PersistedRequests] ERROR: Failed to persist updated request to disk', {
+            command: newRequest.command,
+            queueLength: getLength(),
+            error,
+        });
+    });
 }
 
 function shouldPersistOngoingRequest(request: AnyRequest | null): boolean {

tests/unit/SequentialQueueTest.ts

@@ -74,6 +74,45 @@ describe('SequentialQueue', () => {
         }
     });
 
+    it('should not block the queue when a disk write fails during persist', async () => {
+        // If a conflict-resolution disk write rejects (storage full / corruption), push() must not throw
+        // or strand isReadyPromise — the request should still flush and waitForIdle() should resolve.
+        const mockedFetch = global.fetch as ReturnType<typeof TestHelper.getGlobalFetchMock> & {pause: () => void; resume: () => Promise<void>};
+        const originalSet = Onyx.set.bind(Onyx);
+
+        mockedFetch.pause();
+        try {
+            await SequentialQueue.push({command: 'OpenReport'}); // occupies ongoingRequest
+            await waitForBatchedUpdates();
+            await SequentialQueue.push(request); // ReconnectApp stacks in the queue
+
+            // Fail the conflict-resolution persist (a raw Onyx.set on the persisted-requests key).
+            const setMock = jest
+                .spyOn(Onyx, 'set')
+                .mockImplementation((key, value) => (key === ONYXKEYS.PERSISTED_REQUESTS ? Promise.reject(new Error('simulated disk-write failure')) : originalSet(key, value)));
+            try {
+                const replacing: Request<never> = {
+                    command: 'ReconnectApp',
+                    data: {accountID: 56789},
+                    checkAndFixConflictingRequest: (persistedRequests) => {
+                        const index = persistedRequests.findIndex((r) => r.command === 'ReconnectApp');
+                        return {conflictAction: index === -1 ? {type: 'push'} : {type: 'replace', index}};
+                    },
+                };
+                // The failed disk write must not reject the caller.
+                await expect(SequentialQueue.push(replacing)).resolves.toBeUndefined();
+            } finally {
+                setMock.mockRestore();
+            }
+        } finally {
+            await mockedFetch.resume();
+        }
+
+        // The queue still drains and READs unblock — a hang here would fail the test by timing out.
+        await SequentialQueue.waitForIdle();
+        expect(getLength()).toBe(0);
+    });
+
     it('should push two requests with conflict resolution and replace', async () => {
         // Pause the queue so `process()` does not consume the first request before
         // the conflict resolver runs. Under persist-before-fire `push()` is async,