[$250] Don't fire duplicate ReconnectApp on delegate account switch

[MelvinBot]

This issue tracks the fix for duplicate ReconnectApp requests being fired when switching accounts via delegate access.

When a user switches accounts via delegate access, the app sends OpenApp and then an unnecessary ReconnectApp right after. The OpenApp already performs a full sync, making the subsequent ReconnectApp wasted work.

PR: #89262

---

cc @mountiny @TMisiukiewicz @abzokhattab

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022049849402501236092
• Upwork Job ID: 2049849402501236092
• Last Price Increase: 2026-04-30

[MelvinBot]

Issue Analysis

Root Cause: Race condition in Onyx update ordering during delegate account switching. Onyx.clear() wipes LAST_FULL_RECONNECT_TIME to empty, then when the OpenApp response arrives, applyHTTPSOnyxUpdates processes response.onyxData (containing server's NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE) before successData (which sets LAST_FULL_RECONNECT_TIME). This causes subscribeToFullReconnect to see '' < serverTimestamp → true, firing a spurious ReconnectApp.

Recommended Fix: PR #89262 correctly addresses this by seeding LAST_FULL_RECONNECT_TIME with the current time before Onyx.clear() and preserving it through the clear, so the timestamp is already satisfied when the server NVP arrives.

Investigation details

Data flow:

1. User initiates delegate switch → Delegate.connect() calls Onyx.clear(KEYS_TO_PRESERVE_DELEGATE_ACCESS) — LAST_FULL_RECONNECT_TIME is NOT in the preserve list, so it gets wiped to ''
2. openApp() fires and server responds
3. applyHTTPSOnyxUpdates processes response.onyxData first → NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE gets a real timestamp
4. Onyx subscriber in subscribeToFullReconnect.ts fires: '' < serverTimestamp → triggers reconnectApp() (duplicate)
5. Only then does successData set LAST_FULL_RECONNECT_TIME via App.ts:371-377 — too late

Alternative explanations considered:

• Network reconnect or visibility change triggering ReconnectApp independently — ruled out; the timing (immediately after OpenApp response) points to the Onyx ordering race
• Multiple openApp() calls — no evidence of this in the delegate flow

PR assessment: The fix in #89262 is correct and well-targeted. The new clearOnyxForDelegateTransition() helper sets LAST_FULL_RECONNECT_TIME to current time via Onyx.merge, then passes it as a preserved key to Onyx.clear(). Applied to all four relevant call sites: connect(), disconnect(), restoreDelegateSession(), and setupNewDotAfterTransitionFromOldDot().

---

Next Steps: Reply with @MelvinBot implement this to create a draft PR, or @MelvinBot <your feedback> to refine this analysis.

[melvin-bot]

Current assignee @abzokhattab is eligible for the External assigner, not assigning anyone new.

[melvin-bot]

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

[oqildev]

Proposal

Root cause?

Onyx.clear(KEYS_TO_PRESERVE_DELEGATE_ACCESS) wipes both LAST_FULL_RECONNECT_TIME and NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE to ''. Then openApp() fires, and when the response arrives applyHTTPSOnyxUpdates applies onyxData before successData. This means NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE gets set to a server timestamp first — the subscribeToFullReconnect subscriber fires with '' < serverTimestamp → reconnectApp() fires. Only afterwards does successData set LAST_FULL_RECONNECT_TIME to current time — too late.

The race isn't delegate-specific; it's structural: openApp() is already doing a full sync and will stamp LAST_FULL_RECONNECT_TIME via successData, but the NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE check fires before that stamp lands.

What changes are needed?

Guard doFullReconnectIfNecessary() in subscribeToFullReconnect.ts with an isLoadingApp check. While openApp() is in progress (IS_LOADING_APP = true), a ReconnectApp is by definition redundant — the full sync is already underway and successData will set LAST_FULL_RECONNECT_TIME. Defer the check until loading completes:

// subscribeToFullReconnect.ts

let isLoadingApp = false;
Onyx.connectWithoutView({
    key: ONYXKEYS.IS_LOADING_APP,
    callback: (value) => {
        isLoadingApp = value ?? false;
        // Re-evaluate once openApp() finishes — catches the case where
        // successData never ran (e.g. network failure) and LAST_FULL_RECONNECT_TIME is still empty
        if (!isLoadingApp) {
            doFullReconnectIfNecessary();
        }
    },
});

function doFullReconnectIfNecessary() {
    if (lastFullReconnectTime >= reconnectAppIfFullReconnectBefore) {
        return;
    }
    if (isLoadingApp) {
        // openApp() is in progress and will set LAST_FULL_RECONNECT_TIME via successData
        return;
    }
    Log.info('Full reconnect triggered', false, {lastFullReconnectTime, reconnectAppIfFullReconnectBefore});
    reconnectApp();
}

Why this over alternatives?

• Single file, no new helpers: Everything lives in subscribeToFullReconnect.ts. No need to touch KEYS_TO_PRESERVE_DELEGATE_ACCESS, no new wrapper function, no changes across 4 call sites in Delegate.ts.
• Fixes the conceptual invariant, not the symptom: ReconnectApp should never fire while openApp() is running — that's the invariant. Encoding it here is cleaner than pre-seeding LAST_FULL_RECONNECT_TIME before every Onyx.clear() call.
• Handles openApp() failure correctly: If openApp() fails and successData never runs, IS_LOADING_APP transitions to false via finallyData, which re-triggers doFullReconnectIfNecessary(). At that point LAST_FULL_RECONNECT_TIME is still empty and reconnect fires correctly — better behavior than the status quo.
• Not delegate-specific: Works for any flow that calls openApp(), protecting against the same race in future contexts.

Tests:

• Unit test in subscribeToFullReconnect tests: set NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE while IS_LOADING_APP=true → verify reconnectApp() is NOT called.
• Verify reconnectApp() IS called once IS_LOADING_APP becomes false with LAST_FULL_RECONNECT_TIME still empty (failure path).
• Regression: normal network recovery (IS_LOADING_APP=false) still triggers reconnect correctly.

[ProjectNOVACo]

Proposal

Please re-state the problem that we are trying to solve in this issue.
The app fires duplicate ReconnectApp requests when switching accounts via delegate access, which is unnecessary since the OpenApp call already performs a full sync.

What is the root cause of that problem?
I dug into this and found that the issue starts in src/libs/actions/Delegate.ts. When we switch accounts using delegate access, Onyx.clear(KEYS_TO_PRESERVE_DELEGATE_ACCESS) wipes both LAST_FULL_RECONNECT_TIME and NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE to empty strings. Then when the OpenApp response arrives in src/libs/actions/OnyxUpdates.ts, the function applyHTTPSOnyxUpdates applies response.onyxData (which contains the server's timestamp for NVP_RECONNECT_APP_IF_FULL_RECONNECT_BEFORE) before it processes successData (which sets LAST_FULL_RECONNECT_TIME). This causes a race condition where subscribeToFullReconnect.ts triggers a reconnectApp() call unnecessarily.

What changes do we need to make in order to solve the problem?
We should modify src/libs/actions/Delegate.ts so when switching accounts, LAST_FULL_RECONNECT_TIME is set to a current timestamp right after clearing Onyx keys but before triggering the OpenApp. This will prevent subscribeToFullReconnect.ts from thinking we need a full reconnect.

Here's how we can fix it:

// In src/libs/actions/Delegate.ts, around line 196-203
Onyx.clear(KEYS_TO_PRESERVE_DELEGATE_ACCESS).then(() => {
// Set LAST_FULL_RECONNECT_TIME to current time before OpenApp is triggered
return Onyx.merge(ONYXKEYS.LAST_FULL_RECONNECT_TIME, DateUtils.getDBTime());
}).then(openApp);

That the timestamp for LAST_FULL_RECONNECT_TIME is always up-to-date right after clearing and before any checks in subscribeToFullReconnect.ts, preventing unnecessary duplicate ReconnectApp calls.