@remit/web-client 0.0.13 → 0.0.14

package/src/lib/sender-address.ts

@@ -0,0 +1,37 @@
+import type { RemitImapAddressResponse } from "@remit/api-http-client/types.gen.ts";
+
+/**
+ * `GET /addresses/search` is a prefix search over both the display-name
+ * compound and the normalized email, so a query for one sender's address can
+ * legitimately return several rows (`sup@x.com` also prefixes `support@x.com`,
+ * and any display name starting with the same characters matches too).
+ *
+ * Asking for a single row and taking `items[0]` is therefore wrong twice over:
+ * the row it returns may belong to a different sender, and the row we actually
+ * want may be past the cut. Fetch a small window instead and pick the exact
+ * address out of it.
+ */
+export const SENDER_ADDRESS_SEARCH_LIMIT = 10;
+
+/** Query params for the sender-address lookup. One shape, used by every caller. */
+export const senderAddressSearchQuery = (
+	senderEmail: string | undefined,
+): { q: string; limit: number } => ({
+	q: senderEmail?.toLowerCase() ?? "",
+	limit: SENDER_ADDRESS_SEARCH_LIMIT,
+});
+
+/**
+ * Select the address row for exactly this sender. A prefix match on another
+ * sender is not this sender, so it resolves to `undefined` rather than the
+ * wrong address — silently flagging the wrong sender is worse than not
+ * resolving.
+ */
+export const pickSenderAddress = (
+	items: RemitImapAddressResponse[] | undefined,
+	senderEmail: string | undefined,
+): RemitImapAddressResponse | undefined => {
+	if (!senderEmail) return undefined;
+	const normalized = senderEmail.toLowerCase();
+	return items?.find((item) => item.normalizedEmail === normalized);
+};

package/src/lib/thread-cache.test.ts

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import {
+	isInfiniteThreadData,
+	patchThreadListCache,
+	type ThreadListCache,
+} from "./thread-cache";
+
+const message = (messageId: string): RemitImapThreadMessageResponse =>
+	({ messageId }) as RemitImapThreadMessageResponse;
+
+const drop = (id: string) => (items: RemitImapThreadMessageResponse[]) =>
+	items.filter((item) => item.messageId !== id);
+
+describe("isInfiniteThreadData", () => {
+	it("recognises only the paged shape", () => {
+		assert.equal(isInfiniteThreadData({ pages: [], pageParams: [] }), true);
+		assert.equal(isInfiniteThreadData({ items: [] }), false);
+		assert.equal(isInfiniteThreadData(undefined), false);
+		assert.equal(isInfiniteThreadData(null), false);
+	});
+});
+
+describe("patchThreadListCache", () => {
+	it("patches every page of an infinite query", () => {
+		const cache: ThreadListCache = {
+			pages: [
+				{ items: [message("a"), message("b")] },
+				{ items: [message("c")] },
+			],
+			pageParams: [undefined, "next"],
+		};
+
+		const patched = patchThreadListCache(cache, drop("b"));
+
+		assert.deepEqual(patched, {
+			pages: [{ items: [message("a")] }, { items: [message("c")] }],
+			pageParams: [undefined, "next"],
+		});
+	});
+
+	it("patches a single-shot page, which shares the query-key prefix", () => {
+		// The rescue-candidate search caches this shape under the same prefix the
+		// mailbox list uses. An updater that assumed `pages` threw here, failing
+		// the whole mutation before it ever reached the server (issues #51, #55).
+		const cache: ThreadListCache = {
+			items: [message("a"), message("b")],
+			continuationToken: "t",
+		};
+
+		const patched = patchThreadListCache(cache, drop("a"));
+
+		assert.deepEqual(patched, {
+			items: [message("b")],
+			continuationToken: "t",
+		});
+	});
+
+	it("leaves an unrecognised entry alone instead of throwing", () => {
+		const cache = { total: 3 } as unknown as ThreadListCache;
+		assert.equal(patchThreadListCache(cache, drop("a")), cache);
+		assert.equal(patchThreadListCache(undefined, drop("a")), undefined);
+	});
+});

package/src/lib/thread-cache.ts

@@ -0,0 +1,76 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+
+/**
+ * Optimistic patching of the thread caches.
+ *
+ * `queryClient.setQueriesData({ queryKey: prefix }, …)` matches by key *prefix*,
+ * so an updater written for the mailbox list also runs against every other
+ * cached query sharing that prefix. Those do not all have the same shape: the
+ * mailbox list is an infinite query (`{ pages: [{ items }] }`) while
+ * single-shot readers of the same endpoint — the rescue-candidate search, for
+ * one — cache a plain page (`{ items }`). An updater that assumed the infinite
+ * shape threw `pages is undefined` inside `onMutate`, which React Query reports
+ * as a failed mutation: the move never fired and the user got an error toast
+ * for an action that was never attempted (issues #51, #55).
+ *
+ * `patchThreadListCache` handles both shapes and leaves anything else it does
+ * not recognise untouched.
+ */
+
+export interface ThreadItemsPage {
+	items: RemitImapThreadMessageResponse[];
+	[key: string]: unknown;
+}
+
+export interface InfiniteThreadData {
+	pages: ThreadItemsPage[];
+	pageParams: Array<string | undefined>;
+}
+
+/** Either cached shape served by the thread list/search endpoints. */
+export type ThreadListCache = InfiniteThreadData | ThreadItemsPage;
+
+export const isInfiniteThreadData = (
+	data: unknown,
+): data is InfiniteThreadData =>
+	typeof data === "object" &&
+	data !== null &&
+	Array.isArray((data as { pages?: unknown }).pages);
+
+const isThreadItemsPage = (data: unknown): data is ThreadItemsPage =>
+	typeof data === "object" &&
+	data !== null &&
+	Array.isArray((data as { items?: unknown }).items);
+
+/**
+ * Apply `patchItems` to every list of thread messages inside a cache entry,
+ * whichever shape it holds.
+ *
+ * `old` is `unknown` because that is the truth: a prefix match hands this
+ * whatever happens to be cached under that prefix, and the two shapes below are
+ * the ones we know about today, not the ones we are guaranteed. Declaring a
+ * narrower parameter type is what produced the original bug — the type asserted
+ * a shape the runtime never promised, and the first entry that disagreed threw.
+ * Anything unrecognised is returned untouched.
+ */
+export const patchThreadListCache = (
+	old: unknown,
+	patchItems: (
+		items: RemitImapThreadMessageResponse[],
+	) => RemitImapThreadMessageResponse[],
+): unknown => {
+	if (old === undefined) return old;
+	if (isInfiniteThreadData(old)) {
+		return {
+			...old,
+			pages: old.pages.map((page) => ({
+				...page,
+				items: patchItems(page.items),
+			})),
+		};
+	}
+	if (isThreadItemsPage(old)) {
+		return { ...old, items: patchItems(old.items) };
+	}
+	return old;
+};