@remit/backend 0.0.125 → 0.0.126

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.125",
+  "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/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,
 	);
 };