@remit/imap-worker 0.0.50 → 0.0.51

package/package.json

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

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

@@ -205,6 +205,8 @@ interface Connection {
 	) => Promise<{ uidMap: Map<number, number> }>;
 	deleteMessages: (uids: number[]) => Promise<void>;
 	createMailbox: (path: string) => Promise<void>;
+	fetchMessages: (uids: number[]) => Promise<{ uid: number }[]>;
+	search: (criteria: unknown[]) => Promise<number[]>;
 }
 
 interface Harness {
@@ -217,6 +219,7 @@ interface Harness {
 	mailbox: { mailboxId: string; uidValidity: number; cursorState?: string };
 	mailboxError?: Error;
 	connection: Connection;
+	threadMessageUpdateError?: Error;
 	threadMessage: Record<string, unknown> | null;
 	allThreadMessages: { accountConfigId: string; threadMessageId: string }[];
 	getConnectionCount: number;
@@ -240,8 +243,23 @@ const buildConnection = (): Connection => ({
 	createMailbox: record(
 		"connection.createMailbox",
 	) as Connection["createMailbox"],
+	// The source box still holds the uid unless a case says otherwise, so the
+	// presence probe only reports "gone" where a test made it true.
+	fetchMessages: async (uids: number[]) => uids.map((uid) => ({ uid })),
+	search: async (...args: unknown[]) => {
+		h.calls.push({ method: "connection.search", args });
+		return [10];
+	},
 });
 
+const sourceNoLongerHoldsTheUid = (): void => {
+	h.connection.fetchMessages = async () => [];
+	h.connection.search = async (...args: unknown[]) => {
+		h.calls.push({ method: "connection.search", args });
+		return [];
+	};
+};
+
 const fresh = (): Harness => ({
 	calls: [],
 	account: { accountId: "acc-1", accountConfigId: "cfg-1" },
@@ -277,7 +295,10 @@ const deps = (): MessageDeleteDeps =>
 			threadMessage: {
 				findByMessageId: async () => h.threadMessage,
 				findAllByMessageId: async () => h.allThreadMessages,
-				update: record("threadMessage.update"),
+				update: async (...args: unknown[]) => {
+					h.calls.push({ method: "threadMessage.update", args });
+					if (h.threadMessageUpdateError) throw h.threadMessageUpdateError;
+				},
 				delete: record("threadMessage.delete"),
 			},
 			mailbox: {
@@ -440,10 +461,13 @@ describe("handleMessageDelete", () => {
 		);
 	});
 
-	it("cleans up locally and swallows the error when the message is already gone on IMAP", async () => {
+	// Regression on #212: a permanent delete the server has already applied must
+	// still reconcile the local rows, now that the text alone no longer decides.
+	it("cleans up locally and swallows the error when the message is confirmed gone on IMAP", async () => {
 		h.connection.deleteMessages = async () => {
 			throw new Error("NONEXISTENT uid");
 		};
+		sourceNoLongerHoldsTheUid();
 
 		await handleMessageDelete(permanentEvent, noopLog, deps());
 
@@ -451,6 +475,109 @@ describe("handleMessageDelete", () => {
 		assert.equal(called("threadMessage.delete").length, 2);
 	});
 
+	// Issue #845. The three cases below are the same bug from three directions:
+	// "not found" in an error string is never on its own a reason to destroy the
+	// only local record of live mail.
+
+	it("keeps the rows when a move-to-trash fails after the MOVE landed", async () => {
+		// The MOVE succeeded; the ThreadMessage write behind it did not. The
+		// message is sitting in Trash, and the NotFoundError names a local row,
+		// not a mail-server one.
+		h.threadMessageUpdateError = Object.assign(
+			new Error("Thread message not found"),
+			{ name: "NotFoundError" },
+		);
+		sourceNoLongerHoldsTheUid();
+
+		await assert.rejects(
+			handleMessageDelete(moveEvent, noopLog, deps()),
+			/not found/,
+		);
+
+		assert.equal(
+			called("message.delete").length,
+			0,
+			"the message is in Trash; deleting its row loses the only handle on it",
+		);
+		assert.equal(called("threadMessage.delete").length, 0);
+		assert.equal(
+			called("connection.search").length,
+			0,
+			"a move-to-trash never probes: absence from the source is its success signature",
+		);
+		assert.equal(
+			(called("message.update")[0]?.args[1] as { syncStatus?: string })
+				?.syncStatus,
+			"failed",
+		);
+	});
+
+	it("keeps the rows on a NONEXISTENT move-to-trash whose source still holds the uid", async () => {
+		h.connection.moveMessages = async () => {
+			throw new Error("NONEXISTENT: mailbox does not exist");
+		};
+
+		await assert.rejects(
+			handleMessageDelete(moveEvent, noopLog, deps()),
+			/NONEXISTENT/,
+		);
+
+		assert.equal(called("message.delete").length, 0);
+		assert.equal(called("threadMessage.delete").length, 0);
+		assert.equal(
+			(called("message.update")[0]?.args[1] as { syncStatus?: string })
+				?.syncStatus,
+			"failed",
+		);
+	});
+
+	it("keeps the rows when a permanent delete's source still holds the uid", async () => {
+		h.connection.deleteMessages = async () => {
+			throw new Error("NONEXISTENT uid");
+		};
+		// imapflow drops rows on back-to-back FETCHes (#408); the SEARCH is what
+		// the verdict rests on, and it still lists the uid.
+		h.connection.fetchMessages = async () => [];
+
+		await assert.rejects(
+			handleMessageDelete(permanentEvent, noopLog, deps()),
+			/NONEXISTENT/,
+		);
+
+		assert.equal(
+			called("connection.search").length,
+			1,
+			"the error text only selects a candidate; the source box decides",
+		);
+		assert.equal(called("message.delete").length, 0);
+		assert.equal(called("threadMessage.delete").length, 0);
+	});
+
+	it("keeps the rows and rethrows the original error when the probe cannot answer", async () => {
+		// The SELECT is what failed, so there is no open box left for the probe
+		// to ask. The IMAP error must still be the one that rejects, and the row
+		// must not be stranded mid-delete for the record to carry to the DLQ.
+		h.connection.openBox = async () => {
+			throw new Error("NONEXISTENT mailbox does not exist");
+		};
+		h.connection.fetchMessages = async () => {
+			throw new Error("No mailbox selected");
+		};
+
+		await assert.rejects(
+			handleMessageDelete(permanentEvent, noopLog, deps()),
+			/NONEXISTENT mailbox does not exist/,
+		);
+
+		assert.equal(called("message.delete").length, 0);
+		assert.equal(called("threadMessage.delete").length, 0);
+		assert.equal(
+			(called("message.update")[0]?.args[1] as { syncStatus?: string })
+				?.syncStatus,
+			"failed",
+		);
+	});
+
 	it("creates the trash mailbox and rethrows on TRYCREATE", async () => {
 		h.connection.moveMessages = async () => {
 			throw new Error("TRYCREATE: no such mailbox");

package/src/handlers/message-delete.ts

@@ -8,6 +8,7 @@ import type { Logger } from "@remit/logger-lambda";
 import {
 	guardConnectionCursor,
 	isCursorRebuildNeeded,
+	isMessageGoneFromOpenMailbox,
 	MailboxCursorPausedError,
 } from "@remit/mailbox-service";
 import { isAccountDeleted } from "../account-check.js";
@@ -359,14 +360,32 @@ export const handleMessageDelete = async (
 					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")
-					) {
+					// Reconcile a permanent delete the server already applied (#212).
+					// The error text only nominates a candidate — the source box
+					// decides, since a landed move-to-trash reports that same text from
+					// a LOCAL lookup (#845) — and a probe that cannot answer counts as
+					// not-confirmed, leaving the original error to the rethrow below.
+					const isGoneFromSource =
+						operation === "permanent_delete" &&
+						(errorMessage.includes("not found") ||
+							errorMessage.includes("NONEXISTENT")) &&
+						(await scope
+							.getConnection()
+							.then((connection) =>
+								isMessageGoneFromOpenMailbox(connection, uid),
+							)
+							.catch((probeError: unknown) => {
+								log.warn(
+									{ messageId, uid, mailboxPath, probeError },
+									"Could not confirm whether the message is gone; keeping local rows",
+								);
+								return false;
+							}));
+
+					if (isGoneFromSource) {
 						log.info(
 							{ messageId, uid },
-							"Message not found on IMAP, cleaning up local",
+							"Message confirmed gone from 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).