@remit/imap-worker 0.0.45 → 0.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/handlers/append-sent-message.test.ts

@@ -31,12 +31,7 @@ interface Harness {
 		deletedAt?: number;
 	};
 	outbox: Record<string, unknown>;
-	specialUseSent: { mailboxId: string; fullPath: string } | null;
-	mailboxes: {
-		mailboxId: string;
-		fullPath: string;
-		hierarchyDelimiter: string;
-	}[];
+	sentMailbox: { mailboxId: string; fullPath: string } | null;
 	append: (
 		path: string,
 		raw: Buffer,
@@ -72,15 +67,7 @@ const fresh = (): Harness => ({
 		inReplyTo: "parent@example.com",
 		sentAt: 1700000000000,
 	},
-	specialUseSent: { mailboxId: "sent-mbx", fullPath: "Sent" },
-	mailboxes: [
-		{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "/" },
-		{
-			mailboxId: "sent-items-mbx",
-			fullPath: "Sent Items",
-			hierarchyDelimiter: "/",
-		},
-	],
+	sentMailbox: { mailboxId: "sent-mbx", fullPath: "INBOX/Sent" },
 	append: async (path, raw, flags) => {
 		h.calls.push({ method: "connection.append", args: [path, raw, flags] });
 		return { uid: 55, uidValidity: 7 };
@@ -107,10 +94,7 @@ const deps = (): AppendSentMessageDeps =>
 				discardAll: record("outboxAttachment.discardAll"),
 			},
 			mailboxSpecialUse: {
-				findBySpecialUse: async () => h.specialUseSent,
-			},
-			mailbox: {
-				listAllByAccount: async () => h.mailboxes,
+				findSentMailbox: async () => h.sentMailbox,
 			},
 			secrets: {},
 		}),
@@ -150,7 +134,7 @@ describe("handleAppendSentMessage", () => {
 		await handleAppendSentMessage(event, noopLog, 1, deps());
 
 		const append = called("connection.append")[0];
-		assert.equal(append?.args[0], "Sent");
+		assert.equal(append?.args[0], "INBOX/Sent");
 		assert.deepEqual(append?.args[2], ["\\Seen"]);
 		assert.deepEqual(called("outboxMessage.delete")[0]?.args, [
 			"cfg-1",
@@ -194,60 +178,8 @@ describe("handleAppendSentMessage", () => {
 		assert.match(raw, /^From: alice@example\.com$/m);
 	});
 
-	it("falls back to a conventionally-named Sent folder when no special-use flag is set", async () => {
-		h.specialUseSent = null;
-
-		await handleAppendSentMessage(event, noopLog, 1, deps());
-
-		assert.equal(called("connection.append")[0]?.args[0], "Sent Items");
-	});
-
-	it("files into a Sent folder nested under INBOX when no special-use flag is set", async () => {
-		h.specialUseSent = null;
-		h.mailboxes = [
-			{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "/" },
-			{
-				mailboxId: "sent-mbx",
-				fullPath: "INBOX/Sent",
-				hierarchyDelimiter: "/",
-			},
-			{
-				mailboxId: "sent-messages-mbx",
-				fullPath: "INBOX/Sent Messages",
-				hierarchyDelimiter: "/",
-			},
-		];
-
-		await handleAppendSentMessage(event, noopLog, 1, deps());
-
-		assert.equal(called("connection.append")[0]?.args[0], "INBOX/Sent");
-		assert.deepEqual(called("outboxMessage.delete")[0]?.args, [
-			"cfg-1",
-			"out-1",
-		]);
-	});
-
-	it("files into a nested Sent folder under a non-INBOX prefix and a dot delimiter", async () => {
-		h.specialUseSent = null;
-		h.mailboxes = [
-			{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "." },
-			{
-				mailboxId: "sent-mbx",
-				fullPath: "Mail.Sent Items",
-				hierarchyDelimiter: ".",
-			},
-		];
-
-		await handleAppendSentMessage(event, noopLog, 1, deps());
-
-		assert.equal(called("connection.append")[0]?.args[0], "Mail.Sent Items");
-	});
-
 	it("settles the row as unfiled when the account has no Sent folder at all", async () => {
-		h.specialUseSent = null;
-		h.mailboxes = [
-			{ mailboxId: "inbox-mbx", fullPath: "INBOX", hierarchyDelimiter: "/" },
-		];
+		h.sentMailbox = null;
 
 		await handleAppendSentMessage(event, noopLog, 1, deps());
 
@@ -261,7 +193,7 @@ describe("handleAppendSentMessage", () => {
 		assert.deepEqual(update?.args.slice(0, 2), ["cfg-1", "out-1"]);
 		const patch = update?.args[2] as { status: string; lastError: string };
 		assert.equal(patch.status, "unfiled");
-		assert.match(patch.lastError, /no Sent folder/);
+		assert.match(patch.lastError, /no folder appointed to the Sent role/);
 	});
 
 	it("skips the append while the outbox row is not yet sent", async () => {

package/src/handlers/append-sent-message.ts

@@ -1,9 +1,5 @@
 import { getClient } from "@remit/backend/client";
-import type {
-	IMailboxRepository,
-	IMailboxSpecialUseRepository,
-} from "@remit/data-ports";
-import { MailboxSpecialUse, OutboxMessageStatus } from "@remit/domain-enums";
+import { OutboxMessageStatus } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 import {
 	buildMailMessage,
@@ -12,29 +8,11 @@ import {
 import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import type { AppendSentMessageEvent } from "../events.js";
-import { resolveSentMailboxByName } from "../sent-mailbox.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 
-const findSentMailbox = async (
-	mailboxSpecialUseService: IMailboxSpecialUseRepository,
-	mailboxService: IMailboxRepository,
-	accountId: string,
-): Promise<{ mailboxId: string; fullPath: string } | null> => {
-	const bySpecialUse = await mailboxSpecialUseService.findBySpecialUse(
-		accountId,
-		MailboxSpecialUse.Sent,
-	);
-	if (bySpecialUse) {
-		return bySpecialUse;
-	}
-
-	const mailboxes = await mailboxService.listAllByAccount(accountId);
-	return resolveSentMailboxByName(mailboxes);
-};
-
 const UNFILED_NO_SENT_MAILBOX =
-	"Sent, but not filed: this account has no Sent folder. Create one named Sent and later messages will be filed there.";
+	"Sent, but not filed: this account has no folder appointed to the Sent role and none that a Sent folder could be recognised by. Appoint one in the account's folder settings and later messages will be filed there.";
 
 const UNFILED_SIGNED_OUT =
 	"Sent, but not filed: this account has to be signed in again before a copy can be stored in Sent.";
@@ -100,7 +78,6 @@ export const handleAppendSentMessage = async (
 		outboxMessage: outboxMessageService,
 		outboxAttachment: outboxAttachmentService,
 		mailboxSpecialUse: mailboxSpecialUseService,
-		mailbox: mailboxService,
 		secrets,
 	} = await getClient();
 
@@ -144,11 +121,7 @@ export const handleAppendSentMessage = async (
 		);
 	};
 
-	const sentMailbox = await findSentMailbox(
-		mailboxSpecialUseService,
-		mailboxService,
-		accountId,
-	);
+	const sentMailbox = await mailboxSpecialUseService.findSentMailbox(accountId);
 	if (!sentMailbox) {
 		await settleUnfiled(UNFILED_NO_SENT_MAILBOX);
 		return;

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

@@ -367,6 +367,67 @@ describe("handleMessageDelete", () => {
 		);
 	});
 
+	// The queue handler `JSON.parse`s the body and casts it to WorkerEvent with
+	// no validation, so an event whose `operation` is missing, misspelled or
+	// from a newer producer reaches here. It must never be read as an expunge.
+	for (const [name, operation] of [
+		["missing", undefined],
+		["unknown", "trash"],
+		["empty", ""],
+	] as const) {
+		it(`abandons the delete and hands the row back when operation is ${name}`, async () => {
+			const malformed = {
+				...moveEvent,
+				operation,
+			} as unknown as MessageDeleteEvent;
+
+			await handleMessageDelete(malformed, noopLog, deps());
+
+			assert.equal(
+				called("connection.deleteMessages").length,
+				0,
+				"nothing may be expunged for an operation nobody wrote",
+			);
+			assert.equal(called("message.delete").length, 0);
+			assert.equal(called("threadMessage.delete").length, 0);
+
+			// The row goes back to the mailbox the server still holds it in, so
+			// the failure is visible as the message reappearing rather than as an
+			// invisible syncStatus on a row that claims Trash.
+			assert.deepEqual(called("message.updateUid")[0]?.args, [
+				"msg-1",
+				10,
+				"src-mbx",
+			]);
+			assert.deepEqual(called("message.update")[0]?.args[1], {
+				status: "active",
+				syncStatus: "failed",
+			});
+			assert.deepEqual(called("threadMessage.update")[0]?.args[2], {
+				uid: 10,
+				mailboxId: "src-mbx",
+				isDeleted: false,
+			});
+		});
+	}
+
+	it("refuses to expunge a move-to-trash that names no destination", async () => {
+		const destinationless = {
+			...moveEvent,
+			destinationMailboxId: undefined,
+			destinationMailboxPath: undefined,
+		} as MessageDeleteEvent;
+
+		await handleMessageDelete(destinationless, noopLog, deps());
+
+		assert.equal(called("connection.deleteMessages").length, 0);
+		assert.equal(called("message.delete").length, 0);
+		assert.deepEqual(called("message.update")[0]?.args[1], {
+			status: "active",
+			syncStatus: "failed",
+		});
+	});
+
 	it("expunges on the server and removes every thread row before the message row", async () => {
 		await handleMessageDelete(permanentEvent, noopLog, deps());
 

package/src/handlers/message-delete.ts

@@ -3,7 +3,7 @@ import type {
 	IThreadMessageRepository,
 	ThreadMessageItem,
 } from "@remit/data-ports";
-import { MessageSyncStatus } from "@remit/domain-enums";
+import { MessageStatus, MessageSyncStatus } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 import {
 	guardConnectionCursor,
@@ -56,16 +56,27 @@ export const deleteAllThreadMessagesForMessage = async (
  * the caller silently drops the update. Same root cause as PR #186 fixed for
  * `flag-queue.ts`.
  */
+type ThreadMessageRowState = Pick<
+	ThreadMessageItem,
+	| "sentDate"
+	| "mailboxId"
+	| "isRead"
+	| "isDeleted"
+	| "hasStars"
+	| "hasAttachment"
+>;
+
+const currentComposites = (threadMessage: ThreadMessageRowState) => ({
+	sentDate: threadMessage.sentDate,
+	mailboxId: threadMessage.mailboxId,
+	isRead: threadMessage.isRead,
+	isDeleted: threadMessage.isDeleted,
+	hasStars: threadMessage.hasStars,
+	hasAttachment: threadMessage.hasAttachment,
+});
+
 export const buildThreadMessageTrashUpdate = (
-	threadMessage: Pick<
-		ThreadMessageItem,
-		| "sentDate"
-		| "mailboxId"
-		| "isRead"
-		| "isDeleted"
-		| "hasStars"
-		| "hasAttachment"
-	>,
+	threadMessage: ThreadMessageRowState,
 	newUid: number,
 	destinationMailboxId: string,
 ) => ({
@@ -74,14 +85,27 @@ export const buildThreadMessageTrashUpdate = (
 		mailboxId: destinationMailboxId,
 		isDeleted: true,
 	},
-	composites: {
-		sentDate: threadMessage.sentDate,
-		mailboxId: threadMessage.mailboxId,
-		isRead: threadMessage.isRead,
-		isDeleted: threadMessage.isDeleted,
-		hasStars: threadMessage.hasStars,
-		hasAttachment: threadMessage.hasAttachment,
+	composites: currentComposites(threadMessage),
+});
+
+/**
+ * The inverse payload: put the thread row back where the message still is on
+ * the server. The delete was recorded optimistically, so a delete abandoned
+ * before any IMAP write has to hand the row back rather than leave it claiming
+ * Trash — an invisible `failed` on a row the user cannot see is the shape of
+ * the incident this whole change is about.
+ */
+export const buildThreadMessageMoveRevert = (
+	threadMessage: ThreadMessageRowState,
+	sourceUid: number,
+	sourceMailboxId: string,
+) => ({
+	set: {
+		uid: sourceUid,
+		mailboxId: sourceMailboxId,
+		isDeleted: false,
 	},
+	composites: currentComposites(threadMessage),
 });
 
 export interface MessageDeleteDeps {
@@ -198,7 +222,63 @@ export const handleMessageDelete = async (
 					);
 					await connection.openBox(mailboxPath, false);
 
-					if (operation === "move_to_trash" && destinationMailboxPath) {
+					// Only an operation that explicitly says so destroys mail. The
+					// event is `JSON.parse`d and cast in the queue handler with no
+					// validation, so a missing, misspelled or future `operation` must
+					// abandon the delete — the "anything that is not move_to_trash is
+					// an expunge" inference is the same one that destroyed mail in the
+					// service, and an unrecoverable EXPUNGE is not a default.
+					const abandonDelete = async (
+						reason: string,
+						alert: string,
+					): Promise<void> => {
+						log.error(
+							{ alert, accountId, messageId, uid, mailboxPath, operation },
+							reason,
+						);
+						await messageService.updateUid(messageId, uid, mailboxId);
+						await messageService.update(messageId, {
+							status: MessageStatus.active,
+							syncStatus: MessageSyncStatus.failed,
+						});
+						const threadMessage = await threadMessageService.findByMessageId(
+							account.accountConfigId,
+							messageId,
+						);
+						if (!threadMessage) return;
+						const args = buildThreadMessageMoveRevert(
+							threadMessage,
+							uid,
+							mailboxId,
+						);
+						await threadMessageService.update(
+							threadMessage.accountConfigId,
+							threadMessage.threadMessageId,
+							args.set,
+							{ composites: args.composites },
+						);
+					};
+
+					if (
+						operation !== "move_to_trash" &&
+						operation !== "permanent_delete"
+					) {
+						await abandonDelete(
+							"Refused to delete: event carries an unrecognized operation",
+							"message_delete_unknown_operation",
+						);
+					} else if (
+						operation === "move_to_trash" &&
+						(!destinationMailboxPath || !destinationMailboxId)
+					) {
+						// Defence in depth. `MessageMoveService` always sets both fields,
+						// so nothing mints such an event today; the guard exists so that
+						// a future producer that forgets one cannot reach the expunge.
+						await abandonDelete(
+							"Refused to delete: move to trash carries no destination mailbox",
+							"message_delete_missing_destination",
+						);
+					} else if (operation === "move_to_trash" && destinationMailboxPath) {
 						// Move to Trash
 						const result = await connection.moveMessages(
 							[uid],
@@ -244,7 +324,7 @@ export const handleMessageDelete = async (
 							});
 						}
 					} else {
-						// Permanent delete
+						// Permanent delete — reached only by `operation === "permanent_delete"`.
 						await connection.deleteMessages([uid]);
 
 						// Delete ThreadMessage rows BEFORE the Message row to collapse the

package/src/handlers/sync-messages.ts

@@ -383,6 +383,7 @@ const syncMailboxMessages = async (
 	const syncService = new MessageSyncService(
 		connectionFactory,
 		mailboxService,
+		mailboxSpecialUseService,
 		messageService,
 		envelopeService,
 		addressService,

package/src/sent-mailbox.test.ts

@@ -1,112 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	resolveSentMailboxByName,
-	type SentMailboxCandidate,
-} from "./sent-mailbox.js";
-
-const mailbox = (
-	fullPath: string,
-	hierarchyDelimiter = "/",
-): SentMailboxCandidate => ({
-	mailboxId: `mbx-${fullPath}`,
-	fullPath,
-	hierarchyDelimiter,
-});
-
-describe("resolveSentMailboxByName", () => {
-	it("finds a top-level Sent folder", () => {
-		const found = resolveSentMailboxByName([mailbox("INBOX"), mailbox("Sent")]);
-
-		assert.equal(found?.fullPath, "Sent");
-	});
-
-	it("finds a Sent folder nested under INBOX", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX"),
-			mailbox("INBOX/Archive"),
-			mailbox("INBOX/Sent"),
-		]);
-
-		assert.equal(found?.fullPath, "INBOX/Sent");
-	});
-
-	it("finds a nested Sent folder under a non-INBOX prefix with a non-slash delimiter", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("Mail.Drafts", "."),
-			mailbox("Mail.Sent Items", "."),
-		]);
-
-		assert.equal(found?.fullPath, "Mail.Sent Items");
-	});
-
-	it("finds the Gmail Sent folder by its leaf name", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX"),
-			mailbox("[Gmail]/All Mail"),
-			mailbox("[Gmail]/Sent Mail"),
-		]);
-
-		assert.equal(found?.fullPath, "[Gmail]/Sent Mail");
-	});
-
-	it("prefers the shallowest folder when several leaves match", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX/Clients/Sent"),
-			mailbox("INBOX/Sent"),
-		]);
-
-		assert.equal(found?.fullPath, "INBOX/Sent");
-	});
-
-	it("prefers the plain Sent name over the longer variants", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX/Sent Messages"),
-			mailbox("INBOX/Sent"),
-		]);
-
-		assert.equal(found?.fullPath, "INBOX/Sent");
-	});
-
-	it("matches the leaf regardless of case", () => {
-		const found = resolveSentMailboxByName([mailbox("INBOX.sent items", ".")]);
-
-		assert.equal(found?.fullPath, "INBOX.sent items");
-	});
-
-	it("does not match a folder that merely starts with a Sent name", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX/Sent Archive 2024"),
-			mailbox("INBOX/Sentinel"),
-		]);
-
-		assert.equal(found, null);
-	});
-
-	it("prefers a shallower Sent over a deeper better-named one", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX.Sent Items", "."),
-			mailbox("INBOX.Trash.Sent", "."),
-		]);
-
-		assert.equal(found?.fullPath, "INBOX.Sent Items");
-	});
-
-	it("resolves a flat namespace that reports no delimiter at all", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX", ""),
-			mailbox("Sent", ""),
-		]);
-
-		assert.equal(found?.fullPath, "Sent");
-	});
-
-	it("returns null when the account has no Sent folder", () => {
-		const found = resolveSentMailboxByName([
-			mailbox("INBOX"),
-			mailbox("INBOX/Trash"),
-		]);
-
-		assert.equal(found, null);
-	});
-});

package/src/sent-mailbox.ts

@@ -1,20 +0,0 @@
-import type { MailboxItem } from "@remit/data-ports";
-import { resolveMailboxByLeafName } from "@remit/data-ports/mailbox-name";
-
-export type SentMailboxCandidate = Pick<
-	MailboxItem,
-	"mailboxId" | "fullPath" | "hierarchyDelimiter"
->;
-
-const SENT_FOLDER_NAMES = ["sent", "sent items", "sent messages", "sent mail"];
-
-/**
- * The Sent folder by conventional name, for servers that advertise no `\Sent`
- * special-use. Matches the folder's own leaf segment, so it resolves at any
- * depth under any prefix (`INBOX/Sent`, `Mail.Sent Items`, `[Gmail]/Sent Mail`)
- * without knowing which prefixes a server uses.
- */
-export const resolveSentMailboxByName = (
-	mailboxes: SentMailboxCandidate[],
-): SentMailboxCandidate | null =>
-	resolveMailboxByLeafName(mailboxes, SENT_FOLDER_NAMES);