@remit/imap-worker 0.0.86 → 0.0.88

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

@@ -1,28 +1,31 @@
 import { getClient } from "@remit/backend/client";
-import { isNotFoundError } from "@remit/data-ports/errors";
-import type { Logger } from "@remit/logger-lambda";
-import { recordImapFailure } from "@remit/logger-lambda";
+import { MessageMutation, MessageSyncStatus } from "@remit/domain-enums";
+import type { Logger } from "@remit/logger";
+import { recordImapFailure } from "@remit/logger-lambda/metrics";
 import {
 	guardConnectionCursor,
 	type IImapConnection,
 	isCursorRebuildNeeded,
 	isMessageGoneFromOpenMailbox,
 	MailboxCursorPausedError,
-	reconcileStaleMessage,
 	resolveExhaustedPlacementMoveFailure,
+	restoreSourcePlacement,
 } from "@remit/mailbox-service";
 import { attemptBudget } from "@remit/sqs-client/attempt-budget";
 import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
 import { emitEvent } from "../emit.js";
 import type { PlacementMovePushEvent } from "../events.js";
+import { findMailboxRow } from "../mailbox-row.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import {
 	buildThreadMessageMoveUpdate,
+	emitMailboxResync,
 	emitMoveResync,
 	searchMailboxForHighestMessageIdUid,
 } from "./message-move.js";
+import { probeableMessageIdHeader } from "./probe-message-id.js";
 
 export const getPlacementMoveMaxAttempts = (
 	processEnv: NodeJS.ProcessEnv = process.env,
@@ -150,6 +153,7 @@ export const handlePlacementMovePush = async (
 	event: PlacementMovePushEvent,
 	log: Logger,
 	receiveCount = 1,
+	createConnectionScope = createConnectionScopeWithCredentials,
 ): Promise<void> => {
 	const {
 		account: accountService,
@@ -180,6 +184,11 @@ export const handlePlacementMovePush = async (
 	}
 
 	const message = await messageService.get(messageId);
+	const placementRead = {
+		status: message.status,
+		mailboxId: message.mailboxId,
+		uid: message.uid,
+	};
 
 	// A newer local action (drag-and-drop move, auto-moved Undo) already
 	// changed the message's location away from what this marker still
@@ -205,32 +214,61 @@ export const handlePlacementMovePush = async (
 	// died mid-flight already left it here).
 	await markerService.updateState(messageId, "processing");
 
-	// Either folder can be deleted between enqueue and this push, leaving a
-	// marker 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). The move is moot — drop the marker (as
-	// the superseded branch above does) and ack with a WARN.
-	const mailboxes = await Promise.all([
-		mailboxService.get(accountId, marker.sourceMailboxId),
-		mailboxService.get(accountId, marker.destinationMailboxId),
-	]).catch((error: unknown) => {
-		if (isNotFoundError(error)) return null;
-		throw error;
-	});
-	if (!mailboxes) {
-		await markerService.delete(messageId);
-		log.warn(
+	// No MOVE has left for this marker, so the row is settled, not just unmarked.
+	const [source, destination] = await Promise.all([
+		findMailboxRow(mailboxService, accountId, marker.sourceMailboxId),
+		findMailboxRow(mailboxService, accountId, marker.destinationMailboxId),
+	]);
+	if (source.kind === "gone" || destination.kind === "gone") {
+		const context = {
+			alert: "placement_move_mailbox_unreachable",
+			messageId,
+			accountId,
+			sourceMailboxId: marker.sourceMailboxId,
+			destinationMailboxId: marker.destinationMailboxId,
+		};
+		if (source.kind === "gone") {
+			const reconciled = await messageService.deleteIfPlacement(
+				messageId,
+				placementRead,
+			);
+			await markerService.delete(messageId);
+			log.error(
+				{ ...context, reconciled },
+				"Placement move not pushed: its source folder is gone; the stale row was reconciled",
+			);
+			if (destination.kind === "present") {
+				await emitMailboxResync(emitEvent, {
+					accountId,
+					mailboxId: marker.destinationMailboxId,
+				});
+			}
+			return;
+		}
+		await restoreSourcePlacement(
+			{ messageService, threadMessageService },
 			{
+				accountConfigId,
 				messageId,
-				accountId,
 				sourceMailboxId: marker.sourceMailboxId,
-				destinationMailboxId: marker.destinationMailboxId,
+				uid: message.uid,
+				syncStatus: MessageSyncStatus.synced,
+				abandonedMutation: MessageMutation.none,
 			},
-			"Skipping PLACEMENT_MOVE_PUSH: a mailbox no longer exists (deleted); marker dropped",
 		);
+		await markerService.delete(messageId);
+		log.error(
+			context,
+			"Placement move not pushed: its destination folder is gone; the row was handed back to its source",
+		);
+		await emitMailboxResync(emitEvent, {
+			accountId,
+			mailboxId: marker.sourceMailboxId,
+		});
 		return;
 	}
-	const [sourceMailbox, destinationMailbox] = mailboxes;
+	const sourceMailbox = source.mailbox;
+	const destinationMailbox = destination.mailbox;
 
 	// Cheap frugal skip (epic #1281 invariant 6): either mailbox already known
 	// paused never even borrows a connection. Optimization only — the
@@ -256,7 +294,7 @@ export const handlePlacementMovePush = async (
 		account,
 		log,
 		async (credentials) => {
-			const scope = createConnectionScopeWithCredentials(account, credentials);
+			const scope = createConnectionScope(account, credentials);
 
 			await scope
 				.getConnection()
@@ -283,7 +321,11 @@ export const handlePlacementMovePush = async (
 						sourceMailbox.fullPath,
 						destinationMailbox.fullPath,
 						message.uid,
-						message.messageIdHeader,
+						await probeableMessageIdHeader(
+							threadMessageService,
+							accountConfigId,
+							messageId,
+						),
 					);
 
 					if (outcome.kind === "trycreate") {
@@ -298,10 +340,9 @@ export const handlePlacementMovePush = async (
 					if (outcome.kind === "not-found") {
 						// External delete supersedes the marker entirely (epic invariant 2).
 						await markerService.delete(messageId);
-						const { threadMessagesDeleted } = await reconcileStaleMessage(
-							{ messageService, threadMessageService },
-							accountConfigId,
+						const reconciled = await messageService.deleteIfPlacement(
 							messageId,
+							placementRead,
 						);
 						log.info(
 							{
@@ -309,7 +350,7 @@ export const handlePlacementMovePush = async (
 								accountId,
 								uid: message.uid,
 								sourceMailboxPath: sourceMailbox.fullPath,
-								threadMessagesDeleted,
+								reconciled,
 							},
 							"Message no longer at its pending-move source (external delete or moved away); marker dropped, stale row reconciled",
 						);
@@ -395,6 +436,11 @@ export const handlePlacementMovePush = async (
 					const { outcome } = await resolveExhaustedPlacementMoveFailure(
 						{ markerService, messageService, threadMessageService, log },
 						{
+							placement: {
+								status: message.status,
+								mailboxId: message.mailboxId,
+								uid: message.uid,
+							},
 							accountId,
 							accountConfigId,
 							messageId,

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

@@ -0,0 +1,298 @@
+/**
+ * The two pushes body sync leaves behind: a placement move (Junk, a filter's
+ * folder) and a flag (auto-mark-read). They ride different queues, so either
+ * can reach the server first, and the flag must never land on the uid of a
+ * move that has not settled (#496).
+ */
+import assert from "node:assert/strict";
+import { after, before, describe, it, mock } from "node:test";
+import type { MailboxItem } from "@remit/data-ports";
+import {
+	MailboxCursorState,
+	MailboxSpecialUse,
+	MessageStatus,
+} from "@remit/domain-enums";
+import { PlacementMoveService } from "@remit/mailbox-service";
+import type { FlagPushEvent, PlacementMovePushEvent } from "../events.js";
+import {
+	openStore,
+	type SeededMessage,
+	type World,
+} from "../test-helpers/test-world.js";
+import { FLAG_PUSH_DEFER_MAX_MS, handleFlagPush } from "./flag-push.js";
+import { handlePlacementMovePush } from "./placement-move-push.js";
+
+const SEEN = "\\Seen";
+
+let store: Awaited<ReturnType<typeof openStore>>;
+
+before(async () => {
+	store = await openStore();
+});
+
+after(() => store.close());
+
+interface Arranged {
+	w: World;
+	inbox: MailboxItem;
+	junk: MailboxItem;
+	message: SeededMessage;
+	placement: PlacementMoveService;
+}
+
+const arrange = async (): Promise<Arranged> => {
+	const w = await store.world();
+	const inbox = await w.folder("INBOX");
+	const junk = await w.folder("Junk", { specialUse: MailboxSpecialUse.Junk });
+	const message = await w.message(inbox);
+	const placement = new PlacementMoveService({
+		messageService: w.client.message,
+		threadMessageService: w.client.threadMessage,
+		markerService: w.client.placementMove,
+		addressService: w.client.address,
+		mailboxSpecialUseService: w.client.mailboxSpecialUse,
+		mailboxService: w.client.mailbox,
+		sqsQueueUrl: process.env.SQS_QUEUE_URL_MESSAGE_MGMT ?? "",
+	});
+	return { w, inbox, junk, message, placement };
+};
+
+const queuedOf = <T>(w: World, type: string): T => {
+	const event = w
+		.queued()
+		.filter((body) => body.type === type)
+		.at(-1) as T | undefined;
+	assert.ok(event, `a ${type} was enqueued`);
+	return event;
+};
+
+const markAsRead = async (a: Arranged): Promise<FlagPushEvent> => {
+	await a.w.client.flagQueue.markAsRead(
+		a.w.account.accountConfigId,
+		a.message.messageId,
+		a.w.account.accountId,
+	);
+	return queuedOf<FlagPushEvent>(a.w, "FLAG_PUSH");
+};
+
+const moveToJunk = async (a: Arranged): Promise<PlacementMovePushEvent> => {
+	await a.placement.moveMessage(
+		a.w.account.accountConfigId,
+		a.message.messageId,
+		a.junk.mailboxId,
+		a.w.account.accountId,
+	);
+	return queuedOf<PlacementMovePushEvent>(a.w, "PLACEMENT_MOVE_PUSH");
+};
+
+const pushFlag = (a: Arranged, event: FlagPushEvent, receiveCount = 1) =>
+	handleFlagPush(event, a.w.log, receiveCount, a.w.scope);
+
+const pushMove = (
+	a: Arranged,
+	event: PlacementMovePushEvent,
+	receiveCount = 1,
+) => handlePlacementMovePush(event, a.w.log, receiveCount, a.w.scope);
+
+const seenOnServer = (a: Arranged, path: string): boolean[] =>
+	a.w.imap
+		.messages(path)
+		.filter((m) => m.messageIdHeader === a.message.messageIdHeader)
+		.map((m) => m.flags.includes(SEEN));
+
+describe("a flag push", () => {
+	it("stores the flag on the server and clears its marker", async () => {
+		const a = await arrange();
+		const event = await markAsRead(a);
+
+		await pushFlag(a, event);
+
+		assert.deepEqual(seenOnServer(a, "INBOX"), [true]);
+		assert.equal(
+			await a.w.client.flagPush.find(a.message.messageId, SEEN),
+			null,
+		);
+	});
+
+	it("waits, without connecting, while the message's placement move has not settled", async () => {
+		const a = await arrange();
+		await moveToJunk(a);
+		const event = await markAsRead(a);
+
+		await pushFlag(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.equal(
+			(await a.w.client.flagPush.find(a.message.messageId, SEEN))?.state,
+			"pending",
+		);
+		assert.deepEqual(seenOnServer(a, "INBOX"), [false]);
+	});
+
+	it("lands on the moved message once the placement move has settled", async () => {
+		const a = await arrange();
+		const move = await moveToJunk(a);
+		const flag = await markAsRead(a);
+		await pushFlag(a, flag);
+
+		await pushMove(a, move);
+		await pushFlag(a, flag);
+
+		assert.deepEqual(a.w.imap.uids("INBOX"), []);
+		assert.deepEqual(seenOnServer(a, "Junk"), [true]);
+		assert.equal(
+			await a.w.client.flagPush.find(a.message.messageId, SEEN),
+			null,
+		);
+	});
+
+	// A move that never settles would otherwise park the flag forever, one
+	// queue round trip per sync tick.
+	it("drops the marker without connecting once the move has been stuck past the window", async (t) => {
+		const a = await arrange();
+		await moveToJunk(a);
+		const event = await markAsRead(a);
+		mock.timers.enable({
+			apis: ["Date"],
+			now: Date.now() + FLAG_PUSH_DEFER_MAX_MS + 1,
+		});
+		t.after(() => mock.timers.reset());
+
+		await pushFlag(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.equal(
+			await a.w.client.flagPush.find(a.message.messageId, SEEN),
+			null,
+		);
+		assert.deepEqual(seenOnServer(a, "INBOX"), [false]);
+	});
+
+	it("drops the marker without connecting when the mailbox was deleted", async () => {
+		const a = await arrange();
+		const event = await markAsRead(a);
+		await a.w.client.mailbox.delete(a.w.account.accountId, a.inbox.mailboxId);
+
+		await pushFlag(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.equal(
+			await a.w.client.flagPush.find(a.message.messageId, SEEN),
+			null,
+		);
+	});
+
+	it("drops the marker without connecting when the message row is gone", async () => {
+		const a = await arrange();
+		const event = await markAsRead(a);
+		await a.w.client.message.delete(a.message.messageId);
+
+		await pushFlag(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.equal(
+			await a.w.client.flagPush.find(a.message.messageId, SEEN),
+			null,
+		);
+	});
+
+	it("keeps the marker and stores nothing while the cursor is rebuilding", async () => {
+		const a = await arrange();
+		const event = await markAsRead(a);
+		await a.w.client.mailbox.update(a.w.account.accountId, a.inbox.mailboxId, {
+			cursorState: MailboxCursorState.rebuilding,
+		});
+
+		await pushFlag(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.ok(await a.w.client.flagPush.find(a.message.messageId, SEEN));
+	});
+
+	it("stores nothing when the mailbox's UIDVALIDITY changed under it", async () => {
+		const a = await arrange();
+		const event = await markAsRead(a);
+		a.w.imap.setUidValidity("INBOX", 2);
+
+		await pushFlag(a, event);
+
+		assert.deepEqual(a.w.imap.commands("STORE"), []);
+		assert.ok(await a.w.client.flagPush.find(a.message.messageId, SEEN));
+	});
+
+	it("keeps the marker and redelivers when the connection drops", async () => {
+		const a = await arrange();
+		const event = await markAsRead(a);
+		a.w.imap.failNext.STORE = new Error("Connection reset");
+
+		await assert.rejects(pushFlag(a, event), /Connection reset/);
+
+		assert.ok(await a.w.client.flagPush.find(a.message.messageId, SEEN));
+	});
+});
+
+describe("a placement move push", () => {
+	it("moves the message on the server, settles the row and clears the marker", async () => {
+		const a = await arrange();
+		const event = await moveToJunk(a);
+
+		await pushMove(a, event);
+
+		const [junkUid] = a.w.imap.uids("Junk", a.message.messageIdHeader);
+		const row = await a.w.row(a.message.messageId);
+		assert.equal(row?.mailboxId, a.junk.mailboxId);
+		assert.equal(row?.uid, junkUid);
+		assert.equal(row?.status, MessageStatus.active);
+		assert.equal(
+			await a.w.client.placementMove.find(a.message.messageId),
+			null,
+		);
+	});
+
+	it("drops the marker without connecting when a newer move took the message elsewhere", async () => {
+		const a = await arrange();
+		const event = await moveToJunk(a);
+		const archive = await a.w.folder("Archive");
+		await a.w.client.message.transitionPlacement(
+			a.message.messageId,
+			{ mailboxId: a.junk.mailboxId },
+			{ mailboxId: archive.mailboxId },
+		);
+
+		await pushMove(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.equal(
+			await a.w.client.placementMove.find(a.message.messageId),
+			null,
+		);
+	});
+
+	it("drops the marker without connecting when the destination mailbox was deleted", async () => {
+		const a = await arrange();
+		const event = await moveToJunk(a);
+		await a.w.client.mailbox.delete(a.w.account.accountId, a.junk.mailboxId);
+
+		await pushMove(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.equal(
+			await a.w.client.placementMove.find(a.message.messageId),
+			null,
+		);
+	});
+
+	it("keeps the marker and moves nothing while the source cursor is rebuilding", async () => {
+		const a = await arrange();
+		const event = await moveToJunk(a);
+		await a.w.client.mailbox.update(a.w.account.accountId, a.inbox.mailboxId, {
+			cursorState: MailboxCursorState.rebuilding,
+		});
+
+		await pushMove(a, event);
+
+		assert.equal(a.w.imap.connections, 0);
+		assert.ok(await a.w.client.placementMove.find(a.message.messageId));
+		assert.deepEqual(a.w.imap.uids("INBOX"), [a.message.uid]);
+	});
+});

package/src/handlers/probe-message-id.sqlite.test.ts

@@ -0,0 +1,194 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it, mock } from "node:test";
+import { SQSClient } from "@aws-sdk/client-sqs";
+import type { MailboxItem } from "@remit/data-ports";
+import {
+	AccountAuthType,
+	ConnectionState,
+	MailboxCursorState,
+} from "@remit/domain-enums";
+import {
+	createSqliteRepositories,
+	type DrizzleMessageRepository,
+	type DrizzleThreadMessageRepository,
+	type MailboxRepo,
+	type SqliteRepositories,
+} from "@remit/drizzle-service";
+import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
+import {
+	type IImapConnection,
+	type ManagedConnectionFactory,
+	MessageMoveService,
+	MessageSyncService,
+	SyncWarningService,
+} from "@remit/mailbox-service";
+import type { ImapMessage } from "@remit/mailbox-service/types";
+import { probeableMessageIdHeader } from "./probe-message-id.js";
+
+const ACCOUNT_CONFIG_ID = "cfg-msgid";
+const UID_VALIDITY = 7;
+
+const inboxHolding = (messageIdHeader: string): ImapMessage => ({
+	uid: 3,
+	seq: 1,
+	flags: [],
+	internalDate: new Date(0),
+	size: 100,
+	envelope: {
+		date: new Date(0).toISOString(),
+		messageId: messageIdHeader,
+		subject: "Quarterly report",
+		from: [{ name: "Sender", mailbox: "sender", host: "example.com" }],
+		sender: [],
+		replyTo: [],
+		to: [],
+		cc: [],
+		bcc: [],
+		inReplyTo: "",
+	},
+});
+
+const serverWithInbox = (message: ImapMessage): IImapConnection =>
+	({
+		openBox: async (path: string) => ({
+			name: path,
+			readOnly: false,
+			uidvalidity: UID_VALIDITY,
+			uidnext: message.uid + 1,
+			flags: [],
+			permFlags: [],
+			persistentUIDs: true,
+			messages: { total: 1, new: 0 },
+			newKeywords: false,
+		}),
+		getMailboxStatus: async () => ({
+			messages: 1,
+			recent: 0,
+			unseen: 0,
+			uidNext: message.uid + 1,
+			uidValidity: UID_VALIDITY,
+			highestModseq: "0",
+			deletedCount: 0,
+		}),
+		supportsCondstore: () => false,
+		search: async () => [message.uid],
+		fetchMessages: async () => [message],
+	}) as unknown as IImapConnection;
+
+describe("the Message-ID the move, delete and copy probes ask with", () => {
+	let close: () => void;
+	let repos: SqliteRepositories;
+	let accountId: string;
+	let mailboxes: MailboxRepo;
+	let messages: DrizzleMessageRepository;
+	let threadMessages: DrizzleThreadMessageRepository;
+
+	const createMailbox = async (fullPath: string): Promise<MailboxItem> => {
+		const created = await mailboxes.create({
+			accountId,
+			namespacePrefix: "",
+			hierarchyDelimiter: "/",
+			fullPath,
+			uidValidity: UID_VALIDITY,
+			uidNext: 1,
+			highestModseq: "0",
+			messageCount: 0,
+			unseenCount: 0,
+			deletedCount: 0,
+			totalSize: 0,
+			lastSyncUid: 0,
+			highWaterMarkUid: 0,
+			lastMessageSyncAt: 0,
+			cursorState: MailboxCursorState.normal,
+		} as Parameters<MailboxRepo["create"]>[0]);
+		if (created.outcome !== "Created") throw new Error(`${fullPath} taken`);
+		return created.mailbox;
+	};
+
+	const syncInbox = async (messageIdHeader: string): Promise<string> => {
+		const inbox = await createMailbox("INBOX");
+		const connection = serverWithInbox(inboxHolding(messageIdHeader));
+		const factory: ManagedConnectionFactory = {
+			getConnection: () => connection,
+			close: async () => {},
+		};
+		await new MessageSyncService(
+			factory,
+			mailboxes,
+			repos.mailboxSpecialUse,
+			messages,
+			repos.envelope,
+			repos.address,
+			threadMessages,
+			new SyncWarningService(repos.syncWarning),
+		).syncMessages(inbox.mailboxId, accountId, ACCOUNT_CONFIG_ID);
+		const [synced] = await messages.listAllByMailbox(inbox.mailboxId);
+		if (!synced) throw new Error("sync stored no message");
+		return synced.messageId;
+	};
+
+	const probeable = (messageId: string): Promise<string | undefined> =>
+		probeableMessageIdHeader(threadMessages, ACCOUNT_CONFIG_ID, messageId);
+
+	beforeEach(async () => {
+		const store = createShippedSqliteDb();
+		close = store.close;
+		repos = createSqliteRepositories({
+			app: store.db,
+			mail: store.db,
+			search: store.db,
+		});
+		mailboxes = repos.mailbox;
+		messages = repos.message;
+		threadMessages = repos.threadMessage;
+		const account = await repos.account.create({
+			accountConfigId: ACCOUNT_CONFIG_ID,
+			username: "person@example.com",
+			email: "person@example.com",
+			authType: AccountAuthType.Password,
+			passwordHash: '{"ciphertext":"x"}',
+			imapHost: "imap.example.com",
+			imapPort: 993,
+			imapTls: true,
+			imapStartTls: false,
+			isActive: true,
+			connectionState: ConnectionState.Authenticated,
+		});
+		accountId = account.accountId;
+	});
+
+	afterEach(() => {
+		mock.restoreAll();
+		close();
+	});
+
+	it("reads the Message-ID a real sync stored", async () => {
+		const messageId = await syncInbox("<report@example.com>");
+
+		assert.equal(await probeable(messageId), "<report@example.com>");
+	});
+
+	it("reads the source's Message-ID for a copy", async () => {
+		const sourceId = await syncInbox("<report@example.com>");
+		const archive = await createMailbox("Archive");
+		mock.method(SQSClient.prototype, "send", async () => ({}));
+
+		const copyId = await new MessageMoveService({
+			messageService: messages,
+			mailboxService: mailboxes,
+			mailboxSpecialUseService: repos.mailboxSpecialUse,
+			threadMessageService: threadMessages,
+			addressService: repos.address,
+			sqsQueueUrl: "https://queue.test/messages",
+		}).copyMessage(ACCOUNT_CONFIG_ID, sourceId, archive.mailboxId, accountId);
+
+		assert.notEqual(copyId, sourceId);
+		assert.equal(await probeable(copyId), "<report@example.com>");
+	});
+
+	it("answers unprobeable for a bounce whose Message-ID is <>", async () => {
+		const messageId = await syncInbox("<>");
+
+		assert.equal(await probeable(messageId), undefined);
+	});
+});

package/src/handlers/probe-message-id.ts

@@ -0,0 +1,15 @@
+import type { IThreadMessageRepository } from "@remit/data-ports";
+import { isValidMessageId } from "@remit/data-ports/id";
+
+export const probeableMessageIdHeader = async (
+	threadMessageService: Pick<IThreadMessageRepository, "findByMessageId">,
+	accountConfigId: string,
+	messageId: string,
+): Promise<string | undefined> => {
+	const row = await threadMessageService.findByMessageId(
+		accountConfigId,
+		messageId,
+	);
+	const header = row?.messageIdHeader;
+	return isValidMessageId(header) ? header : undefined;
+};