[$250] App update clears Onyx data not synced with server / PERSISTED_REQUESTS must be preserved during Onyx.clear()

[MelvinBot]

Split from https://github.com/Expensify/Expensify/issues/618149

Problem

When Onyx.clear() is called (e.g., via the RESET_REQUIRED listener), the PERSISTED_REQUESTS queue — which holds all offline API requests waiting to sync — is wiped because it is not in the KEYS_TO_PRESERVE list. This causes permanent loss of offline-created expenses that were never synced to the server.

Customers are reporting missing expenses after app updates. Investigation confirms these expenses were created offline and existed only in the Onyx cache / SequentialQueue.

Root Cause

There are three data loss vectors:

1. RESET_REQUIRED listener wipes offline queue

The listener at App.ts:154-168 calls Onyx.clear(KEYS_TO_PRESERVE) then openApp() without saving/restoring the SequentialQueue.

Contrast with clearOnyxAndResetApp() at App.ts:827-876 which correctly snapshots the queue first:

function clearOnyxAndResetApp() {
    const sequentialQueue = getAll();          // ← Saves queue first
    rollbackOngoingRequest();
    Onyx.clear(KEYS_TO_PRESERVE).then(() => {
        openApp().then(() => {
            for (const request of sequentialQueue) { save(request); }  // ← Restores queue
        });
    });
}

2. Full reconnect replaces local state

When the server returns previousUpdateID=0 (triggered when clientUpdateID is stale or -1), a Pusher ReconnectApp event causes a full state replacement from the server — which knows nothing about expenses that were never synced.

3. Processing window vulnerability

In PersistedRequests.ts:255-284, when a request starts processing, it's removed from PERSISTED_REQUESTS and held only in memory. Expense creation commands do not set persistWhenOngoing, so if the app is killed during this window, the request is lost.

Recommended Fix

1. Add ONYXKEYS.PERSISTED_REQUESTS and ONYXKEYS.PERSISTED_ONGOING_REQUESTS to the KEYS_TO_PRESERVE list in App.ts:122-146, OR modify the RESET_REQUIRED listener to snapshot/restore the queue the same way clearOnyxAndResetApp() already does.

2. Set persistWhenOngoing: true for expense creation commands (REQUEST_MONEY, TRACK_EXPENSE, SPLIT_BILL_AND_OPEN_REPORT, etc.) so in-flight requests survive app kills.

Relevant Code

• App.ts:122-168 — KEYS_TO_PRESERVE list + RESET_REQUIRED listener
• App.ts:827-876 — clearOnyxAndResetApp (correct pattern for queue preservation)
• PersistedRequests.ts:107-147,255-284 — Request persistence + processing window
• Network/enhanceParameters.ts:11 — clientUpdateID defaults to -1
• SignInRedirect.ts:47-105 — Another Onyx.clear() path that doesn't preserve the queue

Implementation Notes

• Adding PERSISTED_REQUESTS to KEYS_TO_PRESERVE is the simplest fix for the RESET_REQUIRED path, but care must be taken to ensure the queue is processed correctly after openApp() refreshes the Onyx state (since the optimistic data keys the queue references will have been cleared)
• The persistWhenOngoing flag already exists in the infrastructure — expense creation commands just need to opt into it

Issue Owner

Current Issue Owner: @ShridharGoel

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022039242963579817769
• Upwork Job ID: 2039242963579817769
• Last Price Increase: 2026-04-01

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @ShridharGoel (External)

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022039242963579817769

[trasnake87]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When Onyx.clear() is called via the RESET_REQUIRED listener, the PERSISTED_REQUESTS queue (holding offline API requests) is wiped because it's not preserved, causing permanent loss of unsynced expenses.

What is the root cause of that problem?

The RESET_REQUIRED listener at App.ts:154-168 calls Onyx.clear(KEYS_TO_PRESERVE) without first snapshotting the sequential queue. ONYXKEYS.PERSISTED_REQUESTS and ONYXKEYS.PERSISTED_ONGOING_REQUESTS are not in the KEYS_TO_PRESERVE list, so the queue is destroyed. The correct pattern already exists in clearOnyxAndResetApp() at App.ts:827-876, which snapshots and restores the queue — but the RESET_REQUIRED listener doesn't use it.

What changes do you think we should make in order to solve the problem?

We should modify the RESET_REQUIRED listener to snapshot and restore the sequential queue, matching the existing pattern in clearOnyxAndResetApp():

// App.ts, RESET_REQUIRED listener (~line 154)
Onyx.connectWithoutView({
    key: ONYXKEYS.RESET_REQUIRED,
    callback: (isResetRequired) => {
        if (!isResetRequired) {
            return;
        }

        const sequentialQueue = getAll();
        rollbackOngoingRequest();

        Onyx.clear(KEYS_TO_PRESERVE).then(() => {
            Onyx.set(ONYXKEYS.RESET_REQUIRED, false);
            openApp().then(() => {
                for (const request of sequentialQueue) {
                    save(request);
                }
            });
        });
    },
});

The getAll, rollbackOngoingRequest, and save imports are already present in App.ts (used by clearOnyxAndResetApp). This ensures offline requests survive the reset, and by restoring them after openApp() resolves, we maintain data consistency — the fresh Onyx state from openApp is established first, then the pending queue is re-enqueued for processing.

[trasnake87]

Contributor details
Your Expensify account email: trasnake87@gmail.com
Upwork Profile Link: https://www.upwork.com/freelancers/~010f770315ab181656

[melvin-bot]

✅ Contributor details stored successfully. Thank you for contributing to Expensify!