Fix SequentialQueue push() ordering regression

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

Author: adhorodyski

src/libs/Network/SequentialQueue.ts

@@ -57,6 +57,11 @@ let currentRequestPromise: Promise<void> | null = null;
 let isQueuePaused = false;
 const sequentialQueueRequestThrottle = new RequestThrottle('SequentialQueue');
 
+// Tracks the latest in-flight Onyx persistence write. process() awaits this before firing
+// the next XHR so the network call cannot race the Onyx.set() commit — if the process
+// is killed after fire but before disk commit, the request would be lost on next launch.
+let pendingPersistencePromise: Promise<void> = Promise.resolve();
+
 /**
  * Puts the queue into a paused state so that no requests will be processed
  */
@@ -162,7 +167,9 @@ function process(): Promise<void> {
     });
 
     // Set the current request to a promise awaiting its processing so that getCurrentRequest can be used to take some action after the current request has processed.
-    currentRequestPromise = processWithMiddleware(requestToProcess, true)
+    // Await pendingPersistencePromise so the XHR is not fired before the Onyx disk commit lands.
+    currentRequestPromise = pendingPersistencePromise
+        .then(() => processWithMiddleware(requestToProcess, true))
         .then((response) => {
             Log.info('[SequentialQueue] Request processed successfully', false, {
                 command: requestToProcess.command,
@@ -504,7 +511,7 @@ async function handleConflictActions<TKey extends OnyxKey>(conflictAction: Confl
     }
 }
 
-async function push<TKey extends OnyxKey>(newRequest: OnyxRequest<TKey>): Promise<void> {
+function push<TKey extends OnyxKey>(newRequest: OnyxRequest<TKey>): Promise<void> {
     const currentRequests = getAllPersistedRequests();
     Log.info('[SequentialQueue] push() called', false, {
         command: newRequest.command,
@@ -514,10 +521,11 @@ async function push<TKey extends OnyxKey>(newRequest: OnyxRequest<TKey>): Promis
         isSequentialQueueRunning,
     });
 
-    // Persist-before-fire: await disk write before any flush(). The in-memory update
-    // inside save()/handleConflictActions happens synchronously, but the network call
-    // must NOT race the Onyx.set() promise. If the process is killed after fire but
-    // before disk commit, the request is lost — no retry on next launch.
+    // save()/handleConflictActions update the in-memory queue synchronously and return a
+    // promise that resolves once the Onyx disk commit completes. flush() runs synchronously
+    // so isSequentialQueueRunning flips immediately and reads can park behind the queue.
+    // The persistencePromise is chained onto pendingPersistencePromise so process() can
+    // await it before firing the XHR — the network call must not race the disk commit.
     let persistencePromise: Promise<void>;
 
     if (newRequest.checkAndFixConflictingRequest) {
@@ -545,20 +553,15 @@ async function push<TKey extends OnyxKey>(newRequest: OnyxRequest<TKey>): Promis
         persistencePromise = savePersistedRequest(newRequest);
     }
 
-    await persistencePromise;
-    Log.info('[SequentialQueue] Request persisted, proceeding to flush', false, {
-        command: newRequest.command,
-        isOffline: isOfflineNetwork(),
-        isSequentialQueueRunning,
-    });
+    pendingPersistencePromise = pendingPersistencePromise.then(() => persistencePromise).catch(() => undefined);
 
     // If we are offline we don't need to trigger the queue to empty as it will happen when we come back online
     if (isOfflineNetwork()) {
         Log.info('[SequentialQueue] Request persisted but not flushing — we are offline', false, {
             command: newRequest.command,
             queueLength: getAllPersistedRequests().length,
         });
-        return;
+        return persistencePromise;
     }
 
     // If the queue is running this request will run once it has finished processing the current batch
@@ -572,13 +575,14 @@ async function push<TKey extends OnyxKey>(newRequest: OnyxRequest<TKey>): Promis
             });
             flush(true);
         });
-        return;
+        return persistencePromise;
     }
 
     Log.info('[SequentialQueue] Queue is not running. Flushing the queue.', false, {
         command: newRequest.command,
     });
     flush(true);
+    return persistencePromise;
 }
 
 function getCurrentRequest(): Promise<void> {

tests/unit/SequentialQueuePersistBeforeFireTest.ts

@@ -87,12 +87,19 @@ describe('SequentialQueue.push - persist-before-fire', () => {
     });
 
     it('at the await boundary, on-disk PERSISTED_REQUESTS already contains the new request', async () => {
-        await SequentialQueue.push({...request});
+        // Pause the queue so process() does not drain (and remove) the request before we can
+        // read it back. We are asserting persistence, not processing.
+        SequentialQueue.pause();
+        try {
+            await SequentialQueue.push({...request});
 
-        // Read straight from Onyx to confirm the persisted shape, not just in-memory state.
-        const onDisk = await OnyxUtils.get(ONYXKEYS.PERSISTED_REQUESTS);
-        expect(onDisk).toBeDefined();
-        expect(onDisk?.some((r) => r.command === request.command)).toBe(true);
+            // Read straight from Onyx to confirm the persisted shape, not just in-memory state.
+            const onDisk = await OnyxUtils.get(ONYXKEYS.PERSISTED_REQUESTS);
+            expect(onDisk).toBeDefined();
+            expect(onDisk?.some((r) => r.command === request.command)).toBe(true);
+        } finally {
+            SequentialQueue.unpause();
+        }
     });
 
     it('offline: push() resolves after persistence and does not call fetch', async () => {