@remit/imap-worker 0.0.75 → 0.0.76

package/package.json

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

package/src/handlers/mailbox-management.test.ts

@@ -596,37 +596,57 @@ describe("processMailboxManagement — the seventh state (#363, D3)", () => {
 	});
 });
 
+/** The delete intent a MAILBOX_DELETE is settled against. */
+const recordDeleteIntent = (): void => {
+	h.rows.set(
+		"mbx-1",
+		row({ mailboxId: "mbx-1", fullPath: "Archive", syncStatus: "deleting" }),
+	);
+};
+
 describe("processMailboxManagement — MAILBOX_DELETE", () => {
 	beforeEach(() => {
 		h = fresh();
+		recordDeleteIntent();
 	});
 
-	it("deletes on the server and drops the local row", async () => {
+	it("deletes on the server and takes the folder's mail with it", async () => {
 		await processMailboxManagement(deleteEvent, noopLogger, deps());
 
 		assert.equal(called("connection.deleteMailbox")[0]?.args[0], "Archive");
-		assert.deepEqual(called("mailbox.delete")[0]?.args, ["acc-1", "mbx-1"]);
+		assert.deepEqual(called("mailbox.deleteMailboxWithMail")[0]?.args, [
+			"acc-1",
+			"mbx-1",
+		]);
+		assert.equal(
+			called("mailbox.delete").length,
+			0,
+			"the bare row delete is what orphaned the folder's mail",
+		);
 	});
 
-	it("drops the local row when the folder is already gone on the server", async () => {
+	it("removes the folder's mail when the folder is already gone on the server", async () => {
 		h.connection.deleteMailbox = async () => {
 			throw new Error("Mailbox not found");
 		};
 
 		await processMailboxManagement(deleteEvent, noopLogger, deps());
 
-		assert.equal(called("mailbox.delete").length, 1);
+		assert.equal(called("mailbox.deleteMailboxWithMail").length, 1);
 	});
 
-	it("restores the mailbox and swallows the error when the server refuses to delete INBOX", async () => {
+	it("marks the delete failed rather than synced when the server refuses INBOX", async () => {
+		// The API refuses a delete of INBOX, so this backstop is unreachable from
+		// it. Reached another way, the honest outcome is `failed`: the folder was
+		// never deleted, and nothing was undone.
 		h.connection.deleteMailbox = async () => {
 			throw new Error("Cannot delete INBOX");
 		};
 
 		await processMailboxManagement(deleteEvent, noopLogger, deps());
 
-		assert.equal(lastSettle().to, "synced");
-		assert.equal(called("mailbox.delete").length, 0);
+		assert.equal(lastSettle().to, "failed");
+		assert.equal(called("mailbox.deleteMailboxWithMail").length, 0);
 	});
 
 	it("marks the mailbox failed and rethrows on any other delete error", async () => {
@@ -642,14 +662,21 @@ describe("processMailboxManagement — MAILBOX_DELETE", () => {
 		assert.equal(lastSettle().to, "failed");
 	});
 
-	it("acks terminally without rethrowing when the rollback write finds the row gone", async () => {
-		h.connection.deleteMailbox = async () => {
-			throw new Error("server exploded");
-		};
+	it("issues no DELETE when the row is not deleting", async () => {
+		h.rows.set("mbx-1", row({ mailboxId: "mbx-1", syncStatus: "synced" }));
+
+		await processMailboxManagement(deleteEvent, noopLogger, deps());
+
+		assert.equal(called("connection.deleteMailbox").length, 0);
+		assert.equal(called("mailbox.deleteMailboxWithMail").length, 0);
+	});
+
+	it("acks terminally without connecting when the folder row is gone", async () => {
 		h.mailboxRowGone = true;
 
 		await processMailboxManagement(deleteEvent, noopLogger, deps());
 
+		assert.equal(called("connection.deleteMailbox").length, 0);
 		assert.equal(h.disconnectCount, 1, "the scope is still disconnected");
 	});
 });
@@ -665,7 +692,8 @@ describe("processMailboxManagement — a tagged NO the server means as success (
 	 * only the message treated an already-absent folder as a failure: the row was
 	 * marked failed and the event left poisoning the account's queue.
 	 */
-	it("treats it as the delete already having happened, and drops the local row", async () => {
+	it("treats it as the delete already having happened, mail and all", async () => {
+		recordDeleteIntent();
 		h.connection.deleteMailbox = async () => {
 			throw Object.assign(new Error("Command failed"), {
 				serverResponseCode: "NONEXISTENT",
@@ -676,11 +704,15 @@ describe("processMailboxManagement — a tagged NO the server means as success (
 		await assert.doesNotReject(
 			processMailboxManagement(deleteEvent, noopLogger, deps()),
 		);
-		assert.deepEqual(called("mailbox.delete")[0]?.args, ["acc-1", "mbx-1"]);
+		assert.deepEqual(called("mailbox.deleteMailboxWithMail")[0]?.args, [
+			"acc-1",
+			"mbx-1",
+		]);
 		assert.equal(called("mailbox.transition").length, 0);
 	});
 
 	it("still marks failed and rethrows when the server fails for any other reason", async () => {
+		recordDeleteIntent();
 		h.connection.deleteMailbox = async () => {
 			throw Object.assign(new Error("Command failed"), {
 				serverResponseCode: "SERVERBUG",

package/src/handlers/mailbox-management.ts

@@ -5,7 +5,6 @@ import { isNotFoundError, NotFoundError } from "@remit/data-ports/errors";
 import { MailboxSyncStatus } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 import {
-	EVERY_MAILBOX_STATE,
 	FolderGoneUpstreamError,
 	FolderRenameSettleError,
 	isMailboxAbsentUpstream,
@@ -37,31 +36,6 @@ const defaultDeps: MailboxManagementDeps = {
 	createConnectionScope: createConnectionScopeWithCredentials,
 };
 
-/**
- * Write the outcome of a folder operation back, as the conditional write that
- * is the only way to write a folder's state
- * (docs/architecture/folder-rename-and-delete.md D3).
- *
- * The from-set is every state because that is what this write-back decides
- * against today — it is the unconditional write it replaces, moved onto the
- * door. #362 narrows the delete's to the state its intent recorded. A null
- * means the row is gone, which is the NotFoundError the whole-chain guards
- * below classify as the user having deleted the folder mid-sync.
- */
-const recordOutcome = async (
-	mailboxService: Pick<IMailboxRepository, "transition">,
-	accountId: string,
-	mailboxId: string,
-	to: (typeof MailboxSyncStatus)[keyof typeof MailboxSyncStatus],
-): Promise<void> => {
-	const written = await mailboxService.transition(accountId, mailboxId, {
-		from: EVERY_MAILBOX_STATE,
-		to,
-		set: {},
-	});
-	if (!written) throw new NotFoundError(`Mailbox not found: ${mailboxId}`);
-};
-
 /**
  * The outcome of a create, written against the state a create in flight is:
  * `pending` with no recorded rename target (D3, D10). Without the absence
@@ -438,37 +412,32 @@ const handleDelete = async (
 						}
 					})
 					.catch(async (error) => {
-						// If mailbox not found, it's already deleted (idempotent)
+						// The folder is already gone from the server, so the delete has
+						// happened. Its mail still goes with it (D8), which is the whole
+						// point of the settle.
 						if (isMailboxAbsentUpstream(error)) {
 							log.info(
-								{ accountId, mailboxId, path },
-								"Mailbox not found on IMAP, deleting local",
-							);
-							await mailboxService.delete(accountId, mailboxId);
-						} else if (
-							error instanceof Error &&
-							error.message.includes("Cannot delete INBOX")
-						) {
-							// Restore the mailbox
-							await recordOutcome(
-								mailboxService,
-								accountId,
-								mailboxId,
-								MailboxSyncStatus.synced,
-							);
-							log.error(
-								{ accountId, mailboxId, path },
-								"Cannot delete INBOX, restoring mailbox",
+								{ accountId, mailboxId, path, intent: "delete" },
+								"Mailbox not found on IMAP, removing the local folder and its mail",
 							);
-							// Don't rethrow - this is an expected error
+							await managementService.settleDelete(accountId, mailboxId);
 						} else {
-							// Restore the mailbox on other errors
-							await recordOutcome(
-								mailboxService,
-								accountId,
-								mailboxId,
-								MailboxSyncStatus.failed,
-							);
+							// T9, INBOX included. The API refuses a delete of INBOX, so the
+							// worker's backstop is unreachable from it; if something else
+							// reaches it, the honest outcome is `failed`, not `synced` —
+							// the folder was never deleted and nothing was undone.
+							await managementService.failDelete(accountId, mailboxId);
+							if (
+								error instanceof Error &&
+								error.message.includes("Cannot delete INBOX")
+							) {
+								log.error(
+									{ accountId, mailboxId, path, intent: "delete" },
+									"Cannot delete INBOX",
+								);
+								// Don't rethrow — no retry can make this succeed.
+								return;
+							}
 							throw error;
 						}
 					})