diff --git a/tests/perf/collections/README.md b/tests/perf/collections/README.md index 408d5d03b2e..e9cfd5a0487 100644 --- a/tests/perf/collections/README.md +++ b/tests/perf/collections/README.md @@ -87,6 +87,22 @@ click to the latest comment on screen over at least 5 fresh browser contexts added to every API response. They also record the idle page's API request count. The timings are attached evidence, not budgets. +`mine-returning-visit.spec.ts` hard loads Mine with the saved query cache +(`paperclip:query-cache:v1::`, primed by one earlier visit in +the same browser context). Its fixture (`returning-visit-fixture.ts`) is a +company with 24 Mine tasks and three pending board approvals, retained in +`test-results/collections/mine-returning-visit-fixture.json`. With every read +of that company held, Mine must show its task rows and saved approvals before +any of those reads answers. An approval dismissed after the cache was saved +stands in until the reads answer and then leaves. Another company's Mine never +shows the saved company's rows. Its timing case records time from navigation +start to the first Mine row with the saved cache and with it cleared, with +every API response delayed `PAPERCLIP_COLLECTION_PERF_API_DELAY_MS` (default +300 ms), over `PAPERCLIP_COLLECTION_PERF_TIMING_RUNS` alternating runs (default +and minimum 5). Each sample names the last API response before the rows and +counts the load's requests; `PAPERCLIP_COLLECTION_PERF_OUTPUT` writes the +report to a file. The timings are attached evidence, not budgets. + Run these focused browser checks before the full collection suite: ```sh diff --git a/tests/perf/collections/mine-returning-visit.spec.ts b/tests/perf/collections/mine-returning-visit.spec.ts new file mode 100644 index 00000000000..f4036357d8f --- /dev/null +++ b/tests/perf/collections/mine-returning-visit.spec.ts @@ -0,0 +1,146 @@ +import fs from "node:fs/promises"; +import { expect, test, type Page } from "@playwright/test"; +import { + freshContext, median, minePath, observeMineLoad, returningVisitFixture, savedQueryCache, type ReturningVisitFixture, +} from "./returning-visit-fixture"; + +// A returning visit to Mine restores its rows, approvals, join requests and +// dismissals from the saved query cache, so rows show before any company read +// answers. The reads still run and replace the saved values. +let fixture: ReturningVisitFixture; +test.beforeAll(async ({ request }) => { + test.setTimeout(120_000); + fixture = await returningVisitFixture(request); +}); + +const companyRead = (companyId: string) => (url: URL) => url.pathname.startsWith(`/api/companies/${companyId}/`); +const taskLink = (page: Page, identifier: string) => page.locator(`[data-inbox-issue-link][href$="/${identifier}"]`); +const approvalRow = (page: Page, approvalId: string) => page.locator(`a[href$="/approvals/${approvalId}"]`); + +function holdReads(page: Page, matches: (url: URL) => boolean) { + let release!: () => void; + const held = new Promise(resolve => { release = resolve; }); + const answered: string[] = []; + page.on("requestfinished", request => { + const url = new URL(request.url()); + if (matches(url)) answered.push(url.pathname); + }); + const ready = page.route(matches, async route => { + await held; + await route.continue().catch(() => {}); + }); + return { ready, release, answered }; +} + +test("a returning visit shows Mine rows and approvals from the saved cache before any company read answers", async ({ browser, baseURL }) => { + const storageState = await savedQueryCache(browser, baseURL, fixture); + const context = await freshContext(browser, baseURL, storageState); + try { + const page = await context.newPage(); + const hold = holdReads(page, companyRead(fixture.company.id)); + await hold.ready; + try { + await page.goto(minePath(fixture)); + for (const task of fixture.tasks.slice(0, 5)) { + await expect(taskLink(page, task.identifier), "Mine rows waited for a company read").toBeVisible({ timeout: 10_000 }); + } + for (const id of fixture.approvalIds) await expect(approvalRow(page, id)).toBeVisible(); + expect(hold.answered, "No company read may answer before the saved rows show").toEqual([]); + } finally { hold.release(); } + // The held reads then answer and leave the same rows in place. + await expect.poll(() => hold.answered.some(path => path.endsWith("/inbox/mine"))).toBe(true); + await expect(taskLink(page, fixture.tasks[0]!.identifier)).toBeVisible(); + } finally { await context.close(); } +}); + +test("a saved approval that left Mine since the last visit goes when the reads answer", async ({ browser, baseURL, request }) => { + const created = await request.post(`/api/companies/${fixture.company.id}/approvals`, { data: { + type: "request_board_approval", payload: { title: "Returning visit stale approval", summary: "Dismissed after the cache was saved." }, + } }); + expect(created.ok(), await created.text()).toBeTruthy(); + const stale = (await created.json()).id as string; + const storageState = await savedQueryCache(browser, baseURL, fixture); + // Dismissed from another device after this browser saved its cache. + const dismissed = await request.post(`/api/companies/${fixture.company.id}/inbox-dismissals`, { data: { itemKey: `approval:${stale}` } }); + expect(dismissed.ok(), await dismissed.text()).toBeTruthy(); + const context = await freshContext(browser, baseURL, storageState); + try { + const page = await context.newPage(); + const hold = holdReads(page, companyRead(fixture.company.id)); + await hold.ready; + await page.goto(minePath(fixture)); + await expect(approvalRow(page, stale), "The saved approval stands in until the reads answer").toBeVisible(); + hold.release(); + await expect(approvalRow(page, stale)).toHaveCount(0); + await expect(taskLink(page, fixture.tasks[0]!.identifier)).toBeVisible(); + } finally { await context.close(); } +}); + +test("a saved cache never shows one company's rows in another company's Mine", async ({ browser, baseURL, request }) => { + const other = await request.post("/api/companies", { data: { name: "Returning visit other company" } }); + expect(other.ok(), await other.text()).toBeTruthy(); + const otherCompany = await other.json() as { id: string; issuePrefix: string }; + const storageState = await savedQueryCache(browser, baseURL, fixture); + const context = await freshContext(browser, baseURL, storageState); + try { + const page = await context.newPage(); + const hold = holdReads(page, companyRead(otherCompany.id)); + await hold.ready; + try { + await page.goto(`/${otherCompany.issuePrefix}/issues?view=mine`); + await page.waitForTimeout(1_500); + await expect(page.locator("[data-inbox-issue-link]")).toHaveCount(0); + for (const id of fixture.approvalIds) await expect(approvalRow(page, id)).toHaveCount(0); + } finally { hold.release(); } + } finally { + await context.close(); + await request.delete(`/api/companies/${otherCompany.id}`); + } +}); + +// Time from navigation start to the first Mine row (two frames after mount), +// with every API response delayed by PAPERCLIP_COLLECTION_PERF_API_DELAY_MS +// (default 300 ms), in fresh browser contexts with and without the saved cache. +// Each sample names the last API response that finished before the rows and +// counts the load's API requests. Timings are evidence, not budgets. +test("records returning-visit time to Mine rows", async ({ browser, baseURL }, testInfo) => { + const runs = Number(process.env.PAPERCLIP_COLLECTION_PERF_TIMING_RUNS ?? 5); + const delayMs = Number(process.env.PAPERCLIP_COLLECTION_PERF_API_DELAY_MS ?? 300); + expect(Number.isInteger(runs) && runs >= 5, "Record at least five samples").toBe(true); + test.setTimeout(60_000 + runs * 2 * 30_000); + const storageState = await savedQueryCache(browser, baseURL, fixture); + const sample = async (cache: "saved" | "cleared") => { + const context = await freshContext(browser, baseURL, cache === "saved" ? storageState : undefined); + try { + const page = await context.newPage(); + const { reads, rowsAt, shellReadCounts } = await observeMineLoad(page, delayMs); + await page.goto(minePath(fixture)); + const rows = await rowsAt(); + const navigationStart = await page.evaluate(() => performance.timeOrigin); + await page.waitForTimeout(5_000); + const before = reads.filter(read => read.finishedAt !== null && read.finishedAt <= rows) + .sort((a, b) => b.finishedAt! - a.finishedAt!); + return { + timeToRowsMs: Math.round(rows - navigationStart), + releasedBy: before[0] ? { path: before[0].path, msBeforeRows: Math.round(rows - before[0].finishedAt!) } : null, + responsesBeforeRows: before.length, + apiRequests: reads.length, + shellReads: shellReadCounts(), + }; + } finally { await context.close(); } + }; + type Sample = Awaited>; + const samples: Record<"saved" | "cleared", Sample[]> = { saved: [], cleared: [] }; + for (let run = 0; run < runs; run++) { + samples.saved.push(await sample("saved")); + samples.cleared.push(await sample("cleared")); + } + const report = (["saved", "cleared"] as const).map(cache => { + const times = samples[cache].map(entry => entry.timeToRowsMs); + console.log(`Mine time to rows, ${cache} cache, API +${delayMs} ms: median ${median(times)} ms over ${runs} runs (${[...times].sort((a, b) => a - b).join(", ")} ms); API requests ${samples[cache].map(entry => entry.apiRequests).join(", ")}`); + return { cache, apiDelayMs: delayMs, medianMs: median(times), samples: samples[cache] }; + }); + await testInfo.attach("mine-returning-visit-timing", { contentType: "application/json", body: Buffer.from(JSON.stringify(report, null, 2)) }); + const output = process.env.PAPERCLIP_COLLECTION_PERF_OUTPUT; + if (output) await fs.writeFile(output, JSON.stringify(report, null, 2)); +}); diff --git a/ui/src/hooks/useInboxBadge.ts b/ui/src/hooks/useInboxBadge.ts index 6be0409150e..1bcb008b21d 100644 --- a/ui/src/hooks/useInboxBadge.ts +++ b/ui/src/hooks/useInboxBadge.ts @@ -1,6 +1,8 @@ import { useCallback, useEffect, useMemo, useState } from "react"; import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"; import { sidebarBadgesApi } from "../api/sidebarBadges"; +import type { InboxDismissal } from "@paperclipai/shared"; +import { isTransientError } from "../api/errors"; import { inboxDismissalsApi } from "../api/inboxDismissals"; import { queryKeys } from "../lib/queryKeys"; import { @@ -40,17 +42,31 @@ export function useDismissedInboxAlerts() { return { dismissed, dismiss }; } -export function useInboxDismissals(companyId: string | null | undefined) { +const NO_DISMISSALS: InboxDismissal[] = []; + +/** + * `fallback` is a saved list for this company (see + * `lib/inbox-mine-reveal-sources.ts`). It stands in until the server answers, + * and after a transient failure. While it does, `isLoading` is false and + * `hasServerData` is false. + */ +export function useInboxDismissals( + companyId: string | null | undefined, + options: { fallback?: InboxDismissal[] | null } = {}, +) { const queryClient = useQueryClient(); const queryKey = companyId ? queryKeys.inboxDismissals(companyId) : ["inbox-dismissals", "__disabled__"] as const; - const { data: dismissals = [], isLoading, error } = useQuery({ + const { data, isLoading: isQueryLoading, error } = useQuery({ queryKey, queryFn: () => inboxDismissalsApi.list(companyId!), enabled: !!companyId, }); + const usesFallback = data === undefined && !!options.fallback && (!error || isTransientError(error)); + const dismissals = data ?? (usesFallback ? options.fallback! : NO_DISMISSALS); + const isLoading = isQueryLoading && !usesFallback; const dismissMutation = useMutation({ mutationFn: ({ itemKey, fingerprint }: { itemKey: string; fingerprint?: string }) => @@ -129,6 +145,7 @@ export function useInboxDismissals(companyId: string | null | undefined) { return { dismissals, isLoading, + hasServerData: data !== undefined, error, dismissedAtByKey, dismiss, diff --git a/ui/src/hooks/useInboxDismissals.test.tsx b/ui/src/hooks/useInboxDismissals.test.tsx new file mode 100644 index 00000000000..c3495ce133e --- /dev/null +++ b/ui/src/hooks/useInboxDismissals.test.tsx @@ -0,0 +1,60 @@ +// @vitest-environment jsdom +import { act } from "react"; +import { createRoot, type Root } from "react-dom/client"; +import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; +import type { InboxDismissal } from "@paperclipai/shared"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; + +const { list } = vi.hoisted(() => ({ list: vi.fn() })); +vi.mock("../api/inboxDismissals", () => ({ inboxDismissalsApi: { list, dismiss: vi.fn(), snooze: vi.fn(), restore: vi.fn() } })); +import { ApiError } from "../api/client"; +import { useInboxDismissals } from "./useInboxBadge"; + +(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true; + +const saved = [{ id: "d-1", companyId: "company-1", userId: "user-1", itemKey: "approval:a-1", dismissedAt: new Date(1_000) }] as unknown as InboxDismissal[]; +type Result = ReturnType; + +describe("useInboxDismissals fallback", () => { + let root: Root; + let client: QueryClient; + let latest: Result | null = null; + beforeEach(() => { + list.mockReset(); + client = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + root = createRoot(document.createElement("div")); + }); + afterEach(async () => { await act(async () => root.unmount()); client.clear(); }); + + async function render(fallback: InboxDismissal[] | null) { + function Probe() { latest = useInboxDismissals("company-1", { fallback }); return null; } + await act(async () => root.render()); + } + + it("stands in while the read is pending and yields to the server answer", async () => { + let resolve!: (value: InboxDismissal[]) => void; + list.mockReturnValue(new Promise(r => { resolve = r; })); + await render(saved); + expect(latest).toMatchObject({ isLoading: false, hasServerData: false }); + expect(latest!.dismissedAtByKey.get("approval:a-1")).toBe(1_000); + await act(async () => resolve([])); + await vi.waitFor(() => expect(latest).toMatchObject({ isLoading: false, hasServerData: true })); + expect(latest!.dismissedAtByKey.size).toBe(0); + }); + + it("keeps the saved list after a transient failure and drops it after a refusal", async () => { + list.mockRejectedValue(new ApiError("Busy", 503, null)); + await render(saved); + await vi.waitFor(() => expect(latest!.error).toBeTruthy()); + expect(latest!.dismissedAtByKey.get("approval:a-1")).toBe(1_000); + list.mockRejectedValue(new ApiError("No access", 403, null)); + await act(async () => { await client.refetchQueries(); }); + await vi.waitFor(() => expect(latest!.dismissedAtByKey.size).toBe(0)); + }); + + it("waits as before without a saved list", async () => { + list.mockReturnValue(new Promise(() => {})); + await render(null); + expect(latest).toMatchObject({ isLoading: true, hasServerData: false }); + }); +}); diff --git a/ui/src/lib/inbox-mine-reveal-sources.test.ts b/ui/src/lib/inbox-mine-reveal-sources.test.ts new file mode 100644 index 00000000000..d046a218d73 --- /dev/null +++ b/ui/src/lib/inbox-mine-reveal-sources.test.ts @@ -0,0 +1,63 @@ +import { describe, expect, it } from "vitest"; +import type { Approval, InboxDismissal, JoinRequest } from "@paperclipai/shared"; +import { + buildMineRevealSources, MINE_REVEAL_SOURCES_MAX_BYTES, mineRevealSourcesQueryKey, readMineRevealSources, +} from "./inbox-mine-reveal-sources"; +import { persistedQueryScope } from "./persisted-query-cache"; + +const approval = (id: string, overrides: Partial = {}) => ({ + id, companyId: "company-1", type: "hire_agent", status: "pending", requestedByUserId: null, requestedByAgentId: "agent-1", + decidedByUserId: null, payload: { name: id }, createdAt: new Date(0), updatedAt: new Date(0), ...overrides, +}) as unknown as Approval; +const joinRequest = (id: string) => ({ id, companyId: "company-1", status: "pending_approval" }) as unknown as JoinRequest; +const dismissal = (itemKey: string) => ({ id: itemKey, companyId: "company-1", userId: "user-1", itemKey, dismissedAt: new Date(0) }) as unknown as InboxDismissal; + +describe("Mine reveal sources", () => { + it("keeps only what Mine renders and the dismissals of those items", () => { + const sources = buildMineRevealSources({ + userId: "user-1", companyId: "company-1", + approvals: [ + approval("pending"), + approval("mine-resolved", { status: "approved", requestedByUserId: "user-1" }), + approval("other-resolved", { status: "approved", requestedByUserId: "user-2" }), + ], + joinRequests: [joinRequest("join-1")], + dismissals: [dismissal("approval:pending"), dismissal("join:join-1"), dismissal("run:run-1"), dismissal("approval:other-resolved"), dismissal("run:other")], + failedRunIds: ["run-1"], + }); + expect(sources.approvals.map((entry) => entry.id)).toEqual(["pending", "mine-resolved"]); + expect(sources.joinRequests.map((entry) => entry.id)).toEqual(["join-1"]); + expect(sources.dismissals.map((entry) => entry.itemKey)).toEqual(["approval:pending", "join:join-1", "run:run-1"]); + expect(readMineRevealSources(sources, "user-1", "company-1")).toBe(sources); + }); + + it("replaces an oversized record with an empty incomplete one that never answers the reveal", () => { + const big = "x".repeat(MINE_REVEAL_SOURCES_MAX_BYTES); + const sources = buildMineRevealSources({ + userId: "user-1", companyId: "company-1", approvals: [approval("big", { payload: { summary: big } })], + joinRequests: [], dismissals: [], failedRunIds: [], + }); + expect(sources).toEqual({ userId: "user-1", companyId: "company-1", approvals: [], joinRequests: [], dismissals: [], incomplete: true }); + expect(readMineRevealSources(sources, "user-1", "company-1")).toBeNull(); + }); + + it("answers only for the same user and company", () => { + const sources = buildMineRevealSources({ userId: "user-1", companyId: "company-1", approvals: [], joinRequests: [], dismissals: [], failedRunIds: [] }); + expect(readMineRevealSources(sources, "user-2", "company-1")).toBeNull(); + expect(readMineRevealSources(sources, "user-1", "company-2")).toBeNull(); + expect(readMineRevealSources(sources, null, "company-1")).toBeNull(); + expect(readMineRevealSources({ userId: "user-1", companyId: "company-1" }, "user-1", "company-1")).toBeNull(); + expect(readMineRevealSources(undefined, "user-1", "company-1")).toBeNull(); + }); + + it("is saved per user and company by the persisted query cache, and only when its data matches its key", () => { + const sources = buildMineRevealSources({ userId: "user-1", companyId: "company-1", approvals: [], joinRequests: [], dismissals: [], failedRunIds: [] }); + const key = mineRevealSourcesQueryKey("company-1", "user-1"); + expect(persistedQueryScope(key, sources, "user-1", ["company-1"])).toBe("company-1"); + expect(persistedQueryScope(key, sources, "user-2", ["company-1"])).toBeUndefined(); + expect(persistedQueryScope(key, sources, "user-1", ["company-2"])).toBeUndefined(); + expect(persistedQueryScope(key, { ...sources, userId: "user-2" }, "user-1", ["company-1"])).toBeUndefined(); + expect(persistedQueryScope(key, { ...sources, companyId: "company-2" }, "user-1", ["company-1"])).toBeUndefined(); + expect(persistedQueryScope([...key, "extra"], sources, "user-1", ["company-1"])).toBeUndefined(); + }); +}); diff --git a/ui/src/lib/inbox-mine-reveal-sources.ts b/ui/src/lib/inbox-mine-reveal-sources.ts new file mode 100644 index 00000000000..4714fe50963 --- /dev/null +++ b/ui/src/lib/inbox-mine-reveal-sources.ts @@ -0,0 +1,63 @@ +import type { Approval, InboxDismissal, JoinRequest } from "@paperclipai/shared"; +import { isApprovalVisibleInMine } from "./inbox"; + +/** + * The approvals, join requests and dismissals that Mine showed on its last + * settled visit, for one user in one company. + * + * Approvals and join requests sort in among Mine's task rows by time, so on a + * first visit Mine waits for their first answer before it shows rows. The + * saved query cache already restores Mine's own snapshot, so on a returning + * visit this record answers that wait too: rows show from saved data at once, + * and every read refreshes in the background. The persisted query cache saves + * this record per user and company (`persistedQueryScope`). + * + * Only what Mine renders is kept: approvals visible in Mine, pending join + * requests, and the dismissals of those items and of Mine's failed runs. When + * that is larger than MINE_REVEAL_SOURCES_MAX_BYTES, an empty record marked + * `incomplete` replaces any older one, so a returning visit waits as a first + * visit does. + */ +export type MineRevealSources = { + userId: string; + companyId: string; + approvals: Approval[]; + joinRequests: JoinRequest[]; + dismissals: InboxDismissal[]; + incomplete?: true; +}; + +export const MINE_REVEAL_SOURCES_MAX_BYTES = 256 * 1024; + +export const mineRevealSourcesQueryKey = (companyId: string, userId: string | null) => + ["inbox", companyId, "mine-reveal-sources", userId] as const; + +export function buildMineRevealSources(input: { + userId: string; + companyId: string; + approvals: readonly Approval[]; + joinRequests: readonly JoinRequest[]; + dismissals: readonly InboxDismissal[]; + failedRunIds: readonly string[]; +}): MineRevealSources { + const approvals = input.approvals.filter((approval) => isApprovalVisibleInMine(approval, input.userId)); + const joinRequests = [...input.joinRequests]; + const itemKeys = new Set([ + ...approvals.map((approval) => `approval:${approval.id}`), + ...joinRequests.map((request) => `join:${request.id}`), + ...input.failedRunIds.map((id) => `run:${id}`), + ]); + const dismissals = input.dismissals.filter((dismissal) => itemKeys.has(dismissal.itemKey)); + const sources: MineRevealSources = { userId: input.userId, companyId: input.companyId, approvals, joinRequests, dismissals }; + return JSON.stringify(sources).length <= MINE_REVEAL_SOURCES_MAX_BYTES ? sources + : { userId: input.userId, companyId: input.companyId, approvals: [], joinRequests: [], dismissals: [], incomplete: true }; +} + +/** The saved record, only when it belongs to this user and company. */ +export function readMineRevealSources(value: unknown, userId: string | null, companyId: string | null): MineRevealSources | null { + if (!value || typeof value !== "object" || !userId || !companyId) return null; + const record = value as Partial; + if (record.userId !== userId || record.companyId !== companyId || record.incomplete) return null; + if (!Array.isArray(record.approvals) || !Array.isArray(record.joinRequests) || !Array.isArray(record.dismissals)) return null; + return record as MineRevealSources; +} diff --git a/ui/src/lib/persisted-query-cache.test.ts b/ui/src/lib/persisted-query-cache.test.ts index 2bca4eed8d3..c9de5c03eb5 100644 --- a/ui/src/lib/persisted-query-cache.test.ts +++ b/ui/src/lib/persisted-query-cache.test.ts @@ -5,6 +5,7 @@ import { ApiError, api, detachInflightGets } from "@/api/client"; import { bindAccount } from "./account-scope"; import { hasUnverifiedSession, markCachedSession } from "./cached-session"; import { queryKeys } from "./queryKeys"; +import { mineRevealSourcesQueryKey } from "./inbox-mine-reveal-sources"; import { readComposerRunSettings } from "../components/task-chat/composer-run-settings"; import { agentConnection, agentDefaultModel } from "./bulk-agent-settings"; import { clearPersistedQueryCache, persistedQueryScope, QUERY_CACHE_ACTIVE, QUERY_CACHE_CLEARED, QUERY_CACHE_MAX_AGE, QUERY_CACHE_PREFIX, startPersistedQueryCache } from "./persisted-query-cache"; @@ -529,6 +530,20 @@ describe("persisted read cache", () => { expect(persistedQueryScope(["agent-chats", "company-one", "bob"], [], "alice", ["company-one"])).toBeUndefined(); }); + it("restores Mine's reveal sources for the same user and company only", () => { + const first = setup(); seed(first.client); + const sources = { userId: "alice", companyId: "company-one", approvals: [{ id: "approval-1", status: "pending" }], joinRequests: [], dismissals: [] }; + first.client.setQueryData(mineRevealSourcesQueryKey("company-one", "alice"), sources); + first.client.setQueryData(mineRevealSourcesQueryKey("company-one", "bob"), { ...sources, userId: "bob" }); + first.handle.flush(); + const restored = setup(first.storage); + const state = restored.client.getQueryState(mineRevealSourcesQueryKey("company-one", "alice")); + expect(state?.data).toEqual(sources); + // Restored reads are marked stale, so every consumer still refreshes them. + expect(state?.isInvalidated).toBe(true); + expect(restored.client.getQueryData(mineRevealSourcesQueryKey("company-one", "bob"))).toBeUndefined(); + }); + it.each(["build", "expiry"])("discards snapshots after %s changes", kind => { vi.useFakeTimers(); const startedAt = Date.now(); diff --git a/ui/src/lib/persisted-query-cache.ts b/ui/src/lib/persisted-query-cache.ts index 717935963c8..cf53fc73a12 100644 --- a/ui/src/lib/persisted-query-cache.ts +++ b/ui/src/lib/persisted-query-cache.ts @@ -111,6 +111,8 @@ export function persistedQueryScope(key: readonly unknown[], data: unknown, user if (root === "agent-chats" && key.length === 3 && third === userId) return second; if (root === "primary-agent" && third === userId && key.length === 3) return second; if (root === "issues" && third === "mine-context" && key.length === 4 && key[3] === userId && object(data)?.userId === userId) return second; + if (root === "inbox" && third === "mine-reveal-sources" && key.length === 4 && key[3] === userId + && object(data)?.userId === userId && object(data)?.companyId === second) return second; if (root === "issues" && ["mine-by-me", "touched-by-me"].includes(String(third)) && key[3] === "index" && key[4] === "with-routine-executions" && key[5] === "live-descendant-summary" && key[6] === 100 && (third === "mine-by-me" ? key.length === 8 && key[7] === userId : key.length === 7)) return second; diff --git a/ui/src/pages/Inbox.test.tsx b/ui/src/pages/Inbox.test.tsx index 7033e2bc572..e5e8f908e4b 100644 --- a/ui/src/pages/Inbox.test.tsx +++ b/ui/src/pages/Inbox.test.tsx @@ -2,6 +2,7 @@ import { CoordinatorPresentation } from "../components/coordinator/CoordinatorPresentation"; import { queryKeys } from "../lib/queryKeys"; +import { mineRevealSourcesQueryKey, type MineRevealSources } from "../lib/inbox-mine-reveal-sources"; import type { ComponentProps } from "react"; import { flushSync } from "react-dom"; import { createRoot } from "react-dom/client"; @@ -150,15 +151,19 @@ vi.mock("../lib/inbox", async () => { }; }); -vi.mock("../hooks/useInboxBadge", () => ({ - useDismissedInboxAlerts: () => ({ dismissed: new Set(), dismiss: vi.fn() }), - useInboxDismissals: () => ({ dismissedAtByKey: new Map(), dismiss: vi.fn() }), - useReadInboxItems: () => ({ - readItems: new Set(), - markRead: vi.fn(), - markUnread: vi.fn(), - }), -})); +vi.mock("../hooks/useInboxBadge", () => { + // Stable values, as the real hook's query data is between renders. + const dismissals = { dismissedAtByKey: new Map(), dismiss: vi.fn(), dismissals: [], hasServerData: true, isLoading: false, error: null }; + return { + useDismissedInboxAlerts: () => ({ dismissed: new Set(), dismiss: vi.fn() }), + useInboxDismissals: () => dismissals, + useReadInboxItems: () => ({ + readItems: new Set(), + markRead: vi.fn(), + markUnread: vi.fn(), + }), + }; +}); vi.mock("../hooks/useIssueExternalObjects", () => ({ useIssueExternalObjectSummaries: () => ({ @@ -2028,6 +2033,98 @@ describe("Inbox toolbar", () => { } finally { await act(() => root.unmount()); client.clear(); } }); + describe("returning visit with saved reveal sources", () => { + const savedApproval = createApproval({ id: "approval-saved", payload: { name: "Saved approval" }, updatedAt: new Date("2026-03-11T00:00:01.500Z") }); + const approvalRowCount = () => container.querySelectorAll('a[href="/approvals/approval-saved"]').length; + // First visit: every read answers and Mine saves what it showed. Then the + // optional reads leave the cache, as on a hard load that restored only + // the saved query cache, and the page mounts again. + const visitThenReturn = async (client: QueryClient, root: ReturnType) => { + apiMocks.approvalsList.mockResolvedValue([savedApproval]); + await renderInbox(client, root); + await vi.waitFor(() => expect(approvalRowCount()).toBe(1)); + await vi.waitFor(() => expect(client.getQueryData(mineRevealSourcesQueryKey("company-1", "local-board"))?.approvals + .map((approval) => approval.id)).toEqual(["approval-saved"])); + await act(async () => root.unmount()); + client.removeQueries({ queryKey: queryKeys.approvals.list("company-1") }); + client.removeQueries({ queryKey: queryKeys.access.joinRequests("company-1") }); + apiMocks.approvalsList.mockClear(); + }; + const client = () => new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity } } }); + + it("reveals rows and the saved approval while the reads are pending, then keeps selection when a new approval arrives", async () => { + routerMock.location.pathname = "/inbox/mine"; + twoRows(); + const queryClient = client(); + let root = createRoot(container); + try { + await visitThenReturn(queryClient, root); + let resolveApprovals: (value: Approval[]) => void = () => {}; + apiMocks.approvalsList.mockReturnValue(new Promise((resolve) => { resolveApprovals = resolve; })); + apiMocks.joinRequestsList.mockReturnValue(new Promise(() => {})); + root = createRoot(container); + await renderInbox(queryClient, root); + await vi.waitFor(() => expect(apiMocks.approvalsList).toHaveBeenCalled()); + expect(rowKeys().filter(Boolean)).toEqual(["PAP-4001", "PAP-4002"]); + expect(approvalRowCount()).toBe(1); + for (let press = 0; press < 3; press += 1) { + await act(async () => { document.body.dispatchEvent(new KeyboardEvent("keydown", { key: "j", bubbles: true })); }); + } + const selectedText = () => [...container.querySelectorAll("[data-inbox-item]")] + .filter((row) => row.querySelector('[class~="bg-accent/50"]') || row.className.split(/\s+/).includes("bg-accent/50")) + .map((row) => row.textContent).join(" | "); + const before = selectedText(); + expect(before).not.toBe(""); + await act(async () => { + resolveApprovals([savedApproval, createApproval({ id: "approval-new", payload: { name: "Late approval" }, updatedAt: new Date("2026-03-11T00:00:05.000Z") })]); + }); + await vi.waitFor(() => expect(container.querySelectorAll('a[href="/approvals/approval-new"]').length).toBe(1)); + expect(selectedText()).toBe(before); + } finally { await act(() => root.unmount()); queryClient.clear(); } + }); + + it("keeps the saved approval through a transient failure and drops it after a refusal", async () => { + routerMock.location.pathname = "/inbox/mine"; + twoRows(); + const queryClient = client(); + let root = createRoot(container); + try { + await visitThenReturn(queryClient, root); + apiMocks.approvalsList.mockRejectedValue(new ApiError("Busy", 503, null)); + root = createRoot(container); + await renderInbox(queryClient, root); + await vi.waitFor(() => expect(apiMocks.approvalsList).toHaveBeenCalled()); + await vi.waitFor(() => expect(queryClient.getQueryState(queryKeys.approvals.list("company-1"))?.status).toBe("error")); + expect(rowKeys().filter(Boolean)).toEqual(["PAP-4001", "PAP-4002"]); + expect(approvalRowCount()).toBe(1); + apiMocks.approvalsList.mockRejectedValue(new ApiError("No access", 403, null)); + await act(async () => { await queryClient.refetchQueries({ queryKey: queryKeys.approvals.list("company-1") }); }); + await vi.waitFor(() => expect(approvalRowCount()).toBe(0)); + expect(rowKeys().filter(Boolean)).toEqual(["PAP-4001", "PAP-4002"]); + } finally { await act(() => root.unmount()); queryClient.clear(); } + }); + + it("ignores saved sources stamped for another user or company and waits as a first visit does", async () => { + routerMock.location.pathname = "/inbox/mine"; + twoRows(); + const queryClient = client(); + queryClient.setQueryData(mineRevealSourcesQueryKey("company-1", "local-board"), { + userId: "someone-else", companyId: "company-1", approvals: [savedApproval], joinRequests: [], dismissals: [], + } satisfies MineRevealSources); + apiMocks.approvalsList.mockReturnValue(new Promise(() => {})); + const root = createRoot(container); + try { + await renderInbox(queryClient, root); + await vi.waitFor(() => { + const mineQueries = queryClient.getQueryCache().findAll({ queryKey: queryKeys.issues.listMineByMe("company-1") }); + expect(mineQueries.some((query) => query.state.status === "success")).toBe(true); + }); + expect(container.querySelector("[data-inbox-item]")).toBeNull(); + expect(approvalRowCount()).toBe(0); + } finally { await act(() => root.unmount()); queryClient.clear(); } + }); + }); + it("bounds a stalled approvals read so rows do not stay behind a skeleton", async () => { routerMock.location.pathname = "/inbox/mine"; twoRows(); diff --git a/ui/src/pages/Inbox.tsx b/ui/src/pages/Inbox.tsx index 8fc8013a2e2..60d3cbde407 100644 --- a/ui/src/pages/Inbox.tsx +++ b/ui/src/pages/Inbox.tsx @@ -35,6 +35,7 @@ import { useToastActions } from "../context/ToastContext"; import { useBreadcrumbs } from "../context/BreadcrumbContext"; import { useSidebar } from "../context/SidebarContext"; import { queryKeys } from "../lib/queryKeys"; +import { buildMineRevealSources, mineRevealSourcesQueryKey, readMineRevealSources, type MineRevealSources } from "../lib/inbox-mine-reveal-sources"; import { useDialogActions } from "../context/DialogContext"; import { useIssueExternalObjectSummaries } from "../hooks/useIssueExternalObjects"; import { @@ -207,6 +208,7 @@ const INBOX_ISSUE_LIST_LIMIT = 100; const INBOX_HOT_PATH_STALE_MS = 30_000; // Stable fallback so memos over unloaded or disabled issue reads do not rerun on every render. const NO_ISSUES: Issue[] = []; +const NO_JOIN_REQUESTS: JoinRequest[] = []; /** Bounds an optional read that can hold task rows hidden; a timeout reveals rows and retries in the background. */ const INBOX_OPTIONAL_READ_TIMEOUT_MS = 10_000; const INBOX_COLLECTION_KEY = "inbox"; @@ -886,7 +888,6 @@ function StreamlinedInbox({ () => loadInboxCollectionPreferences(selectedCompanyId).columns, ); const { dismissed: dismissedAlerts, dismiss: dismissAlert } = useDismissedInboxAlerts(); - const { dismissedAtByKey, dismiss: dismissInboxItem, isLoading: isDismissalsLoading, error: dismissalsError } = useInboxDismissals(selectedCompanyId); const { readItems, markRead: markItemRead, markUnread: markItemUnread } = useReadInboxItems(); const { allCategoryFilter, allApprovalFilter, issueFilters } = filterPreferences; @@ -918,6 +919,21 @@ function StreamlinedInbox({ const currentUserId = session?.user.id ?? session?.session.userId ?? null; const mineContextQueryKey = [...queryKeys.issues.list(selectedCompanyId!), "mine-context", currentUserId] as const; const { data: mineSnapshot } = useQuery({ queryKey: mineContextQueryKey, enabled: false }); + // On a returning visit the saved query cache restores Mine's snapshot and the + // approvals, join requests and dismissals it showed. Those stand in until the + // reads answer, so rows show without waiting on the network. + const revealSourcesQueryKey = mineRevealSourcesQueryKey(selectedCompanyId!, currentUserId); + const { data: savedRevealSourcesData } = useQuery({ queryKey: revealSourcesQueryKey, enabled: false }); + const savedRevealSources = tab === "mine" && mineSnapshot + ? readMineRevealSources(savedRevealSourcesData, currentUserId, selectedCompanyId) : null; + const { + dismissals: inboxDismissals, + dismissedAtByKey, + dismiss: dismissInboxItem, + isLoading: isDismissalsLoading, + hasServerData: hasServerDismissals, + error: dismissalsError, + } = useInboxDismissals(selectedCompanyId, { fallback: savedRevealSources?.dismissals }); const { data: agents, isLoading: isAgentsLoading } = useQuery({ @@ -962,7 +978,7 @@ function StreamlinedInbox({ }, [selectedCompanyId]); const { - data: approvals, + data: serverApprovals, isLoading: isApprovalsLoading, failureCount: approvalsFailureCount, error: approvalsError, @@ -974,7 +990,7 @@ function StreamlinedInbox({ }); const { - data: joinRequests = [], + data: serverJoinRequests, isLoading: isJoinRequestsLoading, failureCount: joinRequestsFailureCount, error: joinRequestsError, @@ -996,6 +1012,29 @@ function StreamlinedInbox({ enabled: !!selectedCompanyId, }); + // Saved values stand in while a read is pending or after a transient failure; + // a refusal (403/404) or a server answer replaces them. + const savedStandsIn = (data: unknown, error: unknown) => + data === undefined && savedRevealSources !== null && (!error || isTransientError(error)); + const approvalsFromSaved = savedStandsIn(serverApprovals, approvalsError); + const joinRequestsFromSaved = savedStandsIn(serverJoinRequests, joinRequestsError); + const approvals = approvalsFromSaved ? savedRevealSources!.approvals : serverApprovals; + const joinRequests = serverJoinRequests ?? (joinRequestsFromSaved ? savedRevealSources!.joinRequests : NO_JOIN_REQUESTS); + + // Save what Mine shows once every source has a server answer, for the next visit. + useEffect(() => { + if (tab !== "mine" || !selectedCompanyId || !currentUserId || !mineSnapshot) return; + if (serverApprovals === undefined || serverJoinRequests === undefined || !hasServerDismissals) return; + const next = buildMineRevealSources({ + userId: currentUserId, companyId: selectedCompanyId, approvals: serverApprovals, joinRequests: serverJoinRequests, + dismissals: inboxDismissals, failedRunIds: mineSnapshot.failureRuns.map((run) => run.id), + }); + const key = mineRevealSourcesQueryKey(selectedCompanyId, currentUserId); + // Each write schedules a save of the query cache; skip unchanged values. + if (JSON.stringify(queryClient.getQueryData(key)) === JSON.stringify(next)) return; + queryClient.setQueryData(key, next); + }, [tab, selectedCompanyId, currentUserId, mineSnapshot, serverApprovals, serverJoinRequests, hasServerDismissals, inboxDismissals, queryClient]); + const dashboardQueryKey = queryKeys.dashboard(selectedCompanyId!); const sharedDashboard = useSharedPollingQuery({ companyId: selectedCompanyId, @@ -2274,9 +2313,12 @@ function StreamlinedInbox({ return keyIndex >= 0 ? keyIndex : resolveInboxSelectionIndex(prev, flatNavItems.length); }); }, [flatNavItems]); + // Record the key only when the selection itself moves. Recording on a list + // change too would store the row now at the old index (one a refresh inserted + // above the selection) before the re-anchor above runs, and move the selection. useEffect(() => { - selectedNavKeyRef.current = selectedIndex >= 0 ? navEntryKey(flatNavItems[selectedIndex]) : null; - }, [flatNavItems, selectedIndex]); + selectedNavKeyRef.current = selectedIndex >= 0 ? navEntryKey(flatNavItemsRef.current[selectedIndex]) : null; + }, [selectedIndex]); useEffect(() => { setUndoableArchiveIssueIds((prev) => @@ -2581,8 +2623,9 @@ function StreamlinedInbox({ // rows down. Wait for their first bounded attempt only; a failure or timeout reveals rows. const approvalsAffectRows = tab !== "blocked" && (tab !== "all" || showApprovalsCategory); const joinRequestsAffectRows = tab !== "blocked" && (tab !== "all" || showJoinRequestsCategory); - const isApprovalsFirstAttemptPending = isApprovalsLoading && approvalsFailureCount === 0; - const isJoinRequestsFirstAttemptPending = isJoinRequestsLoading && joinRequestsFailureCount === 0; + // Saved values from the last visit answer this wait on a returning visit. + const isApprovalsFirstAttemptPending = isApprovalsLoading && approvalsFailureCount === 0 && !approvalsFromSaved; + const isJoinRequestsFirstAttemptPending = isJoinRequestsLoading && joinRequestsFailureCount === 0 && !joinRequestsFromSaved; // User names only fill row text, except when they name and order assignee groups. const userLabelsAffectRows = groupBy === "assignee"; const isMembersFirstAttemptPending = isMembersLoading && membersFailureCount === 0;