@remit/imap-worker 0.0.1

package/src/handlers/message-delete.test.ts

@@ -0,0 +1,176 @@
+import assert from "node:assert";
+import { describe, it, mock } from "node:test";
+import type { ThreadMessageItem } from "@remit/data-ports";
+import {
+	buildThreadMessageTrashUpdate,
+	deleteAllThreadMessagesForMessage,
+} from "./message-delete.js";
+
+const sourceMailboxId = "source-mailbox-id-aaaaaaaaa";
+const trashMailboxId = "trash-mailbox-id-aaaaaaaaa";
+
+const baseThreadMessage = {
+	sentDate: 1700000000000,
+	mailboxId: sourceMailboxId,
+	isRead: true,
+	isDeleted: false,
+	hasStars: true,
+	hasAttachment: false,
+} satisfies Pick<
+	ThreadMessageItem,
+	| "sentDate"
+	| "mailboxId"
+	| "isRead"
+	| "isDeleted"
+	| "hasStars"
+	| "hasAttachment"
+>;
+
+describe("buildThreadMessageTrashUpdate", () => {
+	// Regression for the same composites-direction landmine PR #186 fixed in
+	// `flag-queue.ts`. The CURRENT row state must go in `composites`; the NEW
+	// values must go in `set`. Flipping any of these silently drops the
+	// move-to-trash update on the ThreadMessage row — IMAP shows the message in
+	// Trash but the local thread-list still shows it in the source mailbox.
+
+	it("set carries the NEW uid, destination mailboxId, and isDeleted=true", () => {
+		const args = buildThreadMessageTrashUpdate(
+			baseThreadMessage,
+			42,
+			trashMailboxId,
+		);
+
+		assert.strictEqual(args.set.uid, 42);
+		assert.strictEqual(
+			args.set.mailboxId,
+			trashMailboxId,
+			"set.mailboxId must be the NEW trash mailbox",
+		);
+		assert.strictEqual(
+			args.set.isDeleted,
+			true,
+			"set.isDeleted must be true (move-to-trash marks the row deleted)",
+		);
+	});
+
+	it("composites.mailboxId is the CURRENT (source) mailboxId, not Trash", () => {
+		const args = buildThreadMessageTrashUpdate(
+			baseThreadMessage,
+			42,
+			trashMailboxId,
+		);
+
+		assert.strictEqual(
+			args.composites.mailboxId,
+			sourceMailboxId,
+			"composites.mailboxId must be the CURRENT source mailbox; passing Trash breaks the conditional check",
+		);
+		assert.notStrictEqual(
+			args.composites.mailboxId,
+			trashMailboxId,
+			"composites.mailboxId must NOT match the new trash mailbox id",
+		);
+	});
+
+	it("composites.isDeleted is the CURRENT value, not the new true", () => {
+		const args = buildThreadMessageTrashUpdate(
+			baseThreadMessage,
+			42,
+			trashMailboxId,
+		);
+
+		assert.strictEqual(
+			args.composites.isDeleted,
+			false,
+			"composites.isDeleted must be the CURRENT value (false), not the new value (true)",
+		);
+	});
+
+	it("composites mirrors every CURRENT indexed attribute on the threadMessage", () => {
+		const tm = {
+			sentDate: 1700000000123,
+			mailboxId: sourceMailboxId,
+			isRead: false,
+			isDeleted: false,
+			hasStars: true,
+			hasAttachment: true,
+		};
+
+		const args = buildThreadMessageTrashUpdate(tm, 99, trashMailboxId);
+
+		assert.deepStrictEqual(args.composites, {
+			sentDate: tm.sentDate,
+			mailboxId: tm.mailboxId,
+			isRead: tm.isRead,
+			isDeleted: tm.isDeleted,
+			hasStars: tm.hasStars,
+			hasAttachment: tm.hasAttachment,
+		});
+	});
+});
+
+describe("deleteAllThreadMessagesForMessage (#212)", () => {
+	// Regression for the multi-mailbox cleanup gap in #212. A single Message
+	// can have ThreadMessage rows in multiple mailboxes (e.g. INBOX + a label
+	// folder copy). The pre-fix code used `findByMessageId` (single row) and
+	// left orphan rows behind that then leaked into other mailbox listings.
+
+	const baseRow = (
+		threadMessageId: string,
+		mailboxId: string,
+	): Pick<
+		ThreadMessageItem,
+		"accountConfigId" | "threadMessageId" | "mailboxId"
+	> => ({
+		accountConfigId: "alice-config-aaaaaaaaaa",
+		threadMessageId,
+		mailboxId,
+	});
+
+	it("deletes every ThreadMessage row returned by findAllByMessageId", async () => {
+		const rows = [
+			baseRow("alice-tm-1-aaaaaaaaaa", "alice-inbox-aaaaaaaaa"),
+			baseRow("alice-tm-2-aaaaaaaaaa", "alice-label-aaaaaaaaa"),
+		];
+
+		const findAllByMessageId = mock.fn(async () => rows);
+		const deleteRow = mock.fn(async () => undefined);
+
+		const count = await deleteAllThreadMessagesForMessage(
+			{
+				findAllByMessageId,
+				delete: deleteRow,
+			} as unknown as Parameters<typeof deleteAllThreadMessagesForMessage>[0],
+			"alice-config-aaaaaaaaaa",
+			"alice-msg-multi-aaaaaaaa",
+		);
+
+		assert.equal(count, 2);
+		assert.equal(deleteRow.mock.calls.length, 2);
+		assert.deepEqual(deleteRow.mock.calls[0].arguments, [
+			"alice-config-aaaaaaaaaa",
+			"alice-tm-1-aaaaaaaaaa",
+		]);
+		assert.deepEqual(deleteRow.mock.calls[1].arguments, [
+			"alice-config-aaaaaaaaaa",
+			"alice-tm-2-aaaaaaaaaa",
+		]);
+	});
+
+	it("returns zero when no ThreadMessage rows exist", async () => {
+		const findAllByMessageId = mock.fn(async () => []);
+		const deleteRow = mock.fn(async () => undefined);
+
+		const count = await deleteAllThreadMessagesForMessage(
+			{
+				findAllByMessageId,
+				delete: deleteRow,
+			} as unknown as Parameters<typeof deleteAllThreadMessagesForMessage>[0],
+			"alice-config-aaaaaaaaaa",
+			"alice-msg-missing-aaaaaa",
+		);
+
+		assert.equal(count, 0);
+		assert.equal(deleteRow.mock.calls.length, 0);
+	});
+});

package/src/handlers/message-delete.ts

@@ -0,0 +1,283 @@
+import { getClient } from "@remit/backend/client";
+import type {
+	IThreadMessageRepository,
+	ThreadMessageItem,
+} from "@remit/data-ports";
+import { MessageSyncStatus } from "@remit/domain-enums";
+import type { Logger } from "@remit/logger-lambda";
+import {
+	guardConnectionCursor,
+	isCursorRebuildNeeded,
+	MailboxCursorPausedError,
+} from "@remit/mailbox-service";
+import { isAccountDeleted } from "../account-check.js";
+import { createConnectionScopeWithCredentials } from "../connection-scope.js";
+import type { MessageDeleteEvent } from "../events.js";
+import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
+import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
+
+/**
+ * Delete every ThreadMessage row that points at this messageId.
+ *
+ * A single Message can have multiple ThreadMessage rows — one per mailbox
+ * the message exists in (e.g. INBOX + a label/folder copy). Permanent-delete
+ * cleanup must remove ALL of them; using `findByMessageId` (single row) leaves
+ * orphan rows in other mailboxes that then leak into their listings. See
+ * issue #212.
+ */
+export const deleteAllThreadMessagesForMessage = async (
+	threadMessageService: Pick<
+		IThreadMessageRepository,
+		"findAllByMessageId" | "delete"
+	>,
+	accountConfigId: string,
+	messageId: string,
+): Promise<number> => {
+	const rows = await threadMessageService.findAllByMessageId(
+		accountConfigId,
+		messageId,
+	);
+	for (const row of rows) {
+		await threadMessageService.delete(row.accountConfigId, row.threadMessageId);
+	}
+	return rows.length;
+};
+
+/**
+ * Build the `set` and `composites` payload for the ThreadMessage update on a
+ * MESSAGE_DELETE move-to-trash.
+ *
+ * The CURRENT row state goes in `composites`; the NEW values go in `set`.
+ * ElectroDB uses `composites` to run the conditional check on the existing row
+ * AND to compute the previous sort-key values needed to recompute the new ones.
+ * Passing the NEW values in `composites` makes the conditional check fail with
+ * ConditionalCheckFailedException, which ElectroDB wraps as NotFoundError, and
+ * the caller silently drops the update. Same root cause as PR #186 fixed for
+ * `flag-queue.ts`.
+ */
+export const buildThreadMessageTrashUpdate = (
+	threadMessage: Pick<
+		ThreadMessageItem,
+		| "sentDate"
+		| "mailboxId"
+		| "isRead"
+		| "isDeleted"
+		| "hasStars"
+		| "hasAttachment"
+	>,
+	newUid: number,
+	destinationMailboxId: string,
+) => ({
+	set: {
+		uid: newUid,
+		mailboxId: destinationMailboxId,
+		isDeleted: true,
+	},
+	composites: {
+		sentDate: threadMessage.sentDate,
+		mailboxId: threadMessage.mailboxId,
+		isRead: threadMessage.isRead,
+		isDeleted: threadMessage.isDeleted,
+		hasStars: threadMessage.hasStars,
+		hasAttachment: threadMessage.hasAttachment,
+	},
+});
+
+/**
+ * Handle MESSAGE_DELETE events.
+ * Either moves to Trash (IMAP MOVE) or permanently deletes (IMAP DELETE).
+ */
+export const handleMessageDelete = async (
+	event: MessageDeleteEvent,
+	log: Logger,
+): Promise<void> => {
+	const {
+		account: accountService,
+		message: messageService,
+		threadMessage: threadMessageService,
+		mailbox: mailboxService,
+		secrets,
+	} = await getClient();
+
+	const {
+		accountId,
+		messageId,
+		mailboxId,
+		mailboxPath,
+		uid,
+		operation,
+		destinationMailboxId,
+		destinationMailboxPath,
+	} = event;
+
+	log.info(
+		{ event: event.type, accountId, messageId, mailboxPath, operation },
+		"Handling event",
+	);
+
+	const account = await accountService.get(accountId);
+	if (!account) {
+		throw new Error(`Account ${accountId} not found`);
+	}
+
+	if (isAccountDeleted(account, log)) {
+		return;
+	}
+
+	await withOAuthLifecycle(
+		buildLifecycleDeps(secrets, accountService),
+		account,
+		log,
+		async (credentials) => {
+			const mailbox = await mailboxService.get(accountId, mailboxId);
+
+			// Cheap frugal skip (epic #1281 invariant 6): a mailbox already known
+			// paused never even opens a connection. Optimization only — the
+			// guardConnectionCursor openBox wrap below is the structural guarantee.
+			if (isCursorRebuildNeeded(mailbox.cursorState)) {
+				log.info(
+					{ accountId, messageId, mailboxId },
+					"Mailbox cursor not normal; pausing outbound delete this round",
+				);
+				return;
+			}
+
+			const scope = createConnectionScopeWithCredentials(account, credentials);
+
+			await scope
+				.getConnection()
+				.then(async (rawConnection) => {
+					// Guard at the openBox choke point (epic #1281 invariants 3 & 5):
+					// a fresh mismatch trips the mailbox and throws once the SELECT
+					// reveals it. The delete stays applied locally either way.
+					const connection = guardConnectionCursor(
+						rawConnection,
+						{ mailboxService },
+						accountId,
+						mailbox,
+					);
+					await connection.openBox(mailboxPath, false);
+
+					if (operation === "move_to_trash" && destinationMailboxPath) {
+						// Move to Trash
+						const result = await connection.moveMessages(
+							[uid],
+							destinationMailboxPath,
+						);
+						const newUid = result.uidMap.get(uid);
+
+						if (newUid && destinationMailboxId) {
+							// Update message with new UID in Trash
+							await messageService.updateUid(
+								messageId,
+								newUid,
+								destinationMailboxId,
+							);
+
+							// Update ThreadMessage with new UID and isDeleted = true
+							const threadMessage = await threadMessageService.findByMessageId(
+								account.accountConfigId,
+								messageId,
+							);
+							if (threadMessage) {
+								const args = buildThreadMessageTrashUpdate(
+									threadMessage,
+									newUid,
+									destinationMailboxId,
+								);
+								await threadMessageService.update(
+									threadMessage.accountConfigId,
+									threadMessage.threadMessageId,
+									args.set,
+									{ composites: args.composites },
+								);
+							}
+
+							log.info({ messageId, newUid }, "Message moved to trash");
+						} else {
+							log.error(
+								{ messageId, uid },
+								"Failed to get new UID after move to trash",
+							);
+							await messageService.update(messageId, {
+								syncStatus: MessageSyncStatus.failed,
+							});
+						}
+					} else {
+						// Permanent delete
+						await connection.deleteMessages([uid]);
+
+						// Delete ThreadMessage rows BEFORE the Message row to collapse the
+						// visibility window where the inbox lists a row whose backing
+						// Message has already been deleted (see issue #212). Multi-mailbox
+						// copies are handled by the helper.
+						const threadMessagesDeleted =
+							await deleteAllThreadMessagesForMessage(
+								threadMessageService,
+								account.accountConfigId,
+								messageId,
+							);
+
+						// Delete local Message entity
+						await messageService.delete(messageId);
+
+						log.info(
+							{ messageId, threadMessagesDeleted },
+							"Message permanently deleted",
+						);
+					}
+				})
+				.catch(async (error: unknown) => {
+					if (error instanceof MailboxCursorPausedError) {
+						log.info(
+							{ accountId, messageId, mailboxId, cursorState: error.state },
+							"Mailbox cursor not normal; pausing outbound delete this round",
+						);
+						return;
+					}
+
+					const errorMessage =
+						error instanceof Error ? error.message : String(error);
+
+					// Message not found on IMAP - already deleted (idempotent)
+					if (
+						errorMessage.includes("not found") ||
+						errorMessage.includes("NONEXISTENT")
+					) {
+						log.info(
+							{ messageId, uid },
+							"Message not found on IMAP, cleaning up local",
+						);
+						// Clean up local entities. Multi-mailbox copies are handled by the
+						// helper so we don't leave orphan rows (see issue #212).
+						await messageService.delete(messageId);
+						await deleteAllThreadMessagesForMessage(
+							threadMessageService,
+							account.accountConfigId,
+							messageId,
+						);
+						return;
+					}
+
+					// TRYCREATE - Trash doesn't exist
+					if (errorMessage.includes("TRYCREATE") && destinationMailboxPath) {
+						log.info(
+							{ destinationMailboxPath },
+							"Trash mailbox doesn't exist, creating",
+						);
+						const connection = await scope.getConnection();
+						await connection.createMailbox(destinationMailboxPath);
+						// Re-throw to let the event be retried
+						throw error;
+					}
+
+					// Mark as failed for other errors
+					await messageService.update(messageId, {
+						syncStatus: MessageSyncStatus.failed,
+					});
+					throw error;
+				})
+				.finally(() => scope.disconnect());
+		},
+	);
+};

package/src/handlers/message-move.test.ts

@@ -0,0 +1,168 @@
+import assert from "node:assert";
+import { describe, it, mock } from "node:test";
+import type { ThreadMessageItem } from "@remit/data-ports";
+import {
+	buildThreadMessageMoveUpdate,
+	emitMoveResync,
+	moveThenResync,
+} from "./message-move.js";
+
+const sourceMailboxId = "source-mailbox-id-aaaaaaaaa";
+const destinationMailboxId = "destination-mailbox-aaaaa";
+
+const baseThreadMessage = {
+	sentDate: 1700000000000,
+	mailboxId: sourceMailboxId,
+	isRead: true,
+	isDeleted: false,
+	hasStars: true,
+	hasAttachment: false,
+} satisfies Pick<
+	ThreadMessageItem,
+	| "sentDate"
+	| "mailboxId"
+	| "isRead"
+	| "isDeleted"
+	| "hasStars"
+	| "hasAttachment"
+>;
+
+describe("buildThreadMessageMoveUpdate", () => {
+	// Regression for the same composites-direction landmine PR #186 fixed in
+	// `flag-queue.ts`. The CURRENT row state must go in `composites`; the NEW
+	// values must go in `set`. Flipping any of these silently drops the
+	// ThreadMessage local update on every IMAP MOVE — the row stays in the
+	// source mailbox while the IMAP server thinks it moved.
+
+	it("set carries the NEW uid, mailboxId, and isDeleted=false", () => {
+		const args = buildThreadMessageMoveUpdate(
+			baseThreadMessage,
+			42,
+			destinationMailboxId,
+		);
+
+		assert.strictEqual(args.set.uid, 42, "set.uid must be the NEW uid");
+		assert.strictEqual(
+			args.set.mailboxId,
+			destinationMailboxId,
+			"set.mailboxId must be the NEW destination mailbox",
+		);
+		assert.strictEqual(
+			args.set.isDeleted,
+			false,
+			"set.isDeleted must be false (move is not a delete)",
+		);
+	});
+
+	it("composites.mailboxId is the CURRENT (source) mailboxId, not the destination", () => {
+		const args = buildThreadMessageMoveUpdate(
+			baseThreadMessage,
+			42,
+			destinationMailboxId,
+		);
+
+		assert.strictEqual(
+			args.composites.mailboxId,
+			sourceMailboxId,
+			"composites.mailboxId must be the CURRENT source mailbox; passing the destination breaks the conditional check",
+		);
+		assert.notStrictEqual(
+			args.composites.mailboxId,
+			destinationMailboxId,
+			"composites.mailboxId must NOT match the new destinationMailboxId",
+		);
+	});
+
+	it("composites.isDeleted is the CURRENT value, not the new false", () => {
+		const args = buildThreadMessageMoveUpdate(
+			{ ...baseThreadMessage, isDeleted: true },
+			42,
+			destinationMailboxId,
+		);
+
+		assert.strictEqual(
+			args.composites.isDeleted,
+			true,
+			"composites.isDeleted must be the CURRENT value (true here), not the new value",
+		);
+	});
+
+	it("composites mirrors every CURRENT indexed attribute on the threadMessage", () => {
+		const tm = {
+			sentDate: 1700000000123,
+			mailboxId: sourceMailboxId,
+			isRead: false,
+			isDeleted: true,
+			hasStars: true,
+			hasAttachment: true,
+		};
+
+		const args = buildThreadMessageMoveUpdate(tm, 99, destinationMailboxId);
+
+		assert.deepStrictEqual(args.composites, {
+			sentDate: tm.sentDate,
+			mailboxId: tm.mailboxId,
+			isRead: tm.isRead,
+			isDeleted: tm.isDeleted,
+			hasStars: tm.hasStars,
+			hasAttachment: tm.hasAttachment,
+		});
+	});
+});
+
+const accountId = "alice-account-aaaaaaaaaa";
+
+describe("emitMoveResync (#1031)", () => {
+	// A move shifts a message between two folders; both folders' counts must
+	// refresh from IMAP via the existing per-folder SYNC_MESSAGES sync. Counts
+	// are never mutated locally — only re-read downstream.
+
+	it("emits SYNC_MESSAGES for both the source and destination folders", async () => {
+		const emit = mock.fn(async () => undefined);
+
+		await emitMoveResync(emit, {
+			accountId,
+			sourceMailboxId,
+			destinationMailboxId,
+		});
+
+		assert.equal(emit.mock.calls.length, 2);
+		assert.deepEqual(emit.mock.calls[0].arguments, [
+			{ type: "SYNC_MESSAGES", accountId, mailboxId: sourceMailboxId },
+		]);
+		assert.deepEqual(emit.mock.calls[1].arguments, [
+			{ type: "SYNC_MESSAGES", accountId, mailboxId: destinationMailboxId },
+		]);
+	});
+});
+
+describe("moveThenResync (#1031)", () => {
+	it("runs the resync after the move resolves", async () => {
+		const order: string[] = [];
+		const performMove = mock.fn(async () => {
+			order.push("move");
+		});
+		const resync = mock.fn(async () => {
+			order.push("resync");
+		});
+
+		await moveThenResync(performMove, resync);
+
+		assert.deepEqual(order, ["move", "resync"]);
+		assert.equal(resync.mock.calls.length, 1);
+	});
+
+	it("does not resync when the move fails, and propagates the error", async () => {
+		const performMove = mock.fn(async () => {
+			throw new Error("IMAP move failed");
+		});
+		const resync = mock.fn(async () => undefined);
+
+		await assert.rejects(
+			() => moveThenResync(performMove, resync),
+			/IMAP move failed/,
+		);
+
+		assert.equal(resync.mock.calls.length, 0);
+	});
+});