Merge pull request #89029 from Expensify/claude-migratedUserWelcomeModalV2

rlinoz · web-flow · commit 26397b534d1a · 2026-05-07T14:11:25.000-03:00
Show migrated user welcome modal immediately (v2, race condition fix)
diff --git a/src/components/MigratedUserWelcomeModal.tsx b/src/components/MigratedUserWelcomeModal.tsx
@@ -11,8 +11,11 @@ import {openExternalLink} from '@libs/actions/Link';
 import {dismissProductTraining} from '@libs/actions/Welcome';
 import convertToLTR from '@libs/convertToLTR';
 import Log from '@libs/Log';
+import Navigation from '@libs/Navigation/Navigation';
+import {buildCannedSearchQuery} from '@libs/SearchQueryUtils';
 import variables from '@styles/variables';
 import CONST from '@src/CONST';
+import ROUTES from '@src/ROUTES';
 import type {FeatureListItem} from './FeatureList';
 import FeatureTrainingModal from './FeatureTrainingModal';
 import Icon from './Icon';
@@ -58,6 +61,7 @@ function MigratedUserWelcomeModal() {
     const onClose = () => {
         Log.hmmm('[MigratedUserWelcomeModal] onClose called, dismissing product training');
         dismissProductTraining(CONST.MIGRATED_USER_WELCOME_MODAL);
+        Navigation.navigate(ROUTES.SEARCH_ROOT.getRoute({query: buildCannedSearchQuery({type: CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT})}));
     };
 
     const featureListContent = (
diff --git a/src/libs/Navigation/guards/MigratedUserWelcomeModalGuard.ts b/src/libs/Navigation/guards/MigratedUserWelcomeModalGuard.ts
@@ -4,39 +4,79 @@ import {tryNewDotOnyxSelector} from '@selectors/Onboarding';
 import Onyx from 'react-native-onyx';
 import type {OnyxEntry} from 'react-native-onyx';
 import Log from '@libs/Log';
+import Navigation from '@libs/Navigation/Navigation';
 import isProductTrainingElementDismissed from '@libs/TooltipUtils';
 import CONST from '@src/CONST';
 import NAVIGATORS from '@src/NAVIGATORS';
 import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES from '@src/ROUTES';
 import SCREENS from '@src/SCREENS';
-import type {DismissedProductTraining} from '@src/types/onyx';
+import type {DismissedProductTraining, Session} from '@src/types/onyx';
 import type {GuardResult, NavigationGuard} from './types';
 
 let hasBeenAddedToNudgeMigration = false;
 let dismissedProductTraining: OnyxEntry<DismissedProductTraining>;
+let isDismissedProductTrainingLoaded = false;
+let session: OnyxEntry<Session>;
+let isLoadingApp = true;
 
 let hasRedirectedToMigratedUserModal = false;
 
 function resetSessionFlag() {
     hasRedirectedToMigratedUserModal = false;
 }
 
+/**
+ * Proactively navigate to the migrated user welcome modal when all conditions are met,
+ * without waiting for a user-initiated navigation action.
+ * Waits for NVP_DISMISSED_PRODUCT_TRAINING to load before evaluating, preventing the
+ * race condition where the modal would re-appear on app restart.
+ */
+function navigateToMigratedUserWelcomeModalIfReady() {
+    if (
+        !session?.authToken ||
+        isLoadingApp ||
+        hasRedirectedToMigratedUserModal ||
+        !hasBeenAddedToNudgeMigration ||
+        !isDismissedProductTrainingLoaded ||
+        isProductTrainingElementDismissed('migratedUserWelcomeModal', dismissedProductTraining)
+    ) {
+        return;
+    }
+
+    Log.info('[MigratedUserWelcomeModalGuard] Proactively navigating to migrated user welcome modal');
+    hasRedirectedToMigratedUserModal = true;
+    Navigation.navigate(ROUTES.MIGRATED_USER_WELCOME_MODAL.getRoute());
+}
+
+/**
+ * Called by guards/index.ts when session or loading app state changes.
+ * Reuses the shared Onyx subscriptions from guards/index.ts to avoid duplicate connections.
+ */
+function onSessionOrLoadingAppChanged(sessionValue: OnyxEntry<Session>, isLoadingAppValue: boolean) {
+    session = sessionValue;
+    isLoadingApp = isLoadingAppValue;
+    navigateToMigratedUserWelcomeModalIfReady();
+}
+
 Onyx.connectWithoutView({
     key: ONYXKEYS.NVP_TRY_NEW_DOT,
     callback: (value) => {
         const result = value ? tryNewDotOnyxSelector(value) : undefined;
         hasBeenAddedToNudgeMigration = result?.hasBeenAddedToNudgeMigration ?? false;
+        navigateToMigratedUserWelcomeModalIfReady();
     },
 });
 
 Onyx.connectWithoutView({
     key: ONYXKEYS.NVP_DISMISSED_PRODUCT_TRAINING,
     callback: (value) => {
         dismissedProductTraining = value;
+        isDismissedProductTrainingLoaded = true;
         if (isProductTrainingElementDismissed('migratedUserWelcomeModal', value)) {
             hasRedirectedToMigratedUserModal = false;
         }
+        navigateToMigratedUserWelcomeModalIfReady();
     },
 });
 
@@ -98,4 +138,4 @@ const MigratedUserWelcomeModalGuard: NavigationGuard = {
 };
 
 export default MigratedUserWelcomeModalGuard;
-export {resetSessionFlag};
+export {resetSessionFlag, onSessionOrLoadingAppChanged};
diff --git a/src/libs/Navigation/guards/index.ts b/src/libs/Navigation/guards/index.ts
@@ -4,7 +4,7 @@ import type {OnyxEntry} from 'react-native-onyx';
 import getCurrentUrl from '@libs/Navigation/currentUrl';
 import ONYXKEYS from '@src/ONYXKEYS';
 import type {Session} from '@src/types/onyx';
-import MigratedUserWelcomeModalGuard from './MigratedUserWelcomeModalGuard';
+import MigratedUserWelcomeModalGuard, {onSessionOrLoadingAppChanged} from './MigratedUserWelcomeModalGuard';
 import OnboardingGuard from './OnboardingGuard';
 import type {GuardContext, GuardResult, NavigationGuard} from './types';
 
@@ -19,13 +19,15 @@ Onyx.connectWithoutView({
     key: ONYXKEYS.SESSION,
     callback: (value) => {
         session = value;
+        onSessionOrLoadingAppChanged(session, isLoadingApp);
     },
 });
 
 Onyx.connectWithoutView({
     key: ONYXKEYS.IS_LOADING_APP,
     callback: (value) => {
         isLoadingApp = value ?? true;
+        onSessionOrLoadingAppChanged(session, isLoadingApp);
     },
 });
 
diff --git a/tests/unit/Navigation/guards/MigratedUserWelcomeModalGuard.test.ts b/tests/unit/Navigation/guards/MigratedUserWelcomeModalGuard.test.ts
@@ -1,6 +1,6 @@
 import type {NavigationAction, NavigationState} from '@react-navigation/native';
 import Onyx from 'react-native-onyx';
-import MigratedUserWelcomeModalGuard, {resetSessionFlag} from '@libs/Navigation/guards/MigratedUserWelcomeModalGuard';
+import MigratedUserWelcomeModalGuard, {onSessionOrLoadingAppChanged, resetSessionFlag} from '@libs/Navigation/guards/MigratedUserWelcomeModalGuard';
 import type {GuardContext} from '@libs/Navigation/guards/types';
 import CONST from '@src/CONST';
 import NAVIGATORS from '@src/NAVIGATORS';
@@ -9,6 +9,13 @@ import ROUTES from '@src/ROUTES';
 import SCREENS from '@src/SCREENS';
 import waitForBatchedUpdates from '../../../utils/waitForBatchedUpdates';
 
+const mockNavigate = jest.fn();
+jest.mock('@libs/Navigation/Navigation', () => ({
+    navigate: (...args: unknown[]) => {
+        mockNavigate(...args);
+    },
+}));
+
 describe('MigratedUserWelcomeModalGuard', () => {
     const mockState: NavigationState = {
         key: 'root',
@@ -31,8 +38,12 @@ describe('MigratedUserWelcomeModalGuard', () => {
     };
 
     beforeEach(async () => {
-        await Onyx.clear();
+        // Reset module-level session/loading state first so stale values from
+        // previous tests don't trigger navigation during Onyx.clear() callbacks
+        onSessionOrLoadingAppChanged(undefined, true);
         resetSessionFlag();
+        mockNavigate.mockClear();
+        await Onyx.clear();
         await waitForBatchedUpdates();
     });
 
@@ -324,4 +335,121 @@ describe('MigratedUserWelcomeModalGuard', () => {
             expect(result.type).not.toBe('BLOCK');
         });
     });
+
+    describe('onSessionOrLoadingAppChanged (proactive navigation)', () => {
+        it('should navigate when all conditions are met (session, not loading, nudge migration, training loaded, not dismissed)', async () => {
+            // Set up nudge migration (session is not set yet, so no navigation here)
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: {
+                    timestamp: new Date(),
+                    cohort: 'test',
+                },
+            });
+            await waitForBatchedUpdates();
+            mockNavigate.mockClear();
+
+            // Now signal that session is ready and app is done loading
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, false);
+
+            expect(mockNavigate).toHaveBeenCalledWith(ROUTES.MIGRATED_USER_WELCOME_MODAL.getRoute());
+        });
+
+        it('should not navigate when app is still loading', async () => {
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: {
+                    timestamp: new Date(),
+                    cohort: 'test',
+                },
+            });
+            await waitForBatchedUpdates();
+            mockNavigate.mockClear();
+
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, true);
+
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+
+        it('should not navigate when there is no session', async () => {
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: {
+                    timestamp: new Date(),
+                    cohort: 'test',
+                },
+            });
+            await waitForBatchedUpdates();
+            mockNavigate.mockClear();
+
+            onSessionOrLoadingAppChanged(undefined, false);
+
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+
+        it('should not navigate when user has not been added to nudge migration', async () => {
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: null,
+            });
+            await waitForBatchedUpdates();
+            mockNavigate.mockClear();
+
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, false);
+
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+
+        it('should not navigate when modal was already dismissed', async () => {
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: {
+                    timestamp: new Date(),
+                    cohort: 'test',
+                },
+            });
+            await Onyx.merge(ONYXKEYS.NVP_DISMISSED_PRODUCT_TRAINING, {
+                migratedUserWelcomeModal: {
+                    timestamp: new Date().toISOString(),
+                    dismissedMethod: 'click',
+                },
+            });
+            await waitForBatchedUpdates();
+            mockNavigate.mockClear();
+
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, false);
+
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+
+        it('should only navigate once even if called multiple times', async () => {
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: {
+                    timestamp: new Date(),
+                    cohort: 'test',
+                },
+            });
+            await waitForBatchedUpdates();
+            mockNavigate.mockClear();
+
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, false);
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, false);
+
+            expect(mockNavigate).toHaveBeenCalledTimes(1);
+        });
+
+        it('should navigate via Onyx NVP_DISMISSED_PRODUCT_TRAINING callback when session is already set', async () => {
+            // Set session first
+            onSessionOrLoadingAppChanged({authToken: 'test-token', accountID: 123}, false);
+            mockNavigate.mockClear();
+
+            // Set up nudge migration and dismissed product training (modal not dismissed)
+            await Onyx.merge(ONYXKEYS.NVP_TRY_NEW_DOT, {
+                nudgeMigration: {
+                    timestamp: new Date(),
+                    cohort: 'test',
+                },
+            });
+            await waitForBatchedUpdates();
+
+            // The NVP_TRY_NEW_DOT callback triggers navigateToMigratedUserWelcomeModalIfReady
+            // which should navigate because all conditions are met
+            expect(mockNavigate).toHaveBeenCalledWith(ROUTES.MIGRATED_USER_WELCOME_MODAL.getRoute());
+        });
+    });
 });
