@remit/imap-worker 0.0.85 → 0.0.87

package/src/handlers/message-move.ts

@@ -5,8 +5,8 @@ import {
 	MessageStatus,
 	MessageSyncStatus,
 } from "@remit/domain-enums";
-import type { Logger } from "@remit/logger-lambda";
-import { recordImapFailure } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
+import { recordImapFailure } from "@remit/logger-lambda/metrics";
 import {
 	guardConnectionCursor,
 	type IImapConnection,
@@ -23,6 +23,7 @@ import { findMailboxRow } from "../mailbox-row.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { resolveExhaustedMessageMoveFailure } from "./message-move-terminal.js";
+import { probeableMessageIdHeader } from "./probe-message-id.js";
 
 export const getMessageMoveMaxAttempts = (
 	processEnv: NodeJS.ProcessEnv = process.env,
@@ -229,22 +230,6 @@ export const buildThreadMessageMoveUpdate = (
 	},
 });
 
-export interface MessageMoveDeps {
-	getClient: typeof getClient;
-	buildLifecycleDeps: typeof buildLifecycleDeps;
-	withOAuthLifecycle: typeof withOAuthLifecycle;
-	createConnectionScope: typeof createConnectionScopeWithCredentials;
-	emitEvent: typeof emitEvent;
-}
-
-const defaultDeps: MessageMoveDeps = {
-	getClient,
-	buildLifecycleDeps,
-	withOAuthLifecycle,
-	createConnectionScope: createConnectionScopeWithCredentials,
-	emitEvent,
-};
-
 /**
  * Handle MESSAGE_MOVE events.
  * Executes IMAP MOVE command and updates local state with new UID.
@@ -260,16 +245,8 @@ export const handleMessageMove = async (
 	event: MessageMoveEvent,
 	log: Logger,
 	receiveCount = 1,
-	deps: MessageMoveDeps = defaultDeps,
+	createConnectionScope = createConnectionScopeWithCredentials,
 ): Promise<void> => {
-	const {
-		getClient,
-		buildLifecycleDeps,
-		withOAuthLifecycle,
-		createConnectionScope: createConnectionScopeWithCredentials,
-		emitEvent,
-	} = deps;
-
 	const {
 		account: accountService,
 		message: messageService,
@@ -341,17 +318,35 @@ export const handleMessageMove = async (
 			// a queued event pointing at a gone row. The lookup then throws
 			// NotFoundError forever, and on the account's per-group FIFO that head
 			// message stalls the whole pipeline (issues #287, #289, #290). A deleted
-			// source mailbox makes the move moot: ack with a WARN.
+			// source mailbox makes the move moot, but not the row: left `moving`, it
+			// names the destination with a uid from a folder that no longer exists,
+			// and nothing else settles it. It is reconciled away, and the destination
+			// resync re-projects the message if the MOVE did land there.
 			const source = await findMailboxRow(
 				mailboxService,
 				accountId,
 				sourceMailboxId,
 			);
 			if (source.kind === "gone") {
+				const reconciled = await messageService.deleteIfPlacement(messageId, {
+					status: message.status,
+					mailboxId: message.mailboxId,
+					uid: message.uid,
+				});
 				log.warn(
-					{ accountId, messageId, mailboxId: sourceMailboxId },
-					"Skipping MESSAGE_MOVE: source mailbox no longer exists (deleted)",
+					{
+						metric: "message_move_source_gone",
+						accountId,
+						messageId,
+						mailboxId: sourceMailboxId,
+						reconciled,
+					},
+					"MESSAGE_MOVE not pushed: source mailbox no longer exists (deleted); stale row reconciled",
 				);
+				await emitMailboxResync(emitEvent, {
+					accountId,
+					mailboxId: destinationMailboxId,
+				});
 				return;
 			}
 			const mailbox = source.mailbox;
@@ -462,7 +457,7 @@ export const handleMessageMove = async (
 			}
 			const destinationMailboxPath = destination.mailbox.fullPath;
 
-			const scope = createConnectionScopeWithCredentials(account, credentials);
+			const scope = createConnectionScope(account, credentials);
 
 			// The terminal resolver opens the source itself, and its answer now
 			// WRITES a placement, so it has to reach IMAP through the same
@@ -504,7 +499,11 @@ export const handleMessageMove = async (
 
 				const placement: PausedPlacement = mayHaveIssued
 					? await probePausedPlacement(await scope.getConnection(), {
-							messageIdHeader: message.messageIdHeader,
+							messageIdHeader: await probeableMessageIdHeader(
+								threadMessageService,
+								account.accountConfigId,
+								messageId,
+							),
 							sourceMailboxPath,
 							destinationMailboxPath,
 						})
@@ -602,13 +601,19 @@ export const handleMessageMove = async (
 							// because a handler that returns never redelivers.
 							const newUid =
 								result.uidMap.get(uid) ??
-								(message.messageIdHeader
-									? await searchMailboxForHighestMessageIdUid(
-											rawConnection,
-											destinationMailboxPath,
-											message.messageIdHeader,
-										)
-									: null);
+								(await probeableMessageIdHeader(
+									threadMessageService,
+									account.accountConfigId,
+									messageId,
+								).then((messageIdHeader) =>
+									messageIdHeader
+										? searchMailboxForHighestMessageIdUid(
+												rawConnection,
+												destinationMailboxPath,
+												messageIdHeader,
+											)
+										: null,
+								));
 
 							if (!newUid) {
 								throw new Error(
@@ -679,6 +684,11 @@ export const handleMessageMove = async (
 					const settled = await resolveExhaustedMessageMoveFailure(
 						{ messageService, threadMessageService, log },
 						{
+							placement: {
+								status: message.status,
+								mailboxId: message.mailboxId,
+								uid: message.uid,
+							},
 							accountId,
 							accountConfigId: account.accountConfigId,
 							messageId,

package/src/handlers/placement-move-push.test.ts

@@ -1,370 +1,137 @@
 import assert from "node:assert/strict";
-import { afterEach, before, describe, it, mock } from "node:test";
-import { getClient, type RemitClient, setClient } from "@remit/backend/client";
-import type { Logger } from "@remit/logger-lambda";
-import type { IImapConnection } from "@remit/mailbox-service";
-import type { PlacementMovePushEvent } from "../events.js";
+import { describe, it } from "node:test";
 import {
-	attemptMove,
-	getPlacementMoveMaxAttempts,
-	handlePlacementMovePush,
-	PLACEMENT_MOVE_MAX_ATTEMPTS,
-} from "./placement-move-push.js";
-
-const silentLogger = (() => {
-	const noop = () => {};
-	const log = {
-		info: noop,
-		warn: noop,
-		error: noop,
-		debug: noop,
-		fatal: noop,
-		trace: noop,
-		child: () => log,
-	} as unknown as Logger;
-	return log;
-})();
-
-const buildConnection = (opts: {
-	uidMap?: Map<number, number>;
-	moveError?: Error;
-	/** Message-ID search hits in the destination mailbox — the verification probe. */
-	destinationSearchUids?: number[];
-	/** Whether the message is still in the source mailbox. */
-	stillAtSource?: boolean;
-	/** The source FETCH drops the row for a message that is still there. */
-	sourceFetchDrops?: boolean;
-}): IImapConnection =>
-	({
-		openBox: async () => ({}) as never,
-		moveMessages: async (_uids: number[], destination: string) => {
-			if (opts.moveError) throw opts.moveError;
-			return {
-				destination,
-				uidValidity: 1,
-				uidMap: opts.uidMap ?? new Map(),
-			};
-		},
-		search: async (criteria: unknown[]) => {
-			const [first] = criteria;
-			if (Array.isArray(first) && first[0] === "UID") {
-				return opts.stillAtSource ? [Number(first[1])] : [];
-			}
-			return opts.destinationSearchUids ?? [];
-		},
-		fetchMessages: async (uids: number[]) =>
-			opts.stillAtSource && !opts.sourceFetchDrops
-				? uids.map((uid) => ({ uid }) as unknown as never)
-				: [],
-	}) as unknown as IImapConnection;
-
-const MESSAGE_ID_HEADER = "<abc@example.com>";
+	eml,
+	FakeImapServer,
+} from "@remit/mailbox-service/test-helpers/fake-imap";
+import { attemptMove } from "./placement-move-push.js";
+
+const HEADER = "<abc@example.com>";
+
+/** Junk holds the message at uid 42; INBOX is where the placement sends it. */
+const arrange = (
+	options: { inJunk?: boolean; inInbox?: boolean; inboxExists?: boolean } = {},
+) => {
+	const server = new FakeImapServer();
+	server.addFolder("Junk");
+	if (options.inboxExists !== false) server.addFolder("INBOX");
+	if (options.inJunk !== false)
+		server.deliver("Junk", eml({ "Message-ID": HEADER }), { uid: 42 });
+	if (options.inInbox) server.deliver("INBOX", eml({ "Message-ID": HEADER }));
+	return server;
+};
+
+const move = (
+	server: FakeImapServer,
+	header: string | undefined = HEADER,
+	source = server.connection(),
+) => attemptMove(source, server.connection(), "Junk", "INBOX", 42, header);
 
 describe("attemptMove — the IMAP push (issue #1271)", () => {
-	// Tests use the SAME fake connection for both the source and destination
-	// params — attemptMove treats them as independent handles (real cursor
-	// guarding per mailbox is #1272's `guardConnectionCursor`, tested in
-	// remit-mailbox-service; not re-tested here).
-	it("moved: returns the new uid from the COPYUID map", async () => {
-		const connection = buildConnection({ uidMap: new Map([[42, 99]]) });
+	it("moves the message and returns the uid from the COPYUID map", async () => {
+		const server = arrange();
 
-		const outcome = await attemptMove(
-			connection,
-			connection,
-			"Junk",
-			"INBOX",
-			42,
-			MESSAGE_ID_HEADER,
-		);
-
-		assert.equal(outcome.kind, "moved");
-		assert.equal(outcome.newUid, 99);
-	});
+		const outcome = await move(server);
 
-	it("trycreate: the destination mailbox does not exist yet", async () => {
-		const connection = buildConnection({
-			moveError: new Error("Command failed: TRYCREATE"),
+		assert.deepEqual(outcome, {
+			kind: "moved",
+			newUid: server.uids("INBOX", HEADER)[0],
 		});
-
-		const outcome = await attemptMove(
-			connection,
-			connection,
-			"Junk",
-			"NewLabel",
-			42,
-			MESSAGE_ID_HEADER,
-		);
-
-		assert.equal(outcome.kind, "trycreate");
+		assert.deepEqual(server.uids("Junk"), []);
 	});
 
-	it("propagates any other error untouched (transient/infra failure, retried by the caller)", async () => {
-		const connection = buildConnection({
-			moveError: new Error("ECONNRESET"),
-		});
+	it("answers trycreate when the destination does not exist yet", async () => {
+		const server = arrange({ inboxExists: false });
 
-		await assert.rejects(
-			() =>
-				attemptMove(
-					connection,
-					connection,
-					"Junk",
-					"INBOX",
-					42,
-					MESSAGE_ID_HEADER,
-				),
-			/ECONNRESET/,
-		);
+		assert.equal((await move(server)).kind, "trycreate");
 	});
 
-	describe("no COPYUID entry / explicit not-found — never trust either without verification (PR #1289 review finding 2)", () => {
-		it("moved: no COPYUID entry, but a Message-ID search finds it at the destination (non-UIDPLUS server, genuine success)", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				destinationSearchUids: [77],
-			});
-
-			const outcome = await attemptMove(
-				connection,
-				connection,
-				"Junk",
-				"INBOX",
-				42,
-				MESSAGE_ID_HEADER,
-			);
-
-			assert.equal(outcome.kind, "moved");
-			assert.equal(outcome.newUid, 77);
-		});
-
-		it("moved: explicit NONEXISTENT error, but a Message-ID search finds it at the destination", async () => {
-			const connection = buildConnection({
-				moveError: new Error("Command failed: NONEXISTENT no such message"),
-				destinationSearchUids: [77],
-			});
-
-			const outcome = await attemptMove(
-				connection,
-				connection,
-				"Junk",
-				"INBOX",
-				42,
-				MESSAGE_ID_HEADER,
-			);
-
-			assert.equal(outcome.kind, "moved");
-			assert.equal(outcome.newUid, 77);
-		});
-
-		// Issue #1122. The destination already held an older copy of this
-		// Message-ID; the marker must bind to the copy this MOVE delivered, or
-		// the placement row names mail this push never touched.
-		it("moved: binds to the newest copy when the destination already held an older one", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				destinationSearchUids: [15, 77],
-			});
-
-			const outcome = await attemptMove(
-				connection,
-				connection,
-				"Junk",
-				"INBOX",
-				42,
-				MESSAGE_ID_HEADER,
-			);
-
-			assert.equal(outcome.kind, "moved");
-			assert.equal(outcome.newUid, 77);
-		});
+	it("propagates any other failure untouched for the caller to retry", async () => {
+		const server = arrange();
+		server.failNext.MOVE = new Error("ECONNRESET");
 
-		it("throws (never deletes) when unconfirmed at the destination but STILL present at the source", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				destinationSearchUids: [],
-				stillAtSource: true,
-			});
+		await assert.rejects(move(server), /ECONNRESET/);
+	});
 
-			await assert.rejects(
-				() =>
-					attemptMove(
-						connection,
-						connection,
-						"Junk",
-						"INBOX",
-						42,
-						MESSAGE_ID_HEADER,
-					),
-				/unresolved/,
-			);
-		});
+	// PR #1289 review finding 2: neither a missing COPYUID entry nor an explicit
+	// not-found is trusted without asking the server.
+	it("confirms a move by Message-ID when the server sends no COPYUID", async () => {
+		const server = arrange();
+		server.uidplus = false;
 
-		it("throws (never deletes) when the source FETCH drops the row for a message the server still lists", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				destinationSearchUids: [],
-				stillAtSource: true,
-				sourceFetchDrops: true,
-			});
+		const outcome = await move(server);
 
-			await assert.rejects(
-				() =>
-					attemptMove(
-						connection,
-						connection,
-						"Junk",
-						"INBOX",
-						42,
-						MESSAGE_ID_HEADER,
-					),
-				/unresolved/,
-			);
+		assert.deepEqual(outcome, {
+			kind: "moved",
+			newUid: server.uids("INBOX", HEADER)[0],
 		});
+	});
 
-		it("not-found: confirmed absent from BOTH destination (search miss) AND source (search miss)", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				destinationSearchUids: [],
-				stillAtSource: false,
-			});
-
-			const outcome = await attemptMove(
-				connection,
-				connection,
-				"Junk",
-				"INBOX",
-				42,
-				MESSAGE_ID_HEADER,
-			);
-
-			assert.equal(outcome.kind, "not-found");
-		});
+	it("confirms a move by Message-ID when the server answers NONEXISTENT for one that landed", async () => {
+		const server = arrange({ inJunk: false, inInbox: true });
+		server.failNext.MOVE = new Error(
+			"Command failed: NONEXISTENT no such message",
+		);
 
-		it("no messageIdHeader to verify with: falls back to the source-presence check alone — still never deletes while present at source", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				stillAtSource: true,
-			});
+		const outcome = await move(server);
 
-			await assert.rejects(() =>
-				attemptMove(connection, connection, "Junk", "INBOX", 42, undefined),
-			);
+		assert.deepEqual(outcome, {
+			kind: "moved",
+			newUid: server.uids("INBOX", HEADER)[0],
 		});
+	});
 
-		it("no messageIdHeader to verify with: resolves not-found once confirmed absent from source", async () => {
-			const connection = buildConnection({
-				uidMap: new Map(),
-				stillAtSource: false,
-			});
+	// Issue #1122: the destination already held an older copy, and the row must
+	// bind to the one this MOVE delivered.
+	it("binds to the newest copy when the destination already held an older one", async () => {
+		const server = arrange({ inInbox: true });
+		server.uidplus = false;
 
-			const outcome = await attemptMove(
-				connection,
-				connection,
-				"Junk",
-				"INBOX",
-				42,
-				undefined,
-			);
+		const outcome = await move(server);
 
-			assert.equal(outcome.kind, "not-found");
+		assert.deepEqual(outcome, {
+			kind: "moved",
+			newUid: Math.max(...server.uids("INBOX", HEADER)),
 		});
 	});
-});
 
-describe("getPlacementMoveMaxAttempts — env-derived threshold (mirrors #1270's getBodySyncMaxAttempts)", () => {
-	it("parses the CDK-injected env var", () => {
-		assert.equal(
-			getPlacementMoveMaxAttempts({ PLACEMENT_MOVE_MAX_ATTEMPTS: "3" }),
-			3,
-		);
-		assert.equal(
-			getPlacementMoveMaxAttempts({ PLACEMENT_MOVE_MAX_ATTEMPTS: "5" }),
-			5,
-		);
-	});
+	it("never settles a move the destination does not confirm while the source still holds it", async () => {
+		const server = arrange();
+		server.uidplus = false;
+		server.ignoreNext.add("MOVE");
 
-	it("defaults to 3 when unset", () => {
-		assert.equal(getPlacementMoveMaxAttempts({}), 3);
+		await assert.rejects(move(server), /unresolved/);
 	});
 
-	it("defaults to 3 on a non-numeric or non-positive value", () => {
-		assert.equal(
-			getPlacementMoveMaxAttempts({ PLACEMENT_MOVE_MAX_ATTEMPTS: "nope" }),
-			3,
-		);
-		assert.equal(
-			getPlacementMoveMaxAttempts({ PLACEMENT_MOVE_MAX_ATTEMPTS: "0" }),
-			3,
-		);
-	});
+	it("never settles when the source FETCH drops the row for a message the server still lists", async () => {
+		const server = arrange();
+		server.uidplus = false;
+		server.ignoreNext.add("MOVE");
+		const source = server.connection();
+		source.fetchMessages = async () => [];
 
-	it("PLACEMENT_MOVE_MAX_ATTEMPTS is a concrete, positive number at module load", () => {
-		assert.ok(PLACEMENT_MOVE_MAX_ATTEMPTS > 0);
+		await assert.rejects(move(server, HEADER, source), /unresolved/);
 	});
-});
-
-describe("handlePlacementMovePush — deleted mailbox is terminal (#287/#289)", () => {
-	const accountId = "pm-acc-zzz";
-	const messageId = "pm-msg-zzz";
-	const destinationMailboxId = "pm-dest-zzz";
 
-	const event: PlacementMovePushEvent = {
-		type: "PLACEMENT_MOVE_PUSH",
-		accountId,
-		accountConfigId: "pm-cfg-zzz",
-		messageId,
-		eventId: "pm-evt-zzz",
-		timestamp: 1700000000000,
-	};
+	it("answers not-found once neither folder holds the message", async () => {
+		const server = arrange({ inJunk: false });
+		server.uidplus = false;
 
-	// The client is supplied by injection (`setClient`), so these tests register
-	// the repositories they then mock rather than reaching a composition.
-	before(() => {
-		setClient({
-			account: { get: async () => undefined },
-			message: { get: async () => undefined },
-			mailbox: { get: async () => undefined },
-			placementMove: {
-				find: async () => undefined,
-				updateState: async () => undefined,
-				delete: async () => undefined,
-			},
-		} as unknown as RemitClient);
+		assert.equal((await move(server)).kind, "not-found");
 	});
 
-	afterEach(() => mock.restoreAll());
+	it("falls back to the source alone without a Message-ID, and still never settles while it holds the message", async () => {
+		const server = arrange();
+		server.uidplus = false;
+		server.ignoreNext.add("MOVE");
 
-	it("drops the marker and acks without pushing when a mailbox is gone", async () => {
-		const client = await getClient();
-		mock.method(client.account, "get", async () => ({
-			accountId,
-			accountConfigId: "pm-cfg-zzz",
-		}));
-		mock.method(client.message, "get", async () => ({
-			messageId,
-			mailboxId: destinationMailboxId,
-		}));
-		mock.method(client.mailbox, "get", async () => {
-			throw Object.assign(new Error("Mailbox not found: pm-src-zzz"), {
-				name: "NotFoundError",
-			});
-		});
-		mock.method(client.placementMove, "find", async () => ({
-			sourceMailboxId: "pm-src-zzz",
-			destinationMailboxId,
-		}));
-		mock.method(client.placementMove, "updateState", async () => {});
-		const deleteMarker = mock.method(
-			client.placementMove,
-			"delete",
-			async () => {},
-		);
+		await assert.rejects(move(server, undefined));
+	});
 
-		// Must resolve, not reject — a deleted folder is an expected terminal
-		// outcome, not a fault to retry on the account's per-group FIFO.
-		await handlePlacementMovePush(event, silentLogger, 1);
+	it("answers not-found without a Message-ID once the source no longer holds the message", async () => {
+		const server = arrange({ inJunk: false });
+		server.uidplus = false;
 
-		assert.equal(deleteMarker.mock.calls.length, 1, "the marker is dropped");
-		assert.deepEqual(deleteMarker.mock.calls[0].arguments, [messageId]);
+		assert.equal((await move(server, undefined)).kind, "not-found");
 	});
 });