@remit/web-client 0.0.42 → 0.0.44

package/src/hooks/{useEscalatedDelete.ts → useEscalatedActions.ts}

@@ -5,6 +5,8 @@ import {
 } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import {
 	messageBulkOperationsDeleteMessages,
+	messageBulkOperationsMoveMessages,
+	messageBulkOperationsUpdateFlags,
 	threadOperationsSearchThreads,
 } from "@remit/api-http-client/sdk.gen.ts";
 import type { ThreadOperationsSearchThreadsData } from "@remit/api-http-client/types.gen.ts";
@@ -13,24 +15,39 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
 import { buildMutationErrorBanner } from "@/components/ui/error-banners";
 import {
-	type BulkDeleteProgress,
+	bulkActionFailureDetail,
+	bulkActionFailureTitle,
+} from "@/lib/bulk-action-copy";
+import {
+	type ApplyBatch,
+	type BulkActionProgress,
+	type BulkRunOutcome,
 	countMatches,
-	type DeleteRunOutcome,
 	type FetchIdsPage,
 	honestProgress,
-	runChunkedDelete,
-	runPredicateDelete,
-} from "@/lib/bulk-delete";
+	runChunkedAction,
+	runPredicateAction,
+} from "@/lib/bulk-actions";
 
-/** The predicate a search-scoped delete re-issues on every page — the same
+/** The predicate a search-scoped run re-issues on every page — the same
  *  filters the visible list is searching with, minus pagination/count knobs. */
 export type EscalationSearchQuery = Pick<
 	NonNullable<ThreadOperationsSearchThreadsData["query"]>,
 	"order" | "query" | "subject" | "from" | "unread" | "starred" | "attachments"
 >;
 
+/**
+ * What a bulk run applies to every batch it reaches (#114). Delete, move and
+ * mark-read differ only in the bulk call they issue and the caches that call
+ * invalidates; the paging, chunking, progress and cancellation are the same.
+ */
+export type EscalatedAction =
+	| { kind: "delete" }
+	| { kind: "move"; destinationMailboxId: string }
+	| { kind: "markRead" };
+
 /** Page size for both the counting and the execution loop. Set to the write
- *  side's own 100-id cap so an execution page IS a delete chunk — no
+ *  side's own 100-id cap so an execution page IS a write chunk — no
  *  in-memory accumulation step between reading ids and sending them. Counting
  *  doesn't have that constraint but reuses the same page size rather than
  *  adding a second one to reason about. */
@@ -41,7 +58,7 @@ export type EscalationPhase =
 	| { kind: "counting"; countSoFar: number }
 	| { kind: "escalated"; total: number };
 
-interface UseEscalatedDeleteOptions {
+interface UseEscalatedActionsOptions {
 	mailboxId: string;
 	/** Owning account, forwarded to the unseen-count invalidation on completion. */
 	accountId?: string;
@@ -54,51 +71,58 @@ interface UseEscalatedDeleteOptions {
 	searchQuery: EscalationSearchQuery;
 }
 
-export interface UseEscalatedDeleteResult {
+export interface UseEscalatedActionsResult {
 	phase: EscalationPhase;
 	/** Begin paging the predicate's full match set to find its total. */
 	escalate: () => void;
-	/** Stop whatever's running — counting or a delete — at the next page
+	/** Stop whatever's running — counting or an action — at the next page
 	 *  boundary. A no-op when nothing is running. */
 	stop: () => void;
 	/** Drop an escalated selection back to bounded without confirming anything. */
 	clear: () => void;
-	/** True while a chunked delete (bounded->100 ids, or the escalated
-	 *  predicate) is running. */
-	isDeleting: boolean;
-	deleteProgress: BulkDeleteProgress | undefined;
+	/** True while a chunked run (bounded->100 ids, or the escalated predicate)
+	 *  is in flight. */
+	isRunning: boolean;
+	/** The action currently in flight, for status and progress wording. */
+	runningAction: EscalatedAction | undefined;
+	progress: BulkActionProgress | undefined;
 	/**
-	 * Runs a chunked delete. Pass `ids` for a materialized (bounded) selection;
-	 * omit it to delete the escalated predicate (`phase` must be "escalated").
-	 * Resolves once the run ends for any reason — cancelled, errored, or
-	 * complete — with a `done`/`failedIds` outcome the caller feeds to
-	 * `resolveSelectionAfterDelete` to decide what selection looks like next.
+	 * Runs `action` in chunks. Pass `ids` for a materialized (bounded)
+	 * selection; omit it to run against the escalated predicate (`phase` must
+	 * be "escalated"). Resolves once the run ends for any reason — cancelled,
+	 * errored, or complete — with a `done`/`failedIds` outcome the caller feeds
+	 * to `resolveSelectionAfterRun` to decide what selection looks like next.
 	 * Infrastructure failures are reported through the app's existing
 	 * escalation seam (`pushError`, which itself escalates a 5xx/exception to
 	 * the fatal overlay) — not swallowed here.
 	 */
-	runDelete: (ids?: string[]) => Promise<DeleteRunOutcome>;
+	runAction: (
+		action: EscalatedAction,
+		ids?: string[],
+	) => Promise<BulkRunOutcome>;
 }
 
-export const useEscalatedDelete = ({
+export const useEscalatedActions = ({
 	mailboxId,
 	accountId,
 	enabled,
 	predicateKey,
 	searchQuery,
-}: UseEscalatedDeleteOptions): UseEscalatedDeleteResult => {
+}: UseEscalatedActionsOptions): UseEscalatedActionsResult => {
 	const [phase, setPhase] = useState<EscalationPhase>({ kind: "idle" });
-	const [isDeleting, setIsDeleting] = useState(false);
-	const [deleteProgress, setDeleteProgress] = useState<
-		BulkDeleteProgress | undefined
+	const [runningAction, setRunningAction] = useState<
+		EscalatedAction | undefined
 	>(undefined);
+	const [progress, setProgress] = useState<BulkActionProgress | undefined>(
+		undefined,
+	);
 	const cancelRef = useRef(false);
 	const queryClient = useQueryClient();
 	const { pushError } = useErrorBanners();
 
 	// A different search (or leaving search/desktop) makes any in-flight
 	// escalation meaningless — it would otherwise keep counting or offering to
-	// delete a predicate the visible list no longer reflects.
+	// act on a predicate the visible list no longer reflects.
 	// biome-ignore lint/correctness/useExhaustiveDependencies: enabled/predicateKey are trigger-only — the reset itself is unconditional, not a value read from either.
 	useEffect(() => {
 		cancelRef.current = true;
@@ -127,29 +151,62 @@ export const useEscalatedDelete = ({
 		[mailboxId],
 	);
 
-	const deleteBatch = useCallback(async (ids: string[]) => {
-		const { data } = await messageBulkOperationsDeleteMessages({
-			body: { messageIds: ids },
-			throwOnError: true,
-		});
-		return data;
-	}, []);
+	const applyBatchFor = useCallback(
+		(action: EscalatedAction): ApplyBatch =>
+			async (ids: string[]) => {
+				if (action.kind === "move") {
+					const { data } = await messageBulkOperationsMoveMessages({
+						body: {
+							messageIds: ids,
+							destinationMailboxId: action.destinationMailboxId,
+						},
+						throwOnError: true,
+					});
+					return data;
+				}
+				if (action.kind === "markRead") {
+					const { data } = await messageBulkOperationsUpdateFlags({
+						body: { messageIds: ids, isRead: true },
+						throwOnError: true,
+					});
+					return data;
+				}
+				const { data } = await messageBulkOperationsDeleteMessages({
+					body: { messageIds: ids },
+					throwOnError: true,
+				});
+				return data;
+			},
+		[],
+	);
 
-	const invalidateAfterDelete = useCallback(() => {
-		queryClient.invalidateQueries({
-			queryKey: threadOperationsListThreadsQueryKey({ path: { mailboxId } }),
-		});
-		queryClient.invalidateQueries({
-			queryKey: threadOperationsSearchThreadsQueryKey({ path: { mailboxId } }),
-		});
-		if (accountId) {
+	const invalidateAfterRun = useCallback(
+		(action: EscalatedAction) => {
+			queryClient.invalidateQueries({
+				queryKey: threadOperationsListThreadsQueryKey({ path: { mailboxId } }),
+			});
 			queryClient.invalidateQueries({
-				queryKey: mailboxOperationsListMailboxesQueryKey({
-					path: { accountId },
+				queryKey: threadOperationsSearchThreadsQueryKey({
+					path: { mailboxId },
 				}),
 			});
-		}
-	}, [queryClient, mailboxId, accountId]);
+			if (action.kind === "move") {
+				queryClient.invalidateQueries({
+					queryKey: threadOperationsListThreadsQueryKey({
+						path: { mailboxId: action.destinationMailboxId },
+					}),
+				});
+			}
+			if (accountId) {
+				queryClient.invalidateQueries({
+					queryKey: mailboxOperationsListMailboxesQueryKey({
+						path: { accountId },
+					}),
+				});
+			}
+		},
+		[queryClient, mailboxId, accountId],
+	);
 
 	const escalate = useCallback(() => {
 		cancelRef.current = false;
@@ -187,53 +244,55 @@ export const useEscalatedDelete = ({
 		setPhase({ kind: "idle" });
 	}, []);
 
-	const runDelete = useCallback(
-		async (ids?: string[]): Promise<DeleteRunOutcome> => {
+	const runAction = useCallback(
+		async (
+			action: EscalatedAction,
+			ids?: string[],
+		): Promise<BulkRunOutcome> => {
 			cancelRef.current = false;
-			setIsDeleting(true);
+			setRunningAction(action);
 			// `honestProgress` widens `total` if `done` overtakes it (#109) — the
-			// predicate can match more by the time the delete re-pages it than
+			// predicate can match more by the time the run re-pages it than
 			// `countMatches` saw, and the bar must never show more done than out of.
-			const onProgress = (progress: BulkDeleteProgress) =>
-				setDeleteProgress(honestProgress(progress));
+			const onProgress = (next: BulkActionProgress) =>
+				setProgress(honestProgress(next));
+			const applyBatch = applyBatchFor(action);
 
 			const outcome =
 				ids !== undefined
-					? await runChunkedDelete(
+					? await runChunkedAction(
 							ids,
-							deleteBatch,
+							applyBatch,
 							onProgress,
 							() => cancelRef.current,
 						)
-					: await runPredicateDelete(
+					: await runPredicateAction(
 							fetchIdsPage,
 							phase.kind === "escalated" ? phase.total : 0,
-							deleteBatch,
+							applyBatch,
 							onProgress,
 							() => cancelRef.current,
 						);
 
-			setIsDeleting(false);
-			setDeleteProgress(undefined);
+			setRunningAction(undefined);
+			setProgress(undefined);
 			setPhase({ kind: "idle" });
 
 			if (outcome.error) {
 				pushError(
 					buildMutationErrorBanner(
-						outcome.done > 0
-							? `Stopped after ${outcome.done} — some messages weren't deleted`
-							: "Couldn't delete these messages",
-						"The delete didn't finish.",
+						bulkActionFailureTitle(action.kind, outcome.done),
+						bulkActionFailureDetail(action.kind),
 						outcome.error,
 					),
 				);
 			}
 			if (outcome.done > 0) {
-				invalidateAfterDelete();
+				invalidateAfterRun(action);
 			}
 			return outcome;
 		},
-		[deleteBatch, fetchIdsPage, phase, pushError, invalidateAfterDelete],
+		[applyBatchFor, fetchIdsPage, phase, pushError, invalidateAfterRun],
 	);
 
 	return {
@@ -241,8 +300,9 @@ export const useEscalatedDelete = ({
 		escalate,
 		stop,
 		clear,
-		isDeleting,
-		deleteProgress,
-		runDelete,
+		isRunning: runningAction !== undefined,
+		runningAction,
+		progress,
+		runAction,
 	};
 };

package/src/hooks/useSelection.test.ts

@@ -216,7 +216,7 @@ describe("intersectSelectedIds", () => {
 	});
 
 	test("a post-delete retry selection survives a refetch that still contains it, minus what actually left", () => {
-		// Mirrors processDeleteOutcome materializing the failed ids as the new
+		// Mirrors processRunOutcome materializing the failed ids as the new
 		// selection, then the cache-invalidation refetch running this same
 		// intersection against the freshly reloaded `threads`. One retry id
 		// ("fail-2") is momentarily missing from the refreshed page; the other

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

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import {
+	type BulkActionKind,
+	bulkActionCompletionText,
+	bulkActionFailureDetail,
+	bulkActionFailureTitle,
+	bulkActionPartialText,
+	bulkActionProgressLabel,
+	bulkActionProgressTone,
+} from "./bulk-action-copy.js";
+
+const kinds: BulkActionKind[] = ["delete", "move", "markRead"];
+
+describe("bulkActionProgressLabel", () => {
+	test("names the action and both counts", () => {
+		assert.equal(
+			bulkActionProgressLabel("delete", 1200, 3412),
+			"Deleting 1,200 of 3,412…",
+		);
+		assert.equal(
+			bulkActionProgressLabel("move", 1200, 3412),
+			"Moving 1,200 of 3,412…",
+		);
+		assert.equal(
+			bulkActionProgressLabel("markRead", 1200, 3412),
+			"Marking 1,200 of 3,412 as read…",
+		);
+	});
+});
+
+describe("bulkActionCompletionText", () => {
+	test("says what happened and that the server is still applying it", () => {
+		assert.equal(
+			bulkActionCompletionText("delete", 3412),
+			"3,412 moved to Trash. Your mail server is still catching up.",
+		);
+		assert.equal(
+			bulkActionCompletionText("move", 3412),
+			"3,412 moved. Your mail server is still catching up.",
+		);
+		assert.equal(
+			bulkActionCompletionText("markRead", 3412),
+			"3,412 marked as read. Your mail server is still catching up.",
+		);
+	});
+});
+
+describe("bulkActionPartialText", () => {
+	test("splits what landed from what is still selected", () => {
+		assert.equal(
+			bulkActionPartialText("delete", 3072, 340),
+			"3,072 moved to Trash. 340 couldn't be deleted.",
+		);
+		assert.equal(
+			bulkActionPartialText("move", 3072, 340),
+			"3,072 moved. 340 couldn't be moved.",
+		);
+		assert.equal(
+			bulkActionPartialText("markRead", 3072, 340),
+			"3,072 marked as read. 340 couldn't be marked as read.",
+		);
+	});
+});
+
+describe("bulkActionFailureTitle", () => {
+	test("reports where a partly-done run stopped", () => {
+		assert.equal(
+			bulkActionFailureTitle("move", 3072),
+			"Stopped after 3,072 — some messages couldn't be moved",
+		);
+	});
+
+	test("drops the count when nothing landed", () => {
+		assert.equal(
+			bulkActionFailureTitle("markRead", 0),
+			"Couldn't mark these messages as read",
+		);
+		assert.equal(
+			bulkActionFailureTitle("delete", 0),
+			"Couldn't delete these messages",
+		);
+	});
+});
+
+describe("every action carries its own wording", () => {
+	test("no two actions share a sentence", () => {
+		const sentences: Array<(kind: BulkActionKind) => string> = [
+			(kind) => bulkActionCompletionText(kind, 5),
+			(kind) => bulkActionPartialText(kind, 5, 2),
+			(kind) => bulkActionFailureTitle(kind, 0),
+			(kind) => bulkActionFailureTitle(kind, 5),
+			bulkActionFailureDetail,
+			(kind) => bulkActionProgressLabel(kind, 1, 2),
+		];
+		for (const render of sentences) {
+			assert.equal(new Set(kinds.map(render)).size, kinds.length);
+		}
+	});
+});
+
+describe("bulkActionProgressTone", () => {
+	test("only delete reads as destructive", () => {
+		assert.equal(bulkActionProgressTone("delete"), "danger");
+		assert.equal(bulkActionProgressTone("move"), "info");
+		assert.equal(bulkActionProgressTone("markRead"), "info");
+	});
+});

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

@@ -0,0 +1,85 @@
+import { formatNumber } from "@/lib/format";
+
+/**
+ * Wording for the three bulk actions a selection can run (#114). One place
+ * per sentence the selection bar, the completion banner and the error banner
+ * can say, so a new action is a row in these tables rather than a branch in
+ * every caller.
+ */
+export type BulkActionKind = "delete" | "move" | "markRead";
+
+const progressPhrase: Record<
+	BulkActionKind,
+	(done: string, total: string) => string
+> = {
+	delete: (done, total) => `Deleting ${done} of ${total}…`,
+	move: (done, total) => `Moving ${done} of ${total}…`,
+	markRead: (done, total) => `Marking ${done} of ${total} as read…`,
+};
+
+const pastTense: Record<BulkActionKind, string> = {
+	delete: "moved to Trash",
+	move: "moved",
+	markRead: "marked as read",
+};
+
+const negated: Record<BulkActionKind, string> = {
+	delete: "couldn't be deleted",
+	move: "couldn't be moved",
+	markRead: "couldn't be marked as read",
+};
+
+const failureTitle: Record<BulkActionKind, string> = {
+	delete: "Couldn't delete these messages",
+	move: "Couldn't move these messages",
+	markRead: "Couldn't mark these messages as read",
+};
+
+const failureDetail: Record<BulkActionKind, string> = {
+	delete: "The delete didn't finish.",
+	move: "The move didn't finish.",
+	markRead: "The update didn't finish.",
+};
+
+/** Running status while a chunked or escalated run is in flight. */
+export const bulkActionProgressLabel = (
+	kind: BulkActionKind,
+	done: number,
+	total: number,
+): string => progressPhrase[kind](formatNumber(done), formatNumber(total));
+
+/**
+ * Shown once a run finishes with nothing left over. The second sentence is
+ * the honest part: the bulk endpoints enqueue the IMAP write, so the mail
+ * server is still applying it when this appears.
+ */
+export const bulkActionCompletionText = (
+	kind: BulkActionKind,
+	done: number,
+): string =>
+	`${formatNumber(done)} ${pastTense[kind]}. Your mail server is still catching up.`;
+
+/** Shown when part of a run landed and the rest is still selected for Retry. */
+export const bulkActionPartialText = (
+	kind: BulkActionKind,
+	succeeded: number,
+	remaining: number,
+): string =>
+	`${formatNumber(succeeded)} ${pastTense[kind]}. ${formatNumber(remaining)} ${negated[kind]}.`;
+
+/** Error-banner title for a run stopped by an infrastructure failure. */
+export const bulkActionFailureTitle = (
+	kind: BulkActionKind,
+	done: number,
+): string =>
+	done > 0
+		? `Stopped after ${formatNumber(done)} — some messages ${negated[kind]}`
+		: failureTitle[kind];
+
+export const bulkActionFailureDetail = (kind: BulkActionKind): string =>
+	failureDetail[kind];
+
+/** Progress-bar tone: only delete is destructive. */
+export const bulkActionProgressTone = (
+	kind: BulkActionKind,
+): "danger" | "info" => (kind === "delete" ? "danger" : "info");