@remit/backend 0.0.111 → 0.0.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.111",
+  "version": "0.0.113",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

package/src/handlers/mailbox.ts

@@ -8,6 +8,7 @@ import {
 	type CanonicalMailboxRoleValue,
 	composeFolderRoleAppointmentLabelName,
 } from "@remit/data-ports/folder-role";
+import { rebaseMailboxPath } from "@remit/data-ports/mailbox-name";
 import { MailboxSyncStatus, MessageSystemFlag } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import { getAccountConfigIdFromEvent } from "../auth.js";
@@ -76,24 +77,6 @@ export interface MailboxPatchClient {
 	accountSetting: Pick<IAccountSettingRepository, "get" | "upsert" | "delete">;
 }
 
-/**
- * Where a recorded path lands after the rename, or `undefined` when the rename
- * did not move it. IMAP RENAME moves the whole subtree in one command and
- * `renameChildPaths` rewrites every descendant row with it, so a label under
- * the renamed branch moves exactly as far as its prefix does.
- */
-const rebasePath = (
-	recorded: string,
-	oldPath: string,
-	newPath: string,
-	delimiter: string,
-): string | undefined => {
-	if (recorded === oldPath) return newPath;
-	const branch = `${oldPath}${delimiter}`;
-	if (!recorded.startsWith(branch)) return undefined;
-	return `${newPath}${recorded.slice(oldPath.length)}`;
-};
-
 /**
  * A reader-side rename keeps every mailboxId, so the appointments survive it —
  * but the paths recorded beside them (#887) would still name where the folders
@@ -101,8 +84,8 @@ const rebasePath = (
  * names a path the user has not seen since the rename.
  *
  * The renamed folder is matched by id; its descendants are matched by the path
- * each label already holds, which is the path their rows carried until this
- * rename rewrote them.
+ * each label already holds, which is the path their rows carried until the
+ * rename intent rewrote them.
  */
 const refreshAppointmentLabels = async (
 	accountSetting: Pick<IAccountSettingRepository, "get" | "upsert">,
@@ -122,7 +105,7 @@ const refreshAppointmentLabels = async (
 				? renamed.newPath
 				: appointment.lastKnownPath === undefined
 					? undefined
-					: rebasePath(
+					: rebaseMailboxPath(
 							appointment.lastKnownPath,
 							renamed.oldPath,
 							renamed.newPath,
@@ -144,8 +127,8 @@ const refreshAppointmentLabels = async (
  * Apply a mailbox PATCH body: override changes first (mute flag + display-name/
  * role overrides — written to per-mailbox AccountSetting rows, no IMAP
  * machinery), then rename — which triggers the IMAP rename machinery
- * (syncStatus/oldPath + MAILBOX_RENAME event) — only when `fullPath` is
- * present. An override-only PATCH therefore never calls
+ * (the recorded subtree intent + MAILBOX_RENAME event) — only when `fullPath`
+ * is present. An override-only PATCH therefore never calls
  * `mailboxQueue.renameMailbox`.
  */
 export const applyMailboxPatch = async (
@@ -160,8 +143,8 @@ export const applyMailboxPatch = async (
 	// --- Override settings (mute flag + display-name/role overrides) ---
 	// Written to per-mailbox AccountSetting rows (RFC 032) with the same
 	// null→remove semantics as UpdateAddressFlagsInput. Applied before (and
-	// independent of) any rename so an override-only PATCH never touches
-	// syncStatus/oldPath.
+	// independent of) any rename so an override-only PATCH never touches the
+	// row's mutation state.
 	const changes = pickMailboxOverrideChanges(body);
 	if (Object.keys(changes).length > 0) {
 		await applyMailboxOverrideChanges(
@@ -268,6 +251,11 @@ const toMailboxResponse = (
 	highWaterMarkUid: mailbox.highWaterMarkUid,
 	lastMessageSyncAt: mailbox.lastMessageSyncAt,
 	syncStatus: mailbox.syncStatus,
+	// The row is the only thing that knows what a rename is aiming at, and
+	// `fullPath` stays the confirmed one throughout (D2), so without this a
+	// client cannot tell a create in flight from a rename in flight, name the
+	// target of a failed rename, or offer the right retry.
+	pendingPath: mailbox.pendingPath,
 	muted: overrides.muted,
 	displayNameOverride: overrides.displayNameOverride,
 	createdAt: mailbox.createdAt,

package/src/handlers/unified-threads.test.ts

@@ -442,22 +442,32 @@ describe("buildSearchAllThreadsOptions", () => {
 // the pages a client happened to have loaded. Both are the query's job now.
 describe("executeUnifiedThreadListing", () => {
 	interface Call {
-		mode: "listByDate" | "listByStarred" | "searchByDate";
+		mode: "listByDate" | "listByStarred" | "searchByDate" | "count";
 		search?: SearchOptions;
 		limit?: number;
 		continuationToken?: string;
+		inboxMailboxIds?: Set<string>;
+		mailboxIds?: Set<string>;
 	}
 
 	const emptyPage = { items: [], continuationToken: undefined };
 
 	const buildListingClient = (calls: Call[], count = 0) =>
 		({
-			account: { listAllByAccountConfig: async () => [account("a1")] },
+			account: {
+				listAllByAccountConfig: async () => [account("a1"), account("a2")],
+			},
 			mailbox: {
-				listAllByAccount: async () => [
-					mailbox("m-inbox", "a1", "INBOX"),
-					mailbox("m-archive", "a1", "Archive"),
-				],
+				listAllByAccount: async (accountId: string) =>
+					accountId === "a1"
+						? [
+								mailbox("m-inbox", "a1", "INBOX"),
+								mailbox("m-archive", "a1", "Archive"),
+							]
+						: [
+								mailbox("m2-inbox", "a2", "INBOX"),
+								mailbox("m2-archive", "a2", "Archive"),
+							],
 			},
 			accountSetting: { listByAccountConfig: async () => [] },
 			message: { get: async () => [] },
@@ -487,7 +497,14 @@ describe("executeUnifiedThreadListing", () => {
 					calls.push({ mode: "searchByDate", search, ...options });
 					return emptyPage;
 				},
-				countThreadsInScope: async () => count,
+				countThreadsInScope: async (
+					_config: string,
+					search: SearchOptions,
+					options?: { mailboxIds?: Set<string> },
+				) => {
+					calls.push({ mode: "count", search, ...options });
+					return count;
+				},
 			},
 		}) as unknown as UnifiedThreadClient;
 
@@ -579,7 +596,10 @@ describe("executeUnifiedThreadListing", () => {
 			params({ starredOnly: true, count: true, results: false }),
 		);
 
-		assert.deepEqual(calls, []);
+		assert.deepEqual(
+			calls.map((call) => call.mode),
+			["count"],
+		);
 		assert.equal(response.items, undefined);
 		assert.equal(response.count, 7);
 	});
@@ -595,4 +615,119 @@ describe("executeUnifiedThreadListing", () => {
 		assert.equal(response.count, undefined);
 		assert.deepEqual(response.items, []);
 	});
+
+	// #1128: the one free-text parameter matches subject and From at once, so
+	// `from:` and `subject:` could not be asked for separately and the Flagged
+	// view applied both over the pages it had already fetched.
+	test("sends from and subject as their own terms", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(buildListingClient(calls), CONFIG_ID, {
+			...params({ starredOnly: true }),
+			from: "alice",
+			subject: "invoice",
+		});
+
+		assert.deepEqual(calls[0].search, {
+			from: "alice",
+			subject: "invoice",
+			starred: true,
+		});
+	});
+
+	test("blank field text asks for nothing", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(buildListingClient(calls), CONFIG_ID, {
+			...params(),
+			from: "",
+			subject: "",
+		});
+
+		assert.deepEqual(calls[0].search, {});
+	});
+
+	// #1137: the count answered a wider set than the list, because the browser
+	// dropped muted senders after the rows arrived and nothing told the server.
+	test("the muted term reaches the listing and the count alike", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(buildListingClient(calls), CONFIG_ID, {
+			...params({ count: true }),
+			muted: false,
+		});
+
+		const listing = calls.find((call) => call.mode === "listByDate");
+		const counting = calls.find((call) => call.mode === "count");
+		assert.deepEqual(listing?.search, { muted: false });
+		assert.deepEqual(counting?.search, { muted: false });
+	});
+
+	test("an unstated muted term filters nothing", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(
+			buildListingClient(calls),
+			CONFIG_ID,
+			params(),
+		);
+
+		assert.equal(Object.hasOwn(calls[0].search ?? {}, "muted"), false);
+	});
+
+	// #1136: the account pill narrowed the rows after they arrived, so a count
+	// over every account was not the size of a list showing one and the brief
+	// withheld every number rather than overstate.
+	test("an account scope narrows the listing and the count to that account", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(
+			buildListingClient(calls, 3),
+			CONFIG_ID,
+			params({ accountId: "a2", count: true }),
+		);
+
+		const listing = calls.find((call) => call.mode === "listByDate");
+		const counting = calls.find((call) => call.mode === "count");
+		assert.deepEqual([...(listing?.inboxMailboxIds ?? [])], ["m2-inbox"]);
+		assert.deepEqual([...(counting?.mailboxIds ?? [])].sort(), ["m2-inbox"]);
+	});
+
+	test("an account scope narrows the search scope too", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(buildListingClient(calls), CONFIG_ID, {
+			...params({ accountId: "a2" }),
+			searchText: "invoice",
+		});
+
+		assert.equal(calls[0].mode, "searchByDate");
+		assert.deepEqual([...(calls[0].mailboxIds ?? [])].sort(), [
+			"m2-archive",
+			"m2-inbox",
+		]);
+	});
+
+	test("no account scope leaves the cross-account aggregate", async () => {
+		const calls: Call[] = [];
+		await executeUnifiedThreadListing(
+			buildListingClient(calls),
+			CONFIG_ID,
+			params(),
+		);
+
+		assert.deepEqual([...(calls[0].inboxMailboxIds ?? [])].sort(), [
+			"m-inbox",
+			"m2-inbox",
+		]);
+	});
+
+	// An account the config does not read narrows to nothing, which is the
+	// honest answer — never the whole aggregate under another account's name.
+	test("an unknown account matches nothing", async () => {
+		const calls: Call[] = [];
+		const response = await executeUnifiedThreadListing(
+			buildListingClient(calls, 99),
+			CONFIG_ID,
+			params({ accountId: "a-other", count: true }),
+		);
+
+		assert.deepEqual(calls, []);
+		assert.deepEqual(response.items, []);
+		assert.equal(response.count, 0);
+	});
 });

package/src/handlers/unified-threads.ts

@@ -335,23 +335,62 @@ export const attachAccountIds = (
  * (#308). `starred` and `query` are in here too so one `SearchOptions` says
  * what the whole request narrows by, which is what lets the count run the same
  * predicate as the listing.
+ *
+ * `from` and `subject` name one field each, which `query` cannot — it matches
+ * both at once, so neither token could be asked for on its own and both were
+ * applied over the loaded pages instead (#1128). `muted` is the one criterion
+ * that is not a column at all: it is read from the sender's address, and it is
+ * here because a caller that hides muted mail has to be able to count what it
+ * renders (#1137).
  */
 export const buildUnifiedThreadSearch = (params: {
 	starredOnly: boolean;
 	searchText?: string;
+	from?: string;
+	subject?: string;
 	category?: MessageCategory[];
 	unread?: boolean;
 	attachments?: boolean;
+	muted?: boolean;
 }): SearchOptions => ({
 	...(params.searchText ? { query: params.searchText } : {}),
+	...(params.from ? { from: params.from } : {}),
+	...(params.subject ? { subject: params.subject } : {}),
 	...(params.starredOnly ? { starred: true } : {}),
 	...(params.category?.length ? { category: params.category } : {}),
 	...(params.unread !== undefined ? { unread: params.unread } : {}),
 	...(params.attachments !== undefined
 		? { attachments: params.attachments }
 		: {}),
+	...(params.muted !== undefined ? { muted: params.muted } : {}),
 });
 
+/**
+ * Narrow a mailbox scope to one account's mailboxes.
+ *
+ * The account pill used to narrow the rows a page returned, which took the
+ * number off every section header: a count over every account is not the size
+ * of a list showing one, so the brief withheld it rather than overstate (#1136).
+ * The scope is where the answer belongs — the listing, the search and the count
+ * all read it, so all three agree.
+ *
+ * An account with no mailboxes in the map — one that is muted, or one belonging
+ * to another config — narrows to the empty set, which matches nothing. That is
+ * the honest answer: the caller asked for an account this config does not read.
+ */
+export const scopeToAccount = (
+	mailboxIds: Set<string>,
+	mailboxIdToAccountId: Map<string, string>,
+	accountId: string | undefined,
+): Set<string> => {
+	if (accountId === undefined) return mailboxIds;
+	return new Set(
+		[...mailboxIds].filter(
+			(mailboxId) => mailboxIdToAccountId.get(mailboxId) === accountId,
+		),
+	);
+};
+
 /**
  * Minimal client surface `executeUnifiedThreadListing` needs, declared
  * structurally (like `ThreadSearchClient`) so the mode selection, the row
@@ -386,9 +425,13 @@ export type UnifiedThreadParams = {
 	limit?: number;
 	starredOnly: boolean;
 	searchText?: string;
+	from?: string;
+	subject?: string;
+	accountId?: string;
 	category?: MessageCategory[];
 	unread?: boolean;
 	attachments?: boolean;
+	muted?: boolean;
 	count: boolean;
 	results: boolean;
 };
@@ -413,12 +456,20 @@ export const executeUnifiedThreadListing = async (
 		params.searchText !== undefined && params.searchText.length > 0;
 	const {
 		mailboxIdToAccountId,
-		inboxMailboxIds,
-		starredMailboxIds,
-		searchMailboxIds,
+		inboxMailboxIds: everyInboxMailboxId,
+		starredMailboxIds: everyStarredMailboxId,
+		searchMailboxIds: everySearchMailboxId,
 		virtualCopyMailboxIds,
 	} = await buildInboxMailboxMap(accountConfigId, client);
 
+	// The account scope applies before the mode picks a set, so the listing, the
+	// search and the count all narrow by the same rule.
+	const narrow = (mailboxIds: Set<string>): Set<string> =>
+		scopeToAccount(mailboxIds, mailboxIdToAccountId, params.accountId);
+	const inboxMailboxIds = narrow(everyInboxMailboxId);
+	const starredMailboxIds = narrow(everyStarredMailboxId);
+	const searchMailboxIds = narrow(everySearchMailboxId);
+
 	// Search widens past INBOX to every folder it may reach; `starred=true`
 	// still narrows it to the starred scope, so the two compose.
 	const searchScope = params.starredOnly ? starredMailboxIds : searchMailboxIds;
@@ -527,9 +578,13 @@ export const UnifiedThreadOperations: Record<
 			limit,
 			starred,
 			query,
+			from,
+			subject,
+			accountId,
 			category,
 			unread,
 			attachments,
+			muted,
 			count,
 			results,
 		} = context.request.query as {
@@ -538,29 +593,41 @@ export const UnifiedThreadOperations: Record<
 			limit?: number;
 			starred?: boolean | string;
 			query?: string;
+			from?: string;
+			subject?: string;
+			accountId?: string;
 			category?: MessageCategory | MessageCategory[];
 			unread?: boolean | string;
 			attachments?: boolean | string;
+			muted?: boolean | string;
 			count?: boolean | string;
 			results?: boolean | string;
 		};
 
 		// Whitespace-only text is not a search: it would widen the scope to every
-		// folder while matching nothing in particular.
+		// folder while matching nothing in particular. The two field parameters
+		// are trimmed on the same rule, and neither widens the scope at all.
 		const searchText = query?.trim();
+		const fromText = from?.trim();
+		const subjectText = subject?.trim();
 
 		return executeUnifiedThreadListing(await getClient(), accountConfigId, {
 			continuationToken,
 			order,
 			limit,
-			// Absent means unstated for all five, and each says what it does with
-			// that: the three filters drop out of the predicate, `count` is off
-			// unless it is asked for, and `results` is on unless it is refused.
+			// Absent means unstated for all of them, and each says what it does with
+			// that: the row filters drop out of the predicate, the account scope
+			// stays the cross-account aggregate, `count` is off unless it is asked
+			// for, and `results` is on unless it is refused.
 			starredOnly: toBoolean(starred) === true,
 			searchText: searchText || undefined,
+			from: fromText || undefined,
+			subject: subjectText || undefined,
+			accountId: accountId || undefined,
 			category: toArray(category),
 			unread: toBoolean(unread),
 			attachments: toBoolean(attachments),
+			muted: toBoolean(muted),
 			count: toBoolean(count) === true,
 			results: toBoolean(results) !== false,
 		});