@remit/web-client 0.0.325 → 0.0.326

package/src/hooks/useDebouncedValue.ts

@@ -1,12 +0,0 @@
-import { useEffect, useState } from "react";
-
-export const useDebouncedValue = <T>(value: T, delay: number): T => {
-	const [debouncedValue, setDebouncedValue] = useState(value);
-
-	useEffect(() => {
-		const timer = setTimeout(() => setDebouncedValue(value), delay);
-		return () => clearTimeout(timer);
-	}, [value, delay]);
-
-	return debouncedValue;
-};

package/src/hooks/useDeleteFolder.ts

@@ -1,380 +0,0 @@
-import {
-	configOperationsGetConfigQueryKey,
-	mailboxOperationsListMailboxesQueryKey,
-	syncOperationsGetSyncStatusOptions,
-} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import {
-	mailboxDetailOperationsDeleteMailbox,
-	mailboxOperationsListMailboxes,
-	messageBulkOperationsMoveMessages,
-	syncOperationsTriggerSync,
-	threadOperationsListThreads,
-} from "@remit/api-http-client/sdk.gen.ts";
-import { useQueryClient } from "@tanstack/react-query";
-import { useCallback, useRef, useState } from "react";
-import {
-	advanceMove,
-	beginMove,
-	failMove,
-	MOVE_BATCH_SIZE,
-	type MoveProgress,
-} from "@/lib/delete-folder";
-import {
-	awaitFreshMailboxCount,
-	type FreshCountOutcome,
-	type MailboxCountReading,
-	mailboxSyncStamp,
-} from "@/lib/fresh-mailbox-count";
-
-const PAGE_CAP = 50;
-
-type Outcome<T> = { ok: true; value: T } | { ok: false; error: string };
-
-const errorText = (error: unknown): string =>
-	error instanceof Error ? error.message : "Something went wrong.";
-
-/**
- * Run a network call to a branchable result instead of a thrown exception, so
- * the caller can surface a failed batch to the UI without a block catch (the
- * fail-fast lint rule reserves those for rethrows).
- */
-const attempt = <T>(work: Promise<T>): Promise<Outcome<T>> =>
-	work.then(
-		(value) => ({ ok: true as const, value }),
-		(error) => ({ ok: false as const, error: errorText(error) }),
-	);
-
-/**
- * Collect up to `limit` message ids still living in the mailbox, skipping ones
- * already moved this run and anything flagged deleted. Reads fresh from the
- * server every call so a resumed or interrupted move enumerates what is
- * actually left, never a stale snapshot.
- */
-const collectMovableIds = async (
-	mailboxId: string,
-	alreadyMoved: ReadonlySet<string>,
-	limit: number,
-	signal: AbortSignal,
-): Promise<string[]> => {
-	const ids: string[] = [];
-	let continuationToken: string | undefined;
-	for (let page = 0; page < PAGE_CAP; page += 1) {
-		if (signal.aborted) return ids;
-		const { data } = await threadOperationsListThreads({
-			path: { mailboxId },
-			query: { order: "desc", continuationToken },
-			throwOnError: true,
-		});
-		for (const item of data.items) {
-			if (item.isDeleted) continue;
-			if (alreadyMoved.has(item.messageId)) continue;
-			if (ids.includes(item.messageId)) continue;
-			ids.push(item.messageId);
-			if (ids.length >= limit) return ids;
-		}
-		if (!data.continuationToken) break;
-		continuationToken = data.continuationToken;
-	}
-	return ids;
-};
-
-/**
- * Count live messages still listed in the mailbox with no `moved`-set filtering,
- * an independent read the move loop cannot fool. The delete gates on this: if any
- * message still shows here — including one that lags in the source listing after a
- * move — the folder is not emptied yet and must not be deleted.
- */
-const liveMessageCount = async (
-	mailboxId: string,
-	signal: AbortSignal,
-): Promise<number> => {
-	let count = 0;
-	let continuationToken: string | undefined;
-	for (let page = 0; page < PAGE_CAP; page += 1) {
-		if (signal.aborted) return count;
-		const { data } = await threadOperationsListThreads({
-			path: { mailboxId },
-			query: { order: "desc", continuationToken },
-			throwOnError: true,
-		});
-		for (const item of data.items) {
-			if (item.isDeleted) continue;
-			count += 1;
-		}
-		if (!data.continuationToken) break;
-		continuationToken = data.continuationToken;
-	}
-	return count;
-};
-
-export type DeleteFolderPhase =
-	| "idle"
-	| "checking"
-	| "check-stalled"
-	| "moving"
-	| "deleting"
-	| "done"
-	| "error";
-
-/**
- * What a delete-as-empty did. `blocked` carries the count that stopped it;
- * `pending` means the server has not reported yet and the user decides whether
- * to wait on; `failed` means nothing was established. Neither is ever treated
- * as empty.
- */
-export type EmptyDeleteOutcome =
-	| { status: "deleted" }
-	| { status: "blocked"; messageCount: number }
-	| { status: "pending" }
-	| { status: "failed" };
-
-interface UseDeleteFolderOptions {
-	accountId: string;
-	mailboxId: string;
-	onDeleted: () => void;
-}
-
-export function useDeleteFolder({
-	accountId,
-	mailboxId,
-	onDeleted,
-}: UseDeleteFolderOptions) {
-	const queryClient = useQueryClient();
-	const [phase, setPhase] = useState<DeleteFolderPhase>("idle");
-	const [progress, setProgress] = useState<MoveProgress | null>(null);
-	const [errorMessage, setErrorMessage] = useState<string>();
-	const [checkStartedAt, setCheckStartedAt] = useState<number>();
-	const abortRef = useRef<AbortController | null>(null);
-	/** The folder's sync stamp before the round was asked for; set while a check
-	 * is running or paused, so resuming it re-uses the same baseline. */
-	const sinceRef = useRef<number | undefined>(undefined);
-
-	const invalidate = useCallback(() => {
-		queryClient.invalidateQueries({
-			queryKey: mailboxOperationsListMailboxesQueryKey({ path: { accountId } }),
-		});
-		queryClient.invalidateQueries({
-			queryKey: configOperationsGetConfigQueryKey(),
-		});
-	}, [queryClient, accountId]);
-
-	const deleteMailbox = useCallback(async () => {
-		setPhase("deleting");
-		const outcome = await attempt(
-			mailboxDetailOperationsDeleteMailbox({
-				path: { accountId, mailboxId },
-				throwOnError: true,
-			}),
-		);
-		if (!outcome.ok) {
-			setErrorMessage(outcome.error);
-			setPhase("error");
-			return;
-		}
-		invalidate();
-		setPhase("done");
-		onDeleted();
-	}, [accountId, mailboxId, invalidate, onDeleted]);
-
-	const remainingCount = useCallback(
-		(): Promise<number> =>
-			mailboxOperationsListMailboxes({
-				path: { accountId },
-				throwOnError: true,
-			}).then(
-				({ data }) =>
-					data.items.find((box) => box.mailboxId === mailboxId)?.messageCount ??
-					0,
-			),
-		[accountId, mailboxId],
-	);
-
-	const readMailboxSyncStatus = useCallback(
-		(): Promise<readonly MailboxCountReading[]> =>
-			queryClient
-				.fetchQuery({
-					...syncOperationsGetSyncStatusOptions({ path: { accountId } }),
-					staleTime: 0,
-				})
-				.then((data) => data.mailboxes ?? []),
-		[queryClient, accountId],
-	);
-
-	/**
-	 * Delete a folder the user was told is empty. Every count the client holds is
-	 * the last sync round's, so this waits (R2 of the IMAP mutation rules) for a
-	 * round asked for here to report on the folder, and deletes only on the count
-	 * that round read. A read failure or a folder gone from the account refuses
-	 * the delete: not knowing what a folder holds is never permission.
-	 *
-	 * The round can take minutes — it fans the whole account out behind INBOX —
-	 * so the wait runs in segments. A segment that ends unreported returns
-	 * `pending` and the user decides; calling again resumes the same wait against
-	 * the same baseline, and never asks for a second round.
-	 */
-	const deleteIfEmpty = useCallback(async (): Promise<EmptyDeleteOutcome> => {
-		const controller = new AbortController();
-		abortRef.current = controller;
-		const { signal } = controller;
-		setPhase("checking");
-		setErrorMessage(undefined);
-
-		const resuming = sinceRef.current !== undefined;
-		const counted = await attempt(
-			(async (): Promise<FreshCountOutcome> => {
-				if (!resuming) {
-					signal.throwIfAborted();
-					sinceRef.current = mailboxSyncStamp(
-						await readMailboxSyncStatus(),
-						mailboxId,
-					);
-					signal.throwIfAborted();
-					setCheckStartedAt(Date.now());
-					await syncOperationsTriggerSync({
-						path: { accountId },
-						throwOnError: true,
-					});
-				}
-				return awaitFreshMailboxCount({
-					readMailboxes: readMailboxSyncStatus,
-					mailboxId,
-					since: sinceRef.current ?? 0,
-					signal,
-				});
-			})(),
-		);
-
-		if (signal.aborted) {
-			// The dialog is closing or the user cancelled; leave nothing running
-			// and no phase for a later caller to inherit.
-			setPhase("idle");
-			sinceRef.current = undefined;
-			return { status: "failed" };
-		}
-		if (!counted.ok) {
-			sinceRef.current = undefined;
-			setErrorMessage(counted.error);
-			setPhase("error");
-			return { status: "failed" };
-		}
-		if (counted.value.status === "pending") {
-			setPhase("check-stalled");
-			return { status: "pending" };
-		}
-		sinceRef.current = undefined;
-		if (counted.value.messageCount > 0) {
-			setPhase("idle");
-			invalidate();
-			return { status: "blocked", messageCount: counted.value.messageCount };
-		}
-		await deleteMailbox();
-		return { status: "deleted" };
-	}, [accountId, mailboxId, readMailboxSyncStatus, deleteMailbox, invalidate]);
-
-	const cancel = useCallback(() => {
-		abortRef.current?.abort();
-	}, []);
-
-	const moveThenDelete = useCallback(
-		async (destinationMailboxId: string) => {
-			const controller = new AbortController();
-			abortRef.current = controller;
-			const { signal } = controller;
-			setPhase("moving");
-			setErrorMessage(undefined);
-
-			const counted = await attempt(remainingCount());
-			if (signal.aborted) return;
-			if (!counted.ok) {
-				setErrorMessage(counted.error);
-				setPhase("error");
-				return;
-			}
-			let current = beginMove(counted.value);
-			setProgress(current);
-
-			const moved = new Set<string>();
-			while (true) {
-				if (signal.aborted) return;
-				const collected = await attempt(
-					collectMovableIds(mailboxId, moved, MOVE_BATCH_SIZE, signal),
-				);
-				if (signal.aborted) return;
-				if (!collected.ok) {
-					current = failMove(current, collected.error);
-					setProgress(current);
-					setErrorMessage(collected.error);
-					setPhase("error");
-					return;
-				}
-				const batch = collected.value;
-				if (batch.length === 0) break;
-
-				const movedBatch = await attempt(
-					messageBulkOperationsMoveMessages({
-						body: { messageIds: batch, destinationMailboxId },
-						throwOnError: true,
-					}),
-				);
-				if (signal.aborted) return;
-				if (!movedBatch.ok) {
-					current = failMove(current, movedBatch.error);
-					setProgress(current);
-					setErrorMessage(movedBatch.error);
-					setPhase("error");
-					return;
-				}
-				for (const id of batch) moved.add(id);
-				current = advanceMove(current, batch.length);
-				setProgress(current);
-			}
-
-			const remaining = await attempt(liveMessageCount(mailboxId, signal));
-			if (signal.aborted) return;
-			if (!remaining.ok) {
-				current = failMove(current, remaining.error);
-				setProgress(current);
-				setErrorMessage(remaining.error);
-				setPhase("error");
-				return;
-			}
-			if (remaining.value > 0) {
-				const message = `${remaining.value} ${
-					remaining.value === 1 ? "email is" : "emails are"
-				} still syncing. Re-open delete to finish removing this folder.`;
-				current = failMove(current, message);
-				setProgress(current);
-				setErrorMessage(message);
-				setPhase("error");
-				invalidate();
-				return;
-			}
-
-			await deleteMailbox();
-		},
-		[mailboxId, remainingCount, deleteMailbox, invalidate],
-	);
-
-	const reset = useCallback(() => {
-		abortRef.current?.abort();
-		abortRef.current = null;
-		sinceRef.current = undefined;
-		setPhase("idle");
-		setProgress(null);
-		setErrorMessage(undefined);
-		setCheckStartedAt(undefined);
-	}, []);
-
-	return {
-		phase,
-		progress,
-		errorMessage,
-		/** When the running check asked for its round; the surface shows the wait. */
-		checkStartedAt,
-		deleteMailbox,
-		deleteIfEmpty,
-		moveThenDelete,
-		cancel,
-		reset,
-	};
-}

package/src/hooks/useDeleteMessages.test.ts

@@ -1,62 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { dropDeletedThreads } from "./useDeleteMessages.js";
-
-const make = (
-	overrides: Partial<RemitImapThreadMessageResponse> & {
-		messageId: string;
-		threadMessageId: string;
-	},
-): RemitImapThreadMessageResponse =>
-	({
-		threadId: "t1",
-		mailboxId: "mb1",
-		subject: "s",
-		fromName: "n",
-		fromEmail: "e",
-		sentDate: "2025-01-01T00:00:00Z",
-		snippet: "",
-		hasAttachment: false,
-		hasStars: false,
-		isRead: true,
-		...overrides,
-	}) as RemitImapThreadMessageResponse;
-
-describe("dropDeletedThreads (#212)", () => {
-	// Belt-and-braces UI filter for issue #212. If the backend regresses and
-	// returns a soft-deleted row, the inbox list must still hide it. The
-	// dedicated helper makes the regression cheap to test without rendering
-	// React.
-
-	test("drops items with isDeleted=true and keeps the rest", () => {
-		const items = [
-			make({ messageId: "m1", threadMessageId: "tm1", isDeleted: false }),
-			make({ messageId: "m2", threadMessageId: "tm2", isDeleted: true }),
-			make({ messageId: "m3", threadMessageId: "tm3" }),
-		];
-		const got = dropDeletedThreads(items);
-		assert.deepStrictEqual(
-			got.map((i) => i.messageId),
-			["m1", "m3"],
-		);
-	});
-
-	test("returns the input unchanged when nothing is deleted", () => {
-		const items = [
-			make({ messageId: "m1", threadMessageId: "tm1" }),
-			make({ messageId: "m2", threadMessageId: "tm2", isDeleted: false }),
-		];
-		const got = dropDeletedThreads(items);
-		assert.equal(got.length, 2);
-	});
-
-	test("returns an empty array when every row is deleted", () => {
-		const items = [
-			make({ messageId: "m1", threadMessageId: "tm1", isDeleted: true }),
-			make({ messageId: "m2", threadMessageId: "tm2", isDeleted: true }),
-		];
-		const got = dropDeletedThreads(items);
-		assert.deepStrictEqual(got, []);
-	});
-});

package/src/hooks/useDeleteMessages.ts

@@ -1,260 +0,0 @@
-import {
-	mailboxOperationsListMailboxesQueryKey,
-	messageBulkOperationsDeleteMessagesMutation,
-	threadDetailOperationsListThreadMessagesQueryKey,
-} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { useCallback, useEffect, useRef } from "react";
-import { useRoleAppointmentPrompt } from "@/components/mail/RoleAppointmentPromptProvider";
-import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
-import { formatErrorDetail } from "@/components/ui/error-banners";
-import { isFolderRoleRefusal } from "@/components/ui/folder-role-refusal";
-import {
-	isPlacementRefusal,
-	placementRefusalBanner,
-} from "@/components/ui/placement-refusal";
-import { resolveMailboxesForMessages } from "@/hooks/useMarkAsRead";
-import { runChunkedMutation } from "@/lib/bulk-actions";
-import { softErrorStatuses } from "@/lib/error-classifier";
-import {
-	cancelThreadListQueries,
-	invalidateThreadListQueries,
-	patchThreadListQueries,
-	restoreThreadListQueries,
-	snapshotThreadListQueries,
-	type ThreadMessagesData,
-	type ThreadMutationContext,
-	threadListCacheKeys,
-} from "@/lib/thread-list-cache";
-
-interface UseDeleteMessagesOptions {
-	mailboxId: string;
-	threadId?: string;
-	accountId?: string;
-	/**
-	 * The threads the ids may come from, when the caller has them. A selection in
-	 * the brief or Flagged spans mailboxes and accounts, so the listings to patch
-	 * are the ones each message actually lives in — `mailboxId` alone would leave
-	 * every other mailbox's cached list holding a deleted row.
-	 */
-	messages?: RemitImapThreadMessageResponse[];
-	/**
-	 * Called once the optimistic removal has been applied. Use this to
-	 * navigate away from a now-empty thread (e.g. clear `selectedMessageId`)
-	 * before the server response arrives.
-	 */
-	onAfterOptimisticRemove?: (messageIds: string[]) => void;
-}
-
-/**
- * Pure helper: drop the messages in `messageIds` from a single page's items.
- *
- * Exported so the optimistic-removal math can be exercised without rendering
- * React. Other identity is preserved — only items whose `messageId` is in
- * the set are removed.
- */
-export const removeMessagesFromItems = (
-	items: RemitImapThreadMessageResponse[],
-	messageIds: Set<string>,
-): RemitImapThreadMessageResponse[] =>
-	items.filter((item) => !messageIds.has(item.messageId));
-
-/**
- * Pure helper: drop soft-deleted rows from a flattened thread list.
- *
- * Belt-and-braces guard against #212. The backend already excludes
- * `isDeleted: true` rows from the inbox listing, but if a regression slips
- * back in (or an eventual-consistency window briefly returns a soft-deleted
- * row) the UI must not show it.
- */
-export const dropDeletedThreads = (
-	items: RemitImapThreadMessageResponse[],
-): RemitImapThreadMessageResponse[] =>
-	items.filter((item) => item.isDeleted !== true);
-
-export const useDeleteMessages = ({
-	mailboxId,
-	threadId,
-	accountId,
-	messages,
-	onAfterOptimisticRemove,
-}: UseDeleteMessagesOptions) => {
-	const queryClient = useQueryClient();
-	const { pushError } = useErrorBanners();
-	const { requestAppointment } = useRoleAppointmentPrompt();
-
-	// The refused chunk is not what the user asked for. The whole selection is
-	// held here so the appointment's confirm replays all of it (#887).
-	const selectionRef = useRef<string[]>([]);
-	const runRef = useRef<(messageIds: string[]) => Promise<void>>(
-		async () => {},
-	);
-
-	const { mutateAsync, isPending } = useMutation({
-		...messageBulkOperationsDeleteMessagesMutation(),
-		// A coded 409 is answered here — the prompt, or a banner — so it must not
-		// also take the whole screen. Only 409: a 401, 403 or 5xx on a delete is
-		// still the fatal page's (#1059).
-		meta: softErrorStatuses(409),
-		onMutate: async (variables): Promise<ThreadMutationContext> => {
-			const messageIds = new Set(variables.body.messageIds ?? []);
-
-			const threadMessagesPrefix = threadId
-				? threadDetailOperationsListThreadMessagesQueryKey({
-						path: { threadId },
-					})
-				: [];
-			// Every mailbox the deleted messages live in, plus the unified
-			// cross-account listing that backs the daily brief — deleting from the
-			// brief has to remove the row there too, not only from the per-mailbox
-			// lists (#140, part of #149).
-			const listPrefixes = threadListCacheKeys(
-				resolveMailboxesForMessages(messageIds, messages ?? [], mailboxId),
-			);
-
-			await Promise.all([
-				queryClient.cancelQueries({ queryKey: threadMessagesPrefix }),
-				cancelThreadListQueries(queryClient, listPrefixes),
-			]);
-
-			const previousThreadMessages = threadId
-				? queryClient
-						.getQueriesData<ThreadMessagesData>({
-							queryKey: threadMessagesPrefix,
-						})
-						.filter(
-							(entry): entry is [readonly unknown[], ThreadMessagesData] =>
-								entry[1] !== undefined,
-						)
-						.map(([queryKey, data]) => ({ queryKey, data }))
-				: [];
-
-			const previousThreadsList = snapshotThreadListQueries(
-				queryClient,
-				listPrefixes,
-			);
-
-			if (threadId) {
-				queryClient.setQueriesData<ThreadMessagesData>(
-					{ queryKey: threadMessagesPrefix },
-					(old) => {
-						if (!old) return old;
-						return {
-							...old,
-							items: removeMessagesFromItems(old.items, messageIds),
-						};
-					},
-				);
-			}
-
-			patchThreadListQueries(queryClient, listPrefixes, (items) =>
-				removeMessagesFromItems(items, messageIds),
-			);
-
-			onAfterOptimisticRemove?.(Array.from(messageIds));
-
-			return {
-				threadMessagesPrefix,
-				listPrefixes,
-				previousThreadMessages,
-				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) {
-					queryClient.setQueryData(entry.queryKey, entry.data);
-				}
-				restoreThreadListQueries(queryClient, context.previousThreadsList);
-			}
-			// A provenance refusal is answered by the prompt, not by a banner: the
-			// generic banner is suppressed for this one error, and every other
-			// failure keeps today's.
-			const refusal = isFolderRoleRefusal(err);
-			if (refusal) {
-				const replay = selectionRef.current;
-				requestAppointment({
-					accountId: refusal.accountId,
-					role: refusal.role,
-					reason: refusal.reason,
-					action: { kind: "delete", count: replay.length },
-					onAppointed: () => runRef.current(replay),
-				});
-				return;
-			}
-			const count = vars.body.messageIds?.length ?? 0;
-			const placement = isPlacementRefusal(err);
-			if (placement) {
-				pushError(placementRefusalBanner(placement, count, "delete"));
-				return;
-			}
-			pushError({
-				title:
-					count > 1
-						? `Couldn't delete ${count} messages`
-						: "Couldn't delete this message",
-				detail: formatErrorDetail(err),
-				error: err,
-			});
-		},
-		onSettled: (_data, _err, _vars, context) => {
-			if (!context) return;
-			if (threadId) {
-				queryClient.invalidateQueries({
-					queryKey: context.threadMessagesPrefix,
-				});
-			}
-			invalidateThreadListQueries(queryClient, context.listPrefixes);
-			if (accountId) {
-				queryClient.invalidateQueries({
-					queryKey: mailboxOperationsListMailboxesQueryKey({
-						path: { accountId },
-					}),
-				});
-			}
-		},
-	});
-
-	const runSelection = useCallback(
-		(messageIds: string[]): Promise<void> =>
-			runChunkedMutation(messageIds, (chunk) =>
-				mutateAsync({ body: { messageIds: chunk } }),
-			),
-		[mutateAsync],
-	);
-
-	useEffect(() => {
-		runRef.current = runSelection;
-	}, [runSelection]);
-
-	const deleteMessages = useCallback(
-		(messageIds: string[]) => {
-			if (messageIds.length === 0) return;
-			selectionRef.current = messageIds;
-			void runSelection(messageIds);
-		},
-		[runSelection],
-	);
-
-	return { deleteMessages, isPending };
-};