@remit/imap-worker 0.0.90 → 0.0.92

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

@@ -1,147 +0,0 @@
-import type {
-	IMessageRepository,
-	IThreadMessageRepository,
-	MessageItem,
-} from "@remit/data-ports";
-import { MessageMutation, MessageSyncStatus } from "@remit/domain-enums";
-import {
-	type IImapConnection,
-	isMessageGoneFromOpenMailbox,
-	restoreSourcePlacement,
-} from "@remit/mailbox-service";
-
-export interface MessageDeleteTerminalLogger {
-	info(obj: Record<string, unknown>, msg: string): void;
-	error(obj: Record<string, unknown>, msg: string): void;
-}
-
-export interface ResolveExhaustedMessageDeleteDeps {
-	messageService: Pick<
-		IMessageRepository,
-		"deleteIfPlacement" | "transitionPlacement"
-	>;
-	threadMessageService: Pick<
-		IThreadMessageRepository,
-		"findAllByMessageId" | "deleteMany" | "update"
-	>;
-	log: MessageDeleteTerminalLogger;
-}
-
-export interface ResolveExhaustedMessageDeleteInput {
-	/** Where the row stood when the caller read it; the delete holds only while it still does. */
-	placement: Pick<MessageItem, "status" | "mailboxId" | "uid">;
-	accountId: string;
-	accountConfigId: string;
-	messageId: string;
-	sourceMailboxId: string;
-	uid: number;
-	sourceMailboxPath: string;
-	getConnection: () => Promise<IImapConnection>;
-}
-
-export type MessageDeleteTerminalOutcome = "reconciled" | "broken";
-
-export interface ResolveExhaustedMessageDeleteResult {
-	outcome: MessageDeleteTerminalOutcome;
-}
-
-/**
- * Resolve a MESSAGE_DELETE failure that has exhausted its redelivery budget
- * into exactly one of two terminal outcomes, mirroring
- * `resolveExhaustedMessageMoveFailure` for the same failure taxonomy (issue
- * #655) — no third, softer outcome.
- *
- * 1. RECONCILED (expected) — the message no longer exists at the delete's
- *    source on IMAP, confirmed by {@link isMessageGoneFromOpenMailbox} rather
- *    than by a FETCH coming back empty. The move to Trash landed server-side,
- *    or a foreign client moved or expunged the message; from here those are
- *    indistinguishable and have the same answer. The stale rows are deleted via
- *    `deleteIfPlacement` and the caller resyncs the affected folders,
- *    so whichever folder actually holds the message re-projects it with the
- *    server's own UID. Metric only, no alarm — routine.
- * 2. BROKEN — the message is still at the source, so the delete never took
- *    effect, but it keeps failing: broken code or a broken account, not a
- *    transient blip. The row is put back where the server has just said the
- *    message is: `mailboxId` and `uid` return to the delete's source pair, and
- *    the thread rows lose the deletion mark the optimistic transition
- *    wrote (issue #1098).
- *
- *    Settling `status` to `active` while leaving `mailboxId` on Trash is what
- *    this replaces. `bindsForeignUid` refuses a mismatched pair only while
- *    `status` is `moving`, so clearing it read as consistent, and the UI then
- *    offered "Delete permanently" on a Trash mailbox with the source folder's
- *    uid — an expunge naming a different message. Restoring the pair is not a
- *    revert on ambiguity (what PR #652 was pulled for): the presence probe
- *    above has just answered, so this writes a placement the server confirmed.
- *
- * A server that cannot be reached at exhaustion time never reaches either
- * verdict: the probe throws and the record dead-letters with the row untouched.
- * Absence is only ever concluded from an answer the server gave.
- */
-export const resolveExhaustedMessageDeleteFailure = async (
-	deps: ResolveExhaustedMessageDeleteDeps,
-	input: ResolveExhaustedMessageDeleteInput,
-): Promise<ResolveExhaustedMessageDeleteResult> => {
-	const {
-		accountId,
-		accountConfigId,
-		messageId,
-		sourceMailboxId,
-		uid,
-		sourceMailboxPath,
-		getConnection,
-	} = input;
-
-	const connection = await getConnection();
-	await connection.openBox(sourceMailboxPath, true);
-
-	if (await isMessageGoneFromOpenMailbox(connection, uid)) {
-		const reconciled = await deps.messageService.deleteIfPlacement(
-			messageId,
-			input.placement,
-		);
-		deps.log.info(
-			{
-				metric: "message_delete_stale_row_reconciled",
-				accountId,
-				accountConfigId,
-				messageId,
-				uid,
-				sourceMailboxPath,
-				reconciled,
-			},
-			"Message no longer at its delete source after retry exhaustion (the delete landed server-side, or an external delete or move); stale row reconciled",
-		);
-		return { outcome: "reconciled" };
-	}
-
-	deps.log.error(
-		{
-			alert: "message_delete_failed",
-			accountId,
-			accountConfigId,
-			messageId,
-			uid,
-			sourceMailboxId,
-			sourceMailboxPath,
-		},
-		"Delete could not be pushed to IMAP after retry exhaustion; the message is still at its source — row moved back to the source folder",
-	);
-
-	await restoreSourcePlacement(deps, {
-		accountConfigId,
-		messageId,
-		sourceMailboxId,
-		uid,
-		// The probe above just confirmed the pair, so the row is a faithful
-		// projection of the source again — and the delete the user asked for did
-		// not happen, with nothing left to try it. `abandoned` is the value that
-		// says so without claiming a retry is coming (imap-mutations R3); the
-		// alert stays for the operator, and the mutation names itself so the
-		// reading pane offers the right way out (issue #1229).
-		syncStatus: MessageSyncStatus.abandoned,
-		abandonedMutation: MessageMutation.delete,
-	});
-
-	return { outcome: "broken" };
-};

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

@@ -1,291 +0,0 @@
-import assert from "node:assert/strict";
-import { after, before, describe, it } from "node:test";
-import type { RemitClient } from "@remit/backend/client";
-import {
-	MailboxCursorState,
-	MailboxSpecialUse,
-	MessageMutation,
-	MessageStatus,
-	MessageSyncStatus,
-} from "@remit/domain-enums";
-import type { MessageDeleteEvent } from "../events.js";
-import { mail, openStore, type World } from "../test-helpers/test-world.js";
-import { handleMessageDelete } from "./message-delete.js";
-
-let store: Awaited<ReturnType<typeof openStore>>;
-
-before(async () => {
-	store = await openStore();
-});
-
-after(() => store.close());
-
-interface Arranged {
-	w: World;
-	messageId: string;
-	uid: number;
-	messageIdHeader: string;
-	inboxId: string;
-	trashId: string;
-	event: MessageDeleteEvent;
-}
-
-/**
- * A message in INBOX, deleted through the service the API calls, so the row
- * the handler finds and the event it gets are the ones a person's delete
- * leaves behind.
- */
-const arrange = async (
-	options: { permanent?: boolean; olderCopyInTrash?: boolean } = {},
-): Promise<Arranged> => {
-	const w = await store.world();
-	const inbox = await w.folder("INBOX");
-	const trash = await w.folder("Trash", {
-		specialUse: MailboxSpecialUse.Trash,
-	});
-	const seeded = await w.message(inbox);
-	if (options.olderCopyInTrash)
-		w.imap.deliver("Trash", mail(seeded.messageIdHeader));
-
-	await w.client.messageMove.deleteMessage(
-		w.account.accountConfigId,
-		seeded.messageId,
-		w.account.accountId,
-		options.permanent ? { permanent: true } : { toTrash: true },
-	);
-	const event = w
-		.queued()
-		.find(
-			(body) => body.type === "MESSAGE_DELETE",
-		) as unknown as MessageDeleteEvent;
-	assert.ok(event, "the delete enqueued a MESSAGE_DELETE");
-
-	return {
-		w,
-		messageId: seeded.messageId,
-		uid: seeded.uid,
-		messageIdHeader: seeded.messageIdHeader,
-		inboxId: inbox.mailboxId,
-		trashId: trash.mailboxId,
-		event,
-	};
-};
-
-const run = (a: Arranged, receiveCount = 1, event = a.event) =>
-	handleMessageDelete(event, a.w.log, a.w.queues, receiveCount, a.w.scope);
-
-const resyncs = (w: World): unknown[] =>
-	w
-		.queued()
-		.filter((body) => body.type === "SYNC_MESSAGES")
-		.map((body) => body.mailboxId);
-
-const client = (): RemitClient => store.client;
-
-describe("a move to Trash", () => {
-	it("lands in Trash and settles the row on the uid the server gave it", async () => {
-		const a = await arrange();
-
-		await run(a);
-
-		assert.deepEqual(a.w.imap.uids("INBOX"), []);
-		const [trashUid] = a.w.imap.uids("Trash", a.messageIdHeader);
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.mailboxId, a.trashId);
-		assert.equal(row?.uid, trashUid);
-		assert.equal(row?.status, MessageStatus.active);
-		assert.deepEqual(await a.w.threadRows(a.messageId), [
-			{ mailboxId: a.trashId, uid: trashUid, isDeleted: true },
-		]);
-	});
-
-	// Issue #1122. Without UIDPLUS the destination is asked by Message-ID, and
-	// Trash already holds an older copy: binding the row to it lets Empty Trash
-	// expunge the wrong one and leaves the fresh copy unreachable.
-	it("settles on the copy this move delivered when the server sends no COPYUID", async () => {
-		const a = await arrange({ olderCopyInTrash: true });
-		a.w.imap.uidplus = false;
-
-		await run(a);
-
-		const copies = a.w.imap.uids("Trash", a.messageIdHeader);
-		assert.equal(copies.length, 2);
-		assert.equal((await a.w.row(a.messageId))?.uid, Math.max(...copies));
-	});
-
-	// One Message-ID can have several server copies. A source that still holds
-	// the uid proves the MOVE never ran, so the older copy in Trash is not this
-	// message and must never settle the row.
-	it("never settles on an older copy in Trash while the source still holds the message", async () => {
-		const a = await arrange({ olderCopyInTrash: true });
-		a.w.imap.uidplus = false;
-		a.w.imap.ignoreNext.add("MOVE");
-
-		await assert.rejects(run(a), /unconfirmed/);
-
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.uid, a.uid);
-		assert.equal(row?.status, MessageStatus.moving);
-		assert.equal(row?.syncStatus, MessageSyncStatus.failed);
-	});
-
-	it("issues nothing when a redelivery finds the delete already settled", async () => {
-		const a = await arrange();
-		await run(a);
-		const settled = await a.w.row(a.messageId);
-		const commands = a.w.imap.log.length;
-
-		await run(a);
-
-		assert.equal(
-			a.w.imap.log.length,
-			commands,
-			"no IMAP command on redelivery",
-		);
-		assert.deepEqual(await a.w.row(a.messageId), settled);
-	});
-
-	it("marks the row failed and redelivers when the connection drops mid-move", async () => {
-		const a = await arrange();
-		a.w.imap.failNext.MOVE = new Error("Connection reset");
-
-		await assert.rejects(run(a), /Connection reset/);
-
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.status, MessageStatus.moving);
-		assert.equal(row?.syncStatus, MessageSyncStatus.failed);
-		assert.deepEqual(a.w.imap.uids("INBOX"), [a.uid]);
-	});
-
-	// Issue #980. At the ceiling the server is asked where the message is, and
-	// a message that never left INBOX puts the row back there.
-	it("puts the row back on its source at the ceiling when the message never left", async () => {
-		const a = await arrange();
-		a.w.imap.failNext.MOVE = new Error("Connection reset");
-
-		await run(a, 3);
-
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.mailboxId, a.inboxId);
-		assert.equal(row?.uid, a.uid);
-		assert.notEqual(row?.status, MessageStatus.moving);
-		assert.deepEqual(resyncs(a.w), [a.inboxId, a.trashId]);
-	});
-
-	it("hands the row back without creating a Trash the server does not have", async () => {
-		const a = await arrange();
-		a.w.imap.removeFolder("Trash");
-
-		await run(a);
-
-		assert.deepEqual(a.w.imap.commands("CREATE"), []);
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.mailboxId, a.inboxId);
-		assert.equal(row?.uid, a.uid);
-		assert.equal(row?.syncStatus, MessageSyncStatus.abandoned);
-		assert.equal(row?.abandonedMutation, MessageMutation.delete);
-	});
-
-	it("hands the row back without connecting while the source cursor is rebuilding", async () => {
-		const a = await arrange();
-		await client().mailbox.update(a.w.account.accountId, a.inboxId, {
-			cursorState: MailboxCursorState.rebuilding,
-		});
-
-		await run(a);
-
-		assert.equal(a.w.imap.connections, 0);
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.mailboxId, a.inboxId);
-		assert.equal(row?.status, MessageStatus.active);
-		assert.equal(
-			a.w.logs.filter(
-				(line) => line.fields.metric === "message_delete_dropped_on_pause",
-			).length,
-			1,
-		);
-		assert.deepEqual(resyncs(a.w), [a.inboxId, a.trashId]);
-	});
-
-	// The folder was deleted and recreated on the server: uid 1 now names
-	// whatever the server put there. Nothing may be moved by it.
-	it("moves nothing when the source's UIDVALIDITY changed under it", async () => {
-		const a = await arrange();
-		a.w.imap.setUidValidity("INBOX", 2);
-
-		await run(a);
-
-		assert.deepEqual(a.w.imap.commands("MOVE"), []);
-		assert.equal((await a.w.row(a.messageId))?.mailboxId, a.inboxId);
-		const inbox = await client().mailbox.get(a.w.account.accountId, a.inboxId);
-		assert.notEqual(inbox.cursorState, MailboxCursorState.normal);
-	});
-
-	it("moves from the folder's current path when it was renamed after enqueue", async () => {
-		const a = await arrange();
-		a.w.imap.renameFolder("INBOX", "Old/Inbox");
-		await client().mailbox.update(a.w.account.accountId, a.inboxId, {
-			fullPath: "Old/Inbox",
-		});
-
-		await run(a);
-
-		assert.deepEqual(a.w.imap.uids("Old/Inbox"), []);
-		assert.equal(a.w.imap.uids("Trash", a.messageIdHeader).length, 1);
-	});
-
-	it("acks without connecting when the source mailbox was deleted", async () => {
-		const a = await arrange();
-		await client().mailbox.delete(a.w.account.accountId, a.inboxId);
-
-		await run(a);
-
-		assert.equal(a.w.imap.connections, 0);
-	});
-
-	it("refuses an event minted under an unknown contract and hands the row back", async () => {
-		const a = await arrange();
-
-		await run(a, 1, {
-			...a.event,
-			schemaVersion: 99,
-		} as unknown as MessageDeleteEvent);
-
-		assert.equal(a.w.imap.connections, 0);
-		const row = await a.w.row(a.messageId);
-		assert.equal(row?.mailboxId, a.inboxId);
-		assert.equal(row?.syncStatus, MessageSyncStatus.abandoned);
-	});
-});
-
-describe("a permanent delete", () => {
-	it("expunges the message and removes every local row", async () => {
-		const a = await arrange({ permanent: true });
-
-		await run(a);
-
-		assert.deepEqual(a.w.imap.uids("INBOX"), []);
-		assert.equal(await a.w.row(a.messageId), undefined);
-		assert.deepEqual(await a.w.threadRows(a.messageId), []);
-	});
-
-	it("cleans up locally when another client already expunged it", async () => {
-		const a = await arrange({ permanent: true });
-		a.w.imap.empty("INBOX");
-		a.w.imap.failNext.EXPUNGE = new Error("Message not found (NONEXISTENT)");
-
-		await run(a);
-
-		assert.equal(await a.w.row(a.messageId), undefined);
-	});
-
-	it("keeps the row when the server still holds the message after a failed expunge", async () => {
-		const a = await arrange({ permanent: true });
-		a.w.imap.failNext.EXPUNGE = new Error("Message not found (NONEXISTENT)");
-
-		await assert.rejects(run(a), /NONEXISTENT/);
-
-		assert.equal((await a.w.row(a.messageId))?.status, MessageStatus.deleting);
-		assert.deepEqual(a.w.imap.uids("INBOX"), [a.uid]);
-	});
-});