@remit/web-client 0.0.269 → 0.0.271

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.269",
+  "version": "0.0.271",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/components/mail/MessageList.run-reporting.test.ts

@@ -63,7 +63,7 @@ describe("reporting how a run ended", () => {
 		);
 		assert.equal(stopped?.title, "Stopped after 100");
 		assert.match(stopped?.detail ?? "", /100 of 3,000 moved to Trash\./);
-		assert.match(stopped?.detail ?? "", /Nothing was sent for the rest/);
+		assert.match(stopped?.detail ?? "", /The rest were not sent/);
 
 		const covered = runEndingBanner("delete", 100, ended(), "trash");
 		assert.match(covered?.title ?? "", /^100 moved to Trash\./);

package/src/components/mail/SelectionWizardHost.tsx

@@ -75,6 +75,7 @@ import type { OrganizeMatchPredicate } from "@/lib/organize/sender-fallback";
 import { useSearchConversion } from "@/lib/search-conversion";
 import type { WizardSelectionMessage } from "@/lib/wizard-selection";
 import { useWizardEntryValue, useWizardStep } from "@/routing";
+import { bulkRunReport } from "./bulk-run-state";
 import { organizeRunState } from "./organize-run-state";
 import {
 	retryIntent,
@@ -823,57 +824,21 @@ function SelectionWizardSession({
 
 	const bulkSnapshot = useCallback((): RunSnapshot => {
 		if (!bulkRun) return NOT_STARTED;
-		const { matched, outcome, failureReason } = bulkRun;
-		// Nothing was sent, and nothing about sending it again resolves what was
-		// missing — so the screen carries why rather than the generic ending (#522).
-		if (failureReason !== undefined) {
-			return { ...NOT_STARTED, state: "commitFailed", failureReason };
-		}
-		if (!outcome) {
-			const applied = runProgress?.done ?? 0;
-			// A predicate matches more by the time the run re-pages it than the count
-			// saw, so what it has covered can overtake what it was offered against.
-			// The bar never reads more done than out of, and neither does this.
-			return {
-				state: "backApplyRunning",
-				matched: Math.max(matched, applied),
-				applied,
-				failed: 0,
-				failures: [],
-			};
-		}
-		const stopped = outcome.cancelled || outcome.error !== undefined;
-		if (!stopped) {
-			return {
-				state: "backApplyComplete",
-				matched: Math.max(matched, outcome.done),
-				applied: outcome.done,
-				failed: 0,
-				failures: [],
-			};
-		}
-		if (outcome.done === 0) {
-			return { ...NOT_STARTED, state: "commitFailed" };
-		}
-		// The run stopped part-way. Nothing here was rejected: a returned bulk call
-		// accepts every id in it, so the only failure this layer sees is a call that
-		// threw, and everything after it was never sent. A bounded run hands back
-		// exactly those ids; a predicate run re-resolves its match on every pass and
-		// has no remainder to hand back, so what is left is the difference between
-		// the count and what the run covered.
-		const failures = outcome.failedIds
-			.map((id) => rowsById.get(id))
-			.filter((message): message is WizardMessage => message !== undefined);
-		const unreached =
-			outcome.failedIds.length > 0
-				? outcome.failedIds.length
-				: Math.max(matched - outcome.done, 1);
+		const report = bulkRunReport({
+			matched: bulkRun.matched,
+			outcome: bulkRun.outcome,
+			failureReason: bulkRun.failureReason,
+			progressDone: runProgress?.done ?? 0,
+		});
 		return {
-			state: "runStopped",
-			matched: Math.max(matched, outcome.done),
-			applied: outcome.done,
-			failed: unreached,
-			failures,
+			state: report.state,
+			matched: report.matched,
+			applied: report.applied,
+			failed: report.failed,
+			failures: report.failedIds
+				.map((id) => rowsById.get(id))
+				.filter((message): message is WizardMessage => message !== undefined),
+			failureReason: report.failureReason,
 		};
 	}, [bulkRun, runProgress, rowsById]);
 

package/src/components/mail/bulk-run-state.test.ts

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { BulkRunOutcome } from "@/lib/bulk-actions";
+import { bulkRunReport } from "./bulk-run-state";
+
+const ended = (over: Partial<BulkRunOutcome> = {}): BulkRunOutcome => ({
+	done: 0,
+	failedIds: [],
+	cancelled: false,
+	...over,
+});
+
+const report = (
+	over: Partial<Parameters<typeof bulkRunReport>[0]> = {},
+): ReturnType<typeof bulkRunReport> =>
+	bulkRunReport({
+		matched: 100,
+		outcome: undefined,
+		failureReason: undefined,
+		progressDone: 0,
+		...over,
+	});
+
+describe("what the run screen says a bulk run did", () => {
+	it("shows a run still going against what it was started with", () => {
+		assert.deepEqual(report({ progressDone: 40 }), {
+			state: "backApplyRunning",
+			matched: 100,
+			applied: 40,
+			failed: 0,
+			failedIds: [],
+		});
+	});
+
+	it("never reads more done than out of", () => {
+		const going = report({ matched: 1284, progressDone: 1340 });
+		assert.equal(going.matched, 1340);
+	});
+
+	it("ends a run that covered its match on the success screen", () => {
+		const covered = report({ outcome: ended({ done: 100 }) });
+		assert.equal(covered.state, "backApplyComplete");
+		assert.equal(covered.applied, 100);
+	});
+
+	it("carries a commit that never started, and why", () => {
+		const never = report({ failureReason: "There is no Junk folder" });
+		assert.equal(never.state, "commitFailed");
+		assert.equal(never.failureReason, "There is no Junk folder");
+		assert.equal(never.matched, 0);
+	});
+
+	it("says a run that errored before anything landed never started", () => {
+		const threw = report({ outcome: ended({ error: new Error("500") }) });
+		assert.equal(threw.state, "commitFailed");
+	});
+});
+
+/**
+ * Regression for #113. A stop used to be read only between pages, so it always
+ * landed with at least one batch already applied and `done === 0` could only
+ * mean a failure. Aborting the request in flight makes zero the ordinary
+ * outcome of stopping during the first batch — the only batch a selection of a
+ * hundred or fewer ever has — and answering that with the danger screen told
+ * the user nothing had changed while the server had most likely taken all of
+ * them.
+ */
+describe("a run the user stopped", () => {
+	it("reports a stop during the first batch as stopped, not as a failed start", () => {
+		const stopped = report({
+			matched: 100,
+			outcome: ended({ cancelled: true, failedIds: Array(100).fill("m") }),
+		});
+		assert.equal(stopped.state, "runStopped");
+		assert.notEqual(stopped.state, "commitFailed");
+		assert.equal(stopped.applied, 0);
+		assert.equal(stopped.failed, 100);
+	});
+
+	it("reports a stop that reached nothing at all as stopped too", () => {
+		// The escalated path hands back no remainder: the predicate re-resolves on
+		// every run, so there are no ids to list, only a difference to name.
+		const stopped = report({
+			matched: 3000,
+			outcome: ended({ cancelled: true }),
+		});
+		assert.equal(stopped.state, "runStopped");
+		assert.equal(stopped.failed, 3000);
+	});
+
+	it("still reports a stop that got part-way", () => {
+		const stopped = report({
+			matched: 3000,
+			outcome: ended({ done: 1200, cancelled: true }),
+		});
+		assert.equal(stopped.state, "runStopped");
+		assert.equal(stopped.applied, 1200);
+		assert.equal(stopped.failed, 1800);
+	});
+});

package/src/components/mail/bulk-run-state.ts

@@ -0,0 +1,99 @@
+import type { RunState } from "@remit/ui";
+import type { BulkRunOutcome } from "@/lib/bulk-actions";
+
+/** What the run screen knows about a chunked bulk run it is reporting on. */
+export interface BulkRunReading {
+	/** The count the run was started against. */
+	matched: number;
+	/** Set once the run has ended, for any reason. */
+	outcome: BulkRunOutcome | undefined;
+	/**
+	 * Why the commit never started, when the reason is one the same commit cannot
+	 * get past (#522).
+	 */
+	failureReason: string | undefined;
+	/** Ids covered so far, read off the progress bar while the run is going. */
+	progressDone: number;
+}
+
+export interface BulkRunReport {
+	state: RunState;
+	matched: number;
+	applied: number;
+	failed: number;
+	/** Ids the run leaves unconfirmed; the screen resolves them to rows. */
+	failedIds: readonly string[];
+	failureReason?: string;
+}
+
+const NOTHING_STARTED = {
+	matched: 0,
+	applied: 0,
+	failed: 0,
+	failedIds: [] as readonly string[],
+};
+
+/**
+ * What the run screen says a bulk run did.
+ *
+ * Stopping is read before counting, because a stop is not a failure however
+ * little it reached (#113). Pressing Stop during the first batch — the only
+ * batch a selection of 100 or fewer has — leaves `done` at zero while the
+ * server has most likely applied all of them, and answering that with
+ * "Couldn't start deleting / Nothing has changed" is both alarming and wrong.
+ * Only a run that errored before anything landed has nothing to report but the
+ * failure.
+ */
+export const bulkRunReport = ({
+	matched,
+	outcome,
+	failureReason,
+	progressDone,
+}: BulkRunReading): BulkRunReport => {
+	// Nothing was sent, and nothing about sending it again resolves what was
+	// missing — so the screen carries why rather than the generic ending (#522).
+	if (failureReason !== undefined) {
+		return { ...NOTHING_STARTED, state: "commitFailed", failureReason };
+	}
+	if (!outcome) {
+		// A predicate matches more by the time the run re-pages it than the count
+		// saw, so what it has covered can overtake what it was offered against.
+		// The bar never reads more done than out of, and neither does this.
+		return {
+			state: "backApplyRunning",
+			matched: Math.max(matched, progressDone),
+			applied: progressDone,
+			failed: 0,
+			failedIds: [],
+		};
+	}
+	if (!outcome.cancelled && outcome.error === undefined) {
+		return {
+			state: "backApplyComplete",
+			matched: Math.max(matched, outcome.done),
+			applied: outcome.done,
+			failed: 0,
+			failedIds: [],
+		};
+	}
+	if (!outcome.cancelled && outcome.done === 0) {
+		return { ...NOTHING_STARTED, state: "commitFailed" };
+	}
+	// The run stopped part-way. Nothing here was rejected: a returned bulk call
+	// accepts every id in it, so the only failure this layer sees is a call that
+	// threw or was aborted, and everything after it was never sent. A bounded run
+	// hands back exactly those ids; a predicate run re-resolves its match on every
+	// pass and has no remainder to hand back, so what is left is the difference
+	// between the count and what the run covered.
+	const unreached =
+		outcome.failedIds.length > 0
+			? outcome.failedIds.length
+			: Math.max(matched - outcome.done, 1);
+	return {
+		state: "runStopped",
+		matched: Math.max(matched, outcome.done),
+		applied: outcome.done,
+		failed: unreached,
+		failedIds: outcome.failedIds,
+	};
+};

package/src/hooks/escalated-run-lifetime.render.test.ts

@@ -6,9 +6,9 @@
  *
  * These mount the real hook against the real fetch seam and count the batches
  * that actually left, so what is pinned is the run's own lifetime rather than
- * the wording of whichever screen started it. Every run is parked at a page
- * boundary before the test acts on it: that is where the run reads whether it
- * has been told to stop, and so the only place the difference shows.
+ * the wording of whichever screen started it. Every run is parked on a request
+ * the server is holding before the test acts on it: that is where leaving the
+ * selection and stopping the run tell each other apart.
  */
 
 import assert from "node:assert/strict";
@@ -32,8 +32,12 @@ let server: MailServer | undefined;
 interface MailServer {
 	/** Every message id a delete call carried, in the order they were sent. */
 	deleted: () => string[];
-	/** Deletes queued at the boundary rather than answered. */
+	/** Requests queued at the boundary rather than answered. */
 	held: () => number;
+	/** Requests the client cancelled while they were held. */
+	aborted: () => number;
+	/** Hold the count request too, so a stop can be pressed during counting. */
+	holdCounts: (on: boolean) => void;
 	/** Answer everything held, and stop holding. */
 	release: () => void;
 	restore: () => void;
@@ -61,14 +65,33 @@ const searchPage = (url: URL): unknown => {
 
 /**
  * Answers the search and the bulk delete, holding every delete after the first
- * so a run can be caught mid-flight with real progress behind it.
+ * so a run can be caught mid-flight with real progress behind it. A held
+ * request honours its own abort signal, the way the platform's `fetch` does —
+ * that is the difference a stop is now supposed to make (#113).
  */
 const startMailServer = (): MailServer => {
 	const original = globalThis.fetch;
 	const deleted: string[] = [];
 	let waiting: Array<() => void> = [];
 	let holding = true;
+	let holdingCounts = false;
 	let served = 0;
+	let cancelled = 0;
+
+	const hold = (signal: AbortSignal | undefined): Promise<void> =>
+		new Promise<void>((resolve, reject) => {
+			const fail = () => {
+				cancelled += 1;
+				waiting = waiting.filter((held) => held !== resolve);
+				reject(signal?.reason);
+			};
+			if (signal?.aborted) {
+				fail();
+				return;
+			}
+			signal?.addEventListener("abort", fail, { once: true });
+			waiting.push(resolve);
+		});
 
 	globalThis.fetch = (async (input: RequestInfo | URL): Promise<Response> => {
 		const request = input instanceof Request ? input : undefined;
@@ -76,6 +99,9 @@ const startMailServer = (): MailServer => {
 		const url = new URL(request ? request.url : String(input), "http://x");
 
 		if (url.pathname.endsWith("/threads/search")) {
+			if (holdingCounts && url.searchParams.get("results") === "false") {
+				await hold(request?.signal);
+			}
 			return Response.json(searchPage(url));
 		}
 
@@ -84,7 +110,7 @@ const startMailServer = (): MailServer => {
 			: undefined;
 		served += 1;
 		if (holding && served > 1) {
-			await new Promise<void>((resolve) => waiting.push(resolve));
+			await hold(request?.signal);
 		}
 		deleted.push(...(body?.messageIds ?? []));
 		return Response.json({ successCount: 0, failureCount: 0 });
@@ -93,8 +119,13 @@ const startMailServer = (): MailServer => {
 	return {
 		deleted: () => deleted,
 		held: () => waiting.length,
+		aborted: () => cancelled,
+		holdCounts: (on) => {
+			holdingCounts = on;
+		},
 		release: () => {
 			holding = false;
+			holdingCounts = false;
 			const queued = waiting;
 			waiting = [];
 			for (const resolve of queued) resolve();
@@ -235,6 +266,56 @@ describe("an escalated run the user walks away from", () => {
 	});
 });
 
+// Regression for #113: a stop used to be read only between pages, so the delete
+// already on the wire ran to completion and its whole page — up to a hundred
+// messages — was deleted after the press.
+describe("stopping a run with a delete already on the wire", () => {
+	it("cancels that delete and sends nothing more", async () => {
+		const { hook } = mountEscalation({ query: "npm" });
+		await escalateTo(hook);
+
+		const run = press(() => hook().runAction({ kind: "delete" }));
+		await parkAtBoundary();
+		const sentBeforeStop = server?.deleted().length ?? 0;
+		press(() => hook().stop());
+		press(() => server?.release());
+		await settle();
+		const outcome = await run;
+
+		assert.equal(server?.aborted(), 1, "the delete in flight was cancelled");
+		assert.equal(
+			server?.deleted().length,
+			sentBeforeStop,
+			"no further ids reached the server",
+		);
+		assert.equal(outcome.cancelled, true);
+		assert.equal(
+			outcome.error,
+			undefined,
+			"a stop the user pressed is not a failure to report",
+		);
+		assert.equal(outcome.done, sentBeforeStop);
+	});
+
+	it("cancels a count in flight without raising an error", async () => {
+		server?.holdCounts(true);
+		const { hook } = mountEscalation({ query: "npm" });
+
+		press(() => hook().escalate());
+		await parkAtBoundary();
+		press(() => hook().stop());
+		press(() => server?.release());
+		await settle();
+
+		assert.equal(server?.aborted(), 1);
+		assert.deepEqual(hook().phase, { kind: "idle" });
+		assert.equal(
+			harness?.text().includes("Couldn't count matching messages"),
+			false,
+		);
+	});
+});
+
 describe("stopping the run, which is a different press", () => {
 	it("ends it at the next page boundary and says what it reached", async () => {
 		const { hook } = mountEscalation({ query: "npm" });