@remit/web-client 0.0.325 → 0.0.327

package/src/lib/quarantine-entries.test.ts

@@ -1,77 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { RemitImapQuarantineResponse } from "@remit/api-http-client/types.gen.ts";
-import { toQuarantineEntry } from "./quarantine-entries";
-
-const wire: RemitImapQuarantineResponse = {
-	quarantineId: "8b1e0c2a-0000-4000-8000-000000000001",
-	accountConfigId: "8b1e0c2a-0000-4000-8000-000000000002",
-	accountId: "8b1e0c2a-0000-4000-8000-000000000003",
-	mailboxId: "8b1e0c2a-0000-4000-8000-000000000004",
-	uidValidity: 1717171717,
-	uid: 4211,
-	mailboxRole: "Junk",
-	mailboxPath: "INBOX/Spam",
-	quarantinedAt: 1_750_000_000_000,
-	attempts: 3,
-	failureStage: "BodyParse",
-	failureCode: "UnknownCharset",
-	failureMessage: 'unknown charset "x-mac-roman"',
-	failurePartPath: "1.2",
-	workerVersion: "imap-worker@1.4.0",
-	contentType: "multipart/mixed",
-	transferEncoding: "base64",
-	charset: "x-mac-roman",
-	sizeBytes: 91_204,
-	structure: [
-		{ depth: 0, contentType: "multipart/mixed" },
-		{ depth: 1, contentType: "text/plain" },
-	],
-	messageIdHash: "sha256:abc",
-	createdAt: 1_750_000_000_000,
-	updatedAt: 1_750_000_000_000,
-};
-
-describe("toQuarantineEntry", () => {
-	it("spells the folder role the way the kit does", () => {
-		assert.equal(toQuarantineEntry(wire, "/").mailboxRole, "junk");
-	});
-
-	it("leaves the role absent when the folder has none appointed", () => {
-		const { mailboxRole: _dropped, ...roleless } = wire;
-		assert.equal(toQuarantineEntry(roleless, "/").mailboxRole, undefined);
-	});
-
-	it("carries every field the report and the row are built from", () => {
-		const entry = toQuarantineEntry(wire, "/");
-		assert.equal(entry.quarantineId, wire.quarantineId);
-		assert.equal(entry.uid, wire.uid);
-		assert.equal(entry.uidValidity, wire.uidValidity);
-		assert.equal(entry.mailboxPath, wire.mailboxPath);
-		assert.equal(entry.failureCode, wire.failureCode);
-		assert.equal(entry.failureStage, wire.failureStage);
-		assert.equal(entry.failureMessage, wire.failureMessage);
-		assert.equal(entry.failurePartPath, wire.failurePartPath);
-		assert.equal(entry.attempts, wire.attempts);
-		assert.equal(entry.quarantinedAt, wire.quarantinedAt);
-		assert.equal(entry.workerVersion, wire.workerVersion);
-		assert.equal(entry.contentType, wire.contentType);
-		assert.equal(entry.transferEncoding, wire.transferEncoding);
-		assert.equal(entry.charset, wire.charset);
-		assert.equal(entry.sizeBytes, wire.sizeBytes);
-		assert.equal(entry.messageIdHash, wire.messageIdHash);
-		assert.deepEqual(entry.structure, wire.structure);
-	});
-
-	it("carries the delimiter the caller resolved, which the wire has not", () => {
-		assert.equal("mailboxDelimiter" in wire, false);
-		assert.equal(toQuarantineEntry(wire, ".").mailboxDelimiter, ".");
-	});
-
-	it("drops the fields the settings surface has no use for", () => {
-		const entry = toQuarantineEntry(wire, "/");
-		assert.equal("accountConfigId" in entry, false);
-		assert.equal("createdAt" in entry, false);
-		assert.equal("updatedAt" in entry, false);
-	});
-});

package/src/lib/quarantine-entries.ts

@@ -1,46 +0,0 @@
-import type { RemitImapQuarantineResponse } from "@remit/api-http-client/types.gen.ts";
-import type { QuarantineEntry } from "@remit/ui";
-import { CANONICAL_TO_NAV_ROLE } from "./folder-roles";
-
-/**
- * The wire record carries `accountConfigId`, `createdAt` and `updatedAt`, which
- * the settings surface has no use for, and spells the folder role in the
- * canonical PascalCase the API uses everywhere. Both differences are resolved
- * here rather than by widening the kit's entry type.
- *
- * The record carries no hierarchy delimiter either, so the caller joins the
- * mailbox id against the account's own mailbox list and hands the delimiter in
- * — the row shows a folder name, and a path cannot be cut into one without it.
- * An empty delimiter means no account lists that mailbox, and the row keeps its
- * whole path rather than being cut on a guess.
- */
-export function toQuarantineEntry(
-	wire: RemitImapQuarantineResponse,
-	mailboxDelimiter: string,
-): QuarantineEntry {
-	return {
-		quarantineId: wire.quarantineId,
-		accountId: wire.accountId,
-		mailboxId: wire.mailboxId,
-		uidValidity: wire.uidValidity,
-		uid: wire.uid,
-		mailboxRole: wire.mailboxRole
-			? CANONICAL_TO_NAV_ROLE[wire.mailboxRole]
-			: undefined,
-		mailboxPath: wire.mailboxPath,
-		mailboxDelimiter,
-		failureStage: wire.failureStage,
-		failureCode: wire.failureCode,
-		failureMessage: wire.failureMessage,
-		failurePartPath: wire.failurePartPath,
-		quarantinedAt: wire.quarantinedAt,
-		attempts: wire.attempts,
-		sizeBytes: wire.sizeBytes,
-		contentType: wire.contentType,
-		transferEncoding: wire.transferEncoding,
-		charset: wire.charset,
-		structure: wire.structure,
-		messageIdHash: wire.messageIdHash,
-		workerVersion: wire.workerVersion,
-	};
-}

package/src/lib/query-error-handler.test.ts

@@ -1,87 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import type { Mutation, Query } from "@tanstack/react-query";
-import { ApiError } from "./api";
-import { __resetFatalError, subscribeFatalError } from "./fatal-error";
-import {
-	handleMutationCacheError,
-	handleQueryCacheError,
-} from "./query-error-handler";
-
-const fakeQuery = (
-	meta?: Record<string, unknown>,
-	dataUpdatedAt = 0,
-): Query<unknown, unknown, unknown> =>
-	({ meta, state: { dataUpdatedAt } }) as unknown as Query<
-		unknown,
-		unknown,
-		unknown
-	>;
-
-const fakeMutation = (
-	meta?: Record<string, unknown>,
-): Mutation<unknown, unknown, unknown> =>
-	({ meta }) as unknown as Mutation<unknown, unknown, unknown>;
-
-const abortError = (): Error => {
-	const error = new Error("aborted");
-	error.name = "AbortError";
-	return error;
-};
-
-const escalations = (): string[] => {
-	const seen: string[] = [];
-	subscribeFatalError((fatal) => seen.push(fatal.message));
-	return seen;
-};
-
-afterEach(() => {
-	__resetFatalError();
-});
-
-describe("handleQueryCacheError (fail-fast contract #1059)", () => {
-	it("escalates a 5xx EVEN when the query is marked meta.softError (rule 2 wins)", () => {
-		const seen = escalations();
-		handleQueryCacheError(
-			new ApiError("internal", 500),
-			fakeQuery({ softError: true }, 123456),
-		);
-		assert.deepEqual(seen, ["internal"]);
-	});
-
-	it("does NOT escalate an aborted request", () => {
-		let escalated = false;
-		subscribeFatalError(() => {
-			escalated = true;
-		});
-		handleQueryCacheError(abortError(), fakeQuery());
-		assert.equal(escalated, false);
-	});
-});
-
-describe("handleMutationCacheError (fail-fast contract #1059)", () => {
-	it("escalates a mutation 4xx by DEFAULT", () => {
-		const seen = escalations();
-		handleMutationCacheError(
-			new ApiError("conflict", 409),
-			undefined,
-			undefined,
-			fakeMutation(),
-		);
-		assert.deepEqual(seen, ["conflict"]);
-	});
-
-	it("does NOT escalate a mutation 4xx marked meta.softError", () => {
-		let escalated = false;
-		subscribeFatalError(() => {
-			escalated = true;
-		});
-		handleMutationCacheError(
-			new ApiError("conflict", 409),
-			undefined,
-			undefined,
-			fakeMutation({ softError: true }),
-		);
-		assert.equal(escalated, false);
-	});
-});

package/src/lib/query-error-handler.ts

@@ -1,41 +0,0 @@
-import type { Mutation, Query } from "@tanstack/react-query";
-import { shouldEscalate } from "./error-classifier";
-import { reportFatalError } from "./fatal-error";
-
-/**
- * Global React Query error sink. Every query and mutation error flows through
- * here (wired on the `QueryCache`/`MutationCache` in main.tsx). The fail-fast
- * contract (#1059) lives in `shouldEscalate`: a non-2xx escalates to the
- * full-screen red overlay by default; a 5xx ALWAYS escalates; only aborts,
- * statusless network blips, and non-5xx errors a call site opted out of via
- * `meta.softError` stay soft.
- *
- * The two caches differ on one thing, the `Awaiting` argument. A mutation is
- * something the user did and is owed the outcome of, so a 401 there escalates
- * over `meta.softError` — no banner signs anyone back in. A query is "nobody" as
- * a class: the reads the screen is actually waiting on carry no `meta.softError`
- * and escalate on the default anyway, so the only ones this spares are those
- * that already declared they own their failures.
- *
- * This is the v5 equivalent of `defaultOptions.queries.onError` /
- * `.mutations.onError` — v5 moved the global error hook onto the caches.
- */
-export const handleQueryCacheError = (
-	error: Error,
-	query: Query<unknown, unknown, unknown>,
-): void => {
-	if (shouldEscalate(error, query.meta, "nobody")) {
-		reportFatalError(error);
-	}
-};
-
-export const handleMutationCacheError = (
-	error: unknown,
-	_variables: unknown,
-	_onMutateResult: unknown,
-	mutation: Mutation<unknown, unknown, unknown>,
-): void => {
-	if (shouldEscalate(error, mutation.meta, "user")) {
-		reportFatalError(error);
-	}
-};

package/src/lib/query-escalation.integration.test.ts

@@ -1,139 +0,0 @@
-/**
- * Integration: prove the global React Query caches route a first-party error
- * through the fail-fast handlers → `reportFatalError`, which is what drives the
- * full-screen escalation overlay. React Query's core runs headless (no DOM),
- * so this exercises the real `QueryCache`/`MutationCache` wiring from main.tsx
- * without rendering.
- */
-
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { MutationCache, QueryCache, QueryClient } from "@tanstack/react-query";
-import { ApiError } from "./api";
-import { __resetFatalError, subscribeFatalError } from "./fatal-error";
-import { NetworkError } from "./network-error";
-import {
-	handleMutationCacheError,
-	handleQueryCacheError,
-} from "./query-error-handler";
-
-afterEach(() => {
-	__resetFatalError();
-});
-
-const makeClient = () =>
-	new QueryClient({
-		queryCache: new QueryCache({ onError: handleQueryCacheError }),
-		mutationCache: new MutationCache({ onError: handleMutationCacheError }),
-		defaultOptions: { queries: { retry: false } },
-	});
-
-describe("global query/mutation escalation", () => {
-	it("a first-party 5xx from a query escalates to the fatal overlay seam", async () => {
-		const seen: string[] = [];
-		subscribeFatalError((fatal) => seen.push(fatal.message));
-		const client = makeClient();
-
-		await client
-			.fetchQuery({
-				queryKey: ["explode"],
-				queryFn: async () => {
-					throw new ApiError("internal server error", 500);
-				},
-			})
-			.catch(() => {});
-
-		assert.deepEqual(seen, ["internal server error"]);
-	});
-
-	it("a 5xx on a background REFETCH escalates — the exact #1059 bug (search-style query that 500s after first rendering data)", async () => {
-		const seen: string[] = [];
-		subscribeFatalError((fatal) => seen.push(fatal.message));
-		const client = makeClient();
-		const queryKey = ["search"];
-		let calls = 0;
-		const queryFn = async () => {
-			calls += 1;
-			if (calls === 1) return { items: [] as string[] };
-			throw new ApiError("search exploded", 500);
-		};
-
-		// First load succeeds → query now has data (dataUpdatedAt !== 0). Under the
-		// deleted guard this refetch 500 vanished into `data?.items ?? []`.
-		await client.fetchQuery({ queryKey, queryFn });
-		await client.refetchQueries({ queryKey }).catch(() => {});
-
-		assert.deepEqual(seen, ["search exploded"]);
-	});
-
-	it("a first-party 5xx from a mutation escalates to the fatal overlay seam", async () => {
-		const seen: string[] = [];
-		subscribeFatalError((fatal) => seen.push(fatal.message));
-		const client = makeClient();
-
-		const mutation = client.getMutationCache().build(client, {
-			mutationFn: async () => {
-				throw new ApiError("mutation blew up", 503);
-			},
-		});
-		await mutation.execute(undefined).catch(() => {});
-
-		assert.deepEqual(seen, ["mutation blew up"]);
-	});
-
-	it("a 404 on a query marked meta.softError does NOT escalate (call site owns the empty state)", async () => {
-		let escalated = false;
-		subscribeFatalError(() => {
-			escalated = true;
-		});
-		const client = makeClient();
-
-		await client
-			.fetchQuery({
-				queryKey: ["missing"],
-				queryFn: async () => {
-					throw new ApiError("not found", 404);
-				},
-				meta: { softError: true },
-			})
-			.catch(() => {});
-
-		assert.equal(escalated, false);
-	});
-
-	it("a 404 on a query that did NOT opt out escalates by default", async () => {
-		const seen: string[] = [];
-		subscribeFatalError((fatal) => seen.push(fatal.message));
-		const client = makeClient();
-
-		await client
-			.fetchQuery({
-				queryKey: ["unhandled-404"],
-				queryFn: async () => {
-					throw new ApiError("not found", 404);
-				},
-			})
-			.catch(() => {});
-
-		assert.deepEqual(seen, ["not found"]);
-	});
-
-	it("an offline blip tagged at the fetch boundary does NOT escalate", async () => {
-		let escalated = false;
-		subscribeFatalError(() => {
-			escalated = true;
-		});
-		const client = makeClient();
-
-		await client
-			.fetchQuery({
-				queryKey: ["offline"],
-				queryFn: async () => {
-					throw new NetworkError(new TypeError("Failed to fetch"));
-				},
-			})
-			.catch(() => {});
-
-		assert.equal(escalated, false);
-	});
-});

package/src/lib/recent-searches.test.ts

@@ -1,53 +0,0 @@
-import assert from "node:assert";
-import { beforeEach, describe, test } from "node:test";
-import { loadRecentSearches, saveRecentSearch } from "./recent-searches.js";
-
-function installMemoryStorage(): void {
-	const store = new Map<string, string>();
-	globalThis.localStorage = {
-		getItem: (k: string) => store.get(k) ?? null,
-		setItem: (k: string, v: string) => void store.set(k, v),
-		removeItem: (k: string) => void store.delete(k),
-		clear: () => store.clear(),
-		key: () => null,
-		length: 0,
-	} as Storage;
-}
-
-describe("recent-searches", () => {
-	beforeEach(installMemoryStorage);
-
-	test("starts empty", () => {
-		assert.deepEqual(loadRecentSearches(), []);
-	});
-
-	test("saves and loads a query", () => {
-		assert.deepEqual(saveRecentSearch("alice"), ["alice"]);
-		assert.deepEqual(loadRecentSearches(), ["alice"]);
-	});
-
-	test("most recent first, deduplicated", () => {
-		saveRecentSearch("alice");
-		saveRecentSearch("bob");
-		assert.deepEqual(saveRecentSearch("alice"), ["alice", "bob"]);
-	});
-
-	test("caps at five entries", () => {
-		for (const q of ["a", "b", "c", "d", "e", "f"]) saveRecentSearch(q);
-		assert.deepEqual(loadRecentSearches(), ["f", "e", "d", "c", "b"]);
-	});
-
-	test("ignores blank queries", () => {
-		saveRecentSearch("alice");
-		assert.deepEqual(saveRecentSearch("   "), ["alice"]);
-	});
-
-	test("trims before storing", () => {
-		assert.deepEqual(saveRecentSearch("  bob  "), ["bob"]);
-	});
-
-	test("survives corrupt storage", () => {
-		globalThis.localStorage.setItem("remit.recentSearches", "{not json");
-		assert.deepEqual(loadRecentSearches(), []);
-	});
-});

package/src/lib/recent-searches.ts

@@ -1,34 +0,0 @@
-/**
- * Recent search queries for the mobile search takeover, persisted in
- * localStorage. Best-effort: storage failures (private mode, quota) degrade to
- * an empty list rather than crashing the search surface.
- */
-const RECENT_SEARCHES_KEY = "remit.recentSearches";
-const MAX_RECENT = 5;
-
-export function loadRecentSearches(): string[] {
-	try {
-		const raw = localStorage.getItem(RECENT_SEARCHES_KEY);
-		if (!raw) return [];
-		const parsed: unknown = JSON.parse(raw);
-		if (!Array.isArray(parsed)) return [];
-		return parsed.filter((q): q is string => typeof q === "string");
-	} catch {
-		return [];
-	}
-}
-
-export function saveRecentSearch(query: string): string[] {
-	const trimmed = query.trim();
-	if (!trimmed) return loadRecentSearches();
-	const next = [
-		trimmed,
-		...loadRecentSearches().filter((q) => q !== trimmed),
-	].slice(0, MAX_RECENT);
-	try {
-		localStorage.setItem(RECENT_SEARCHES_KEY, JSON.stringify(next));
-	} catch {
-		return next;
-	}
-	return next;
-}

package/src/lib/recipient-suggestions.test.ts

@@ -1,109 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { RemitImapAddressResponse } from "@remit/api-http-client";
-import { offerableAsRecipient } from "./recipient-suggestions";
-
-const setAt = 1;
-
-const address = (
-	over: Partial<RemitImapAddressResponse> = {},
-): RemitImapAddressResponse =>
-	({
-		normalizedEmail: "sales@pharma.example",
-		outboundCount: 0,
-		replyCount: 0,
-		flags: {},
-		...over,
-	}) as RemitImapAddressResponse;
-
-describe("who the compose picker may offer", () => {
-	it("refuses a sender met only on mail in Junk", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({ flags: { junkOnly: { value: true, setAt } } }),
-			),
-			false,
-		);
-	});
-
-	it("refuses a sender the account blocked", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({ flags: { blocked: { value: true, setAt } } }),
-			),
-			false,
-		);
-	});
-
-	it("refuses a blocked sender the search still has to return", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({
-					flags: {
-						junkOnly: { value: true, setAt },
-						blocked: { value: true, setAt },
-					},
-				}),
-			),
-			false,
-		);
-	});
-
-	it("offers a muted sender, which is about notice and not about mail", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({ flags: { muted: { value: true, setAt } } }),
-			),
-			true,
-		);
-	});
-
-	it("offers a withheld sender the account has since sent mail to", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({
-					outboundCount: 1,
-					flags: { junkOnly: { value: true, setAt } },
-				}),
-			),
-			true,
-		);
-	});
-
-	it("offers a withheld sender the account has since replied to", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({ replyCount: 1, flags: { junkOnly: { value: true, setAt } } }),
-			),
-			true,
-		);
-	});
-
-	it("offers a withheld sender the account has since named a VIP", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({
-					flags: {
-						junkOnly: { value: true, setAt },
-						vip: { value: true, setAt },
-					},
-				}),
-			),
-			true,
-		);
-	});
-
-	it("offers a withheld sender the account has since trusted", () => {
-		assert.equal(
-			offerableAsRecipient(
-				address({
-					flags: {
-						junkOnly: { value: true, setAt },
-						trusted: { value: true, setAt },
-					},
-				}),
-			),
-			true,
-		);
-	});
-});

package/src/lib/recipient-suggestions.ts

@@ -1,15 +0,0 @@
-import type { RemitImapAddressResponse } from "@remit/api-http-client";
-
-const accountHasCorresponded = (address: RemitImapAddressResponse): boolean =>
-	address.outboundCount > 0 ||
-	address.replyCount > 0 ||
-	address.flags?.vip?.value === true ||
-	address.flags?.trusted?.value === true;
-
-export const offerableAsRecipient = (
-	address: RemitImapAddressResponse,
-): boolean => {
-	if (address.flags?.blocked?.value === true) return false;
-	if (address.flags?.junkOnly?.value !== true) return true;
-	return accountHasCorresponded(address);
-};