@remit/mailbox-service 0.0.59 → 0.0.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.59",
+  "version": "0.0.60",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -185,6 +185,7 @@ export {
 	type MessageMoveConfig,
 	type MessageMoveLogger,
 	MessageMoveService,
+	NoTrashMailboxError,
 } from "./message-move.js";
 export {
 	type ParsedMessageContent,

package/src/message-delete-junk-reconcile.test.ts

@@ -98,10 +98,12 @@ describe("deleting a message re-asks what its senders stand on", () => {
 		assert.deepEqual(reconciled, []);
 	});
 
-	it("asks nothing when the account has no Trash folder", async () => {
+	it("asks nothing when the account has no Trash folder, because the delete is refused", async () => {
 		const { service, reconciled } = buildWorld(false);
 
-		await service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT);
+		await assert.rejects(() =>
+			service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT),
+		);
 
 		assert.deepEqual(reconciled, []);
 	});

package/src/message-delete-no-trash.test.ts

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IAddressRepository,
+	IMailboxRepository,
+	IMailboxSpecialUseRepository,
+	IMessageRepository,
+	IThreadMessageRepository,
+} from "@remit/data-ports";
+import {
+	type MessageMoveConfig,
+	MessageMoveService,
+	NoTrashMailboxError,
+} from "./message-move.js";
+
+const ACCOUNT = "acc-1";
+const ACCOUNT_CONFIG = "cfg-1";
+const INBOX = "mbx-inbox";
+const TRASH = "mbx-trash";
+const MESSAGE_ID = "msg-1";
+
+interface EnqueuedEvent {
+	operation: string;
+	destinationMailboxPath?: string;
+}
+
+const buildWorld = (
+	trash: { mailboxId: string; fullPath: string } | null,
+	startingMailboxId = INBOX,
+) => {
+	const patches: Array<Record<string, unknown>> = [];
+	const events: EnqueuedEvent[] = [];
+	const threadMessageDeletes: string[] = [];
+
+	const message = {
+		messageId: MESSAGE_ID,
+		mailboxId: startingMailboxId,
+		uid: 337,
+		status: "active",
+		syncStatus: "synced",
+	};
+
+	const messageService = {
+		get: async () => [message],
+		update: async (_id: string, patch: Record<string, unknown>) => {
+			patches.push(patch);
+			return Object.assign(message, patch);
+		},
+		updateForMove: async (_id: string, patch: Record<string, unknown>) => {
+			patches.push(patch);
+			return Object.assign(message, patch);
+		},
+	} as unknown as IMessageRepository;
+
+	const threadMessageService = {
+		findAllByMessageId: async () => [],
+		getByMessageId: async () => ({
+			accountConfigId: ACCOUNT_CONFIG,
+			threadMessageId: "tm-1",
+			messageId: MESSAGE_ID,
+			mailboxId: startingMailboxId,
+		}),
+		update: async () => {},
+		delete: async (_cfg: string, id: string) => {
+			threadMessageDeletes.push(id);
+		},
+	} as unknown as IThreadMessageRepository;
+
+	const mailboxService = {
+		get: async () => [
+			{ mailboxId: INBOX, fullPath: "INBOX", accountId: ACCOUNT },
+			{ mailboxId: TRASH, fullPath: "INBOX/Trash", accountId: ACCOUNT },
+		],
+	} as unknown as IMailboxRepository;
+
+	const mailboxSpecialUseService = {
+		findTrashMailbox: async () => trash,
+	} as unknown as IMailboxSpecialUseRepository;
+
+	const addressService = {
+		reconcileJunkOnlyForMessage: async () => {},
+	} as unknown as IAddressRepository;
+
+	const config: MessageMoveConfig = {
+		messageService,
+		mailboxService,
+		mailboxSpecialUseService,
+		threadMessageService,
+		addressService,
+		sqsQueueUrl: "http://localhost:9324/000000000000/remit-messages.fifo",
+	};
+
+	const service = new MessageMoveService(config);
+	(
+		service as unknown as {
+			enqueueEventsBatch: (batch: EnqueuedEvent[]) => Promise<void>;
+		}
+	).enqueueEventsBatch = async (batch) => {
+		events.push(...batch);
+	};
+
+	return { service, patches, events, message };
+};
+
+describe("delete only expunges when it was asked to", () => {
+	it("moves to a Trash the account resolves under a nested path", async () => {
+		const { service, events, message } = buildWorld({
+			mailboxId: TRASH,
+			fullPath: "INBOX/Trash",
+		});
+
+		await service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT);
+
+		assert.deepEqual(
+			events.map((event) => event.operation),
+			["move_to_trash"],
+		);
+		assert.equal(events[0].destinationMailboxPath, "INBOX/Trash");
+		assert.equal(message.mailboxId, TRASH);
+	});
+
+	it("refuses, and touches nothing, when no Trash resolves", async () => {
+		const { service, patches, events, message } = buildWorld(null);
+
+		await assert.rejects(
+			() => service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT),
+			(error: unknown) =>
+				error instanceof NoTrashMailboxError &&
+				error.statusCode === 409 &&
+				error.message.includes("no Trash folder"),
+		);
+
+		assert.deepEqual(events, []);
+		assert.deepEqual(patches, []);
+		assert.equal(message.mailboxId, INBOX);
+		assert.equal(message.status, "active");
+	});
+
+	it("expunges only when the caller asked for a permanent delete", async () => {
+		const { service, events } = buildWorld({
+			mailboxId: TRASH,
+			fullPath: "INBOX/Trash",
+		});
+
+		await service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT, {
+			permanent: true,
+		});
+
+		assert.deepEqual(
+			events.map((event) => event.operation),
+			["permanent_delete"],
+		);
+	});
+
+	it("expunges a message already in Trash, which the dialog asks as such", async () => {
+		const { service, events } = buildWorld(
+			{ mailboxId: TRASH, fullPath: "INBOX/Trash" },
+			TRASH,
+		);
+
+		await service.deleteMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ACCOUNT);
+
+		assert.deepEqual(
+			events.map((event) => event.operation),
+			["permanent_delete"],
+		);
+	});
+});

package/src/message-move.ts

@@ -11,6 +11,7 @@ import type {
 	IMessageRepository,
 	IThreadMessageRepository,
 } from "@remit/data-ports";
+import { HTTPError } from "@remit/data-ports/errors";
 import { deriveCopyMessageId } from "@remit/data-ports/id";
 import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
 import { createQueueProducer } from "@remit/sqs-client/producer";
@@ -103,6 +104,23 @@ export interface MessageMoveConfig {
 	logger?: MessageMoveLogger;
 }
 
+/**
+ * The account resolves no Trash folder, so a move-to-Trash delete has nowhere
+ * to put the mail. A designed, user-facing outcome carrying its own text and
+ * a 409 so the backend returns it verbatim: the absence of a Trash folder is
+ * a blocker the user resolves by appointing one, never a licence to expunge.
+ */
+export class NoTrashMailboxError extends HTTPError {
+	name = "NoTrashMailboxError";
+	statusCode = 409;
+
+	constructor() {
+		super(
+			"This account has no Trash folder, so nothing was deleted. Appoint one under Settings → Folder roles, then delete again.",
+		);
+	}
+}
+
 /**
  * Options for delete operations
  */
@@ -191,9 +209,26 @@ export class MessageMoveService {
 		);
 		const mailboxMap = new Map(mailboxes.map((m) => [m.mailboxId, m]));
 
-		// Find trash mailbox once
-		const trashMailbox =
-			await this.mailboxSpecialUseService.findTrashMailbox(accountId);
+		// A permanent delete is only ever what the caller explicitly asked for.
+		// Everything else is a move to Trash, and a Trash folder that does not
+		// resolve blocks it — the user was asked "move to Trash?" and expunging
+		// their mail instead is unrecoverable and answers a question nobody put
+		// to them. Thrown before any local write or event, so the server and the
+		// projection are both left untouched.
+		const wantsPermanentDelete =
+			options.permanent === true || options.toTrash === false;
+
+		const trashMailbox = wantsPermanentDelete
+			? null
+			: await this.mailboxSpecialUseService.findTrashMailbox(accountId);
+
+		if (!wantsPermanentDelete && !trashMailbox) {
+			this.log.error(
+				{ accountId, messageCount: messages.length },
+				"Refused to delete: account resolves no Trash mailbox",
+			);
+			throw new NoTrashMailboxError();
+		}
 
 		// Group messages by operation type
 		const moveToTrashMessages: Array<{
@@ -212,12 +247,8 @@ export class MessageMoveService {
 			if (!sourceMailbox) continue;
 
 			const isInTrash =
-				trashMailbox && message.mailboxId === trashMailbox.mailboxId;
-			const shouldMoveToTrash =
-				options.toTrash !== false &&
-				!options.permanent &&
-				!isInTrash &&
-				trashMailbox;
+				trashMailbox !== null && message.mailboxId === trashMailbox.mailboxId;
+			const shouldMoveToTrash = trashMailbox !== null && !isInTrash;
 
 			const entry = {
 				messageId: message.messageId,
@@ -228,7 +259,7 @@ export class MessageMoveService {
 				},
 			};
 
-			if (shouldMoveToTrash && trashMailbox) {
+			if (shouldMoveToTrash) {
 				moveToTrashMessages.push(entry);
 			} else {
 				permanentDeleteMessages.push(entry);