@remit/web-client 0.0.185 → 0.0.186

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/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,
+});