@remit/mailbox-service 0.0.111 → 0.0.113

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

@@ -1,276 +0,0 @@
-/**
- * The boundary this feature lives or dies on (issue #72).
- *
- * A message the parser refuses is set aside and stops being requeued. Storage
- * and database failures — which the same per-message frame catches — keep
- * propagating to the requeue path, because recording one as a quarantine would
- * tell the user that mail Remit could not reach was mail Remit could not read,
- * and let go of it. That discrimination is the `error instanceof BodyParseError`
- * branch in `syncBodies`' stream loop, and these tests drive it there.
- *
- * The parse cases inject the `BodyParseError` at the storage write rather than
- * feeding mailparser bytes it refuses: mailparser accepts every byte sequence a
- * test can construct, and the branch under test asks only what type of error
- * reached it. That only `parseMessageBody` ever constructs one — so an instance
- * of it really is proof the message and not the infrastructure failed — is
- * pinned in `body-parse.test.ts`.
- */
-
-import assert from "node:assert/strict";
-import { Readable } from "node:stream";
-import { describe, it } from "node:test";
-import type {
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMailboxSpecialUseRepository,
-	IMessageRepository,
-	IQuarantineRepository,
-	IThreadMessageRepository,
-	MessageItem,
-	QuarantineItem,
-	QuarantineUpsertInput,
-	UpdateMessageInput,
-} from "@remit/data-ports";
-import { NotFoundError } from "@remit/data-ports/errors";
-import { MessageCategory } from "@remit/domain-enums";
-import type { StorageService } from "@remit/storage-service";
-import { BodyParseError } from "./body-parse.js";
-import { BodySyncService } from "./body-sync.js";
-import { QuarantineService } from "./quarantine.js";
-import type { IImapConnection } from "./types.js";
-
-const WELL_FORMED = Buffer.from(
-	[
-		"From: someone@example.com",
-		"To: me@example.com",
-		"Subject: hello",
-		"Content-Type: text/plain",
-		"",
-		"body",
-	].join("\r\n"),
-);
-
-const buildHarness = (options: {
-	existing?: QuarantineItem[];
-	storeBodyFails?: unknown;
-	storeParsedFails?: unknown;
-	upsertFails?: boolean;
-}) => {
-	const writes: QuarantineUpsertInput[] = [];
-	const messageUpdates: string[] = [];
-
-	const message: MessageItem = {
-		messageId: "m-1",
-		mailboxId: "mbx-1",
-		uid: 40217,
-		rfc822Size: 2048,
-		messageIdHeader: "<abc@example.com>",
-		category: MessageCategory.uncategorized,
-		classificationState: "NotExamined",
-	} as MessageItem;
-
-	const messageService = {
-		get: async () => message,
-		update: async (messageId: string, _input: UpdateMessageInput) => {
-			messageUpdates.push(messageId);
-		},
-	} as unknown as IMessageRepository;
-
-	const storageService = {
-		retrieve: async () => {
-			throw new Error("the sync path never reads a body back");
-		},
-		storeMessageBodyStream: async () => {
-			if (options.storeBodyFails !== undefined) throw options.storeBodyFails;
-			return { uri: "s3://bodies/m-1" };
-		},
-		storeParsedBody: async () => {
-			if (options.storeParsedFails !== undefined)
-				throw options.storeParsedFails;
-		},
-		listBodyParts: async () => [],
-	} as unknown as StorageService;
-
-	const envelopeService = {
-		getMessageData: async () => ({ bodyPart: [], bodyPartParameter: [] }),
-		listBodyParts: async () => [],
-	} as unknown as IEnvelopeRepository;
-
-	const addressService = {
-		getAddress: async () => {
-			throw new NotFoundError("Address not found");
-		},
-		incrementInboundCount: async () => {},
-	} as unknown as IAddressRepository;
-
-	const repository = {
-		listByAccountConfigId: async () => options.existing ?? [],
-		upsert: async (input: QuarantineUpsertInput) => {
-			if (options.upsertFails) throw new Error("database unavailable");
-			writes.push(input);
-		},
-	} satisfies IQuarantineRepository;
-
-	const service = new BodySyncService(
-		messageService,
-		storageService,
-		{
-			findAllByMessageId: async () => [
-				{
-					threadMessageId: "tm-1",
-					sentDate: 1,
-					mailboxId: "mbx-1",
-					isRead: false,
-					isDeleted: false,
-					hasStars: false,
-					hasAttachment: false,
-				},
-			],
-			update: async () => {},
-		} as unknown as IThreadMessageRepository,
-		addressService,
-		envelopeService,
-		{ info: () => {}, error: () => {}, debug: () => {} },
-		undefined,
-		undefined,
-		{
-			quarantineService: new QuarantineService(
-				repository,
-				{
-					listByMailboxId: async () => [],
-				} as unknown as IMailboxSpecialUseRepository,
-				"sha-abc",
-				{ info: () => {}, warn: () => {} },
-			),
-			mailboxId: "mbx-1",
-			uidValidity: 1_712_000_000,
-			attempts: 2,
-		},
-	);
-
-	return { service, writes, messageUpdates };
-};
-
-const connection = () =>
-	({
-		openBox: async () => {},
-		async *fetchMessageBodies(uids: number[]) {
-			for (const uid of uids) {
-				yield { uid, source: Readable.from([WELL_FORMED]) };
-			}
-		},
-	}) as unknown as IImapConnection;
-
-const sync = (service: BodySyncService) =>
-	service.syncBodies(
-		["m-1"],
-		"acc-1",
-		"cfg-1",
-		{ fullPath: "INBOX", placement: "inbox" },
-		async () => connection(),
-	);
-
-const parseRefusal = () =>
-	new BodyParseError(new Error("boundary never closed"));
-
-describe("body sync quarantines a message the parser refuses", () => {
-	it("records the failure instead of requeueing the message forever", async () => {
-		const harness = buildHarness({ storeBodyFails: parseRefusal() });
-
-		const result = await sync(harness.service);
-
-		assert.equal(harness.writes.length, 1);
-		assert.deepEqual(result.failedMessageIds, []);
-	});
-
-	it("names the message by uid and UIDVALIDITY, so the record is idempotent", async () => {
-		const harness = buildHarness({ storeBodyFails: parseRefusal() });
-
-		await sync(harness.service);
-
-		assert.equal(harness.writes[0]?.uid, 40217);
-		assert.equal(harness.writes[0]?.uidValidity, 1_712_000_000);
-		assert.equal(harness.writes[0]?.failureStage, "BodyParse");
-	});
-
-	it("does not mark the message synced — it was set aside, not applied", async () => {
-		const harness = buildHarness({ storeBodyFails: parseRefusal() });
-
-		const result = await sync(harness.service);
-
-		assert.deepEqual(result.syncedMessageIds, []);
-		assert.deepEqual(harness.messageUpdates, []);
-	});
-});
-
-describe("body sync leaves infrastructure failures alone", () => {
-	it("requeues a storage failure rather than calling the message unreadable", async () => {
-		const harness = buildHarness({
-			storeBodyFails: new Error("S3 503 SlowDown"),
-		});
-
-		const result = await sync(harness.service);
-
-		assert.deepEqual(harness.writes, []);
-		assert.deepEqual(result.failedMessageIds, ["m-1"]);
-	});
-
-	it("requeues a database failure the same way, parse already past", async () => {
-		const throughput = new Error("ProvisionedThroughputExceededException");
-		throughput.name = "ProvisionedThroughputExceededException";
-		const harness = buildHarness({ storeParsedFails: throughput });
-
-		// The body parsed cleanly and the failure came after it, so nothing here
-		// may say the message is unreadable.
-		const result = await sync(harness.service);
-
-		assert.deepEqual(harness.writes, []);
-		assert.deepEqual(result.failedMessageIds, ["m-1"]);
-	});
-});
-
-describe("body sync contains a failure to write the record", () => {
-	it("requeues the message instead of aborting the batch", async () => {
-		const harness = buildHarness({
-			storeBodyFails: parseRefusal(),
-			upsertFails: true,
-		});
-
-		// Writing the record is database work, so its failure is infrastructure:
-		// the message keeps its place in the queue rather than being let go of
-		// with nothing written down, and the rest of the batch is unaffected.
-		const result = await sync(harness.service);
-
-		assert.deepEqual(harness.writes, []);
-		assert.deepEqual(result.failedMessageIds, ["m-1"]);
-	});
-});
-
-describe("body sync skips what is already quarantined", () => {
-	it("does not fetch or re-parse a uid already set aside", async () => {
-		const harness = buildHarness({
-			existing: [
-				{
-					mailboxId: "mbx-1",
-					uidValidity: 1_712_000_000,
-					uid: 40217,
-				} as QuarantineItem,
-			],
-		});
-
-		const result = await harness.service.syncBodies(
-			["m-1"],
-			"acc-1",
-			"cfg-1",
-			{ fullPath: "INBOX", placement: "inbox" },
-			async () => {
-				throw new Error("a quarantined message must not be fetched again");
-			},
-		);
-
-		assert.equal(result.skippedCount, 1);
-		assert.deepEqual(result.failedMessageIds, []);
-		assert.deepEqual(harness.writes, []);
-		assert.deepEqual(harness.messageUpdates, []);
-	});
-});

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

@@ -1,124 +0,0 @@
-import assert from "node:assert";
-import { describe, it, mock } from "node:test";
-import {
-	type BodySyncQueueLogger,
-	BodySyncQueueService,
-} from "./body-sync-queue.js";
-
-interface CapturedInput {
-	QueueUrl: string;
-	MessageBody: string;
-	MessageGroupId?: string;
-	MessageDeduplicationId?: string;
-}
-
-const buildService = (
-	overrides: {
-		sqsQueueUrl?: string;
-		send?: (command: { input: CapturedInput }) => Promise<unknown>;
-		logger?: BodySyncQueueLogger;
-	} = {},
-) => {
-	const sent: CapturedInput[] = [];
-	const send = mock.fn(
-		overrides.send ??
-			(async (command: { input: CapturedInput }) => {
-				sent.push(command.input);
-				return { MessageId: "id" };
-			}),
-	);
-	const service = new BodySyncQueueService({
-		sqsQueueUrl:
-			overrides.sqsQueueUrl ?? "http://localhost:9324/000/remit-body",
-		logger: overrides.logger,
-	});
-	// @ts-expect-error - inject mock SQS client for the test
-	service.sqs = { send };
-	return { service, send, sent };
-};
-
-describe("BodySyncQueueService.requestBodySync", () => {
-	it("emits a SYNC_MESSAGE_BODY event with the message id and uid pair", async () => {
-		const { service, send, sent } = buildService();
-
-		await service.requestBodySync({
-			accountId: "acc-1",
-			mailboxId: "mbx-1",
-			messageId: "msg-1",
-			uid: 42,
-		});
-
-		assert.equal(send.mock.calls.length, 1);
-		const event = JSON.parse(sent[0].MessageBody);
-		assert.equal(event.type, "SYNC_MESSAGE_BODY");
-		assert.equal(event.accountId, "acc-1");
-		assert.equal(event.mailboxId, "mbx-1");
-		assert.deepEqual(event.messageIds, ["msg-1"]);
-		assert.deepEqual(event.messages, [{ messageId: "msg-1", uid: 42 }]);
-		// The worker's skip guard must be bypassed for this message — a read
-		// miss already proved bodyStorageKey is stale.
-		assert.equal(event.force, true);
-		// A standard queue must not carry FIFO parameters.
-		assert.equal(sent[0].MessageGroupId, undefined);
-	});
-
-	it("omits the uid pair when no uid is known", async () => {
-		const { service, sent } = buildService();
-
-		await service.requestBodySync({
-			accountId: "acc-1",
-			mailboxId: "mbx-1",
-			messageId: "msg-1",
-		});
-
-		const event = JSON.parse(sent[0].MessageBody);
-		assert.deepEqual(event.messageIds, ["msg-1"]);
-		assert.equal(event.messages, undefined);
-	});
-
-	it("never rejects when the queue send fails — the read path already returned 202", async () => {
-		const { service } = buildService({
-			send: async () => {
-				throw new Error("queue down");
-			},
-		});
-
-		await assert.doesNotReject(() =>
-			service.requestBodySync({
-				accountId: "acc-1",
-				mailboxId: "mbx-1",
-				messageId: "msg-1",
-			}),
-		);
-	});
-
-	it("logs an alertable body_sync_cue_enqueue_failed error instead of rejecting — the swallow is not silent operationally, only silent to the caller (RFC 033 D5)", async () => {
-		const errorCalls: Array<[Record<string, unknown>, string]> = [];
-		const logger: BodySyncQueueLogger = {
-			info: () => {},
-			error: (obj, msg) => {
-				errorCalls.push([obj, msg]);
-			},
-		};
-		const { service } = buildService({
-			send: async () => {
-				throw new Error("queue down");
-			},
-			logger,
-		});
-
-		await service.requestBodySync({
-			accountId: "acc-1",
-			mailboxId: "mbx-1",
-			messageId: "msg-1",
-		});
-
-		assert.equal(errorCalls.length, 1);
-		const [fields, message] = errorCalls[0];
-		assert.equal(fields.alert, "body_sync_cue_enqueue_failed");
-		assert.equal(fields.accountId, "acc-1");
-		assert.equal(fields.mailboxId, "mbx-1");
-		assert.equal(fields.messageId, "msg-1");
-		assert.match(message, /read path returned a retryable 202/);
-	});
-});

package/src/body-sync-queue.ts

@@ -1,131 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
-import { createQueueProducer } from "@remit/sqs-client/producer";
-
-/**
- * SYNC_MESSAGE_BODY event structure (matches remit-imap-worker/events.ts). The
- * consumer falls back to `messageIds` when `messages` (id+uid pairs) is absent.
- */
-interface SyncMessageBodyTarget {
-	messageId: string;
-	uid: number;
-}
-
-interface SyncMessageBodyEvent {
-	type: "SYNC_MESSAGE_BODY";
-	eventId: string;
-	timestamp: number;
-	accountId: string;
-	mailboxId: string;
-	messageIds: string[];
-	messages?: SyncMessageBodyTarget[];
-	/**
-	 * Always true for this read-miss re-arm cue: the caller only reaches
-	 * `requestBodySync` when a `/content` read found `bodyStorageKey` set but
-	 * the storage object missing, so the worker must bypass its "already
-	 * stored" skip guard and re-fetch even though the DB row is stale.
-	 */
-	force: true;
-}
-
-export interface BodySyncQueueLogger {
-	info(obj: Record<string, unknown>, msg: string): void;
-	error(obj: Record<string, unknown>, msg: string): void;
-}
-
-const noopLogger: BodySyncQueueLogger = {
-	info: () => {},
-	error: () => {},
-};
-
-export interface BodySyncQueueConfig {
-	sqsQueueUrl: string;
-	sqsEndpoint?: string;
-	logger?: BodySyncQueueLogger;
-}
-
-export interface RequestBodySyncInput {
-	accountId: string;
-	mailboxId: string;
-	messageId: string;
-	/** UID resolved at read time so the worker issues one FETCH without a lookup. */
-	uid?: number;
-}
-
-/**
- * Re-arms the body-sync cue for a single message from the read path.
- *
- * The worker emits SYNC_MESSAGE_BODY during metadata sync; this service lets the
- * API re-emit that cue on demand when a body-fetch finds the storage object
- * missing (never synced, or lost). The subsequent client retry then resolves
- * once the worker has stored the body.
- *
- * A queue-send failure never rejects: the read path already returns a retryable
- * 202 to the caller, and a rejection here would land on the shared API event
- * loop and fail an unrelated in-flight request. It is logged loudly with an
- * alertable field instead.
- */
-export class BodySyncQueueService {
-	private sqs: SQSClient;
-	private queueUrl: string;
-	private log: BodySyncQueueLogger;
-
-	constructor(config: BodySyncQueueConfig) {
-		this.queueUrl = config.sqsQueueUrl;
-		this.log = config.logger ?? noopLogger;
-		this.sqs = createQueueProducer({
-			queueUrl: config.sqsQueueUrl,
-			endpoint: config.sqsEndpoint,
-		});
-	}
-
-	requestBodySync = async (input: RequestBodySyncInput): Promise<void> => {
-		const { accountId, mailboxId, messageId, uid } = input;
-		const event: SyncMessageBodyEvent = {
-			type: "SYNC_MESSAGE_BODY",
-			eventId: randomUUID(),
-			timestamp: Date.now(),
-			accountId,
-			mailboxId,
-			messageIds: [messageId],
-			...(uid !== undefined && { messages: [{ messageId, uid }] }),
-			force: true,
-		};
-
-		const useFifo = this.queueUrl.endsWith(".fifo");
-
-		await this.sqs
-			.send(
-				new SendMessageCommand({
-					QueueUrl: this.queueUrl,
-					MessageBody: JSON.stringify(event),
-					...(useFifo && {
-						MessageGroupId: accountId,
-						MessageDeduplicationId: event.eventId,
-					}),
-				}),
-			)
-			.then(() => {
-				this.log.info(
-					{ eventId: event.eventId, accountId, mailboxId, messageId },
-					"Re-armed SYNC_MESSAGE_BODY cue",
-				);
-			})
-			.catch((error: unknown) => {
-				this.log.error(
-					{
-						alert: "body_sync_cue_enqueue_failed",
-						eventId: event.eventId,
-						accountId,
-						mailboxId,
-						messageId,
-						errorName: (error as { name?: string })?.name,
-						errorCode:
-							(error as { Code?: string })?.Code ??
-							(error as { code?: string })?.code,
-					},
-					"Failed to re-arm SYNC_MESSAGE_BODY cue (read path returned a retryable 202)",
-				);
-			});
-	};
-}