Restore workspace sub-page on tab re-entry via URL navigation

adamgrzybowski · adamgrzybowski · commit 7e184c0ea7d9 · 2026-04-29T16:34:51.000+02:00
diff --git a/src/hooks/useRestoreWorkspacesTabOnNavigate.ts b/src/hooks/useRestoreWorkspacesTabOnNavigate.ts
@@ -105,8 +105,9 @@ function useRestoreWorkspacesTabOnNavigate() {
             domain: lastViewedDomain,
             lastWorkspacesTabNavigatorRoute,
             topmostFullScreenRoute,
+            workspacesTabState,
         });
-    }, [shouldUseNarrowLayout, currentUserLogin, lastViewedPolicy, lastViewedDomain, lastWorkspacesTabNavigatorRoute, topmostFullScreenRoute]);
+    }, [shouldUseNarrowLayout, currentUserLogin, lastViewedPolicy, lastViewedDomain, lastWorkspacesTabNavigatorRoute, topmostFullScreenRoute, workspacesTabState]);
 }
 
 export default useRestoreWorkspacesTabOnNavigate;
diff --git a/src/libs/Navigation/helpers/navigateToWorkspacesPage.ts b/src/libs/Navigation/helpers/navigateToWorkspacesPage.ts
@@ -6,24 +6,42 @@ import navigationRef from '@libs/Navigation/navigationRef';
 import {isPendingDeletePolicy, shouldShowPolicy as shouldShowPolicyUtil} from '@libs/PolicyUtils';
 import NAVIGATORS from '@src/NAVIGATORS';
 import ROUTES from '@src/ROUTES';
+import type {Route} from '@src/ROUTES';
 import SCREENS from '@src/SCREENS';
 import type {Domain, Policy} from '@src/types/onyx';
 import getActiveTabName from './getActiveTabName';
+import getPathFromState from './getPathFromState';
 
 type RouteType = NavigationState['routes'][number] | PartialState<NavigationState>['routes'][number];
 
+/**
+ * Wraps a leaf navigation state in successive ancestor navigators (outermost first).
+ * Used to reconstruct the linking-config hierarchy that `getPathFromState` walks when
+ * resolving a state subtree to a URL.
+ */
+function wrapStateInNavigators(state: PartialState<NavigationState>, navigators: readonly string[]): PartialState<NavigationState> {
+    return navigators.reduceRight<PartialState<NavigationState>>((acc, name) => ({routes: [{name, state: acc}], index: 0}), state);
+}
+
 type Params = {
     currentUserLogin?: string;
     shouldUseNarrowLayout: boolean;
     policy?: Policy;
     domain?: Domain;
     lastWorkspacesTabNavigatorRoute?: RouteType;
     topmostFullScreenRoute?: RouteType;
+    /**
+     * The full WorkspaceSplitNavigator inner state captured by the hook.
+     * Wrapped in a synthetic outer node and fed to `getPathFromState` to reconstruct
+     * the deep URL the user was on (e.g. `/workspaces/POLICY_ID/workflows`). Navigating
+     * via that URL goes through `getStateFromPath` which produces a fully-formed
+     * navigation state — bypassing custom router actions that don't seed nested state
+     * when pushing a fresh TabNavigator on top of an existing fullscreen stack.
+     */
+    workspacesTabState?: NavigationState | PartialState<NavigationState>;
 };
 
-// Navigates to the appropriate workspace tab or workspace list page.
-// eslint-disable-next-line @typescript-eslint/no-unused-vars -- shouldUseNarrowLayout kept for API compat with callers
-const navigateToWorkspacesPage = ({currentUserLogin, shouldUseNarrowLayout, policy, domain, lastWorkspacesTabNavigatorRoute, topmostFullScreenRoute}: Params) => {
+const navigateToWorkspacesPage = ({currentUserLogin, shouldUseNarrowLayout, policy, domain, lastWorkspacesTabNavigatorRoute, topmostFullScreenRoute, workspacesTabState}: Params) => {
     const rootState = navigationRef.getRootState();
     const focusedRoute = rootState ? findFocusedRoute(rootState) : undefined;
     const isOnWorkspacesList = focusedRoute?.name === SCREENS.WORKSPACES_LIST;
@@ -61,9 +79,26 @@ const navigateToWorkspacesPage = ({currentUserLogin, shouldUseNarrowLayout, poli
                 return;
             }
 
-            // Restore to last-visited workspace — navigate through standard routing which switches the tab
             if (policy?.id) {
-                Navigation.navigate(ROUTES.WORKSPACE_INITIAL.getRoute(policy.id));
+                // Synthesize a URL from the captured WorkspaceSplitNavigator inner state and navigate
+                // to it. URL-based navigation goes through `getStateFromPath`, which produces a fully
+                // formed nested state and reliably handles pushing a fresh TabNavigator on top of an
+                // existing fullscreen stack. The state has to be wrapped with its full ancestor chain
+                // (TAB_NAVIGATOR > WORKSPACE_NAVIGATOR > WORKSPACE_SPLIT_NAVIGATOR) so `getPathFromState`
+                // can match the linking-config hierarchy and produce a real URL like
+                // `/workspaces/POLICY_ID/workflows`; otherwise the resolver falls back to navigator
+                // names as path segments and the result hits 404. Narrow layouts skip the deep-restore
+                // and go to the workspace's initial page (mirrors mobile behavior).
+                const wrappedState =
+                    !shouldUseNarrowLayout && workspacesTabState
+                        ? wrapStateInNavigators(workspacesTabState as PartialState<NavigationState>, [
+                              NAVIGATORS.TAB_NAVIGATOR,
+                              NAVIGATORS.WORKSPACE_NAVIGATOR,
+                              NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                          ])
+                        : undefined;
+                const targetPath = (wrappedState ? getPathFromState(wrappedState) : ROUTES.WORKSPACE_INITIAL.getRoute(policy.id)) as Route;
+                Navigation.navigate(targetPath);
             }
             return;
         }
diff --git a/tests/unit/hooks/useRestoreWorkspacesTabOnNavigate.test.ts b/tests/unit/hooks/useRestoreWorkspacesTabOnNavigate.test.ts
@@ -1,7 +1,9 @@
 import {renderHook} from '@testing-library/react-native';
+import getPathFromState from '@libs/Navigation/helpers/getPathFromState';
 import Navigation from '@libs/Navigation/Navigation';
 import NAVIGATORS from '@src/NAVIGATORS';
 import ROUTES from '@src/ROUTES';
+import SCREENS from '@src/SCREENS';
 import createRandomPolicy from '../../utils/collections/policies';
 
 jest.mock('@libs/Navigation/AppNavigator/createSplitNavigator/usePreserveNavigatorState', () => ({
@@ -12,7 +14,8 @@ jest.mock('@libs/Navigation/helpers/lastVisitedTabPathUtils', () => ({
     getWorkspacesTabStateFromSessionStorage: jest.fn(() => undefined),
 }));
 
-jest.mock('@hooks/useResponsiveLayout', () => () => ({shouldUseNarrowLayout: false}));
+const mockResponsiveLayout = jest.fn(() => ({shouldUseNarrowLayout: false}));
+jest.mock('@hooks/useResponsiveLayout', () => () => mockResponsiveLayout());
 
 jest.mock('@hooks/useCurrentUserPersonalDetails', () => () => ({login: 'test@example.com'}));
 
@@ -24,7 +27,11 @@ jest.mock('@hooks/useOnyx', () => (key: unknown, opts?: unknown) => mockUseOnyx(
 
 jest.mock('@libs/interceptAnonymousUser', () => (cb: () => void) => cb());
 
-jest.mock('@libs/Navigation/navigationRef', () => ({getRootState: jest.fn(() => ({routes: []})), isReady: jest.fn(() => true)}));
+jest.mock('@libs/Navigation/navigationRef', () => ({
+    getRootState: jest.fn(() => ({routes: []})),
+    isReady: jest.fn(() => true),
+    dispatch: jest.fn(),
+}));
 
 jest.mock('@react-navigation/native', () => ({
     findFocusedRoute: jest.fn(() => ({name: 'some-screen'})),
@@ -35,6 +42,11 @@ jest.mock('@libs/Navigation/Navigation', () => ({
     goBack: jest.fn(),
 }));
 
+jest.mock('@libs/Navigation/helpers/getPathFromState', () => ({
+    __esModule: true,
+    default: jest.fn(),
+}));
+
 // eslint-disable-next-line no-restricted-syntax
 jest.mock('@libs/PolicyUtils', () => ({
     shouldShowPolicy: jest.fn(() => true),
@@ -43,13 +55,17 @@ jest.mock('@libs/PolicyUtils', () => ({
 
 const fakePolicyID = 'ABCD1234';
 const mockPolicy = {...createRandomPolicy(0), id: fakePolicyID};
+const mockedGetPathFromState = getPathFromState as jest.MockedFunction<typeof getPathFromState>;
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const useRestoreWorkspacesTabOnNavigate = (require('@hooks/useRestoreWorkspacesTabOnNavigate') as {default: () => () => void}).default;
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports, no-restricted-syntax
 const PolicyUtils = require('@libs/PolicyUtils') as {shouldShowPolicy: jest.Mock; isPendingDeletePolicy: jest.Mock};
 
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const lastVisitedTabPathUtils = require('@libs/Navigation/helpers/lastVisitedTabPathUtils') as {getWorkspacesTabStateFromSessionStorage: jest.Mock};
+
 function setupOnyxForPolicy() {
     mockUseOnyx.mockImplementation((_key: unknown, opts?: {selector?: (data: unknown) => unknown}) => {
         if (opts?.selector) {
@@ -83,18 +99,30 @@ describe('useRestoreWorkspacesTabOnNavigate', () => {
     beforeEach(() => {
         jest.clearAllMocks();
         mockUseOnyx.mockReturnValue([undefined]);
+        mockResponsiveLayout.mockReturnValue({shouldUseNarrowLayout: false});
+        lastVisitedTabPathUtils.getWorkspacesTabStateFromSessionStorage.mockReturnValue(undefined);
         PolicyUtils.shouldShowPolicy.mockReturnValue(true);
         PolicyUtils.isPendingDeletePolicy.mockReturnValue(false);
+        mockedGetPathFromState.mockReset();
     });
 
     it('restores to the last visited workspace when re-entering the Workspaces tab', () => {
         setupOnyxForPolicy();
-        mockRootState.mockReturnValue(buildStateWithUserOnDifferentTab([{name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR, state: {routes: [{params: {policyID: fakePolicyID}}]}}]));
+        const restoredPath = `/workspaces/${fakePolicyID}` as const;
+        mockedGetPathFromState.mockReturnValue(restoredPath);
+        mockRootState.mockReturnValue(
+            buildStateWithUserOnDifferentTab([
+                {
+                    name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                    state: {routes: [{name: SCREENS.WORKSPACE.INITIAL, params: {policyID: fakePolicyID}}]},
+                },
+            ]),
+        );
 
         const {result} = renderHook(() => useRestoreWorkspacesTabOnNavigate());
         result.current();
 
-        expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.WORKSPACE_INITIAL.getRoute(fakePolicyID));
+        expect(Navigation.navigate).toHaveBeenCalledWith(restoredPath);
     });
 
     it('falls back to the workspaces list when no workspace was previously visited', () => {
@@ -117,11 +145,167 @@ describe('useRestoreWorkspacesTabOnNavigate', () => {
         PolicyUtils.isPendingDeletePolicy.mockReturnValue(true);
 
         setupOnyxForPolicy();
-        mockRootState.mockReturnValue(buildStateWithUserOnDifferentTab([{name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR, state: {routes: [{params: {policyID: fakePolicyID}}]}}]));
+        mockRootState.mockReturnValue(
+            buildStateWithUserOnDifferentTab([
+                {
+                    name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                    state: {routes: [{name: SCREENS.WORKSPACE.INITIAL, params: {policyID: fakePolicyID}}]},
+                },
+            ]),
+        );
 
         const {result} = renderHook(() => useRestoreWorkspacesTabOnNavigate());
         result.current();
 
         expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.WORKSPACES_LIST.route);
     });
+
+    // Regression: clicking the Workspaces tab from any other tab should land the user on the *exact* sub-page
+    // they had open inside the workspace (e.g. Workflows), not the workspace's initial page.
+    it('preserves the focused workspace sub-page (Workflows) when restoring on a wide layout', () => {
+        setupOnyxForPolicy();
+        const restoredPath = `/workspaces/${fakePolicyID}/workflows` as const;
+        mockedGetPathFromState.mockReturnValue(restoredPath);
+        mockRootState.mockReturnValue(
+            buildStateWithUserOnDifferentTab([
+                {
+                    name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                    state: {
+                        index: 1,
+                        routes: [
+                            {name: SCREENS.WORKSPACE.INITIAL, params: {policyID: fakePolicyID}},
+                            {name: SCREENS.WORKSPACE.WORKFLOWS, params: {policyID: fakePolicyID}},
+                        ],
+                    },
+                },
+            ]),
+        );
+
+        const {result} = renderHook(() => useRestoreWorkspacesTabOnNavigate());
+        result.current();
+
+        expect(Navigation.navigate).toHaveBeenCalledWith(restoredPath);
+    });
+
+    // Regression for the original bug (#89106): when an RHP-driven navigation pushes a fresh TabNavigator above
+    // the modal, the new TabNavigator's WORKSPACE_NAVIGATOR is empty. The hook must reach into the *older*
+    // TabNavigator instance still alive in the root stack to recover the user's last workspace sub-page.
+    it('reads workspace state from an older TabNavigator instance when the topmost one is empty', () => {
+        setupOnyxForPolicy();
+        const restoredPath = `/workspaces/${fakePolicyID}/workflows` as const;
+        mockedGetPathFromState.mockReturnValue(restoredPath);
+        mockRootState.mockReturnValue({
+            routes: [
+                // Older TabNavigator: still holds the workspace state with WORKFLOWS focused.
+                {
+                    name: NAVIGATORS.TAB_NAVIGATOR,
+                    state: {
+                        index: 1,
+                        routes: [
+                            {name: NAVIGATORS.REPORTS_SPLIT_NAVIGATOR},
+                            {
+                                name: NAVIGATORS.WORKSPACE_NAVIGATOR,
+                                state: {
+                                    routes: [
+                                        {
+                                            name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                                            state: {
+                                                index: 1,
+                                                routes: [
+                                                    {name: SCREENS.WORKSPACE.INITIAL, params: {policyID: fakePolicyID}},
+                                                    {name: SCREENS.WORKSPACE.WORKFLOWS, params: {policyID: fakePolicyID}},
+                                                ],
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+                // Newer TabNavigator pushed above the modal: WORKSPACE_NAVIGATOR is empty.
+                {
+                    name: NAVIGATORS.TAB_NAVIGATOR,
+                    state: {
+                        index: 0,
+                        routes: [{name: NAVIGATORS.REPORTS_SPLIT_NAVIGATOR}, {name: NAVIGATORS.WORKSPACE_NAVIGATOR}],
+                    },
+                },
+            ],
+        });
+
+        const {result} = renderHook(() => useRestoreWorkspacesTabOnNavigate());
+        result.current();
+
+        expect(Navigation.navigate).toHaveBeenCalledWith(restoredPath);
+    });
+
+    // On narrow layouts (mobile), the URL-based restore is skipped: we always land on the workspace's
+    // initial page so the user can navigate inward via the side-list — matches mobile UX and the docs.
+    it('falls back to the workspace initial page on narrow layouts even when a sub-page is focused', () => {
+        mockResponsiveLayout.mockReturnValue({shouldUseNarrowLayout: true});
+        setupOnyxForPolicy();
+        mockRootState.mockReturnValue(
+            buildStateWithUserOnDifferentTab([
+                {
+                    name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                    state: {
+                        index: 1,
+                        routes: [
+                            {name: SCREENS.WORKSPACE.INITIAL, params: {policyID: fakePolicyID}},
+                            {name: SCREENS.WORKSPACE.WORKFLOWS, params: {policyID: fakePolicyID}},
+                        ],
+                    },
+                },
+            ]),
+        );
+
+        const {result} = renderHook(() => useRestoreWorkspacesTabOnNavigate());
+        result.current();
+
+        expect(mockedGetPathFromState).not.toHaveBeenCalled();
+        expect(Navigation.navigate).toHaveBeenCalledWith(ROUTES.WORKSPACE_INITIAL.getRoute(fakePolicyID));
+    });
+
+    // Cold-start path: when no workspace route exists anywhere in the live nav tree, fall back to the
+    // sessionStorage-persisted state so a fresh page-load still restores the user's last workspace sub-page.
+    it('hydrates from sessionStorage when the live navigation tree has no workspace route', () => {
+        setupOnyxForPolicy();
+        const restoredPath = `/workspaces/${fakePolicyID}/workflows` as const;
+        mockedGetPathFromState.mockReturnValue(restoredPath);
+        mockRootState.mockReturnValue({
+            routes: [
+                {
+                    name: NAVIGATORS.TAB_NAVIGATOR,
+                    state: {index: 0, routes: [{name: NAVIGATORS.REPORTS_SPLIT_NAVIGATOR}]},
+                },
+            ],
+        });
+        lastVisitedTabPathUtils.getWorkspacesTabStateFromSessionStorage.mockReturnValue({
+            routes: [
+                {
+                    name: NAVIGATORS.WORKSPACE_NAVIGATOR,
+                    state: {
+                        routes: [
+                            {
+                                name: NAVIGATORS.WORKSPACE_SPLIT_NAVIGATOR,
+                                state: {
+                                    index: 1,
+                                    routes: [
+                                        {name: SCREENS.WORKSPACE.INITIAL, params: {policyID: fakePolicyID}},
+                                        {name: SCREENS.WORKSPACE.WORKFLOWS, params: {policyID: fakePolicyID}},
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+            ],
+        });
+
+        const {result} = renderHook(() => useRestoreWorkspacesTabOnNavigate());
+        result.current();
+
+        expect(Navigation.navigate).toHaveBeenCalledWith(restoredPath);
+    });
 });
diff --git a/tests/unit/navigateToWorkspacesPageTest.ts b/tests/unit/navigateToWorkspacesPageTest.ts
