@remit/web-client 0.0.200 → 0.0.202

package/src/components/mail/selection-wizard-run-controls.test.ts

@@ -0,0 +1,230 @@
+/**
+ * What the run screen's controls decide (#521, #526).
+ *
+ * The wizard host wires routing, history and several data hooks together, so
+ * the decision is taken out of it and asserted by its result — the same move
+ * `runEndingBanner` made for the completion banner. What the run screen then
+ * shows for each state is `@remit/ui`'s `selection-wizard.render.test.ts`, and
+ * the poll a refresh re-issues is `../../hooks/useOrganizeJob.render.test.ts`.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { BulkActionTarget, BulkRunOutcome } from "@/lib/bulk-actions";
+import {
+	type RetryContext,
+	retryIntent,
+	runIsInFlight,
+	stopRunner,
+	wizardExit,
+} from "./selection-wizard-run-controls";
+
+const target = (id: string): BulkActionTarget => ({ id, accountId: "acc-1" });
+
+const context = (over: Partial<RetryContext> = {}): RetryContext => ({
+	runState: "backApplyComplete",
+	isEscalated: false,
+	committedScope: "just-these",
+	createFilterFailed: false,
+	backApplyPending: false,
+	widenRunsAsJob: false,
+	failedIds: [],
+	sent: [target("m1"), target("m2")],
+	...over,
+});
+
+describe("retrying a run whose status could not be read", () => {
+	it("looks at the job it already has rather than queuing a second pass", () => {
+		assert.deepEqual(retryIntent(context({ runState: "statusUnknown" })), {
+			kind: "refreshStatus",
+		});
+	});
+
+	// The back-apply is still running on the server, so every other branch —
+	// each of which starts something — has to lose to this one.
+	for (const over of [
+		{ isEscalated: true },
+		{ committedScope: "standing" as const, backApplyPending: true },
+		{ committedScope: "temporary" as const, createFilterFailed: true },
+		{ committedScope: "all-like-these" as const, widenRunsAsJob: true },
+		{ committedScope: "just-these" as const },
+	]) {
+		it(`wins over ${JSON.stringify(over)}`, () => {
+			assert.deepEqual(
+				retryIntent(context({ ...over, runState: "statusUnknown" })).kind,
+				"refreshStatus",
+			);
+		});
+	}
+});
+
+describe("retrying an escalated predicate", () => {
+	it("re-resolves the predicate rather than resuming a page list", () => {
+		assert.deepEqual(retryIntent(context({ isEscalated: true })), {
+			kind: "rerunEscalated",
+		});
+	});
+});
+
+describe("retrying a filter that was being saved", () => {
+	it("clears the failed create before sending the same commit again", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ committedScope: "standing", createFilterFailed: true }),
+			),
+			{ kind: "resetAndResend" },
+		);
+	});
+
+	it("starts the pass over existing mail when the create landed", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ committedScope: "temporary", backApplyPending: true }),
+			),
+			{ kind: "startBackApply" },
+		);
+	});
+
+	it("starts nothing for a saved filter with no pass behind it", () => {
+		assert.deepEqual(retryIntent(context({ committedScope: "standing" })), {
+			kind: "waitOnJob",
+		});
+	});
+});
+
+describe("retrying a widened match", () => {
+	it("re-sends the commit when the widen runs as a job", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ committedScope: "all-like-these", widenRunsAsJob: true }),
+			),
+			{ kind: "resend" },
+		);
+	});
+
+	it("re-sends the resolved ids when it does not", () => {
+		assert.deepEqual(
+			retryIntent(context({ committedScope: "all-like-these" })),
+			{ kind: "rerunBulk", targets: [target("m1"), target("m2")] },
+		);
+	});
+});
+
+describe("retrying a bounded run", () => {
+	it("re-sends only what the run never reached", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ sent: [target("m1"), target("m2")], failedIds: ["m2"] }),
+			),
+			{ kind: "rerunBulk", targets: [target("m2")] },
+		);
+	});
+
+	// A run that threw before it handed anything back reports no failed ids, and
+	// re-sending nothing is a retry that silently does nothing at all.
+	it("re-sends everything when the run named no id it missed", () => {
+		assert.deepEqual(retryIntent(context()), {
+			kind: "rerunBulk",
+			targets: [target("m1"), target("m2")],
+		});
+	});
+
+	it("keeps each id's own account, so a cross-account retry still batches", () => {
+		const sent = [
+			{ id: "m1", accountId: "acc-work" },
+			{ id: "m2", accountId: "acc-personal" },
+		];
+		assert.deepEqual(retryIntent(context({ sent, failedIds: ["m2"] })), {
+			kind: "rerunBulk",
+			targets: [{ id: "m2", accountId: "acc-personal" }],
+		});
+	});
+});
+
+describe("whether the run screen offers a way to end the run", () => {
+	const outcome: BulkRunOutcome = {
+		done: 2,
+		failedIds: [],
+		cancelled: false,
+	};
+
+	it("offers nothing before a commit has been sent", () => {
+		assert.equal(runIsInFlight(undefined), false);
+	});
+
+	it("offers it while the runner is still paging", () => {
+		assert.equal(runIsInFlight({}), true);
+	});
+
+	it("withdraws it once the runner has handed back an outcome", () => {
+		assert.equal(runIsInFlight({ outcome }), false);
+	});
+
+	// Nothing was sent, so there is nothing paging to end — the screen carries
+	// why instead, and a control claiming to stop a run would stop nothing.
+	it("withdraws it for a commit that could not start", () => {
+		assert.equal(runIsInFlight({ failureReason: "no Junk folder" }), false);
+	});
+});
+
+describe("which runner the stop reaches", () => {
+	const spies = () => {
+		const called: string[] = [];
+		return {
+			called,
+			escalated: { stop: () => called.push("escalated") },
+			stopBulk: () => called.push("bulk"),
+		};
+	};
+
+	it("stops the list's runner when the selection is a predicate", () => {
+		const { called, escalated, stopBulk } = spies();
+		stopRunner(escalated, stopBulk);
+		assert.deepEqual(called, ["escalated"]);
+	});
+
+	// A bounded select-all runs on the wizard's own runner and reaches the same
+	// control, so a stop that only knows about the predicate leaves that button
+	// on screen doing nothing at all.
+	it("stops the wizard's own runner for a bounded selection", () => {
+		const { called, stopBulk } = spies();
+		stopRunner(undefined, stopBulk);
+		assert.deepEqual(called, ["bulk"]);
+	});
+});
+
+describe("which movement the wizard's exit is", () => {
+	const movements = () => {
+		const called: string[] = [];
+		return {
+			called,
+			handlers: {
+				dismiss: () => called.push("dismiss"),
+				cancel: () => called.push("cancel"),
+			},
+		};
+	};
+
+	it("walks away from the run on the run screen, leaving it going", () => {
+		const { called, handlers } = movements();
+		wizardExit("run", handlers)();
+		assert.deepEqual(called, ["dismiss"]);
+	});
+
+	// Rewinding the entries the wizard owns is only safe before anything is
+	// sent; taken off the run screen it offers the commit a second time.
+	for (const step of [
+		"match",
+		"properties",
+		"folder",
+		"rule",
+		"name",
+		"review",
+	] as const) {
+		it(`rewinds the walk from ${step}`, () => {
+			const { called, handlers } = movements();
+			wizardExit(step, handlers)();
+			assert.deepEqual(called, ["cancel"]);
+		});
+	}
+});

package/src/components/mail/selection-wizard-run-controls.ts

@@ -0,0 +1,101 @@
+import type { RunState, StepId } from "@remit/ui";
+import type { BulkActionTarget, BulkRunOutcome } from "@/lib/bulk-actions";
+import type { OrganizeScope } from "@/lib/organize/organize-model";
+
+export interface RetryContext {
+	runState: RunState;
+	isEscalated: boolean;
+	committedScope: OrganizeScope | undefined;
+	createFilterFailed: boolean;
+	backApplyPending: boolean;
+	widenRunsAsJob: boolean;
+	failedIds: readonly string[];
+	sent: readonly BulkActionTarget[];
+}
+
+export type RetryIntent =
+	| { kind: "refreshStatus" }
+	| { kind: "rerunEscalated" }
+	| { kind: "resetAndResend" }
+	| { kind: "resend" }
+	| { kind: "startBackApply" }
+	| { kind: "waitOnJob" }
+	| { kind: "rerunBulk"; targets: readonly BulkActionTarget[] };
+
+/**
+ * What pressing the run screen's retry asks for, given where the commit got to.
+ *
+ * A back-apply whose status could not be read is still running on the server
+ * (#526), so that one is decided before anything that could queue a second pass
+ * over the same mail.
+ */
+export const retryIntent = (context: RetryContext): RetryIntent => {
+	if (context.runState === "statusUnknown") return { kind: "refreshStatus" };
+	// The predicate is re-resolved, not resumed: every verb it carries is
+	// idempotent, so the messages the first pass already reached are a no-op.
+	if (context.isEscalated) return { kind: "rerunEscalated" };
+	if (
+		context.committedScope === "standing" ||
+		context.committedScope === "temporary"
+	) {
+		if (context.createFilterFailed) return { kind: "resetAndResend" };
+		return context.backApplyPending
+			? { kind: "startBackApply" }
+			: { kind: "waitOnJob" };
+	}
+	if (context.committedScope === "all-like-these" && context.widenRunsAsJob) {
+		return { kind: "resend" };
+	}
+	// A run hands back ids, and each one's account came from the batch it was
+	// sent in — so a retry re-sends the targets the run was given, filtered to
+	// what it never reached.
+	const outstanding = new Set(context.failedIds);
+	return {
+		kind: "rerunBulk",
+		targets:
+			outstanding.size > 0
+				? context.sent.filter((target) => outstanding.has(target.id))
+				: context.sent,
+	};
+};
+
+/**
+ * What a commit has left paging. A commit that never started, one whose runner
+ * has handed back its outcome, and one that could not start at all all have
+ * nothing to end — so the run screen offers no control that would claim to end
+ * them (#521).
+ */
+export const runIsInFlight = (
+	bulkRun: { outcome?: BulkRunOutcome; failureReason?: string } | undefined,
+): boolean =>
+	bulkRun !== undefined &&
+	bulkRun.outcome === undefined &&
+	bulkRun.failureReason === undefined;
+
+/**
+ * Ends the run rather than leaving it. An escalated predicate is paged by the
+ * list's own runner and a bounded selection by the wizard's, so the stop has to
+ * follow whichever one is paging: a stop that reaches only one of them leaves
+ * the other's control on screen doing nothing.
+ */
+export const stopRunner = (
+	escalated: { stop: () => void } | undefined,
+	stopBulk: () => void,
+): void => {
+	if (escalated) {
+		escalated.stop();
+		return;
+	}
+	stopBulk();
+};
+
+/**
+ * Which of the two movements the wizard's exit is, on the step it is taken
+ * from. Everywhere but the run screen it rewinds the entries the wizard owns
+ * and leaves the selection where it was; on the run screen the action has
+ * already been sent, so leaving walks away from a run that keeps going.
+ */
+export const wizardExit = (
+	step: StepId,
+	movements: { dismiss: () => void; cancel: () => void },
+): (() => void) => (step === "run" ? movements.dismiss : movements.cancel);

package/src/lib/delete-folder.test.ts

@@ -285,3 +285,20 @@ describe("initialStage", () => {
 		assert.equal(initialStage(3), "choose-fate");
 	});
 });
+
+describe("hasChildFolders in a flat namespace", () => {
+	it("does not read a shared prefix as a child", () => {
+		const target = folder({
+			mailboxId: "work",
+			fullPath: "Work",
+			hierarchyDelimiter: "",
+		});
+		assert.equal(
+			hasChildFolders(target, [
+				target,
+				{ mailboxId: "shop", fullPath: "Workshop" },
+			]),
+			false,
+		);
+	});
+});

package/src/lib/delete-folder.ts

@@ -34,12 +34,14 @@ const isInboxPath = (fullPath: string): boolean =>
 /**
  * A folder has children when another mailbox's path is nested under it — the
  * folder's own path followed by the hierarchy delimiter. The delimiter matters:
- * `Work` is not a parent of `Workshop`, only of `Work/Shop`.
+ * `Work` is not a parent of `Workshop`, only of `Work/Shop`. A server that
+ * reports no delimiter has a flat namespace, where nothing nests at all.
  */
 export const hasChildFolders = (
 	folder: Pick<FolderNode, "mailboxId" | "fullPath" | "hierarchyDelimiter">,
 	all: readonly Pick<FolderNode, "mailboxId" | "fullPath">[],
 ): boolean => {
+	if (folder.hierarchyDelimiter.length === 0) return false;
 	const prefix = `${folder.fullPath}${folder.hierarchyDelimiter}`;
 	return all.some(
 		(other) =>

package/src/lib/new-folder.test.ts

@@ -107,3 +107,21 @@ describe("validateNewFolderName", () => {
 		);
 	});
 });
+
+describe("validateNewFolderName in a flat namespace", () => {
+	const flat = { delimiter: "", existingPaths: ["INBOX", "Archive"] };
+
+	it("accepts a name when the server reports no delimiter", () => {
+		assert.equal(
+			validateNewFolderName({ ...flat, name: "Receipts" }),
+			undefined,
+		);
+	});
+
+	it("still catches a collision", () => {
+		assert.match(
+			validateNewFolderName({ ...flat, name: "inbox" }) ?? "",
+			/already exists/,
+		);
+	});
+});

package/src/lib/new-folder.ts

@@ -19,7 +19,7 @@ export function composeFolderPath(name: string, parent?: FolderTarget): string {
  * match `inbox/x` against `INBOX/x` without folding case anywhere else.
  */
 const canonicalizePath = (path: string, delimiter: string): string => {
-	const parts = path.split(delimiter);
+	const parts = delimiter.length === 0 ? [path] : path.split(delimiter);
 	if (parts[0]?.toLowerCase() === "inbox") parts[0] = "INBOX";
 	return parts.join(delimiter);
 };
@@ -29,7 +29,8 @@ const canonicalizePath = (path: string, delimiter: string): string => {
  * name must be non-empty, must not contain the hierarchy delimiter (nesting is
  * expressed by the parent select, not by typing a path), and must not collide
  * with an existing folder — INBOX compared case-insensitively, everything else
- * exactly.
+ * exactly. A server that reports no delimiter has a flat namespace, so there is
+ * no separator to forbid and every name would otherwise contain it.
  */
 export function validateNewFolderName({
 	name,
@@ -44,7 +45,7 @@ export function validateNewFolderName({
 }): string | undefined {
 	const trimmed = name.trim();
 	if (trimmed === "") return "Enter a folder name.";
-	if (trimmed.includes(delimiter))
+	if (delimiter.length > 0 && trimmed.includes(delimiter))
 		return `A folder name can't contain "${delimiter}".`;
 	const candidate = canonicalizePath(
 		composeFolderPath(trimmed, parent),

package/src/components/mail/BriefPane.selection.test.ts

@@ -1,51 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-
-/**
- * The phone brief must mount the same selection surface the multi-pane list
- * does (#203). `BriefPane` wires the bulk verbs and the selection bar into
- * `DailyBrief` from the `BriefList` slot; the phone view used to render
- * `DailyBrief` directly, without `onDeleteMessages`, so a selection made in the
- * brief on a phone raised no action bar — selectable, but nothing to act with.
- *
- * As with `MessageList.selection.test.ts`, `BriefPane` weaves routing and
- * several data hooks together, so the rule is enforced by reading the source:
- * the phone view reuses the list slot rather than a bare `DailyBrief`.
- */
-
-const here = dirname(fileURLToPath(import.meta.url));
-const source = readFileSync(resolve(here, "BriefPane.tsx"), "utf8");
-
-const briefPhoneBody = (): string => {
-	const start = source.indexOf("function BriefPhone(");
-	assert.notEqual(start, -1, "BriefPhone is defined");
-	const next = source.indexOf("\nfunction ", start + 1);
-	return source.slice(start, next === -1 ? undefined : next);
-};
-
-describe("BriefPane phone selection surface (#203)", () => {
-	it("the phone brief reuses the list slot, not a bare DailyBrief", () => {
-		const body = briefPhoneBody();
-		assert.match(
-			body,
-			/<BriefList \/>/,
-			"phone brief renders the list slot that wires the bulk verbs",
-		);
-		assert.doesNotMatch(
-			body,
-			/<DailyBrief\b/,
-			"phone brief must not render DailyBrief directly — that drops onDeleteMessages and the selection bar with it",
-		);
-	});
-
-	it("the list slot hands DailyBrief the delete verb the selection bar gates on", () => {
-		const start = source.indexOf("function BriefList(");
-		assert.notEqual(start, -1, "BriefList is defined");
-		const next = source.indexOf("\nfunction ", start + 1);
-		const body = source.slice(start, next === -1 ? undefined : next);
-		assert.match(body, /onDeleteMessages=\{onDeleteMessages\}/);
-	});
-});

package/src/components/mail/DailyBrief.selection.test.ts

@@ -1,75 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-
-/**
- * The brief raises one selection surface at every width, and select-all is on
- * it — wired into the touch sheet alone, the same list could be selected whole
- * on a phone and not on a desktop (#453).
- *
- * As with `MessageList.selection.test.ts`, `DailyBrief` weaves routing, the
- * cursor and several data hooks together, so the rule is enforced by reading
- * the source. `resolveBriefSelectionScope` carries the decisions that can be
- * unit-tested on their own.
- */
-
-const here = dirname(fileURLToPath(import.meta.url));
-const source = readFileSync(resolve(here, "DailyBrief.tsx"), "utf8");
-
-const chromeBody = (): string => {
-	const start = source.indexOf("function BriefSelectionChrome(");
-	assert.notEqual(start, -1, "BriefSelectionChrome is defined");
-	const next = source.indexOf("\nfunction ", start + 1);
-	return source.slice(start, next === -1 ? undefined : next);
-};
-
-describe("the brief's select-all", () => {
-	it("reaches the one selection bar from one derivation", () => {
-		const body = chromeBody();
-		const derivations = body.match(/const selectAll = useMemo\(/g) ?? [];
-		assert.equal(derivations.length, 1, "one select-all");
-		const bars = body.match(/<SelectionTopBar\b/g) ?? [];
-		assert.equal(bars.length, 1, "one surface, at every width (#480)");
-		const wired = body.match(/selectAll=\{selectAll\}/g) ?? [];
-		assert.equal(wired.length, 1, "the bar takes it");
-	});
-
-	it("is offered only when there are rows to select", () => {
-		assert.match(chromeBody(), /orderedIds\.length > 0/);
-	});
-
-	it("mounts the bar unconditionally — it is the list header (#480)", () => {
-		assert.match(
-			chromeBody(),
-			/const selectionBar = \(chrome: ListHeaderChrome\) => \(\s*<SelectionTopBar/,
-		);
-	});
-
-	it("carries every verb the bar can offer (#477 1.4)", () => {
-		// That each of them opens the wizard is `selection-verbs.test.ts`, over
-		// every surface at once. What this pins is that none of them was dropped
-		// from the bar the brief raises.
-		const body = chromeBody();
-		for (const prop of [
-			"onDelete",
-			"onMove",
-			"onOrganize",
-			"onJunk",
-			"onMarkRead",
-		]) {
-			assert.match(body, new RegExp(`${prop}=`));
-		}
-		assert.doesNotMatch(body, /onSomethingElse/);
-	});
-
-	it("drives the wizard and the keyboard layer from one control", () => {
-		// Two copies of "which verb is the wizard on" is how the brief came to
-		// offer a verb the mailbox list did not, and how its keyboard came to act
-		// behind a wizard the bar had opened.
-		assert.match(source, /const wizard = useSelectionWizard\(\);/);
-		assert.match(source, /onSelectionVerb={wizard.start}/);
-		assert.match(source, /wizardOpen={wizard.isOpen}/);
-	});
-});