@remit/web-client 0.0.272 → 0.0.274

package/src/components/ui/placement-refusal.ts

@@ -9,11 +9,13 @@ import type { PushErrorInput } from "@/components/ui/error-banners";
 import { type CodedApiErrorBody, codedApiErrorBody } from "@/lib/api";
 
 /**
- * `in_flight` clears on its own once the mail server confirms the move;
- * `unverified` does not, because the move gave up without confirming and
- * nothing routine repairs the row.
+ * One reason, because one state produces the refusal: a mutation is still in
+ * flight and the pair clears on its own, so the copy words a wait. A mutation
+ * that gave up hands the row back to a placement the mail server confirmed
+ * before it stops (imap-mutations R3), and that row is acted on rather than
+ * refused — there is no second reason left to word.
  */
-export type PlacementRefusalReason = "in_flight" | "unverified";
+export type PlacementRefusalReason = "in_flight";
 
 export interface PlacementRefusal {
 	reason: PlacementRefusalReason;
@@ -22,7 +24,6 @@ export interface PlacementRefusal {
 
 const REASONS: ReadonlySet<string> = new Set<PlacementRefusalReason>([
 	"in_flight",
-	"unverified",
 ]);
 
 const stringAt = (
@@ -53,11 +54,11 @@ export const isPlacementRefusal = (
 export type PlacementRefusalAction = "delete" | "move";
 
 /**
- * The banner copy. Both reasons say what happened and what to do; neither is a
- * dead end, and neither repeats the server's uuid at the user.
+ * The banner copy. It says what happened and what to do, is not a dead end, and
+ * does not repeat the server's uuid at the user.
  */
 export const placementRefusalBanner = (
-	refusal: PlacementRefusal,
+	_refusal: PlacementRefusal,
 	count: number,
 	action: PlacementRefusalAction,
 ): PushErrorInput => ({
@@ -66,8 +67,5 @@ export const placementRefusalBanner = (
 		count > 1
 			? `Couldn't ${action} ${count} messages yet`
 			: `Couldn't ${action} this message yet`,
-	detail:
-		refusal.reason === "in_flight"
-			? "It is still being moved on the mail server. Try again in a moment."
-			: `An earlier move never finished, so where this message sits is unknown. Sync the folder, then ${action} it again.`,
+	detail: "It is still being moved on the mail server. Try again in a moment.",
 });

package/src/hooks/useDeleteMessages.ts

@@ -161,6 +161,25 @@ export const useDeleteMessages = ({
 				previousThreadsList,
 			};
 		},
+		// A batch that partly applied answers 200 with a non-zero `failureCount`:
+		// the rows whose placement changed under it were never claimed
+		// (imap-mutations R3). `onSettled` invalidates, so those rows come back on
+		// their own — this is what stops them coming back unexplained, which is
+		// the dead-button failure wearing a different face (#1229).
+		onSuccess: (data, vars) => {
+			const refused = data?.failureCount ?? 0;
+			if (refused === 0) return;
+			const asked = vars.body.messageIds?.length ?? 0;
+			pushError({
+				severity: "warning",
+				title:
+					refused > 1
+						? `Couldn't delete ${refused} of ${asked} messages yet`
+						: "Couldn't delete this message yet",
+				detail:
+					"Something else moved it while the delete was being prepared. It is back where it now sits — try again.",
+			});
+		},
 		onError: (err, vars, context) => {
 			if (context) {
 				for (const entry of context.previousThreadMessages) {

package/src/hooks/useMailboxAccount.ts

@@ -25,9 +25,14 @@ interface MailboxAccountResolution {
 export const useMailboxAccount = (
 	mailboxId: string | undefined,
 ): MailboxAccountResolution => {
+	// Disabled where there is no mailbox to resolve, the way the fan-out below
+	// already is. A caller that already knows its account passes `undefined` and
+	// this subscribes to nothing — which keeps the hook from pulling `/config`
+	// into trees that never asked for it.
 	const { data: config, isLoading: isConfigLoading } = useQuery({
 		...configOperationsGetConfigOptions(),
 		staleTime: Infinity,
+		enabled: !!mailboxId,
 	});
 
 	const accountIds = useMemo(

package/src/hooks/useToggleStar.test.ts

@@ -14,6 +14,7 @@ const make = (
 	senderTrust: "unknown",
 	status: "active",
 	syncStatus: "pending",
+	abandonedMutation: "none",
 	category: "uncategorized",
 	threadId: "t1",
 	threadMessageId: `tm-${messageId}`,

package/src/hooks/useToggleTrusted.test.ts

@@ -70,6 +70,7 @@ describe("patchDescribeMessage", () => {
 				internalDate: 1,
 				status: "active",
 				syncStatus: "pending",
+				abandonedMutation: "none",
 			},
 			envelope: {
 				messageId: "m",

package/src/lib/brief.test.ts

@@ -43,6 +43,7 @@ function threadResponse(
 		senderTrust: "unknown",
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 		muted: false,
 		createdAt: 0,
 		updatedAt: 0,

package/src/lib/bulk-actions.test.ts

@@ -132,6 +132,28 @@ describe("chunkTargets", () => {
 describe("runChunkedAction", () => {
 	const noopProgress = () => undefined;
 
+	// A select-all is walked a hundred ids at a time. Summed here so the caller
+	// states the refusals once for the run, rather than pushing a banner per
+	// chunk until the surface caps them.
+	test("sums the rows the server refused across every chunk", async () => {
+		const outcome = await runChunkedAction(
+			Array.from({ length: 250 }, (_, i) => ({
+				id: `m${i}`,
+				accountId: "acc-1",
+			})),
+			async (chunk) => ({
+				successCount: chunk.length - 1,
+				failureCount: 1,
+			}),
+			noopProgress,
+			neverAborted(),
+		);
+
+		assert.equal(outcome.refused, 3, "one per chunk, over three chunks");
+		assert.equal(outcome.done, 250, "every id was reached");
+		assert.deepEqual(outcome.failedIds, [], "and none was left unattempted");
+	});
+
 	test("zero ids does nothing and reports done=0", async () => {
 		const calls: string[][] = [];
 		const outcome = await runChunkedAction(
@@ -146,6 +168,7 @@ describe("runChunkedAction", () => {
 		assert.deepEqual(outcome, {
 			done: 0,
 			failedIds: [],
+			refused: 0,
 			cancelled: false,
 		});
 		assert.equal(calls.length, 0);
@@ -356,7 +379,12 @@ describe("runPredicateAction", () => {
 			noopProgress,
 			neverAborted(),
 		);
-		assert.deepEqual(outcome, { done: 0, failedIds: [], cancelled: false });
+		assert.deepEqual(outcome, {
+			done: 0,
+			failedIds: [],
+			refused: 0,
+			cancelled: false,
+		});
 	});
 
 	test("exactly 100 matches — a page size's worth — resolves in a single page with no continuation", async () => {

package/src/lib/bulk-actions.ts

@@ -10,10 +10,13 @@
  *
  * The endpoints enqueue the IMAP write and return; they do not apply it. So a
  * returned call means every id in it was accepted, not that the mail server
- * applied it — there is no per-id success/failure in the response to read. The
- * only failure this layer can observe is a thrown call: an infrastructure
- * failure (auth, the write, or the enqueue) that takes out the whole batch and
- * stops the run.
+ * applied it. Delete is the one action that can accept some of a batch and not
+ * the rest — a row whose placement changed under it is refused and counted in
+ * the response (imap-mutations R3) — and it reports that itself, on the call,
+ * rather than here: this layer only ever hands ids back, and an id this run did
+ * reach is not one it should re-offer. The only failure it observes is a thrown
+ * call: an infrastructure failure (auth, the write, or the enqueue) that takes
+ * out the whole batch and stops the run.
  *
  * Cancellation is an `AbortSignal` the caller owns, handed to every call the run
  * makes (#113). Aborting ends the request in flight rather than waiting for it,
@@ -165,10 +168,19 @@ export interface BulkActionOutcome {
 	 * An aborted batch is counted here too: aborting the request does not
 	 * un-send what the server already accepted, so its ids are "may not have
 	 * landed" rather than "did not", and every action here is idempotent.
-	 * There is no per-id failure source: a returned batch call counts every id in
-	 * it as accepted (see the module header).
+	 * A returned batch call counts every id in it as reached. Delete's own
+	 * per-row refusals ride its response and are surfaced by the caller, not
+	 * folded in here (see the module header).
 	 */
 	failedIds: string[];
+	/**
+	 * Rows the server reached and refused: their placement changed under the
+	 * run, so the action never claimed them (imap-mutations R3). Summed across
+	 * every chunk so the caller states it once for the whole run rather than
+	 * once per hundred ids. Not folded into `failedIds` — those were never
+	 * reached, and these were.
+	 */
+	refused: number;
 	cancelled: boolean;
 	/** Set when a batch call threw — an infrastructure failure, not a
 	 *  per-item failure. The run stops at the point it was raised. */
@@ -198,26 +210,34 @@ export const runChunkedAction = async (
 	const chunks = chunkTargets(targets);
 	const total = targets.length;
 	let done = 0;
+	let refused = 0;
 	const failedIds: string[] = [];
 
 	for (let i = 0; i < chunks.length; i++) {
 		if (signal.aborted) {
 			failedIds.push(...chunks.slice(i).flat());
-			return { done, failedIds, cancelled: true };
+			return { done, failedIds, refused, cancelled: true };
 		}
 		const chunk = chunks[i];
 		const attempted = await attempt(applyBatch(chunk, signal));
 		if (!attempted.ok) {
 			failedIds.push(...chunks.slice(i).flat());
-			if (signal.aborted) return { done, failedIds, cancelled: true };
+			if (signal.aborted) return { done, failedIds, refused, cancelled: true };
 			onProgress({ done, total });
-			return { done, failedIds, cancelled: false, error: attempted.error };
+			return {
+				done,
+				failedIds,
+				refused,
+				cancelled: false,
+				error: attempted.error,
+			};
 		}
+		refused += attempted.value?.failureCount ?? 0;
 		done += chunk.length;
 		onProgress({ done, total });
 	}
 
-	return { done, failedIds, cancelled: false };
+	return { done, failedIds, refused, cancelled: false };
 };
 
 /**
@@ -290,27 +310,42 @@ export const runPredicateAction = async (
 	signal: AbortSignal,
 ): Promise<BulkActionOutcome> => {
 	let done = 0;
+	let refused = 0;
 	const failedIds: string[] = [];
 	let token: string | undefined;
 
 	do {
 		if (signal.aborted) {
-			return { done, failedIds, cancelled: true };
+			return { done, failedIds, refused, cancelled: true };
 		}
 
 		const fetched = await attempt(fetchIdsPage(token, signal));
 		if (!fetched.ok) {
-			if (signal.aborted) return { done, failedIds, cancelled: true };
-			return { done, failedIds, cancelled: false, error: fetched.error };
+			if (signal.aborted) return { done, failedIds, refused, cancelled: true };
+			return {
+				done,
+				failedIds,
+				refused,
+				cancelled: false,
+				error: fetched.error,
+			};
 		}
 		const page = fetched.value;
 
 		if (page.ids.length > 0) {
 			const attempted = await attempt(applyBatch(page.ids, signal));
 			if (!attempted.ok) {
-				if (signal.aborted) return { done, failedIds, cancelled: true };
-				return { done, failedIds, cancelled: false, error: attempted.error };
+				if (signal.aborted)
+					return { done, failedIds, refused, cancelled: true };
+				return {
+					done,
+					failedIds,
+					refused,
+					cancelled: false,
+					error: attempted.error,
+				};
 			}
+			refused += attempted.value?.failureCount ?? 0;
 			done += page.ids.length;
 			onProgress({ done, total });
 		}
@@ -318,7 +353,7 @@ export const runPredicateAction = async (
 		token = page.continuationToken;
 	} while (token);
 
-	return { done, failedIds, cancelled: false };
+	return { done, failedIds, refused, cancelled: false };
 };
 
 /**
@@ -342,6 +377,14 @@ export const honestProgress = (
 export interface BulkRunOutcome {
 	done: number;
 	failedIds: string[];
+	/**
+	 * Rows the server reached and refused: their placement changed under the
+	 * run, so the action never claimed them (imap-mutations R3). Summed across
+	 * every chunk so the caller states it once for the whole run rather than
+	 * once per hundred ids. Not folded into `failedIds` — those were never
+	 * reached, and these were.
+	 */
+	refused: number;
 	cancelled: boolean;
 	error?: unknown;
 }

package/src/lib/dedupe-thread-messages.test.ts

@@ -26,6 +26,7 @@ function threadMessage(
 		senderTrust: "unknown",
 		status: "active",
 		syncStatus: "pending",
+		abandonedMutation: "none",
 		muted: false,
 		createdAt: 0,
 		updatedAt: 0,

package/src/lib/row-settlement.ts

@@ -1,15 +1,28 @@
 import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { hasAbandonedDelete } from "@remit/data-ports/message-settlement";
+import { abandonedMutationOf } from "@remit/data-ports/message-settlement";
+import { MessageMutation } from "@remit/domain-enums";
 import type { ThreadRowData } from "@remit/ui";
 
 /**
- * The row treatment for a message whose delete Remit abandoned (issue #1002). The
- * client decides nothing: `hasAbandonedDelete` owns which `status`/`syncStatus`
- * pair proves a terminal give-up, and why no other pair does. Any other row —
- * settled, mid-retry, or an undecidable move — carries no key at all and
+ * The row treatment for a message whose mutation Remit gave up on (issue
+ * #1002). The client decides nothing: `abandonedMutationOf` owns which values
+ * prove a terminal give-up and which operation it was. A copy that gave up
+ * leaves a `deleted` row no listing carries, so it reaches no row here; any
+ * other row — settled, mid-retry, or in flight — carries no key at all and
  * renders exactly as it always has.
  */
 export const rowSettlement = (
-	thread: Pick<RemitImapThreadMessageResponse, "status" | "syncStatus">,
-): Pick<ThreadRowData, "settlement"> =>
-	hasAbandonedDelete(thread) ? { settlement: "delete_failed" } : {};
+	thread: Pick<
+		RemitImapThreadMessageResponse,
+		"status" | "syncStatus" | "abandonedMutation"
+	>,
+): Pick<ThreadRowData, "settlement"> => {
+	switch (abandonedMutationOf(thread)) {
+		case MessageMutation.delete:
+			return { settlement: "delete_failed" };
+		case MessageMutation.move:
+			return { settlement: "move_failed" };
+		default:
+			return {};
+	}
+};

package/src/lib/thread-search-tokens.test.ts

@@ -43,6 +43,7 @@ const thread = (
 	senderTrust: "unknown",
 	status: "active",
 	syncStatus: "pending",
+	abandonedMutation: "none",
 	muted: false,
 	createdAt: 0,
 	updatedAt: 0,

package/src/test-support/fixtures.ts

@@ -80,6 +80,7 @@ export const makeThreadMessage = (
 	isDeleted: false,
 	status: "active",
 	syncStatus: "pending",
+	abandonedMutation: "none",
 	senderTrust: "unknown",
 	muted: false,
 	createdAt: 0,