@remit/mailbox-service 0.0.112 → 0.0.113

package/src/body-sync-terminal.test.ts

@@ -1,148 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import type { AccountItem, MailboxItem } from "@remit/data-ports";
-import type { StorageService } from "@remit/storage-service";
-import {
-	isMessageBodySyncBroken,
-	resolveExhaustedBodySyncFailures,
-} from "./body-sync-terminal.js";
-import { eml, FakeImapServer } from "./test-helpers/fake-imap.js";
-import {
-	messageAtUid,
-	openStore,
-	type Store,
-	seedAccount,
-	seedMailbox,
-	silentLog,
-	syncFolder,
-} from "./test-helpers/test-store.js";
-
-let store: Store;
-let storage: StorageService;
-let imap: FakeImapServer;
-let account: AccountItem;
-let inbox: MailboxItem;
-
-beforeEach(async () => {
-	store = await openStore();
-	storage = store.storage();
-	imap = new FakeImapServer();
-	account = await seedAccount(store);
-	inbox = await seedMailbox(store, account, "INBOX");
-	imap.addFolder("INBOX");
-});
-
-afterEach(() => store.close());
-
-const arrive = async (subject: string) => {
-	const uid = imap.deliver("INBOX", eml({ Subject: subject }));
-	await syncFolder(store, account, inbox, imap);
-	return { uid, messageId: (await messageAtUid(store, inbox, uid)).messageId };
-};
-
-const resolve = (failedMessageIds: string[], connection = imap.connection()) =>
-	resolveExhaustedBodySyncFailures(
-		{
-			messageService: store.message,
-			storageService: storage,
-			log: silentLog,
-		},
-		{
-			accountId: account.accountId,
-			accountConfigId: account.accountConfigId,
-			mailboxId: inbox.mailboxId,
-			mailboxPath: "INBOX",
-			failedMessageIds,
-			getConnection: async () => connection,
-		},
-	);
-
-const isBroken = (messageId: string) =>
-	isMessageBodySyncBroken(
-		storage,
-		account.accountConfigId,
-		account.accountId,
-		messageId,
-	);
-
-describe("a body sync that exhausted its retries", () => {
-	it("removes the row and every thread copy of a message the server expunged", async () => {
-		const { uid, messageId } = await arrive("gone");
-		const [row] = await store.threadMessage.findAllByMessageId(
-			account.accountConfigId,
-			messageId,
-		);
-		await store.threadMessage.create({ ...row, threadId: "drifted-root" });
-		imap.expunge("INBOX", uid);
-
-		const result = await resolve([messageId]);
-
-		assert.deepEqual(result, {
-			reconciledMessageIds: [messageId],
-			brokenMessageIds: [],
-		});
-		await assert.rejects(store.message.get(messageId));
-		assert.deepEqual(
-			await store.threadMessage.findAllByMessageId(
-				account.accountConfigId,
-				messageId,
-			),
-			[],
-		);
-		assert.equal(await isBroken(messageId), false);
-	});
-
-	it("marks a message the server still holds as broken and keeps its row", async () => {
-		const { messageId } = await arrive("broken");
-
-		const result = await resolve([messageId]);
-
-		assert.deepEqual(result.brokenMessageIds, [messageId]);
-		assert.ok(await store.message.get(messageId));
-		assert.equal(await isBroken(messageId), true);
-	});
-
-	it("does not read a dropped FETCH row as absence", async () => {
-		const first = await arrive("first");
-		const second = await arrive("second");
-		const connection = imap.connection();
-		const fetch = connection.fetchMessages;
-		connection.fetchMessages = async (uids) =>
-			uids.includes(second.uid) ? [] : fetch(uids);
-
-		const result = await resolve(
-			[first.messageId, second.messageId],
-			connection,
-		);
-
-		assert.deepEqual(result.reconciledMessageIds, []);
-		assert.deepEqual(result.brokenMessageIds, [
-			first.messageId,
-			second.messageId,
-		]);
-		assert.ok(await store.message.get(second.messageId));
-	});
-
-	it("never opens a connection when nothing failed", async () => {
-		const result = await resolveExhaustedBodySyncFailures(
-			{
-				messageService: store.message,
-				storageService: storage,
-				log: silentLog,
-			},
-			{
-				accountId: account.accountId,
-				accountConfigId: account.accountConfigId,
-				mailboxId: inbox.mailboxId,
-				mailboxPath: "INBOX",
-				failedMessageIds: [],
-				getConnection: async () => assert.fail("no connection is needed"),
-			},
-		);
-
-		assert.deepEqual(result, {
-			reconciledMessageIds: [],
-			brokenMessageIds: [],
-		});
-	});
-});

package/src/body-sync-terminal.ts

@@ -1,174 +0,0 @@
-import type { IMessageRepository } from "@remit/data-ports";
-import type { StorageService } from "@remit/storage-service";
-import type { BodySyncLogger } from "./body-sync.js";
-import { isMessageGoneFromOpenMailbox } from "./message-presence.js";
-import type { IImapConnection } from "./types.js";
-
-/**
- * Body-part sentinel path a permanently-broken message's failure context is
- * written under, mirroring the `.materialized` deferred-parts sentinel in
- * `body-sync.ts`. Using the existing per-message body-part storage (instead
- * of a new Message-row column) means no schema change: the read path checks
- * for it with the same `bodyPartExists` HEAD it already issues.
- */
-const BODY_SYNC_FAILED_MARKER_PATH = ".sync-failed";
-
-export interface ResolveExhaustedBodySyncDeps {
-	messageService: Pick<IMessageRepository, "get" | "deleteIfPlacement">;
-	storageService: Pick<StorageService, "storeBodyPart" | "bodyPartExists">;
-	log: BodySyncLogger;
-}
-
-export interface ResolveExhaustedBodySyncInput {
-	accountId: string;
-	accountConfigId: string;
-	mailboxId: string;
-	mailboxPath: string;
-	failedMessageIds: string[];
-	getConnection: () => Promise<IImapConnection>;
-}
-
-export interface ResolveExhaustedBodySyncResult {
-	/** Outcome 1 (EXPECTED): message gone upstream, row deleted. */
-	reconciledMessageIds: string[];
-	/** Outcome 2 (BROKEN): message exists but is unfetchable/unparseable. */
-	brokenMessageIds: string[];
-}
-
-/**
- * Whether a message's body-sync has already been marked permanently failed
- * (outcome 2 of {@link resolveExhaustedBodySyncFailures}). The read path
- * calls this before attempting or re-arming any fetch so a client that opens
- * a broken message gets the explicit unrecoverable error immediately instead
- * of looping through another 202 or another IMAP round-trip.
- */
-export const isMessageBodySyncBroken = (
-	storageService: Pick<StorageService, "bodyPartExists">,
-	accountConfigId: string,
-	accountId: string,
-	messageId: string,
-): Promise<boolean> =>
-	storageService.bodyPartExists(
-		accountConfigId,
-		accountId,
-		messageId,
-		BODY_SYNC_FAILED_MARKER_PATH,
-	);
-
-const markMessageBodySyncFailed = async (
-	storageService: Pick<StorageService, "storeBodyPart">,
-	accountConfigId: string,
-	accountId: string,
-	messageId: string,
-	context: Record<string, unknown>,
-): Promise<void> => {
-	await storageService.storeBodyPart({
-		accountConfigId,
-		accountId,
-		messageId,
-		partPath: BODY_SYNC_FAILED_MARKER_PATH,
-		content: Buffer.from(JSON.stringify({ ...context, failedAt: Date.now() })),
-		contentType: "application/json",
-	});
-};
-
-/**
- * Resolve every SYNC_MESSAGE_BODY failure that has exhausted the body
- * queue's redelivery budget (see `BODY_SYNC_MAX_ATTEMPTS` in
- * `sync-message-body.ts`) into exactly one of the two terminal outcomes
- * issue #1270 / epic #1281 invariant 3 require. There is no third, softer
- * outcome — every failed id lands in one of the two result lists.
- *
- * 1. EXPECTED — the message no longer exists on IMAP (expunged, or a
- *    UIDVALIDITY change moved it, #1272), confirmed by
- *    {@link isMessageGoneFromOpenMailbox}. This loop is the most exposed of
- *    the four sites that used to read an empty FETCH as absence: it issues
- *    back-to-back single-UID FETCHes on one connection, which is the
- *    condition imapflow #408 drops rows under. The stale row is deleted via
- *    `deleteIfPlacement` so the existing missing-row 404 path
- *    takes over. Callers should emit a metric only — this is routine, not an
- *    incident.
- * 2. BROKEN — the message still exists on IMAP but its body could not be
- *    fetched or parsed. The failure is persisted as a body-part sentinel
- *    (survives across invocations and warm/cold starts) and logged with an
- *    `alert`-shaped entry so an operator alarm can key off it. Callers
- *    should treat this as loud: the message is unrecoverable until an
- *    operator investigates.
- *
- * Neither outcome re-enqueues: both are terminal, so the caller acks the SQS
- * message either way — retrying a stale or broken message can never succeed.
- */
-export const resolveExhaustedBodySyncFailures = async (
-	deps: ResolveExhaustedBodySyncDeps,
-	input: ResolveExhaustedBodySyncInput,
-): Promise<ResolveExhaustedBodySyncResult> => {
-	const {
-		accountId,
-		accountConfigId,
-		mailboxId,
-		mailboxPath,
-		failedMessageIds,
-		getConnection,
-	} = input;
-
-	const reconciledMessageIds: string[] = [];
-	const brokenMessageIds: string[] = [];
-
-	if (failedMessageIds.length === 0) {
-		return { reconciledMessageIds, brokenMessageIds };
-	}
-
-	const connection = await getConnection();
-	await connection.openBox(mailboxPath);
-
-	for (const messageId of failedMessageIds) {
-		const message = await deps.messageService.get(messageId);
-
-		if (await isMessageGoneFromOpenMailbox(connection, message.uid)) {
-			const reconciled = await deps.messageService.deleteIfPlacement(
-				messageId,
-				{
-					status: message.status,
-					mailboxId: message.mailboxId,
-					uid: message.uid,
-				},
-			);
-			deps.log.info(
-				{
-					metric: "body_sync_stale_row_reconciled",
-					accountId,
-					accountConfigId,
-					mailboxId,
-					messageId,
-					uid: message.uid,
-					reconciled,
-				},
-				"Message no longer exists on IMAP after retry exhaustion; stale row reconciled",
-			);
-			reconciledMessageIds.push(messageId);
-			continue;
-		}
-
-		await markMessageBodySyncFailed(
-			deps.storageService,
-			accountConfigId,
-			accountId,
-			messageId,
-			{ accountId, accountConfigId, mailboxId, messageId, uid: message.uid },
-		);
-		deps.log.error?.(
-			{
-				alert: "body_sync_message_broken",
-				accountId,
-				accountConfigId,
-				mailboxId,
-				messageId,
-				uid: message.uid,
-			},
-			"Message body could not be fetched/parsed after retry exhaustion; message exists on IMAP but is unrecoverable",
-		);
-		brokenMessageIds.push(messageId);
-	}
-
-	return { reconciledMessageIds, brokenMessageIds };
-};