@remit/backend 0.0.124 → 0.0.126

package/package.json

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

package/scripts/backfill-classification.ts

@@ -69,6 +69,8 @@ const run = async (): Promise<void> => {
 	const result = await backfillClassifications(
 		{
 			accountConfigService: client.accountConfig,
+			accountService: client.account,
+			mailboxSpecialUseService: client.mailboxSpecialUse,
 			addressService: client.address,
 			threadMessageService: client.threadMessage,
 			messageService: client.message,

package/src/handlers/mailbox.test.ts

@@ -1,6 +1,7 @@
 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";
@@ -11,7 +12,11 @@ import {
 	type RemitClient,
 	setClient,
 } from "../service/data-client.js";
-import { MailboxDetailOperations, TrashOperations } from "./mailbox.js";
+import {
+	MailboxDetailOperations,
+	MailboxOperations,
+	TrashOperations,
+} from "./mailbox.js";
 
 const SUB = "cognito-sub-887";
 const ACCOUNT_ID = "acc-887";
@@ -230,3 +235,46 @@ describe("MailboxDetailOperations_deleteMailbox — what it refuses (D4, D16)",
 		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.",
+		);
+	});
+});

package/src/handlers/mailbox.ts

@@ -402,7 +402,7 @@ export const MailboxOperations: Record<
 		const account = await client.account.get(accountId);
 		assertAccountOwnership(account, accountConfigId, "act");
 
-		const mailbox = await client.mailboxQueue.createMailbox(
+		const created = await client.mailboxQueue.createMailbox(
 			{
 				accountId,
 				namespaceType: namespaceType as "personal" | "other_users" | "shared",
@@ -423,8 +423,13 @@ export const MailboxOperations: Record<
 			accountId,
 			true,
 		);
+		if (created.outcome === "PathTaken") {
+			throw new BadRequestError(
+				`A folder named “${fullPath}” is already there.`,
+			);
+		}
 
-		return toMailboxResponse(mailbox);
+		return toMailboxResponse(created.mailbox);
 	},
 };
 

package/src/handlers/message-read-backfill.test.ts

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { Context } from "openapi-backend";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "../service/data-client.js";
+import { MessageOperations } from "./message.js";
+
+type Handler = (
+	context: Context,
+	event: APIGatewayProxyEvent,
+) => Promise<unknown>;
+
+const describeMessage =
+	MessageOperations.MessageOperations_describeMessage as unknown as Handler;
+const getRawMessage =
+	MessageOperations.MessageOperations_getRawMessage as unknown as Handler;
+
+const MESSAGE_ID = "msg-1";
+const MAILBOX_ID = "mb-1";
+const ACCOUNT_ID = "acc-1";
+
+const event = {
+	requestContext: { authorizer: { claims: { sub: "sub-610" } } },
+} as unknown as APIGatewayProxyEvent;
+
+const context = {
+	request: { params: { messageId: MESSAGE_ID } },
+} as unknown as Context;
+
+const unstoredMessage = {
+	messageId: MESSAGE_ID,
+	mailboxId: MAILBOX_ID,
+	uid: 7,
+	internalDate: 1,
+	status: "active",
+	syncStatus: "synced",
+};
+
+const mailboxRow = {
+	mailboxId: MAILBOX_ID,
+	accountId: ACCOUNT_ID,
+	fullPath: "Junk",
+	cursorState: "normal",
+};
+
+const clientWithFailingFolderLookup = (opened: string[]): RemitClient =>
+	({
+		message: {
+			get: async () => unstoredMessage,
+			describe: async () => ({
+				message: [unstoredMessage],
+				envelope: [],
+				envelopeAddress: [],
+				messageFlag: [],
+				bodyPart: [],
+				messageReference: [],
+			}),
+		},
+		messageLabel: { listByMessageId: async () => [] },
+		account: {
+			listAllByAccountConfig: async () => [{ accountId: ACCOUNT_ID }],
+		},
+		mailbox: {
+			get: async (_accountId: string, ids: string | string[]) =>
+				Array.isArray(ids) ? [mailboxRow] : mailboxRow,
+		},
+		storage: { bodyPartExists: async () => false },
+		mailboxSpecialUse: {
+			findJunkMailbox: async () => {
+				throw new Error("special-use lookup timed out");
+			},
+			findInboxMailbox: async () => null,
+		},
+		createConnectionScope: async (accountId: string) => {
+			opened.push(accountId);
+			return {
+				getConnection: async () => ({}),
+				disconnect: async () => {},
+			};
+		},
+	}) as unknown as RemitClient;
+
+describe("reading an unstored message when the folder lookup fails", () => {
+	afterEach(() => _resetForTest());
+
+	for (const [name, handler] of [
+		["describeMessage", describeMessage],
+		["getRawMessage", getRawMessage],
+	] as const) {
+		it(`${name} opens no IMAP connection`, async () => {
+			const opened: string[] = [];
+			setClient(clientWithFailingFolderLookup(opened));
+
+			await assert.rejects(handler(context, event), /special-use lookup/);
+
+			assert.deepEqual(opened, []);
+		});
+	}
+});

package/src/handlers/message.ts

@@ -26,6 +26,7 @@ import {
 	MailboxCursorPausedError,
 	MoveNotSettledError,
 	NoJunkMailboxError,
+	resolveFolderPlacement,
 } from "@remit/mailbox-service";
 import {
 	isStorageNotFoundError as isStorageNotFoundErrorFromService,
@@ -605,6 +606,14 @@ export const MessageOperations: Record<
 					"Mailbox cursor not normal; skipping IMAP body backfill for this request",
 				);
 			} else {
+				const folder = {
+					fullPath: mailbox.fullPath,
+					placement: await resolveFolderPlacement(
+						client.mailboxSpecialUse,
+						accountId,
+						mailbox.mailboxId,
+					),
+				};
 				const scope = await client.createConnectionScope(accountId);
 				// Guard at the one choke point every UID-based IMAP op already
 				// passes through: openBox. A mismatch trips the mailbox to
@@ -619,12 +628,8 @@ export const MessageOperations: Record<
 				);
 
 				await client.bodySync
-					.fetchAndGetBody(
-						messageId,
-						accountId,
-						accountConfigId,
-						mailbox.fullPath,
-						() => Promise.resolve(connection),
+					.fetchAndGetBody(messageId, accountId, accountConfigId, folder, () =>
+						Promise.resolve(connection),
 					)
 					.catch((error: unknown) => {
 						if (error instanceof MailboxCursorPausedError) {
@@ -742,6 +747,14 @@ export const MessageOperations: Record<
 					"Mailbox cursor not normal; skipping IMAP body backfill for this request",
 				);
 			} else {
+				const folder = {
+					fullPath: mailbox.fullPath,
+					placement: await resolveFolderPlacement(
+						client.mailboxSpecialUse,
+						accountId,
+						mailbox.mailboxId,
+					),
+				};
 				const scope = await client.createConnectionScope(accountId);
 				// Guard at the openBox choke point — a fresh mismatch trips the
 				// mailbox and throws once the SELECT reveals it; caught below.
@@ -752,12 +765,8 @@ export const MessageOperations: Record<
 					mailbox,
 				);
 				await client.bodySync
-					.fetchAndGetBody(
-						messageId,
-						accountId,
-						accountConfigId,
-						mailbox.fullPath,
-						() => Promise.resolve(connection),
+					.fetchAndGetBody(messageId, accountId, accountConfigId, folder, () =>
+						Promise.resolve(connection),
 					)
 					.catch((error: unknown) => {
 						if (error instanceof MailboxCursorPausedError) {

package/src/service/read-path-filter-config.test.ts

@@ -165,7 +165,7 @@ const readBodyThroughClient = async (
 		"m-1",
 		"acc-1",
 		"cfg-1",
-		"INBOX",
+		{ fullPath: "INBOX", placement: "inbox" },
 		async () => connection,
 	);
 };