@remit/backend 0.0.142 → 0.0.144

package/src/handlers/address.test.ts

@@ -1,381 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it, mock } from "node:test";
-import type { SendMessageCommand } from "@aws-sdk/client-sqs";
-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";
-import {
-	_resetForTest,
-	type RemitClient,
-	setClient,
-} from "../service/data-client.js";
-import { sqsClient } from "../service/sqs.js";
-import { AddressDetailOperations, AddressOperations } from "./address.js";
-
-const searchAddresses =
-	AddressOperations.AddressOperations_searchAddresses as unknown as (
-		context: Context,
-		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);
-
-const eventFor = (sub: string): APIGatewayProxyEvent =>
-	({
-		requestContext: { authorizer: { claims: { sub } } },
-	}) as unknown as APIGatewayProxyEvent;
-
-const contextFor = (query: { q: string; limit?: number }): Context =>
-	({ request: { query } }) as unknown as Context;
-
-const address = (over: Partial<AddressItem>): AddressItem =>
-	({
-		addressId: "addr-1",
-		accountConfigId: ACCOUNT_CONFIG_ID,
-		localPart: "amsterdam",
-		domain: "pocahondas.nl",
-		normalizedEmail: "amsterdam@pocahondas.nl",
-		normalizedCompound: "pocahondas locatie amsterdam amsterdam@pocahondas.nl",
-		displayName: "Pocahondas locatie amsterdam",
-		flags: {},
-		inboundCount: 4,
-		outboundCount: 1,
-		replyCount: 2,
-		lastInboundAt: 1_000,
-		lastReplyAt: 900,
-		createdAt: 100,
-		updatedAt: 200,
-		...over,
-	}) as AddressItem;
-
-interface Listing {
-	accountConfigId: string;
-	search?: string;
-	limit?: number;
-}
-
-const clientReturning = (items: AddressItem[], seen: Listing[]): RemitClient =>
-	({
-		address: {
-			listByAccountConfig: async (
-				input: Listing,
-			): Promise<ResultList<AddressItem>> => {
-				seen.push(input);
-				return { items, continuationToken: undefined };
-			},
-		},
-	}) as unknown as RemitClient;
-
-afterEach(() => {
-	mock.restoreAll();
-	_resetForTest();
-});
-
-describe("AddressOperations_searchAddresses", () => {
-	it("looks a partial term up against the caller's own addresses (#704)", async () => {
-		const seen: Listing[] = [];
-		setClient(clientReturning([address({})], seen));
-
-		const response = await searchAddresses(
-			contextFor({ q: "Po", limit: 8 }),
-			eventFor(SUB),
-		);
-
-		assert.deepEqual(seen, [
-			{ accountConfigId: ACCOUNT_CONFIG_ID, search: "po", limit: 8 },
-		]);
-		assert.deepEqual(
-			response.items.map((item) => item.normalizedEmail),
-			["amsterdam@pocahondas.nl"],
-		);
-		assert.equal(response.items[0].displayName, "Pocahondas locatie amsterdam");
-	});
-
-	it("hands the suggestion list back in the order it was ranked", async () => {
-		const seen: Listing[] = [];
-		setClient(
-			clientReturning(
-				[
-					address({
-						addressId: "addr-frequent",
-						normalizedEmail: "zoe@pocahondas.nl",
-					}),
-					address({
-						addressId: "addr-stranger",
-						normalizedEmail: "aaron@pocahondas.nl",
-						inboundCount: 0,
-						replyCount: 0,
-					}),
-				],
-				seen,
-			),
-		);
-
-		const response = await searchAddresses(
-			contextFor({ q: "po" }),
-			eventFor(SUB),
-		);
-
-		assert.deepEqual(
-			response.items.map((item) => item.addressId),
-			["addr-frequent", "addr-stranger"],
-		);
-	});
-
-	it("asks for a suggestion-sized window when the caller names no limit", async () => {
-		const seen: Listing[] = [];
-		setClient(clientReturning([], seen));
-
-		await searchAddresses(contextFor({ q: "po" }), eventFor(SUB));
-
-		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;
-
-/**
- * The never-spam grant (#605) travels the same route every other flag does. The
- * exclusivity against `blocked` is not asserted here: it lives in the repo's
- * merge fold, the only place that sees both keys at once.
- */
-describe("AddressDetailOperations_updateAddress never-spam (#605)", () => {
-	it("forwards the grant to the merge patch and hands it back on the address", async () => {
-		const seen: FlagsMergePatch[] = [];
-		setClient(clientHolding(address({ flags: {} }), seen));
-
-		const response = await updateAddress(
-			updateContextFor({ flags: { neverSpam: { value: true, setAt: 20 } } }),
-			eventFor(SUB),
-		);
-
-		assert.deepEqual(seen, [{ neverSpam: { value: true, setAt: 20 } }]);
-		assert.deepEqual(response.flags.neverSpam, { value: true, setAt: 20 });
-	});
-
-	it("clears the grant by naming the key, the removal form every flag shares", async () => {
-		const seen: FlagsMergePatch[] = [];
-		setClient(
-			clientHolding(
-				address({ flags: { neverSpam: { value: true, setAt: 10 } } }),
-				seen,
-			),
-		);
-
-		const response = await updateAddress(
-			updateContextFor({ clearFlags: ["neverSpam"] }),
-			eventFor(SUB),
-		);
-
-		assert.deepEqual(seen, [{ neverSpam: null }]);
-		assert.equal(response.flags.neverSpam, undefined);
-	});
-});
-
-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);
-	});
-});
-
-/**
- * The retroactive half of a sender-category override (#415). Setting the flag
- * enqueues one back-apply carrying the category it was set to; clearing it —
- * the revert-to-auto route — enqueues nothing, because the classifier's own
- * answer for mail already filed cannot be re-derived without every body.
- */
-describe("AddressDetailOperations_updateAddress category back-apply (#415)", () => {
-	const withStubbedQueue = (enqueued: SendMessageCommand[]): void => {
-		process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
-			"http://localhost:9324/queue/account-fanout-test";
-		mock.method(sqsClient, "send", async (command: SendMessageCommand) => {
-			enqueued.push(command);
-			return {};
-		});
-	};
-
-	it("enqueues a back-apply naming the sender and the set it was fired for", async () => {
-		const enqueued: SendMessageCommand[] = [];
-		withStubbedQueue(enqueued);
-		setClient(clientHolding(address({ flags: {} }), []));
-
-		await updateAddress(
-			updateContextFor({
-				flags: { category: { value: "newsletter", setAt: 20 } },
-			}),
-			eventFor(SUB),
-		);
-
-		assert.equal(enqueued.length, 1);
-		assert.deepEqual(JSON.parse(String(enqueued[0]?.input.MessageBody)), {
-			type: "SenderCategoryBackApply",
-			accountConfigId: ACCOUNT_CONFIG_ID,
-			addressId: "addr-1",
-			normalizedEmail: "amsterdam@pocahondas.nl",
-			category: "newsletter",
-			categorySetAt: 20,
-		});
-	});
-
-	it("says the override is saved and names the retry when the queue refuses", async () => {
-		process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
-			"http://localhost:9324/queue/account-fanout-test";
-		mock.method(sqsClient, "send", async () => {
-			throw new Error("AWS.SimpleQueueService.NonExistentQueue");
-		});
-		setClient(clientHolding(address({ flags: {} }), []));
-
-		await assert.rejects(
-			updateAddress(
-				updateContextFor({
-					flags: { category: { value: "newsletter", setAt: 20 } },
-				}),
-				eventFor(SUB),
-			),
-			(error: Error) => {
-				assert.match(error.message, /saved/);
-				assert.match(error.message, /same category again/);
-				return true;
-			},
-		);
-	});
-
-	it("enqueues nothing when the override is cleared back to auto", async () => {
-		const enqueued: SendMessageCommand[] = [];
-		withStubbedQueue(enqueued);
-		setClient(
-			clientHolding(
-				address({ flags: { category: { value: "newsletter", setAt: 10 } } }),
-				[],
-			),
-		);
-
-		const response = await updateAddress(
-			updateContextFor({ clearFlags: ["category"] }),
-			eventFor(SUB),
-		);
-
-		assert.equal(response.flags.category, undefined);
-		assert.deepEqual(enqueued, []);
-	});
-
-	it("enqueues nothing for a flag that has no bearing on classification", async () => {
-		const enqueued: SendMessageCommand[] = [];
-		withStubbedQueue(enqueued);
-		setClient(clientHolding(address({ flags: {} }), []));
-
-		await updateAddress(
-			updateContextFor({ flags: { muted: { value: true, setAt: 20 } } }),
-			eventFor(SUB),
-		);
-
-		assert.deepEqual(enqueued, []);
-	});
-});

package/src/handlers/address.ts

@@ -1,200 +0,0 @@
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
-import type {
-	AddressResponse,
-	UpdateAddressInput,
-} from "@remit/api-openapi-types";
-import type {
-	AddressFlags,
-	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 { env } from "expect-env";
-import type { Context } from "openapi-backend";
-import { getAccountConfigIdFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
-import { sqsClient } from "../service/sqs.js";
-import type {
-	AddressDetailOperationIds,
-	AddressOperationIds,
-	OperationHandler,
-} from "../types.js";
-
-export const toAddressResponse = (item: AddressItem): AddressResponse => ({
-	addressId: item.addressId,
-	accountConfigId: item.accountConfigId,
-	displayName: item.displayName,
-	localPart: item.localPart,
-	domain: item.domain,
-	normalizedEmail: item.normalizedEmail,
-	flags: item.flags ?? {},
-	inboundCount: item.inboundCount ?? 0,
-	outboundCount: item.outboundCount ?? 0,
-	replyCount: item.replyCount ?? 0,
-	lastInboundAt: item.lastInboundAt ?? 0,
-	lastReplyAt: item.lastReplyAt ?? 0,
-	createdAt: item.createdAt,
-	updatedAt: item.updatedAt,
-});
-
-type FlagKey = (typeof AddressFlagKey)[keyof typeof AddressFlagKey];
-
-const FLAG_KEYS = Object.values(AddressFlagKey) as readonly FlagKey[];
-
-/**
- * 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).
- *
- * `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 | undefined,
-): FlagsMergePatch => {
-	if (!input) return {};
-	const patch = {} as Record<FlagKey, unknown>;
-	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;
-		}
-	}
-	for (const key of input.clearFlags ?? []) {
-		if (!FLAG_KEYS.includes(key)) continue;
-		patch[key] = null;
-	}
-	return patch as FlagsMergePatch;
-};
-
-/**
- * The category flag a back-apply should be enqueued for, or `undefined` when
- * this patch asks for none (issue #415).
- *
- * A SET fires one; a CLEAR — `null` in the patch, whether it came from
- * `clearFlags` or from the nullable flag value — never does. Reverting a sender
- * to auto-classification says nothing about what the classifier would have
- * answered on mail already filed, and re-deriving that would need every
- * message's body back; the revert takes effect on the sender's next message,
- * exactly as the override itself did before this.
- *
- * The whole flag, not just its value: `setAt` identifies WHICH set the job was
- * fired for, and the worker refuses to apply a job whose set is no longer the
- * one standing on the Address.
- */
-export const backApplyCategoryFlag = (
-	patch: FlagsMergePatch,
-): NonNullable<AddressFlags["category"]> | undefined => {
-	const flag = patch.category;
-	if (flag === null || flag === undefined) return undefined;
-	return flag;
-};
-
-export const AddressOperations: Record<
-	AddressOperationIds,
-	OperationHandler<AddressOperationIds>
-> = {
-	AddressOperations_searchAddresses: async (
-		context: Context,
-		...args: unknown[]
-	) => {
-		const event = args[0] as APIGatewayProxyEvent;
-		const accountConfigId = getAccountConfigIdFromEvent(event);
-		const { q, limit } = context.request.query as {
-			q: string;
-			limit?: number;
-		};
-
-		const client = await getClient();
-
-		const result = await client.address.listByAccountConfig({
-			accountConfigId,
-			search: q.toLowerCase(),
-			limit: limit ?? 10,
-		});
-
-		return {
-			items: result.items.map(toAddressResponse),
-			continuationToken: result.continuationToken,
-		};
-	},
-};
-
-export const AddressDetailOperations: Record<
-	AddressDetailOperationIds,
-	OperationHandler<AddressDetailOperationIds>
-> = {
-	AddressDetailOperations_updateAddress: async (
-		context: Context,
-		...args: unknown[]
-	) => {
-		const event = args[0] as APIGatewayProxyEvent;
-		const accountConfigId = getAccountConfigIdFromEvent(event);
-		const { addressId } = context.request.params as { addressId: string };
-		const body = (context.request.requestBody ?? {}) as UpdateAddressInput;
-
-		const client = await getClient();
-
-		// Authorize: address must belong to the caller's accountConfig
-		const existing = await client.address.getAddress(
-			accountConfigId,
-			addressId,
-		);
-		if (existing.accountConfigId !== accountConfigId) {
-			throw new ForbiddenError(`Address ${addressId} not in account config`);
-		}
-
-		const patch = buildFlagsPatch(body);
-		if (Object.keys(patch).length === 0) {
-			return toAddressResponse(existing);
-		}
-
-		const updated = await client.address.mergeFlags(
-			accountConfigId,
-			addressId,
-			patch,
-		);
-
-		const flag = backApplyCategoryFlag(patch);
-		if (flag) {
-			// The flag itself is already durable. A queue failure here costs the
-			// user the retroactive pass and nothing else, so the 500 says so and
-			// names the retry — re-sending the same category enqueues a fresh job.
-			await sqsClient
-				.send(
-					new SendMessageCommand({
-						QueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
-						MessageBody: JSON.stringify({
-							type: "SenderCategoryBackApply",
-							accountConfigId,
-							addressId,
-							normalizedEmail: updated.normalizedEmail,
-							category: flag.value,
-							categorySetAt: flag.setAt,
-						}),
-					}),
-				)
-				.catch((cause: unknown) => {
-					throw new Error(
-						`The ${flag.value} override is saved and applies to this sender's next message, but the pass over their existing mail could not be started. Setting the same category again retries it.`,
-						{ cause },
-					);
-				});
-		}
-
-		return toAddressResponse(updated);
-	},
-};