@remit/web-client 0.0.185 → 0.0.187

package/src/hooks/useToggleTrusted.ts

@@ -11,19 +11,15 @@ import type {
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { buildMutationErrorBanner } from "@/components/ui/error-banners";
+import type { SnapshotEntry } from "@/lib/thread-list-cache";
 
 interface UseToggleTrustedOptions {
 	messageId: string;
 }
 
-interface SnapshotEntry {
-	queryKey: readonly unknown[];
-	data: RemitImapDescribeMessageResponse;
-}
-
 interface ToggleTrustedContext {
 	describePrefix: readonly unknown[];
-	previous: SnapshotEntry[];
+	previous: SnapshotEntry<RemitImapDescribeMessageResponse>[];
 }
 
 export const buildTrustedFlag = (

package/src/lib/bulk-action-copy.ts

@@ -1,4 +1,13 @@
-import { formatNumber } from "@/lib/format";
+import type { ErrorBannerSeverity } from "@/components/ui/error-banners";
+import type { BulkRunOutcome } from "@/lib/bulk-actions";
+import { type DeleteOutcome, formatNumber } from "@/lib/format";
+
+/** A run ending, as the list banners it. */
+export interface RunEndingBanner {
+	severity: ErrorBannerSeverity;
+	title: string;
+	detail?: string;
+}
 
 /**
  * Wording for the three bulk actions a selection can run (#114). One place
@@ -23,6 +32,16 @@ const pastTense: Record<BulkActionKind, string> = {
 	markRead: "marked as read",
 };
 
+/**
+ * What the run did, in the past tense. A delete inside Trash expunges rather
+ * than moves (#855), and that holds for a run that stopped halfway exactly as
+ * it does for one that finished — the half that ran is still erased.
+ */
+const pastTenseFor = (kind: BulkActionKind, outcome: DeleteOutcome): string =>
+	kind === "delete" && outcome === "permanent"
+		? "permanently deleted"
+		: pastTense[kind];
+
 const negated: Record<BulkActionKind, string> = {
 	delete: "couldn't be deleted",
 	move: "couldn't be moved",
@@ -52,12 +71,18 @@ export const bulkActionProgressLabel = (
  * Shown once a run finishes with nothing left over. The second sentence is
  * the honest part: the bulk endpoints enqueue the IMAP write, so the mail
  * server is still applying it when this appears.
+ *
+ * A delete inside Trash expunges rather than moves (#855), so the run that just
+ * finished is named by its outcome — telling a reader their mail is "moved to
+ * Trash" after it was erased is the same lie the confirmation stopped telling,
+ * one screen later.
  */
 export const bulkActionCompletionText = (
 	kind: BulkActionKind,
 	done: number,
+	outcome: DeleteOutcome = "trash",
 ): string =>
-	`${formatNumber(done)} ${pastTense[kind]}. Your mail server is still catching up.`;
+	`${formatNumber(done)} ${pastTenseFor(kind, outcome)}. Your mail server is still catching up.`;
 
 /**
  * Shown when a run ended before it covered what it was started against. The
@@ -72,8 +97,9 @@ export const bulkActionStoppedDetail = (
 	kind: BulkActionKind,
 	done: number,
 	total: number,
+	outcome: DeleteOutcome = "trash",
 ): string =>
-	`${formatNumber(done)} of ${formatNumber(total)} ${pastTense[kind]}. Nothing was sent for the rest, so they are untouched.`;
+	`${formatNumber(done)} of ${formatNumber(total)} ${pastTenseFor(kind, outcome)}. Nothing was sent for the rest, so they are untouched.`;
 
 /** Error-banner title for a run stopped by an infrastructure failure. */
 export const bulkActionFailureTitle = (
@@ -91,3 +117,43 @@ export const bulkActionFailureDetail = (kind: BulkActionKind): string =>
 export const bulkActionProgressTone = (
 	kind: BulkActionKind,
 ): "danger" | "info" => (kind === "delete" ? "danger" : "info");
+
+/**
+ * How a run that has already ended is announced, or `null` when it announces
+ * itself elsewhere.
+ *
+ * The run screen invites the user to close it and keeps going past that, so by
+ * the time a run ends there is often no screen of its own left to say how it
+ * went (#521) — the list says it instead. Three endings, and they are not the
+ * same news: a run stopped short is a warning, because mail the user asked to
+ * be acted on was left untouched; a run that covered everything is a passing
+ * note; and a run stopped by a thrown batch already bannered where it threw, so
+ * saying it twice is the one wrong answer.
+ *
+ * Pure, so the severity of each ending is pinned by its result rather than by
+ * the shape of the caller that produces it.
+ */
+export const runEndingBanner = (
+	kind: BulkActionKind,
+	matched: number,
+	outcome: BulkRunOutcome,
+	deleteOutcome: DeleteOutcome,
+): RunEndingBanner | null => {
+	if (outcome.error !== undefined) return null;
+	if (outcome.cancelled) {
+		return {
+			severity: "warning",
+			title: bulkActionStoppedTitle(outcome.done),
+			detail: bulkActionStoppedDetail(
+				kind,
+				outcome.done,
+				matched,
+				deleteOutcome,
+			),
+		};
+	}
+	return {
+		severity: "info",
+		title: bulkActionCompletionText(kind, outcome.done, deleteOutcome),
+	};
+};

package/src/lib/format.test.ts

@@ -1,7 +1,9 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
+import type { DeleteTarget } from "./format.js";
 import {
 	deleteConfirmationCopy,
+	deleteOutcomeFor,
 	formatDate,
 	formatDatePreset,
 	formatDeleteToTrashTitle,
@@ -155,3 +157,183 @@ describe("deleteConfirmationCopy", () => {
 		});
 	});
 });
+
+/**
+ * Issue #855. The failure branch is the one that matters: TanStack sets
+ * `status: "error"` with `data` undefined, so a config read that failed leaves
+ * an empty Trash set behind. Reading that as "this folder is not Trash" hands an
+ * expired session a "Move to Trash?" dialog over an expunge — #845 reinstated on
+ * the error path.
+ */
+describe("deleteOutcomeFor", () => {
+	const trashByAccount = new Map([
+		["acct-1", "mbx-trash"],
+		["acct-2", undefined],
+	]);
+	const settled = { trashByAccount, hasAppointments: true, isError: false };
+	// No default for the account: a default parameter is applied to an explicit
+	// `undefined` too, so "the row names no account" silently became "acct-1"
+	// and the case asserting it read back as an ordinary move to Trash.
+	const target = (
+		mailboxId: string,
+		accountId: string | undefined,
+	): DeleteTarget => ({ accountId, mailboxId });
+
+	test("a row outside Trash is a reversible move", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-inbox", "acct-1")],
+			}),
+			"trash",
+		);
+	});
+
+	test("a row inside its own account's Trash is an expunge", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-trash", "acct-1")],
+			}),
+			"permanent",
+		);
+	});
+
+	test("one row inside Trash makes a mixed set permanent", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-inbox", "acct-1"), target("mbx-trash", "acct-1")],
+			}),
+			"permanent",
+		);
+	});
+
+	test("an account that appoints no Trash is its own answer, not a move", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-inbox", "acct-2")],
+			}),
+			"noTrash",
+			"the server refuses that delete rather than moving anything",
+		);
+	});
+
+	test("a refused account outranks an expunge in the same set", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-trash", "acct-1"), target("mbx-inbox", "acct-2")],
+			}),
+			"noTrash",
+		);
+	});
+
+	test("another account's Trash is not this row's Trash", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				trashByAccount: new Map([
+					["acct-1", "mbx-trash"],
+					["acct-2", "mbx-other-trash"],
+				]),
+				targets: [target("mbx-trash", "acct-2")],
+			}),
+			"trash",
+		);
+	});
+
+	test("appointments that have not arrived commit to neither wording", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				targets: [target("mbx-inbox", "acct-1")],
+				trashByAccount: new Map(),
+				hasAppointments: false,
+				isError: false,
+			}),
+			"unknown",
+			"a paused offline query reports neither loading nor error",
+		);
+	});
+
+	test("an account nothing is known about yet is unknown, not a move", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-inbox", "acct-9")],
+			}),
+			"unknown",
+		);
+	});
+
+	test("a row with no account is unknown, not a move", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-inbox", undefined)],
+			}),
+			"unknown",
+		);
+	});
+
+	test("a failed read refuses the delete rather than promising a move", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				targets: [target("mbx-inbox", "acct-1")],
+				trashByAccount: new Map(),
+				hasAppointments: false,
+				isError: true,
+			}),
+			"unavailable",
+		);
+	});
+
+	test("a failed read outranks a settled appointment set", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({
+				...settled,
+				targets: [target("mbx-inbox", "acct-1")],
+				isError: true,
+			}),
+			"unavailable",
+		);
+	});
+
+	test("nothing pending is not an answer", () => {
+		assert.strictEqual(
+			deleteOutcomeFor({ ...settled, targets: [] }),
+			"unknown",
+		);
+	});
+});
+
+describe("deleteConfirmationCopy — the refusal", () => {
+	test("states what failed and offers the way back in", () => {
+		assert.deepStrictEqual(deleteConfirmationCopy(1, "unavailable"), {
+			title: "Can't delete 1 message",
+			description:
+				"reader couldn't read this account's folder settings, so it can't say whether this would move the mail to Trash or erase it. Nothing has been deleted.",
+			confirmLabel: "Sign in again",
+		});
+	});
+
+	test("never offers the reversible wording on the failure path", () => {
+		const copy = deleteConfirmationCopy(3, "unavailable");
+		assert.ok(!copy.title.includes("Move"));
+		assert.ok(!copy.description.includes("restore"));
+	});
+
+	test("sends an unappointed Trash to the screen that appoints one", () => {
+		const copy = deleteConfirmationCopy(3, "noTrash");
+		assert.strictEqual(copy.title, "Can't delete 3 messages");
+		assert.match(copy.description, /appointed as Trash/);
+		assert.strictEqual(copy.confirmLabel, "Open folder settings");
+	});
+
+	test("never promises a restore when no Trash is appointed", () => {
+		const copy = deleteConfirmationCopy(3, "noTrash");
+		assert.ok(!copy.title.includes("Move"));
+		assert.ok(!copy.description.includes("restore"));
+	});
+});

package/src/lib/format.ts

@@ -168,12 +168,85 @@ export interface DeleteConfirmationCopy {
 }
 
 /**
- * What a delete will actually do to the selected mail. `unknown` is the state
- * before the account's Trash appointment has resolved — a real state on a cold
- * open, and the one the copy must not guess at, because guessing "move to
- * Trash" over an expunge is the dishonesty this whole flow exists to remove.
+ * What a delete will actually do to the selected mail.
+ *
+ * `unknown` is the state before the account's Trash appointment has resolved — a
+ * real state on a cold open, and the one the copy must not guess at, because
+ * guessing "move to Trash" over an expunge is the dishonesty this whole flow
+ * exists to remove.
+ *
+ * `noTrash` is a resolved answer of "none": the account appoints no Trash, so
+ * the server refuses the delete outright (#846) rather than moving anything.
+ * It is a different fact from "this row is not in Trash" and must never share
+ * an outcome with it — one promises a restore that can happen, the other a
+ * delete that will not.
+ *
+ * `unavailable` is the appointment failing to resolve at all. A read that
+ * cannot answer is not an answer: treating an errored `/config` as "no Trash
+ * here" reinstates the same lie on the failure path, where an expired session
+ * would collect "Move to Trash?" over an expunge. The delete is refused and the
+ * failure is stated instead.
  */
-export type DeleteOutcome = "trash" | "permanent" | "unknown";
+export type DeleteOutcome =
+	| "trash"
+	| "permanent"
+	| "noTrash"
+	| "unknown"
+	| "unavailable";
+
+/** A row about to be deleted, and the account whose Trash decides its fate. */
+export interface DeleteTarget {
+	accountId: string | undefined;
+	mailboxId: string;
+}
+
+export interface DeleteOutcomeInput {
+	targets: readonly DeleteTarget[];
+	/**
+	 * Each account's appointed Trash. A key present with `undefined` is an
+	 * account that appoints none — an answer, not a gap. A key absent is an
+	 * account nothing is known about yet.
+	 */
+	trashByAccount: ReadonlyMap<string, string | undefined>;
+	/**
+	 * The appointments have actually arrived. Never `!isLoading`: React Query
+	 * v5 leaves a paused offline query pending-but-not-fetching, which reads as
+	 * loaded while `data` is still undefined.
+	 */
+	hasAppointments: boolean;
+	/** The read for them failed. */
+	isError: boolean;
+}
+
+/**
+ * The outcome of deleting `targets`.
+ *
+ * One row bound for an expunge makes the whole delete unrecoverable, so a mixed
+ * set is permanent: the wording may overstate what is destroyed, never what is
+ * kept. One row on an account with no Trash refuses the whole call, so that
+ * outranks both. Pure, so every branch — the failure ones above all — is
+ * testable without a DOM.
+ */
+export const deleteOutcomeFor = ({
+	targets,
+	trashByAccount,
+	hasAppointments,
+	isError,
+}: DeleteOutcomeInput): DeleteOutcome => {
+	if (isError) return "unavailable";
+	if (!hasAppointments) return "unknown";
+	if (targets.length === 0) return "unknown";
+
+	let expunges = false;
+	for (const target of targets) {
+		if (target.accountId === undefined) return "unknown";
+		if (!trashByAccount.has(target.accountId)) return "unknown";
+		const trashMailboxId = trashByAccount.get(target.accountId);
+		if (trashMailboxId === undefined) return "noTrash";
+		if (trashMailboxId === target.mailboxId) expunges = true;
+	}
+	return expunges ? "permanent" : "trash";
+};
 
 /**
  * The confirmation for a delete, worded for what the delete actually does.
@@ -181,6 +254,13 @@ export type DeleteOutcome = "trash" | "permanent" | "unknown";
  * nothing survives that, so it is asked as a permanent delete — a dialog that
  * says "Move to Trash" over an expunge collects an answer to a question the
  * user was never asked.
+ *
+ * `noTrash` and `unavailable` are not confirmations at all but refusals:
+ * nothing is deleted, and the label names the way out rather than the delete.
+ * The caller wires each to its own remedy — folder settings for the missing
+ * appointment, re-authentication for the failed read, because an account read
+ * that fails is a session that ended under the reader far more often than it is
+ * anything else.
  */
 export const deleteConfirmationCopy = (
 	count: number,
@@ -189,6 +269,22 @@ export const deleteConfirmationCopy = (
 	const quantity = count === 1 ? "1" : formatNumber(count);
 	const noun = count === 1 ? "message" : "messages";
 
+	if (outcome === "noTrash") {
+		return {
+			title: `Can't delete ${quantity} ${noun}`,
+			description:
+				"No folder on this account is appointed as Trash, so there is nowhere to move the mail — and deleting it would erase it from the server instead. Appoint a Trash folder to delete from here.",
+			confirmLabel: "Open folder settings",
+		};
+	}
+	if (outcome === "unavailable") {
+		return {
+			title: `Can't delete ${quantity} ${noun}`,
+			description:
+				"reader couldn't read this account's folder settings, so it can't say whether this would move the mail to Trash or erase it. Nothing has been deleted.",
+			confirmLabel: "Sign in again",
+		};
+	}
 	if (outcome === "unknown") {
 		return {
 			title: `Delete ${quantity} ${noun}?`,

package/src/lib/thread-list-cache.ts

@@ -7,9 +7,31 @@ import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/type
 import type { QueryClient } from "@tanstack/react-query";
 import { patchThreadListCache, type ThreadListCache } from "./thread-cache.js";
 
-export interface ThreadListSnapshotEntry {
+export interface SnapshotEntry<T> {
 	queryKey: readonly unknown[];
-	data: ThreadListCache;
+	data: T;
+}
+
+export type ThreadListSnapshotEntry = SnapshotEntry<ThreadListCache>;
+
+/** A cached page of one thread's messages, as the thread-detail endpoint serves it. */
+export interface ThreadMessagesData {
+	items: RemitImapThreadMessageResponse[];
+	[key: string]: unknown;
+}
+
+/**
+ * The rollback state an optimistic thread mutation captures in `onMutate`.
+ *
+ * The shape belongs to the snapshot/restore helpers below rather than to any
+ * one mutation, so mark-read, star, delete and move all carry the same one
+ * (#868).
+ */
+export interface ThreadMutationContext {
+	threadMessagesPrefix: readonly unknown[];
+	listPrefixes: ReadonlyArray<readonly unknown[]>;
+	previousThreadMessages: SnapshotEntry<ThreadMessagesData>[];
+	previousThreadsList: ThreadListSnapshotEntry[];
 }
 
 /**

package/src/test-support/fixtures.ts

@@ -6,6 +6,7 @@
 
 import type {
 	RemitImapAccountResponse,
+	RemitImapConfigDescriptionResponse,
 	RemitImapMailboxResponse,
 	RemitImapThreadMessageResponse,
 } from "@remit/api-http-client/types.gen.ts";
@@ -83,3 +84,16 @@ export const makeThreadMessage = (
 	updatedAt: 0,
 	...overrides,
 });
+
+export const makeConfig = (
+	accounts: RemitImapAccountResponse[],
+): RemitImapConfigDescriptionResponse => ({
+	accountConfig: {
+		accountConfigId: "cfg-1",
+		userId: "user-1",
+		state: "active",
+		createdAt: 0,
+		updatedAt: 0,
+	},
+	accounts,
+});