fix: align time entry workspace scope

Author: CorrectRoadH

apps/backend/internal/bootstrap/cache_regression_test.go

@@ -73,6 +73,25 @@ func TestArchivedClientDetailInvalidatesCachedClient(t *testing.T) {
 		t.Fatalf("expected client id, got %#v", clientBody)
 	}
 
+	warmClient := performAuthorizedJSONRequest(
+		t,
+		app,
+		http.MethodGet,
+		"/api/v9/workspaces/"+intToString(workspaceID)+"/clients/"+intToString(clientBody.ID),
+		nil,
+		authorization,
+	)
+	if warmClient.Code != http.StatusOK {
+		t.Fatalf("expected warm client detail status 200, got %d body=%s", warmClient.Code, warmClient.Body.String())
+	}
+	var activeClient struct {
+		Archived bool `json:"archived"`
+	}
+	mustDecodeJSON(t, warmClient.Body.Bytes(), &activeClient)
+	if activeClient.Archived {
+		t.Fatalf("expected pre-archive client detail to show archived=false, got body=%s", warmClient.Body.String())
+	}
+
 	archiveClient := performAuthorizedJSONRequest(
 		t,
 		app,

apps/website/src/shared/query/offline-optimistic.test.ts

@@ -1,3 +1,4 @@
+/* @vitest-environment jsdom */
 import { QueryClient } from "@tanstack/react-query";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 

apps/website/src/shared/query/web-shell-time-entries.test.ts

@@ -1,11 +1,121 @@
-import { describe, expect, it } from "vitest";
+/* @vitest-environment jsdom */
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { renderHook, waitFor } from "@testing-library/react";
+import { createElement, type ReactNode } from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { timeEntriesQueryKey } from "./web-shell-time-entries.ts";
+const mockGetTimeEntries = vi.fn();
+const mockUpdateWebSession = vi.fn();
+
+vi.mock("../api/public/track/index.ts", () => ({
+  deleteWorkspaceTimeEntries: vi.fn(),
+  getCurrentTimeEntry: vi.fn(),
+  getTimeEntries: (...args: unknown[]) => mockGetTimeEntries(...args),
+  patchWorkspaceStopTimeEntryHandler: vi.fn(),
+  postWorkspaceTimeEntries: vi.fn(),
+  putWorkspaceTimeEntryHandler: vi.fn(),
+}));
+
+vi.mock("../api/web/index.ts", () => ({
+  listRecentWorkspaceTimeEntrySuggestions: vi.fn(),
+  updateWebSession: (...args: unknown[]) => mockUpdateWebSession(...args),
+}));
+
+vi.mock("../api/web-client.ts", () => ({
+  unwrapWebApiResult: (p: Promise<unknown>) =>
+    p.then((result) =>
+      typeof result === "object" && result !== null && "data" in result
+        ? (result as { data: unknown }).data
+        : result,
+    ),
+}));
+
+const { sessionQueryKey, timeEntriesQueryKey, useTimeEntriesQuery } =
+  await import("./web-shell.ts");
+
+function createTestQueryClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: {
+      queries: { retry: false },
+    },
+  });
+}
+
+function createWrapper(queryClient: QueryClient) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return createElement(QueryClientProvider, { client: queryClient }, children);
+  };
+}
 
 describe("timeEntriesQueryKey", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it("scopes time entry lists by workspace", () => {
     expect(timeEntriesQueryKey(1, "2026-05-01", "2026-05-07", false)).not.toEqual(
       timeEntriesQueryKey(2, "2026-05-01", "2026-05-07", false),
     );
   });
+
+  it("aligns the server session workspace before reading /me time entries", async () => {
+    const queryClient = createTestQueryClient();
+    queryClient.setQueryData(sessionQueryKey, {
+      current_workspace_id: 1,
+    });
+    mockUpdateWebSession.mockResolvedValue({
+      data: {
+        current_workspace_id: 2,
+      },
+    });
+    mockGetTimeEntries.mockResolvedValue({ data: [] });
+
+    renderHook(
+      () =>
+        useTimeEntriesQuery({
+          endDate: "2026-05-07",
+          startDate: "2026-05-01",
+          workspaceId: 2,
+        }),
+      {
+        wrapper: createWrapper(queryClient),
+      },
+    );
+
+    await waitFor(() => expect(mockGetTimeEntries).toHaveBeenCalledTimes(1));
+    expect(mockUpdateWebSession).toHaveBeenCalledWith({
+      body: {
+        workspace_id: 2,
+      },
+    });
+    expect(mockGetTimeEntries.mock.invocationCallOrder[0]).toBeGreaterThan(
+      mockUpdateWebSession.mock.invocationCallOrder[0],
+    );
+    expect(queryClient.getQueryData(sessionQueryKey)).toEqual({
+      current_workspace_id: 2,
+    });
+  });
+
+  it("does not update the server session when the workspace is already current", async () => {
+    const queryClient = createTestQueryClient();
+    queryClient.setQueryData(sessionQueryKey, {
+      current_workspace_id: 2,
+    });
+    mockGetTimeEntries.mockResolvedValue({ data: [] });
+
+    renderHook(
+      () =>
+        useTimeEntriesQuery({
+          endDate: "2026-05-07",
+          startDate: "2026-05-01",
+          workspaceId: 2,
+        }),
+      {
+        wrapper: createWrapper(queryClient),
+      },
+    );
+
+    await waitFor(() => expect(mockGetTimeEntries).toHaveBeenCalledTimes(1));
+    expect(mockUpdateWebSession).not.toHaveBeenCalled();
+  });
 });

apps/website/src/shared/query/web-shell-time-entries.ts

@@ -12,8 +12,9 @@ import {
   putWorkspaceTimeEntryHandler,
 } from "../api/public/track/index.ts";
 import { listRecentWorkspaceTimeEntrySuggestions } from "../api/web/index.ts";
+import { updateWebSession } from "../api/web/index.ts";
 
-import { toTrackUtcString } from "./web-shell.ts";
+import { sessionQueryKey, toTrackUtcString } from "./web-shell.ts";
 
 export const timeEntriesQueryKey = (
   workspaceId: number,
@@ -32,6 +33,23 @@ const currentTimeEntryQueryKey = ["current-time-entry"] as const;
 const recentTimeEntrySuggestionsQueryKey = (workspaceId: number) =>
   ["time-entry-suggestions", workspaceId] as const;
 
+async function ensureTimeEntriesWorkspaceScope(
+  queryClient: ReturnType<typeof useQueryClient>,
+  workspaceId: number,
+) {
+  const session = queryClient.getQueryData<{ current_workspace_id?: number }>(sessionQueryKey);
+  if (session?.current_workspace_id === workspaceId) return;
+
+  const updated = await unwrapWebApiResult(
+    updateWebSession({
+      body: {
+        workspace_id: workspaceId,
+      },
+    }),
+  );
+  queryClient.setQueryData(sessionQueryKey, updated);
+}
+
 async function invalidateProjectRollups(
   queryClient: ReturnType<typeof useQueryClient>,
   workspaceId: number,
@@ -54,10 +72,13 @@ export function useTimeEntriesQuery(options: {
   startDate: string;
   workspaceId: number;
 }) {
+  const queryClient = useQueryClient();
+
   return useQuery({
     enabled: options.enabled ?? true,
-    queryFn: () =>
-      unwrapWebApiResult(
+    queryFn: async () => {
+      await ensureTimeEntriesWorkspaceScope(queryClient, options.workspaceId);
+      return unwrapWebApiResult(
         getTimeEntries({
           query: {
             end_date: options?.endDate,
@@ -66,7 +87,8 @@ export function useTimeEntriesQuery(options: {
             start_date: options?.startDate,
           },
         }),
-      ),
+      );
+    },
     queryKey: timeEntriesQueryKey(
       options.workspaceId,
       options.startDate,