@remit/web-client 0.0.325 → 0.0.327

package/src/hooks/useRescueCandidates.test.ts

@@ -1,194 +0,0 @@
-/**
- * useRescueCandidates — exercises the real hook.
- *
- * Strategy: pre-seed a QueryClient cache with a mocked
- * threadOperationsSearchThreads response (same key the hook generates), then
- * render the hook synchronously via renderToString + QueryClientProvider. The
- * hook reads from the cache, so the queryFn never fires; mapping drift in the
- * hook source will break these assertions.
- */
-
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { threadOperationsSearchThreadsQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type {
-	RemitImapSenderTrust,
-	RemitImapThreadMessageResponse,
-	RemitImapThreadSearchResponse,
-} from "@remit/api-http-client/types.gen.ts";
-import type { RescueCandidate } from "@remit/ui";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createElement } from "react";
-import { renderToString } from "react-dom/server";
-import { useRescueCandidates } from "./useRescueCandidates.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const JUNK_MAILBOX_ID = "mb-junk";
-
-/** Query options the hook passes — must stay in sync with useRescueCandidates.ts */
-const HOOK_QUERY_OPTIONS = {
-	path: { mailboxId: JUNK_MAILBOX_ID },
-	query: {
-		senderTrust: ["vip", "wellknown"] as RemitImapSenderTrust[],
-		dkimMismatch: false,
-		results: true,
-		limit: 500,
-	},
-};
-
-function makeThread(
-	overrides: Partial<RemitImapThreadMessageResponse> &
-		Pick<RemitImapThreadMessageResponse, "messageId" | "senderTrust">,
-): RemitImapThreadMessageResponse {
-	return {
-		threadMessageId: `tm-${overrides.messageId}`,
-		threadId: `t-${overrides.messageId}`,
-		accountConfigId: "acc",
-		mailboxId: JUNK_MAILBOX_ID,
-		sentDate: 1_000_000,
-		isRead: false,
-		hasAttachment: false,
-		hasStars: false,
-		isDeleted: false,
-		createdAt: 1_000_000,
-		updatedAt: 1_000_000,
-		fromName: "Anna de Vries",
-		fromEmail: "anna@example.nl",
-		subject: "Re: invoice",
-		snippet: "See attached.",
-		...overrides,
-	} as RemitImapThreadMessageResponse;
-}
-
-/**
- * Pre-seeds a QueryClient with `response` under the key the hook generates,
- * renders the hook synchronously inside a QueryClientProvider, and returns
- * whatever the hook returned.
- */
-function renderHookWithResponse(response: RemitImapThreadSearchResponse): {
-	candidates: RescueCandidate[];
-} {
-	const client = new QueryClient({
-		defaultOptions: { queries: { retry: false } },
-	});
-	client.setQueryData(
-		threadOperationsSearchThreadsQueryKey(HOOK_QUERY_OPTIONS),
-		response,
-	);
-
-	let captured: { candidates: RescueCandidate[] } = { candidates: [] };
-
-	function Capture() {
-		captured = useRescueCandidates(JUNK_MAILBOX_ID);
-		return null;
-	}
-
-	renderToString(
-		createElement(
-			QueryClientProvider,
-			{ client },
-			createElement(Capture),
-		) as never,
-	);
-
-	return captured;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("useRescueCandidates: empty / disabled states", () => {
-	test("returns empty candidates when the response has no items", () => {
-		const { candidates } = renderHookWithResponse({ items: [] });
-		assert.deepEqual(candidates, []);
-	});
-
-	test("returns empty candidates and does not fire when junkMailboxId is undefined", () => {
-		const client = new QueryClient({
-			defaultOptions: { queries: { retry: false } },
-		});
-
-		// Prove the query was never seeded — so if enabled fired, it would hang
-		let captured: { candidates: RescueCandidate[] } = { candidates: [] };
-
-		function Capture() {
-			captured = useRescueCandidates(undefined);
-			return null;
-		}
-
-		renderToString(
-			createElement(
-				QueryClientProvider,
-				{ client },
-				createElement(Capture),
-			) as never,
-		);
-
-		assert.deepEqual(captured.candidates, []);
-	});
-});
-
-describe("useRescueCandidates: candidate mapping from real hook output", () => {
-	const vipThread = makeThread({ messageId: "m1", senderTrust: "vip" });
-	const wellknownThread = makeThread({
-		messageId: "m2",
-		senderTrust: "wellknown",
-	});
-
-	test("falls back to fromEmail when fromName is absent", () => {
-		const thread = makeThread({
-			messageId: "m3",
-			senderTrust: "vip",
-			fromName: undefined,
-		});
-		const { candidates } = renderHookWithResponse({ items: [thread] });
-		assert.equal(candidates[0].senderName, "anna@example.nl");
-	});
-
-	test("falls back to 'Unknown sender' when both name and email are absent", () => {
-		const thread = makeThread({
-			messageId: "m4",
-			senderTrust: "vip",
-			fromName: undefined,
-			fromEmail: undefined,
-		});
-		const { candidates } = renderHookWithResponse({ items: [thread] });
-		assert.equal(candidates[0].senderName, "Unknown sender");
-		assert.equal(candidates[0].senderAddress, "");
-	});
-
-	test("falls back to '(no subject)' when subject is absent", () => {
-		const thread = makeThread({
-			messageId: "m5",
-			senderTrust: "vip",
-			subject: undefined,
-		});
-		const { candidates } = renderHookWithResponse({ items: [thread] });
-		assert.equal(candidates[0].subject, "(no subject)");
-	});
-
-	test("sets vip trustSubReason via rescueCandidateReason", () => {
-		const { candidates } = renderHookWithResponse({ items: [vipThread] });
-		assert.equal(candidates[0].trustSubReason, "A sender you know");
-	});
-
-	test("sets wellknown trustSubReason via rescueCandidateReason", () => {
-		const { candidates } = renderHookWithResponse({
-			items: [wellknownThread],
-		});
-		assert.equal(candidates[0].trustSubReason, "You've emailed them before");
-	});
-
-	test("maps all response items to candidates in order", () => {
-		const { candidates } = renderHookWithResponse({
-			items: [vipThread, wellknownThread],
-		});
-		assert.equal(candidates.length, 2);
-		assert.equal(candidates[0].id, "m1");
-		assert.equal(candidates[1].id, "m2");
-	});
-});

package/src/hooks/useRescueCandidates.ts

@@ -1,48 +0,0 @@
-import { threadOperationsSearchThreadsOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { RescueCandidate } from "@remit/ui";
-import { useQuery } from "@tanstack/react-query";
-import { rescueCandidateReason } from "@/lib/rescue-candidates";
-
-const TRUST_REASON = "We can verify this sender";
-
-/**
- * Fetch rescue candidates from the backend for the given Junk mailbox.
- *
- * Filters by senderTrust=[vip,wellknown] and dkimMismatch=false. The
- * dkimMismatch=false filter excludes senders with no authenticity signal
- * (undefined), not just confirmed mismatches — this is intentional: it closes
- * the impersonation path where a spoofed trusted-sender From with no DKIM
- * would otherwise surface as a rescue candidate.
- *
- * Only fires when junkMailboxId is provided.
- */
-export function useRescueCandidates(junkMailboxId: string | undefined): {
-	candidates: RescueCandidate[];
-} {
-	const { data } = useQuery({
-		...threadOperationsSearchThreadsOptions({
-			path: { mailboxId: junkMailboxId ?? "" },
-			query: {
-				senderTrust: ["vip", "wellknown"],
-				dkimMismatch: false,
-				results: true,
-				limit: 500,
-			},
-		}),
-		enabled: !!junkMailboxId,
-		staleTime: 60_000,
-	});
-
-	const candidates: RescueCandidate[] = (data?.items ?? []).map((thread) => ({
-		id: thread.messageId,
-		senderName: thread.fromName || thread.fromEmail || "Unknown sender",
-		senderAddress: thread.fromEmail ?? "",
-		subject: thread.subject || "(no subject)",
-		snippet: thread.snippet ?? "",
-		trustReason: TRUST_REASON,
-		trustSubReason: rescueCandidateReason(thread.senderTrust),
-		senderTrust: thread.senderTrust,
-	}));
-
-	return { candidates };
-}

package/src/hooks/useResultCount.render.test.ts

@@ -1,161 +0,0 @@
-/**
- * The result count is one question asked of the server, not a walk of the
- * pages (#307).
- *
- * The header used to render `threads.length`, which understated every search
- * matching more than one page and climbed as the reader scrolled. These mount
- * the real hook against the real fetch seam and read what actually left: the
- * whole match set from one request, no second request when the list pages, and
- * nothing at all for a query still being typed.
- */
-
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import type { ResultCount } from "@remit/ui";
-import { createElement } from "react";
-import { createDomHarness, type DomHarness } from "../test-support/dom";
-import { type HttpMock, mockFetch } from "../test-support/http";
-import { type ThreadSearchCriteria, useResultCount } from "./useResultCount.js";
-
-const INBOX = "mbx-inbox";
-/** Far more than a page holds — the number the header must not derive itself. */
-const TOTAL_MATCHES = 1284;
-
-let harness: DomHarness | undefined;
-let http: HttpMock | undefined;
-
-afterEach(() => {
-	harness?.close();
-	harness = undefined;
-	http?.restore();
-	http = undefined;
-});
-
-/** Count-only requests, in order — the ones that asked for a number. */
-const countRequests = () =>
-	(http?.to("/threads/search") ?? []).filter(
-		(call) =>
-			new URL(call.url, "http://localhost").searchParams.get("count") ===
-			"true",
-	);
-
-interface Probe {
-	count: () => ResultCount;
-	/**
-	 * Render again on the same client, so a second search reaches the cache the
-	 * first one filled — which is the only place a stale count can come from.
-	 */
-	rerender: (next?: {
-		criteria?: ThreadSearchCriteria;
-		enabled?: boolean;
-	}) => Promise<void>;
-}
-
-const mount = async (
-	criteria: ThreadSearchCriteria,
-	enabled: boolean,
-	answer: unknown = { items: [], count: TOTAL_MATCHES },
-): Promise<Probe> => {
-	http = mockFetch((call) =>
-		call.path.endsWith("/threads/search") ? answer : { items: [] },
-	);
-
-	let value: ResultCount | undefined;
-	const CountProbe = ({
-		search,
-		on,
-	}: {
-		search: ThreadSearchCriteria;
-		on: boolean;
-	}) => {
-		value = useResultCount({ mailboxId: INBOX, criteria: search, enabled: on });
-		return null;
-	};
-
-	const mounted = createDomHarness();
-	harness = mounted;
-	let search = criteria;
-	let on = enabled;
-	const render: Probe["rerender"] = async (next) => {
-		if (next?.criteria) search = next.criteria;
-		if (next?.enabled !== undefined) on = next.enabled;
-		mounted.renderApp(createElement(CountProbe, { search, on }));
-		await mounted.flush();
-		await mounted.wait(20);
-		await mounted.flush();
-	};
-	await render();
-	return {
-		count: () => {
-			if (!value) throw new Error("hook did not render");
-			return value;
-		},
-		rerender: render,
-	};
-};
-
-describe("useResultCount (#307)", () => {
-	it("answers with the whole match set the server counted", async () => {
-		const probe = await mount({ query: "invoice" }, true);
-
-		assert.deepEqual(probe.count(), { kind: "exact", value: TOTAL_MATCHES });
-		assert.equal(countRequests().length, 1);
-	});
-
-	it("asks with no cursor, so paging the list never re-counts", async () => {
-		const probe = await mount({ query: "invoice" }, true);
-		await probe.rerender();
-		await probe.rerender();
-
-		assert.equal(
-			countRequests().length,
-			1,
-			"the count was asked again for a predicate that did not change",
-		);
-		const asked = new URL(countRequests()[0]?.url ?? "", "http://localhost")
-			.searchParams;
-		assert.equal(asked.get("continuationToken"), null);
-		assert.equal(asked.get("results"), "false");
-	});
-
-	it("issues no request at all while it is disabled", async () => {
-		const probe = await mount({ query: "in" }, false);
-
-		assert.equal(countRequests().length, 0);
-		assert.deepEqual(
-			probe.count(),
-			{ kind: "unknown" },
-			"an uncounted search reported a number",
-		);
-	});
-
-	/**
-	 * `enabled` gates the request, not the cache. Two searches reach the same key
-	 * whenever what separates them never reaches the request — `invoice` and
-	 * `invoice before:2020` send identical criteria — so the second must not read
-	 * the first one's answer back out of the cache.
-	 */
-	it("forgets the number the moment it stops being asked for", async () => {
-		const probe = await mount({ query: "invoice" }, true);
-		assert.deepEqual(probe.count(), { kind: "exact", value: TOTAL_MATCHES });
-
-		await probe.rerender({ enabled: false });
-
-		assert.deepEqual(
-			probe.count(),
-			{ kind: "unknown" },
-			"a count nobody asked for was served from the cache",
-		);
-		assert.equal(countRequests().length, 1, "the gate stopped gating requests");
-	});
-
-	it("reports no number when the server withholds the count", async () => {
-		const probe = await mount({ query: "invoice" }, true, { items: [] });
-
-		assert.deepEqual(
-			probe.count(),
-			{ kind: "unknown" },
-			"an absent count became a zero",
-		);
-	});
-});

package/src/hooks/useResultCount.ts

@@ -1,68 +0,0 @@
-import { threadOperationsSearchThreadsQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { threadOperationsSearchThreads } from "@remit/api-http-client/sdk.gen.ts";
-import type { ThreadOperationsSearchThreadsData } from "@remit/api-http-client/types.gen.ts";
-import type { ResultCount } from "@remit/ui";
-import { useQuery } from "@tanstack/react-query";
-import { toResultCount } from "@/lib/result-count";
-
-/**
- * What the list is asking about, with nothing about paging in it. The count is
- * a property of the criteria alone, so a page fetch can never trigger one.
- */
-export type ThreadSearchCriteria = Omit<
-	NonNullable<ThreadOperationsSearchThreadsData["query"]>,
-	"continuationToken" | "limit" | "count" | "results"
->;
-
-export interface UseResultCountOptions {
-	mailboxId: string;
-	criteria: ThreadSearchCriteria;
-	/**
-	 * Whether this search is worth counting at all — see
-	 * `shouldRequestResultCount`. Disabled, the surface renders no number rather
-	 * than a stale one from the search before it.
-	 */
-	enabled: boolean;
-}
-
-/** A minute: long enough that returning to a search just left costs nothing. */
-const COUNT_STALE_TIME_MS = 60_000;
-
-/**
- * How many messages the search matches, from the server that resolves it —
- * one request against the criteria, never a walk of the pages (#307).
- *
- * Its own query, keyed on the criteria without the cursor, so the list pages
- * without re-counting. An answer that carries no count — off-row criteria, per
- * #305 — stays absent rather than becoming a zero.
- */
-export const useResultCount = ({
-	mailboxId,
-	criteria,
-	enabled,
-}: UseResultCountOptions): ResultCount => {
-	const query = { ...criteria, count: true, results: false };
-	const { data } = useQuery({
-		queryKey: threadOperationsSearchThreadsQueryKey({
-			path: { mailboxId },
-			query,
-		}),
-		queryFn: async () => {
-			const { data: response } = await threadOperationsSearchThreads({
-				path: { mailboxId },
-				query,
-				throwOnError: true,
-			});
-			return response;
-		},
-		enabled,
-		staleTime: COUNT_STALE_TIME_MS,
-	});
-	// `enabled` gates the request, not the cache: a criteria set that asks for no
-	// count still reads whatever the last identical key left behind. Two searches
-	// share a key whenever the terms that separate them reach the request as
-	// nothing — `before:`/`after:`/`account:` are stripped from the free text and
-	// carry no param — so a disabled count that read `data` would render the
-	// previous search's total over this one's rows.
-	return enabled ? toResultCount(data?.count) : { kind: "unknown" };
-};

package/src/hooks/useResultFolderIndex.ts

@@ -1,88 +0,0 @@
-/**
- * Fans out the per-account mailbox-list query (the same one `MailSidebarAdapter`
- * and `useMailboxNameIndex` run — cached forever, react-query dedupes the
- * identical key across call sites) and reduces it to the mailboxId → folder map
- * search results resolve their provenance against. See `lib/result-folder.ts`.
- *
- * The read state travels with the index: a folder label cut on a delimiter that
- * has not arrived is wrong rather than late, so a surface that names folders can
- * wait for this, and say so when it fails.
- */
-import { mailboxOperationsListMailboxesOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type {
-	RemitImapAccountResponse,
-	RemitImapMailboxResponse,
-} from "@remit/api-http-client/types.gen.ts";
-import { useQueries } from "@tanstack/react-query";
-import { useMemo } from "react";
-import {
-	buildResultFolderIndex,
-	type ResultFolderIndex,
-} from "@/lib/result-folder";
-
-type MailboxItems = RemitImapMailboxResponse[];
-
-interface MailboxListsState {
-	items: MailboxItems[];
-	isPending: boolean;
-	// Typed as the generated wire body by TanStack now that the operation
-	// declares its failures, but always an `ApiError` or a `NetworkError` by the
-	// time it arrives — `client.ts` re-wraps every HTTP failure.
-	// `formatErrorMessage` reads a message off any of them.
-	error: unknown;
-}
-
-export interface ResultFolderIndexState {
-	index: ResultFolderIndex;
-	isPending: boolean;
-	error: unknown;
-}
-
-/**
- * Hoisted, not inline: `useQueries` skips re-running `combine` when it is given
- * the same function, so a stable reference is what makes this a memo rather than
- * a per-render reduce. Without it the index — and every search-result memo keyed
- * on it — rebuilds on every render.
- */
-const combineMailboxLists = (
-	results: {
-		data?: { items: MailboxItems };
-		isPending: boolean;
-		error: unknown;
-	}[],
-): MailboxListsState => ({
-	items: results.map((result) => result.data?.items ?? []),
-	isPending: results.some((result) => result.isPending),
-	error: results.find((result) => result.error)?.error ?? null,
-});
-
-export function useResultFolderIndex(
-	accounts: RemitImapAccountResponse[],
-): ResultFolderIndexState {
-	const mailboxLists = useQueries({
-		queries: accounts.map((account) => ({
-			...mailboxOperationsListMailboxesOptions({
-				path: { accountId: account.accountId },
-			}),
-			staleTime: Infinity,
-		})),
-		combine: combineMailboxLists,
-	});
-
-	const index = useMemo(
-		() =>
-			buildResultFolderIndex(
-				accounts.map((account, i) => ({
-					folderAppointments: account.folderAppointments,
-					mailboxes: mailboxLists.items[i] ?? [],
-				})),
-			),
-		[accounts, mailboxLists],
-	);
-
-	return {
-		index,
-		isPending: mailboxLists.isPending,
-		error: mailboxLists.error,
-	};
-}

package/src/hooks/useReturnFromRedirect.ts

@@ -1,41 +0,0 @@
-import { useEffect, useRef } from "react";
-
-/**
- * Run `onReturn` every time the app is looked at again while it has a window
- * out at an external identity provider.
- *
- * Microsoft sign-in is the one flow that leaves this origin, and where it comes
- * back to is not ours to decide: launched from a home screen on iOS the return
- * leg can land in the browser instead of the app window, which then holds a
- * view of a sign-in that finished somewhere else. The window being looked at is
- * the one that has to reconcile, so it asks the server what happened rather
- * than trusting what it last saw.
- *
- * Every look, not just the first: a user who switches back mid-sign-in to read
- * a password has not finished anything, and a check that spent itself on that
- * look would miss the return that matters.
- *
- * `pageshow` covers the back-forward cache, where a restored page fires no
- * visibility change.
- */
-export const useReturnFromRedirect = (
-	active: boolean,
-	onReturn: () => void,
-): void => {
-	const latest = useRef(onReturn);
-	latest.current = onReturn;
-
-	useEffect(() => {
-		if (!active) return;
-		const handle = () => {
-			if (document.visibilityState !== "visible") return;
-			latest.current();
-		};
-		document.addEventListener("visibilitychange", handle);
-		window.addEventListener("pageshow", handle);
-		return () => {
-			document.removeEventListener("visibilitychange", handle);
-			window.removeEventListener("pageshow", handle);
-		};
-	}, [active]);
-};