@remit/backend 0.0.142 → 0.0.144

package/src/handlers/mailbox-settled-target.test.ts

@@ -1,251 +0,0 @@
-/**
- * Every API write that binds a durable reference to a folder requires that
- * folder to be settled (D12, first row; imap-mutations R2: wait). Driven
- * through the real handlers rather than the helper, because the claim is that
- * each call site is wired to it — a helper that nothing calls refuses nothing.
- *
- * The other half of the same invariant is the delete refusal (D16), in
- * `mailbox.test.ts`: a binding is only created against a settled folder and
- * only removed by the user, so a `mailboxId` that names nothing never exists.
- */
-import assert from "node:assert/strict";
-import { afterEach, describe, it, mock } from "node:test";
-import type { MailboxItem } from "@remit/data-ports";
-import { CanonicalMailboxRole, MailboxSyncStatus } from "@remit/domain-enums";
-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 { FilterDetailOperations, FilterOperations } from "./filter.js";
-import { FolderRoleOperations } from "./folder-role.js";
-import { MessageBulkOperations } from "./message.js";
-
-const SUB = "cognito-sub-365";
-const ACCOUNT_ID = "acc-365";
-const CONFIG_ID = deriveAccountConfigId(SUB);
-const TARGET = "mbx-target";
-
-const target = (syncStatus: MailboxItem["syncStatus"]): MailboxItem =>
-	({
-		mailboxId: TARGET,
-		accountId: ACCOUNT_ID,
-		fullPath: "Receipts",
-		hierarchyDelimiter: "/",
-		syncStatus,
-	}) as MailboxItem;
-
-interface Writes {
-	filters: unknown[];
-	filterPatches: unknown[];
-	appointments: unknown[];
-	moves: unknown[];
-	copies: unknown[];
-}
-
-const world = (syncStatus: MailboxItem["syncStatus"]): Writes => {
-	const writes: Writes = {
-		filters: [],
-		filterPatches: [],
-		appointments: [],
-		moves: [],
-		copies: [],
-	};
-	const row = target(syncStatus);
-	process.env.SQS_QUEUE_URL_ACCOUNT_FANOUT =
-		"http://localhost:9324/queue/account-fanout-test";
-	mock.method(sqsClient, "send", async () => ({}));
-
-	setClient({
-		account: {
-			get: async () => ({ accountId: ACCOUNT_ID, accountConfigId: CONFIG_ID }),
-			listAllByAccountConfig: async () => [{ accountId: ACCOUNT_ID }],
-		},
-		mailbox: {
-			get: async (_accountId: string, mailboxId: string | string[]) =>
-				Array.isArray(mailboxId)
-					? mailboxId.map((id) => ({ mailboxId: id, accountId: ACCOUNT_ID }))
-					: row,
-			listAllByAccount: async () => [row],
-		},
-		message: {
-			get: async () => ({ mailboxId: "mbx-source" }),
-		},
-		filter: {
-			get: async () => ({ filterId: "flt-1", scope: "Standing" }),
-			update: async (...args: unknown[]) => {
-				writes.filterPatches.push(args);
-				return { filterId: "flt-1" };
-			},
-			listByAccountConfig: async () => [],
-		},
-		filterAnchorTransaction: {
-			createWithAnchor: async (input: unknown) => {
-				writes.filters.push(input);
-				return { filterId: "flt-1" };
-			},
-		},
-		organizeJobRequest: {
-			create: async (input: Record<string, unknown>) => ({
-				...input,
-				organizeJobId: "job-1",
-				state: "Pending",
-			}),
-		},
-		accountSetting: {
-			get: async () => null,
-			upsert: async (item: unknown) => {
-				writes.appointments.push(item);
-				return item;
-			},
-			delete: async () => undefined,
-		},
-		messageMove: {
-			moveMessages: async (...args: unknown[]) => {
-				writes.moves.push(args);
-			},
-			copyMessages: async (...args: unknown[]) => {
-				writes.copies.push(args);
-			},
-		},
-	} as unknown as RemitClient);
-
-	return writes;
-};
-
-const event = {
-	requestContext: { authorizer: { claims: { sub: SUB } } },
-} as unknown as APIGatewayProxyEvent;
-
-const call = <T>(
-	handler: unknown,
-	request: Record<string, unknown>,
-): Promise<T> =>
-	(handler as (context: Context, event: APIGatewayProxyEvent) => Promise<T>)(
-		{ request } as unknown as Context,
-		event,
-	);
-
-const appoint = () =>
-	call(FolderRoleOperations.FolderRoleOperations_appointFolderRole, {
-		params: { accountId: ACCOUNT_ID, role: CanonicalMailboxRole.Archive },
-		requestBody: { mailboxId: TARGET },
-	});
-
-const createFilter = () =>
-	call(FilterOperations.FilterOperations_createFilter, {
-		params: { accountId: ACCOUNT_ID },
-		requestBody: {
-			name: "Invoices",
-			scope: "Standing",
-			actionMailboxId: TARGET,
-		},
-	});
-
-const updateFilter = () =>
-	call(FilterDetailOperations.FilterDetailOperations_updateFilter, {
-		params: { accountId: ACCOUNT_ID, filterId: "flt-1" },
-		requestBody: { actionMailboxId: TARGET },
-	});
-
-const moveMessages = () =>
-	call(MessageBulkOperations.MessageBulkOperations_moveMessages, {
-		params: {},
-		requestBody: { messageIds: ["msg-1"], destinationMailboxId: TARGET },
-	});
-
-const copyMessages = () =>
-	call(MessageBulkOperations.MessageBulkOperations_copyMessages, {
-		params: {},
-		requestBody: { messageIds: ["msg-1"], destinationMailboxId: TARGET },
-	});
-
-const unready = (error: unknown): boolean =>
-	(error as { statusCode?: number }).statusCode === 422 &&
-	(error as { publicApiError?: { code?: string } }).publicApiError?.code ===
-		"mailbox_not_settled";
-
-const SITES = [
-	["appointing a role", appoint, (w: Writes) => w.appointments],
-	["creating a filter", createFilter, (w: Writes) => w.filters],
-	["updating a filter", updateFilter, (w: Writes) => w.filterPatches],
-	["moving messages", moveMessages, (w: Writes) => w.moves],
-	["copying messages", copyMessages, (w: Writes) => w.copies],
-] as const;
-
-describe("a write that binds to a folder requires a settled folder", () => {
-	afterEach(() => {
-		mock.restoreAll();
-		_resetForTest();
-	});
-
-	for (const [what, run, written] of SITES) {
-		for (const state of [
-			MailboxSyncStatus.pending,
-			MailboxSyncStatus.deleting,
-			MailboxSyncStatus.failed,
-		]) {
-			it(`refuses ${what} against a ${state} folder, writing nothing`, async () => {
-				const writes = world(state);
-
-				await assert.rejects(run(), unready);
-				assert.deepEqual(written(writes), []);
-			});
-		}
-
-		it(`accepts ${what} against a settled folder`, async () => {
-			const writes = world(MailboxSyncStatus.synced);
-
-			await run();
-			assert.equal(written(writes).length > 0, true);
-		});
-	}
-
-	it("never answers 409 from these paths", async () => {
-		// 409 belongs to the folder's own mutation losing a compare-and-set
-		// (#362, #363). Reusing it here would make "somebody else is changing this
-		// folder" and "the folder you are pointing at is not ready" the same
-		// answer, with different copy and different remedies behind it.
-		world(MailboxSyncStatus.pending);
-
-		await assert.rejects(
-			appoint(),
-			(error: unknown) => (error as { statusCode?: number }).statusCode !== 409,
-		);
-	});
-
-	it("does not gate clearing a role whose folder is on its way out", async () => {
-		const writes = world(MailboxSyncStatus.deleting);
-
-		await call(FolderRoleOperations.FolderRoleOperations_appointFolderRole, {
-			params: { accountId: ACCOUNT_ID, role: CanonicalMailboxRole.Archive },
-			requestBody: { mailboxId: null },
-		});
-
-		assert.deepEqual(
-			writes.appointments,
-			[],
-			"the row is deleted, not upserted",
-		);
-	});
-
-	it("does not gate a filter that applies no move action", async () => {
-		// `None` is the sentinel for "no move action", so it binds to nothing.
-		const writes = world(MailboxSyncStatus.deleting);
-
-		await call(FilterOperations.FilterOperations_createFilter, {
-			params: { accountId: ACCOUNT_ID },
-			requestBody: {
-				name: "Just a label",
-				scope: "Standing",
-				actionMailboxId: "None",
-			},
-		});
-
-		assert.equal(writes.filters.length, 1);
-	});
-});

package/src/handlers/mailbox.test.ts

@@ -1,280 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import type { MailboxItem } from "@remit/data-ports";
-import { BadRequestError } from "@remit/data-ports/errors";
-import { MailboxSyncStatus } from "@remit/domain-enums";
-import { UnconfirmedTrashMailboxError } from "@remit/mailbox-service";
-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 {
-	MailboxDetailOperations,
-	MailboxOperations,
-	TrashOperations,
-} from "./mailbox.js";
-
-const SUB = "cognito-sub-887";
-const ACCOUNT_ID = "acc-887";
-
-const emptyTrash = TrashOperations.TrashOperations_emptyTrash as unknown as (
-	context: Context,
-	event: APIGatewayProxyEvent,
-) => Promise<{ deletedCount: number }>;
-
-const callEmptyTrash = (
-	serviceEmptyTrash: () => Promise<{ deletedCount: number }>,
-): Promise<{ deletedCount: number }> => {
-	setClient({
-		account: {
-			get: async () => ({
-				accountId: ACCOUNT_ID,
-				accountConfigId: deriveAccountConfigId(SUB),
-			}),
-		},
-		messageMove: { emptyTrash: serviceEmptyTrash },
-	} as unknown as RemitClient);
-
-	return emptyTrash(
-		{ request: { params: { accountId: ACCOUNT_ID } } } as unknown as Context,
-		{
-			requestContext: { authorizer: { claims: { sub: SUB } } },
-		} as unknown as APIGatewayProxyEvent,
-	);
-};
-
-describe("TrashOperations_emptyTrash", () => {
-	afterEach(() => {
-		_resetForTest();
-	});
-
-	it("reports the service's count rather than one of its own", async () => {
-		// The handler resolves no folder and counts no rows: a second read would
-		// be free to disagree with the one that actually marked them.
-		const response = await callEmptyTrash(async () => ({ deletedCount: 7 }));
-
-		assert.deepEqual(response, { deletedCount: 7 });
-	});
-
-	it("lets the service's coded refusal through untouched", async () => {
-		await assert.rejects(
-			callEmptyTrash(async () => {
-				throw new UnconfirmedTrashMailboxError(ACCOUNT_ID);
-			}),
-			(error: unknown) =>
-				error instanceof UnconfirmedTrashMailboxError &&
-				error.statusCode === 409 &&
-				error.publicApiError?.details?.reason === "unconfirmed",
-		);
-	});
-});
-
-const deleteMailbox =
-	MailboxDetailOperations.MailboxDetailOperations_deleteMailbox as unknown as (
-		context: Context,
-		event: APIGatewayProxyEvent,
-	) => Promise<{ statusCode: number }>;
-
-const folder = (over: Partial<MailboxItem> = {}): MailboxItem =>
-	({
-		mailboxId: "mbx-1",
-		accountId: ACCOUNT_ID,
-		fullPath: "Receipts",
-		hierarchyDelimiter: "/",
-		syncStatus: MailboxSyncStatus.synced,
-		...over,
-	}) as MailboxItem;
-
-interface DeleteWorld {
-	mailbox?: MailboxItem;
-	children?: MailboxItem[];
-	filters?: { name: string; actionMailboxId: string }[];
-	appointments?: Record<string, string>;
-}
-
-const callDelete = (
-	world: DeleteWorld,
-): { run: () => Promise<{ statusCode: number }>; deleted: string[] } => {
-	const deleted: string[] = [];
-	setClient({
-		account: {
-			get: async () => ({
-				accountId: ACCOUNT_ID,
-				accountConfigId: deriveAccountConfigId(SUB),
-			}),
-		},
-		mailbox: {
-			get: async () => world.mailbox ?? folder(),
-			findByPathPrefix: async () => world.children ?? [],
-		},
-		filter: {
-			listByAccountConfig: async () => world.filters ?? [],
-		},
-		accountSetting: {
-			get: async (_configId: string, name: string) => {
-				for (const [role, mailboxId] of Object.entries(
-					world.appointments ?? {},
-				)) {
-					if (name === `FolderRoleAppointment#${ACCOUNT_ID}#${role}`) {
-						return { value: { kind: "String", value: mailboxId } };
-					}
-				}
-				return null;
-			},
-		},
-		mailboxQueue: {
-			deleteMailbox: async (mailboxId: string) => {
-				deleted.push(mailboxId);
-			},
-		},
-	} as unknown as RemitClient);
-
-	return {
-		deleted,
-		run: () =>
-			deleteMailbox(
-				{
-					request: { params: { accountId: ACCOUNT_ID, mailboxId: "mbx-1" } },
-				} as unknown as Context,
-				{
-					requestContext: { authorizer: { claims: { sub: SUB } } },
-				} as unknown as APIGatewayProxyEvent,
-			),
-	};
-};
-
-const refusal = (match: RegExp) => (error: unknown) =>
-	(error as { statusCode?: number }).statusCode === 400 &&
-	match.test((error as Error).message);
-
-describe("MailboxDetailOperations_deleteMailbox — what it refuses (D4, D16)", () => {
-	afterEach(() => {
-		_resetForTest();
-	});
-
-	it("refuses the inbox", async () => {
-		const { run, deleted } = callDelete({
-			mailbox: folder({ fullPath: "INBOX" }),
-		});
-
-		await assert.rejects(run(), refusal(/inbox can't be deleted/));
-		assert.deepEqual(deleted, []);
-	});
-
-	it("refuses a folder that has folders inside it", async () => {
-		// The server would keep the parent's name as a placeholder and leave the
-		// children untouched — an outcome no local row describes.
-		const { run, deleted } = callDelete({
-			children: [folder({ mailboxId: "mbx-2", fullPath: "Receipts/2026" })],
-		});
-
-		await assert.rejects(run(), refusal(/has folders inside it/));
-		assert.deepEqual(deleted, []);
-	});
-
-	/**
-	 * D16. Refusing is what makes the settled-target rule total: a binding is
-	 * only created against a settled folder and only removed by the user, so a
-	 * mailboxId that names nothing never exists and no reader needs a
-	 * missing-target branch.
-	 */
-	it("refuses a folder a filter moves mail into, naming the filter", async () => {
-		const { run, deleted } = callDelete({
-			filters: [{ name: "Invoices → Receipts", actionMailboxId: "mbx-1" }],
-		});
-
-		await assert.rejects(run(), refusal(/the filter “Invoices → Receipts”/));
-		assert.deepEqual(deleted, []);
-	});
-
-	it("refuses a folder appointed to a role, naming the role", async () => {
-		const { run, deleted } = callDelete({ appointments: { Archive: "mbx-1" } });
-
-		await assert.rejects(run(), refusal(/the Archive role/));
-		assert.deepEqual(deleted, []);
-	});
-
-	it("names both when both are bound", async () => {
-		const { run } = callDelete({
-			filters: [{ name: "Invoices", actionMailboxId: "mbx-1" }],
-			appointments: { Archive: "mbx-1" },
-		});
-
-		await assert.rejects(
-			run(),
-			refusal(/the filter “Invoices” and the Archive role/),
-		);
-	});
-
-	it("ignores a filter that moves mail into a different folder", async () => {
-		const { run, deleted } = callDelete({
-			filters: [{ name: "Elsewhere", actionMailboxId: "mbx-9" }],
-		});
-
-		assert.deepEqual(await run(), { statusCode: 204 });
-		assert.deepEqual(deleted, ["mbx-1"]);
-	});
-
-	it("ignores a filter with no move action at all", async () => {
-		const { run, deleted } = callDelete({
-			filters: [{ name: "Just a label", actionMailboxId: "None" }],
-		});
-
-		assert.deepEqual(await run(), { statusCode: 204 });
-		assert.deepEqual(deleted, ["mbx-1"]);
-	});
-
-	it("records the intent for an ordinary folder", async () => {
-		const { run, deleted } = callDelete({});
-
-		assert.deepEqual(await run(), { statusCode: 204 });
-		assert.deepEqual(deleted, ["mbx-1"]);
-	});
-});
-
-const createMailbox =
-	MailboxOperations.MailboxOperations_createMailbox as unknown as (
-		context: Context,
-		event: APIGatewayProxyEvent,
-	) => Promise<unknown>;
-
-describe("MailboxOperations_createMailbox", () => {
-	afterEach(() => {
-		_resetForTest();
-	});
-
-	it("refuses a path the account already has a folder at", async () => {
-		setClient({
-			account: {
-				get: async () => ({
-					accountId: ACCOUNT_ID,
-					accountConfigId: deriveAccountConfigId(SUB),
-				}),
-			},
-			mailboxQueue: {
-				createMailbox: async () => ({ outcome: "PathTaken" }),
-			},
-		} as unknown as RemitClient);
-
-		await assert.rejects(
-			createMailbox(
-				{
-					request: {
-						params: { accountId: ACCOUNT_ID },
-						requestBody: { namespaceType: "personal", fullPath: "Receipts" },
-					},
-				} as unknown as Context,
-				{
-					requestContext: { authorizer: { claims: { sub: SUB } } },
-				} as unknown as APIGatewayProxyEvent,
-			),
-			(error: unknown) =>
-				error instanceof BadRequestError &&
-				error.message === "A folder named “Receipts” is already there.",
-		);
-	});
-});