@remit/backend 0.0.110 → 0.0.112

package/package.json

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

package/src/handlers/address.test.ts

@@ -1,6 +1,14 @@
 import assert from "node:assert/strict";
 import { afterEach, describe, it } from "node:test";
-import type { AddressItem, ResultList } from "@remit/data-ports";
+import type {
+	AddressResponse,
+	UpdateAddressInput,
+} from "@remit/api-openapi-types";
+import type {
+	AddressItem,
+	FlagsMergePatch,
+	ResultList,
+} from "@remit/data-ports";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import type { Context } from "openapi-backend";
 import { deriveAccountConfigId } from "../auth.js";
@@ -9,7 +17,7 @@ import {
 	type RemitClient,
 	setClient,
 } from "../service/data-client.js";
-import { AddressOperations } from "./address.js";
+import { AddressDetailOperations, AddressOperations } from "./address.js";
 
 const searchAddresses =
 	AddressOperations.AddressOperations_searchAddresses as unknown as (
@@ -17,6 +25,12 @@ const searchAddresses =
 		event: APIGatewayProxyEvent,
 	) => Promise<ResultList<AddressItem>>;
 
+const updateAddress =
+	AddressDetailOperations.AddressDetailOperations_updateAddress as unknown as (
+		context: Context,
+		event: APIGatewayProxyEvent,
+	) => Promise<AddressResponse>;
+
 const SUB = "cognito-sub-704";
 const ACCOUNT_CONFIG_ID = deriveAccountConfigId(SUB);
 
@@ -130,3 +144,102 @@ describe("AddressOperations_searchAddresses", () => {
 		assert.equal(seen[0].limit, 10);
 	});
 });
+
+const updateContextFor = (body: UpdateAddressInput): Context =>
+	({
+		request: { params: { addressId: "addr-1" }, requestBody: body },
+	}) as unknown as Context;
+
+/**
+ * Fake data client that applies the same merge semantics the repo does:
+ * a `null` in the patch deletes the key, anything else writes it.
+ */
+const clientHolding = (
+	stored: AddressItem,
+	seen: FlagsMergePatch[],
+): RemitClient =>
+	({
+		address: {
+			getAddress: async (): Promise<AddressItem> => stored,
+			mergeFlags: async (
+				_accountConfigId: string,
+				_addressId: string,
+				patch: FlagsMergePatch,
+			): Promise<AddressItem> => {
+				seen.push(patch);
+				const flags: Record<string, unknown> = { ...(stored.flags ?? {}) };
+				for (const [key, value] of Object.entries(patch)) {
+					if (value === undefined) continue;
+					if (value === null) delete flags[key];
+					else flags[key] = value;
+				}
+				return { ...stored, flags } as AddressItem;
+			},
+		},
+	}) as unknown as RemitClient;
+
+describe("AddressDetailOperations_updateAddress removing a flag (#615)", () => {
+	it("clears the category override, which has no false-equivalent value to send", async () => {
+		const seen: FlagsMergePatch[] = [];
+		setClient(
+			clientHolding(
+				address({
+					flags: { category: { value: "newsletter", setAt: 10 } },
+				}),
+				seen,
+			),
+		);
+
+		const response = await updateAddress(
+			updateContextFor({ clearFlags: ["category"] }),
+			eventFor(SUB),
+		);
+
+		assert.deepEqual(seen, [{ category: null }]);
+		assert.equal(response.flags.category, undefined);
+	});
+
+	it("clears a boolean flag by the same route, leaving the untouched ones alone", async () => {
+		const seen: FlagsMergePatch[] = [];
+		setClient(
+			clientHolding(
+				address({
+					flags: {
+						muted: { value: true, setAt: 10 },
+						vip: { value: true, setAt: 11 },
+					},
+				}),
+				seen,
+			),
+		);
+
+		const response = await updateAddress(
+			updateContextFor({ clearFlags: ["muted"] }),
+			eventFor(SUB),
+		);
+
+		assert.equal(response.flags.muted, undefined);
+		assert.deepEqual(response.flags.vip, { value: true, setAt: 11 });
+	});
+
+	it("removes a key named in both halves, because clearFlags is applied last", async () => {
+		const seen: FlagsMergePatch[] = [];
+		setClient(
+			clientHolding(
+				address({ flags: { muted: { value: true, setAt: 10 } } }),
+				seen,
+			),
+		);
+
+		const response = await updateAddress(
+			updateContextFor({
+				flags: { muted: { value: true, setAt: 20 } },
+				clearFlags: ["muted"],
+			}),
+			eventFor(SUB),
+		);
+
+		assert.deepEqual(seen, [{ muted: null }]);
+		assert.equal(response.flags.muted, undefined);
+	});
+});

package/src/handlers/address.ts

@@ -4,6 +4,7 @@ import type {
 } from "@remit/api-openapi-types";
 import type { AddressItem, FlagsMergePatch } from "@remit/data-ports";
 import { ForbiddenError } from "@remit/data-ports/errors";
+import { AddressFlagKey } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import type { Context } from "openapi-backend";
 import { getAccountConfigIdFromEvent } from "../auth.js";
@@ -31,39 +32,43 @@ export const toAddressResponse = (item: AddressItem): AddressResponse => ({
 	updatedAt: item.updatedAt,
 });
 
-const FLAG_KEYS = [
-	"trusted",
-	"blocked",
-	"muted",
-	"vip",
-	"junkOnly",
-	"category",
-	"autoArchive",
-	"unsubscribed",
-] as const;
+type FlagKey = (typeof AddressFlagKey)[keyof typeof AddressFlagKey];
 
-type FlagKey = (typeof FLAG_KEYS)[number];
+const FLAG_KEYS = Object.values(AddressFlagKey) as readonly FlagKey[];
 
 /**
- * Translate the wire-format `UpdateAddressFlagsInput` into a service-level
+ * Translate the wire-format `UpdateAddressInput` into a service-level
  * `FlagsMergePatch`. Only known flag keys are forwarded; unknown keys are
  * silently dropped (a TypeSpec-only schema means unknown keys are a client
- * bug, not a security risk). `null` becomes the explicit "remove" signal.
+ * bug, not a security risk).
+ *
+ * `clearFlags` is the removal form for every flag whatever its value type, and
+ * is applied after `flags`, so a key named in both ends up removed. The `null`
+ * alternative on a flag key stays honoured for callers that can express it,
+ * but it is unreachable over OAS 3.0: TypeSpec emits a nullable `$ref` as
+ * `allOf`, and the request validator drops the `nullable` there.
  */
 export const buildFlagsPatch = (
-	input: UpdateAddressInput["flags"] | undefined,
+	input: UpdateAddressInput | undefined,
 ): FlagsMergePatch => {
 	if (!input) return {};
 	const patch = {} as Record<FlagKey, unknown>;
-	for (const key of FLAG_KEYS) {
-		if (!(key in input)) continue;
-		const value = (input as Record<FlagKey, unknown>)[key];
-		if (value === null) {
-			patch[key] = null;
-			continue;
+	const flags = input.flags;
+	if (flags) {
+		for (const key of FLAG_KEYS) {
+			if (!(key in flags)) continue;
+			const value = (flags as Record<FlagKey, unknown>)[key];
+			if (value === null) {
+				patch[key] = null;
+				continue;
+			}
+			if (value === undefined) continue;
+			patch[key] = value;
 		}
-		if (value === undefined) continue;
-		patch[key] = value;
+	}
+	for (const key of input.clearFlags ?? []) {
+		if (!FLAG_KEYS.includes(key)) continue;
+		patch[key] = null;
 	}
 	return patch as FlagsMergePatch;
 };
@@ -122,7 +127,7 @@ export const AddressDetailOperations: Record<
 			throw new ForbiddenError(`Address ${addressId} not in account config`);
 		}
 
-		const patch = buildFlagsPatch(body.flags);
+		const patch = buildFlagsPatch(body);
 		if (Object.keys(patch).length === 0) {
 			return toAddressResponse(existing);
 		}

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,
 		});