@remit/mailbox-service 0.0.44 → 0.0.46

package/package.json

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

package/src/message-move-same-mailbox.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IMailboxRepository,
+	IMailboxSpecialUseRepository,
+	IMessageRepository,
+	IThreadMessageRepository,
+} from "@remit/data-ports";
+import { type MessageMoveConfig, MessageMoveService } from "./message-move.js";
+
+const ACCOUNT = "acc-1";
+const ACCOUNT_CONFIG = "cfg-1";
+const INBOX = "mbx-inbox";
+const ARCHIVE = "mbx-archive";
+const MESSAGE_ID = "msg-1";
+
+const buildWorld = () => {
+	const message = {
+		messageId: MESSAGE_ID,
+		mailboxId: INBOX,
+		uid: 337,
+		status: "active",
+		syncStatus: "synced",
+	};
+
+	const threadRow = {
+		accountConfigId: ACCOUNT_CONFIG,
+		threadMessageId: "tm-1",
+		messageId: MESSAGE_ID,
+		mailboxId: INBOX,
+		sentDate: 1_700_000_000_000,
+		isRead: false,
+		isDeleted: false,
+		hasStars: false,
+		hasAttachment: false,
+	};
+
+	const mailboxes = new Map<string, Record<string, unknown>>([
+		[INBOX, { mailboxId: INBOX, fullPath: "INBOX", accountId: ACCOUNT }],
+		[ARCHIVE, { mailboxId: ARCHIVE, fullPath: "Archive", accountId: ACCOUNT }],
+	]);
+
+	const messageService = {
+		get: async () => message,
+		update: async (_id: string, patch: Record<string, unknown>) =>
+			Object.assign(message, patch),
+		updateForMove: async (_id: string, patch: Record<string, unknown>) =>
+			Object.assign(message, patch),
+	} as unknown as IMessageRepository;
+
+	const threadMessageService = {
+		getByMessageId: async () => threadRow,
+		update: async (_cfg: string, _id: string, patch: Record<string, unknown>) =>
+			Object.assign(threadRow, patch),
+	} as unknown as IThreadMessageRepository;
+
+	const mailboxService = {
+		get: async (_acc: string, id: string) => mailboxes.get(id),
+	} as unknown as IMailboxRepository;
+
+	const mailboxSpecialUseService = {
+		findTrashMailbox: async () => null,
+	} as unknown as IMailboxSpecialUseRepository;
+
+	const config: MessageMoveConfig = {
+		messageService,
+		mailboxService,
+		mailboxSpecialUseService,
+		threadMessageService,
+		sqsQueueUrl: "http://localhost:9324/000000000000/remit-messages.fifo",
+	};
+
+	const service = new MessageMoveService(config);
+	const sent: unknown[] = [];
+	(
+		service as unknown as { sqs: { send: (c: unknown) => Promise<unknown> } }
+	).sqs = {
+		send: async (command: unknown) => {
+			sent.push(command);
+			return {};
+		},
+	};
+
+	return { service, message, threadRow, sent };
+};
+
+// IMAP has no in-place MOVE: a same-mailbox move expunges the message and
+// re-appends it under a new UID, so a request naming the folder the message is
+// already in destroys its identity for nothing. It reached the mail server
+// because the client can fire the same move twice — the second one after the
+// first has already landed.
+describe("MessageMoveService.moveMessage — same-mailbox move (#594)", () => {
+	it("enqueues nothing when the destination is the mailbox the message is in", async () => {
+		const { service, sent } = buildWorld();
+
+		await service.moveMessages(ACCOUNT_CONFIG, [MESSAGE_ID], INBOX, ACCOUNT);
+
+		assert.equal(sent.length, 0, "no IMAP move event was enqueued");
+	});
+
+	it("leaves the message row exactly as it was", async () => {
+		const { service, message, threadRow } = buildWorld();
+
+		await service.moveMessages(ACCOUNT_CONFIG, [MESSAGE_ID], INBOX, ACCOUNT);
+
+		assert.deepEqual(message, {
+			messageId: MESSAGE_ID,
+			mailboxId: INBOX,
+			uid: 337,
+			status: "active",
+			syncStatus: "synced",
+		});
+		assert.equal(threadRow.mailboxId, INBOX);
+	});
+
+	it("still moves a message whose destination is a different mailbox", async () => {
+		const { service, message, sent } = buildWorld();
+
+		await service.moveMessages(ACCOUNT_CONFIG, [MESSAGE_ID], ARCHIVE, ACCOUNT);
+
+		assert.equal(sent.length, 1, "the real move is enqueued");
+		assert.equal(message.mailboxId, ARCHIVE);
+		assert.equal(message.syncStatus, "pending");
+	});
+});

package/src/message-move.ts

@@ -335,6 +335,20 @@ export class MessageMoveService {
 		accountId: string,
 	): Promise<void> => {
 		const message = await this.messageService.get(messageId);
+
+		// IMAP has no same-mailbox MOVE: the server copies the message, expunges
+		// the original and hands back a fresh UID, so a request that asks for the
+		// mailbox the message is already in destroys its identity to reach the
+		// state it was already in. The requested end state holds, so there is
+		// nothing to record as pending and nothing to enqueue.
+		if (message.mailboxId === destinationMailboxId) {
+			this.log.info(
+				{ messageId, mailboxId: destinationMailboxId },
+				"Skipping move: message is already in the destination mailbox",
+			);
+			return;
+		}
+
 		const sourceMailbox = await this.mailboxService.get(
 			accountId,
 			message.mailboxId,

package/src/outbox-queue.ts

@@ -5,6 +5,7 @@ import type {
 	IOutboxMessageRepository,
 	OutboxMessageItem,
 } from "@remit/data-ports";
+import { ConflictError } from "@remit/data-ports/errors";
 import { OutboxMessageStatus } from "@remit/domain-enums";
 import { createQueueProducer } from "@remit/sqs-client/producer";
 
@@ -31,6 +32,7 @@ export interface OutboxQueueConfig {
 	accountService: IAccountRepository;
 	sqsSmtpQueueUrl: string;
 	sqsEndpoint?: string;
+	sqsClient?: SQSClient;
 	logger?: OutboxQueueLogger;
 }
 
@@ -91,10 +93,12 @@ export class OutboxQueueService {
 		this.queueUrl = sqsSmtpQueueUrl;
 		this.log = config.logger ?? noopLogger;
 
-		this.sqs = createQueueProducer({
-			queueUrl: sqsSmtpQueueUrl,
-			endpoint: sqsEndpoint,
-		});
+		this.sqs =
+			config.sqsClient ??
+			createQueueProducer({
+				queueUrl: sqsSmtpQueueUrl,
+				endpoint: sqsEndpoint,
+			});
 	}
 
 	createDraft = async (input: CreateDraftInput): Promise<OutboxMessageItem> => {
@@ -137,8 +141,8 @@ export class OutboxQueueService {
 			"act",
 		);
 		if (existing.status !== OutboxMessageStatus.draft) {
-			throw new Error(
-				`Cannot update outbox message with status: ${existing.status}`,
+			throw new ConflictError(
+				`This message is already ${existing.status} and can no longer be edited as a draft. Start a new message to change it.`,
 			);
 		}
 
@@ -184,8 +188,8 @@ export class OutboxQueueService {
 			existing.status !== OutboxMessageStatus.failed &&
 			existing.status !== OutboxMessageStatus.blocked
 		) {
-			throw new Error(
-				`Cannot send outbox message with status: ${existing.status}`,
+			throw new ConflictError(
+				`This message is already ${existing.status} and cannot be sent again. Open the Outbox to see where it stands.`,
 			);
 		}
 
@@ -252,8 +256,8 @@ export class OutboxQueueService {
 			existing.status !== OutboxMessageStatus.failed &&
 			existing.status !== OutboxMessageStatus.blocked
 		) {
-			throw new Error(
-				`Cannot delete outbox message with status: ${existing.status}`,
+			throw new ConflictError(
+				`This message is already ${existing.status} and can no longer be discarded. Open the Outbox to see where it stands.`,
 			);
 		}