@remit/web-client 0.0.268 → 0.0.270

package/src/hooks/useEscalatedActions.ts

@@ -84,7 +84,9 @@ export interface UseEscalatedActionsResult {
 	 *  selection to that predicate once it answers. */
 	escalate: () => void;
 	/**
-	 * Stop whatever's running — the count or an action — at the next boundary.
+	 * Stop whatever's running — the count or an action. The request in flight is
+	 * aborted and nothing further leaves (#113); a delete the server has already
+	 * accepted still applies, so the batch on the wire is what a stop is worth.
 	 * A no-op when nothing is running. The only thing that ends a run in
 	 * flight: leaving the selection, the wizard or the search does not.
 	 */
@@ -147,7 +149,10 @@ export const useEscalatedActions = ({
 	const [progress, setProgress] = useState<BulkActionProgress | undefined>(
 		undefined,
 	);
-	const cancelRef = useRef(false);
+	// Cancellation is the signal every call the run makes is issued under, so a
+	// stop ends the request on the wire instead of waiting for it to come back
+	// (#113). Replaced, never reused, at the start of each count and each run.
+	const abortRef = useRef<AbortController | undefined>(undefined);
 	// True from the moment a run starts until its outcome is in hand. A run is
 	// mail already leaving the mailbox, so nothing that merely changes what the
 	// list is showing gets to end it — only `stop`.
@@ -170,7 +175,7 @@ export const useEscalatedActions = ({
 	// against and reports what it reached, wherever the list moved on to.
 	// biome-ignore lint/correctness/useExhaustiveDependencies: enabled/predicateKey are trigger-only — the reset itself reads neither.
 	useEffect(() => {
-		if (!runningRef.current) cancelRef.current = true;
+		if (!runningRef.current) abortRef.current?.abort();
 		setPhase({ kind: "idle" });
 	}, [enabled, predicateKey]);
 
@@ -179,10 +184,11 @@ export const useEscalatedActions = ({
 
 	const fetchPagesOf = useCallback(
 		(query: EscalationSearchQuery): FetchIdsPage =>
-			async (continuationToken) => {
+			async (continuationToken, signal) => {
 				const { data } = await threadOperationsSearchThreads({
 					path: { mailboxId },
 					query: { ...query, continuationToken, limit: PAGE_SIZE },
+					signal,
 					throwOnError: true,
 				});
 				return {
@@ -198,27 +204,32 @@ export const useEscalatedActions = ({
 	 * resolves it (#509). One count-only request: `limit` is a page size and has
 	 * no bearing on the answer, so nothing is paged to arrive at it.
 	 */
-	const fetchMatchCount = useCallback(async (): Promise<number> => {
-		const { data } = await threadOperationsSearchThreads({
-			path: { mailboxId },
-			query: { ...searchQueryRef.current, count: true, results: false },
-			throwOnError: true,
-		});
-		if (data.count === undefined) {
-			throw new Error("the search returned no count for the selection");
-		}
-		return data.count;
-	}, [mailboxId]);
+	const fetchMatchCount = useCallback(
+		async (signal: AbortSignal): Promise<number> => {
+			const { data } = await threadOperationsSearchThreads({
+				path: { mailboxId },
+				query: { ...searchQueryRef.current, count: true, results: false },
+				signal,
+				throwOnError: true,
+			});
+			if (data.count === undefined) {
+				throw new Error("the search returned no count for the selection");
+			}
+			return data.count;
+		},
+		[mailboxId],
+	);
 
 	const applyBatchFor = useCallback(
 		(action: EscalatedAction): ApplyBatch =>
-			async (ids: string[]) => {
+			async (ids: string[], signal: AbortSignal) => {
 				if (action.kind === "move") {
 					const { data } = await messageBulkOperationsMoveMessages({
 						body: {
 							messageIds: ids,
 							destinationMailboxId: action.destinationMailboxId,
 						},
+						signal,
 						throwOnError: true,
 					});
 					return data;
@@ -226,12 +237,14 @@ export const useEscalatedActions = ({
 				if (action.kind === "markRead") {
 					const { data } = await messageBulkOperationsUpdateFlags({
 						body: { messageIds: ids, isRead: true },
+						signal,
 						throwOnError: true,
 					});
 					return data;
 				}
 				const { data } = await messageBulkOperationsDeleteMessages({
 					body: { messageIds: ids },
+					signal,
 					throwOnError: true,
 				});
 				return data;
@@ -267,17 +280,24 @@ export const useEscalatedActions = ({
 	);
 
 	const escalate = useCallback(() => {
-		cancelRef.current = false;
+		const controller = new AbortController();
+		abortRef.current = controller;
 		setPhase({ kind: "counting" });
-		fetchMatchCount().then(
+		fetchMatchCount(controller.signal).then(
 			(total) => {
-				if (cancelRef.current) {
+				if (controller.signal.aborted) {
 					setPhase({ kind: "idle" });
 					return;
 				}
 				setPhase({ kind: "escalated", total });
 			},
 			(error: unknown) => {
+				// A stopped count rejects with its own abort. That is the press the
+				// user made, not a failure to report back to them.
+				if (controller.signal.aborted) {
+					setPhase({ kind: "idle" });
+					return;
+				}
 				pushError(
 					buildMutationErrorBanner(
 						"Couldn't count matching messages",
@@ -291,12 +311,12 @@ export const useEscalatedActions = ({
 	}, [fetchMatchCount, pushError]);
 
 	const stop = useCallback(() => {
-		cancelRef.current = true;
+		abortRef.current?.abort();
 	}, []);
 
 	const clear = useCallback(() => {
 		if (runningRef.current) return;
-		cancelRef.current = true;
+		abortRef.current?.abort();
 		setPhase({ kind: "idle" });
 	}, []);
 
@@ -305,7 +325,8 @@ export const useEscalatedActions = ({
 			action: EscalatedAction,
 			targets?: readonly BulkActionTarget[],
 		): Promise<BulkRunOutcome> => {
-			cancelRef.current = false;
+			const controller = new AbortController();
+			abortRef.current = controller;
 			runningRef.current = true;
 			setRunningAction(action);
 			// Read before the run clears the phase below, so a refusal can say how
@@ -334,14 +355,14 @@ export const useEscalatedActions = ({
 								targets,
 								applyBatch,
 								onProgress,
-								() => cancelRef.current,
+								controller.signal,
 							)
 						: await runPredicateAction(
 								runPages,
 								phase.kind === "escalated" ? phase.total : 0,
 								applyBatch,
 								onProgress,
-								() => cancelRef.current,
+								controller.signal,
 							);
 			} finally {
 				runningRef.current = false;

package/src/hooks/useMoveMessages.ts

@@ -8,7 +8,12 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { useCallback } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { formatErrorDetail } from "@/components/ui/error-banners";
+import {
+	isPlacementRefusal,
+	placementRefusalBanner,
+} from "@/components/ui/placement-refusal";
 import { runChunkedMutation } from "@/lib/bulk-actions";
+import { softErrorStatuses } from "@/lib/error-classifier";
 import {
 	cancelThreadListQueries,
 	invalidateThreadListQueries,
@@ -57,6 +62,10 @@ export const useMoveMessages = ({
 
 	const { mutateAsync, isPending, isError } = useMutation({
 		...messageBulkOperationsMoveMessagesMutation(),
+		// A coded 409 is answered here — a banner — so it must not also take the
+		// whole screen. Only 409: a 401, 403 or 5xx on a move is still the fatal
+		// page's (#1059).
+		meta: softErrorStatuses(409),
 		onMutate: async (variables): Promise<ThreadMutationContext> => {
 			const messageIds = new Set(variables.body.messageIds ?? []);
 
@@ -136,6 +145,13 @@ export const useMoveMessages = ({
 				restoreThreadListQueries(queryClient, context.previousThreadsList);
 			}
 			const count = vars.body.messageIds?.length ?? 0;
+			// A placement refusal is a wait or a resync, not a failure to report as
+			// one: the move was never made, and the banner says which.
+			const placement = isPlacementRefusal(err);
+			if (placement) {
+				pushError(placementRefusalBanner(placement, count, "move"));
+				return;
+			}
 			pushError({
 				title:
 					count > 1

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

@@ -68,19 +68,29 @@ describe("bulkActionFailureTitle", () => {
 });
 
 describe("a run that stopped short of its match", () => {
-	test("states what it reached and that the rest is untouched", () => {
+	test("states what it reached and what became of the rest", () => {
 		assert.equal(bulkActionStoppedTitle(1200), "Stopped after 1,200");
 		assert.equal(
 			bulkActionStoppedDetail("delete", 1200, 3412),
-			"1,200 of 3,412 moved to Trash. Nothing was sent for the rest, so they are untouched.",
+			"1,200 of 3,412 moved to Trash. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.",
 		);
 		assert.equal(
 			bulkActionStoppedDetail("markRead", 1200, 3412),
-			"1,200 of 3,412 marked as read. Nothing was sent for the rest, so they are untouched.",
+			"1,200 of 3,412 marked as read. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.",
 		);
 	});
 
-	test("never reads as a rejection — nothing was sent", () => {
+	// Stopping aborts the request on the wire; it does not un-send one the server
+	// already took (#113). Promising the remainder is untouched would be a claim
+	// the client cannot make about the batch that was in flight.
+	test("stops short of promising the batch in flight never landed", () => {
+		assert.match(
+			bulkActionStoppedDetail("move", 1, 2),
+			/may still have gone through/,
+		);
+	});
+
+	test("never reads as a rejection — nothing was refused", () => {
 		assert.doesNotMatch(
 			bulkActionStoppedDetail("move", 1, 2),
 			/rejected|couldn't/i,

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

@@ -86,9 +86,11 @@ export const bulkActionCompletionText = (
 
 /**
  * Shown when a run ended before it covered what it was started against. The
- * remainder was never sent, so the mail is where it was and only the user can
+ * remainder was never sent, so that mail is where it was and only the user can
  * decide to run it again — which is why this is stated rather than left to a
- * list that quietly stops changing.
+ * list that quietly stops changing. Stopping aborts the request already on the
+ * wire rather than un-sending it (#113), so what the copy can promise about the
+ * remainder stops short of the batch that was in flight.
  */
 export const bulkActionStoppedTitle = (done: number): string =>
 	`Stopped after ${formatNumber(done)}`;
@@ -99,7 +101,7 @@ export const bulkActionStoppedDetail = (
 	total: number,
 	outcome: DeleteOutcome = "trash",
 ): string =>
-	`${formatNumber(done)} of ${formatNumber(total)} ${pastTenseFor(kind, outcome)}. Nothing was sent for the rest, so they are untouched.`;
+	`${formatNumber(done)} of ${formatNumber(total)} ${pastTenseFor(kind, outcome)}. The rest were not sent, apart from the ones already on their way when you stopped — those may still have gone through.`;
 
 /** Error-banner title for a run stopped by an infrastructure failure. */
 export const bulkActionFailureTitle = (

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

@@ -11,6 +11,24 @@ import {
 	runPredicateAction,
 } from "./bulk-actions.js";
 
+/** A run nobody stops. */
+const neverAborted = (): AbortSignal => new AbortController().signal;
+
+/**
+ * What an aborted request does: reject with the signal's own reason, whether it
+ * was already aborted when the call was made or aborted while in flight.
+ */
+const abortable = (signal: AbortSignal): Promise<never> =>
+	new Promise((_, reject) => {
+		if (signal.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		signal.addEventListener("abort", () => reject(signal.reason), {
+			once: true,
+		});
+	});
+
 const ids = (count: number, prefix = "m"): string[] =>
 	Array.from({ length: count }, (_, i) => `${prefix}${i}`);
 
@@ -112,7 +130,6 @@ describe("chunkTargets", () => {
 });
 
 describe("runChunkedAction", () => {
-	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
 
 	test("zero ids does nothing and reports done=0", async () => {
@@ -124,7 +141,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(outcome, {
 			done: 0,
@@ -144,7 +161,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(calls.length, 2);
 		assert.equal(calls[0].length, BULK_ACTION_CHUNK_SIZE);
@@ -159,7 +176,7 @@ describe("runChunkedAction", () => {
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.done, input.length);
 		assert.deepEqual(outcome.failedIds, []);
@@ -168,16 +185,16 @@ describe("runChunkedAction", () => {
 	test("cancelling mid-run folds every unreached chunk into failedIds", async () => {
 		const input = targets(BULK_ACTION_CHUNK_SIZE * 3);
 		let calls = 0;
-		let cancelled = false;
+		const stop = new AbortController();
 		const outcome = await runChunkedAction(
 			input,
 			async (chunk) => {
 				calls++;
-				if (calls === 1) cancelled = true; // cancel after the first chunk lands
+				if (calls === 1) stop.abort(); // cancel after the first chunk lands
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			() => cancelled,
+			stop.signal,
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(calls, 1);
@@ -195,7 +212,7 @@ describe("runChunkedAction", () => {
 				throw boom;
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 		assert.equal(outcome.done, 0);
@@ -215,7 +232,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(calls, [["a1", "a2"], ["b1"]]);
 		assert.equal(outcome.done, 3);
@@ -231,7 +248,7 @@ describe("runChunkedAction", () => {
 			],
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			(p) => seen.push(p),
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(seen, [
 			{ done: 1, total: 2 },
@@ -240,7 +257,7 @@ describe("runChunkedAction", () => {
 	});
 
 	test("cancelling at an account boundary hands back the accounts never reached", async () => {
-		let cancelled = false;
+		const stop = new AbortController();
 		const outcome = await runChunkedAction(
 			[
 				{ id: "a1", accountId: "acct-a" },
@@ -248,11 +265,11 @@ describe("runChunkedAction", () => {
 				{ id: "c1", accountId: "acct-c" },
 			],
 			async (chunk) => {
-				cancelled = true;
+				stop.abort();
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			() => cancelled,
+			stop.signal,
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(outcome.done, 1);
@@ -271,7 +288,7 @@ describe("runChunkedAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 		assert.equal(outcome.done, 1);
@@ -291,7 +308,7 @@ describe("runChunkedAction", () => {
 				throw new Error("auth expired");
 			},
 			() => undefined,
-			neverCancelled,
+			neverAborted(),
 		);
 		// The run stops where it threw rather than trying the accounts behind it:
 		// what it hands back is exactly what is still untouched, which is what a
@@ -308,7 +325,7 @@ describe("runChunkedAction", () => {
 			input,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			(p) => progressCalls.push(p),
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(progressCalls, [
 			{ done: BULK_ACTION_CHUNK_SIZE, total: input.length },
@@ -318,7 +335,6 @@ describe("runChunkedAction", () => {
 });
 
 describe("runPredicateAction", () => {
-	const neverCancelled = () => false;
 	const noopProgress = () => undefined;
 
 	/** Builds a paged fixture: `pages[i]` is what the i-th call returns. */
@@ -338,7 +354,7 @@ describe("runPredicateAction", () => {
 			0,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(outcome, { done: 0, failedIds: [], cancelled: false });
 	});
@@ -354,7 +370,7 @@ describe("runPredicateAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(deleteCalls.length, 1);
 		assert.equal(outcome.done, BULK_ACTION_CHUNK_SIZE);
@@ -374,7 +390,7 @@ describe("runPredicateAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(deleteCalls.length, 2);
 		assert.equal(outcome.done, 150);
@@ -397,7 +413,7 @@ describe("runPredicateAction", () => {
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.deepEqual(deleteCalls, [
 			["a", "b"],
@@ -408,7 +424,7 @@ describe("runPredicateAction", () => {
 
 	test("cancelling mid-delete stops paging without inventing failedIds for unfetched pages", async () => {
 		let fetchCalls = 0;
-		let cancelled = false;
+		const stop = new AbortController();
 		const fetch = async (): Promise<FetchIdsPageResult> => {
 			fetchCalls++;
 			return { ids: ["a", "b"], continuationToken: "more" };
@@ -417,11 +433,11 @@ describe("runPredicateAction", () => {
 			fetch,
 			1000,
 			async (chunk) => {
-				cancelled = true; // cancel takes effect on the next loop iteration
+				stop.abort(); // cancel takes effect on the next loop iteration
 				return { successCount: chunk.length, failureCount: 0 };
 			},
 			() => undefined,
-			() => cancelled,
+			stop.signal,
 		);
 		assert.equal(outcome.cancelled, true);
 		assert.equal(fetchCalls, 1);
@@ -439,7 +455,7 @@ describe("runPredicateAction", () => {
 			100,
 			async (chunk) => ({ successCount: chunk.length, failureCount: 0 }),
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 		assert.equal(outcome.done, 0);
@@ -455,12 +471,85 @@ describe("runPredicateAction", () => {
 				throw boom;
 			},
 			noopProgress,
-			neverCancelled,
+			neverAborted(),
 		);
 		assert.equal(outcome.error, boom);
 	});
 });
 
+// Regression for #113: a stop used to be a flag read between pages, so the
+// search or delete already on the wire ran to completion — up to a hundred
+// messages deleted after the press. The run's signal is now the call's signal.
+describe("stopping a run that has a request in flight", () => {
+	test("a bounded run reports the aborted batch as a clean stop, never an error", async () => {
+		const stop = new AbortController();
+		const calls: string[][] = [];
+		const outcome = await runChunkedAction(
+			targets(BULK_ACTION_CHUNK_SIZE * 3),
+			async (chunk, signal) => {
+				calls.push(chunk);
+				stop.abort();
+				return abortable(signal);
+			},
+			() => undefined,
+			stop.signal,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.error, undefined);
+		assert.equal(calls.length, 1, "nothing further left after the stop");
+		assert.equal(outcome.done, 0);
+		// The aborted batch may or may not have been accepted server-side, so it
+		// comes back with the chunks never attempted rather than counted as done.
+		assert.equal(outcome.failedIds.length, BULK_ACTION_CHUNK_SIZE * 3);
+	});
+
+	test("a predicate run whose delete is aborted sends nothing more and reports a clean stop", async () => {
+		const stop = new AbortController();
+		let fetches = 0;
+		let deletes = 0;
+		const outcome = await runPredicateAction(
+			async () => {
+				fetches++;
+				return { ids: ["a", "b"], continuationToken: "more" };
+			},
+			1000,
+			async (_chunk, signal) => {
+				deletes++;
+				stop.abort();
+				return abortable(signal);
+			},
+			() => undefined,
+			stop.signal,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.error, undefined);
+		assert.equal(deletes, 1);
+		assert.equal(fetches, 1);
+		assert.equal(outcome.done, 0);
+	});
+
+	test("a predicate run whose search page is aborted deletes nothing", async () => {
+		const stop = new AbortController();
+		let deletes = 0;
+		const outcome = await runPredicateAction(
+			async (_token, signal) => {
+				stop.abort();
+				return abortable(signal);
+			},
+			1000,
+			async (chunk) => {
+				deletes++;
+				return { successCount: chunk.length, failureCount: 0 };
+			},
+			() => undefined,
+			stop.signal,
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(outcome.error, undefined);
+		assert.equal(deletes, 0);
+	});
+});
+
 describe("honestProgress", () => {
 	// Regression for #109: the count and `runPredicateAction` resolve the same
 	// predicate independently, so the delete can outrun the frozen `total` it