@remit/mailbox-service 0.0.112 → 0.0.114

package/src/message-parser.ts

@@ -1,26 +0,0 @@
-/**
- * Message parsing utilities for extracting content from raw RFC822 messages.
- */
-
-import { simpleParser } from "mailparser";
-
-export interface ParsedMessageContent {
-	text: string | null;
-	html: string | null;
-}
-
-/**
- * Parse a raw RFC822 message buffer and extract text/html content.
- *
- * @param buffer - The raw message content (RFC822 format)
- * @returns Parsed content with text and html fields
- */
-export const parseMessageContent = async (
-	buffer: Buffer,
-): Promise<ParsedMessageContent> => {
-	const parsed = await simpleParser(buffer);
-	return {
-		text: parsed.text ?? null,
-		html: typeof parsed.html === "string" ? parsed.html : null,
-	};
-};

package/src/message-presence.test.ts

@@ -1,50 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { isMessageGoneFromOpenMailbox } from "./message-presence.js";
-import type { IImapConnection } from "./types.js";
-
-type Probe = Pick<IImapConnection, "fetchMessages" | "search">;
-
-const buildProbe = (
-	fetched: number[],
-	searched: number[],
-	searchCalls: unknown[][] = [],
-): Probe => ({
-	fetchMessages: async () => fetched.map((uid) => ({ uid }) as never),
-	search: async (criteria: unknown[]) => {
-		searchCalls.push(criteria);
-		return searched;
-	},
-});
-
-describe("isMessageGoneFromOpenMailbox", () => {
-	it("a FETCH row is proof of presence — no SEARCH needed", async () => {
-		const searchCalls: unknown[][] = [];
-		const gone = await isMessageGoneFromOpenMailbox(
-			buildProbe([7], [], searchCalls),
-			7,
-		);
-
-		assert.equal(gone, false);
-		assert.equal(searchCalls.length, 0);
-	});
-
-	it("an empty FETCH the SEARCH contradicts is a dropped row, not an absence", async () => {
-		const gone = await isMessageGoneFromOpenMailbox(buildProbe([], [7]), 7);
-
-		assert.equal(gone, false);
-	});
-
-	it("only a SEARCH that does not list the uid confirms it is gone", async () => {
-		const gone = await isMessageGoneFromOpenMailbox(buildProbe([], []), 7);
-
-		assert.equal(gone, true);
-	});
-
-	it("asks the server for the uid it is about to reconcile", async () => {
-		const searchCalls: unknown[][] = [];
-		await isMessageGoneFromOpenMailbox(buildProbe([], [], searchCalls), 42);
-
-		assert.deepEqual(searchCalls, [[["UID", "42"]]]);
-	});
-});

package/src/message-read.ts

@@ -1,87 +0,0 @@
-import { isStorageNotFoundError } from "@remit/storage-service";
-
-/**
- * The slice of `BodySyncService` the read path needs to lazily materialize
- * deferred per-part objects.
- */
-export interface BodyPartMaterializer {
-	ensureBodyPartsStored(
-		accountConfigId: string,
-		accountId: string,
-		messageId: string,
-		bodyStorageKey: string,
-	): Promise<unknown>;
-}
-
-export interface MaterializeLogger {
-	warn(obj: Record<string, unknown>, msg: string): void;
-	error(obj: Record<string, unknown>, msg: string): void;
-}
-
-/**
- * Re-arms the body-sync cue for one message (the read-path slice of
- * `BodySyncQueueService`).
- */
-export interface BodySyncCue {
-	requestBodySync(input: {
-		accountId: string;
-		mailboxId: string;
-		messageId: string;
-		uid?: number;
-	}): Promise<void>;
-}
-
-export interface MaterializeResult {
-	/** `false` when the body object was missing — the caller must not serve the body. */
-	ready: boolean;
-}
-
-/**
- * Materialize the deferred per-part storage objects for a message before any
- * part is read. Distinguishes the two failure modes the body contract cares
- * about:
- *
- * - Missing storage object (never synced or lost) — re-arm the SYNC_MESSAGE_BODY
- *   cue so the worker (re)stores the body, and report `ready: false`. Not a
- *   500: a retry succeeds once the worker catches up.
- * - Any other error — rethrow so the request 500s and the bug is observable.
- *   Never swallowed, never "best-effort".
- *
- * No-op (`ready: true`) when the body isn't stored yet (no `bodyStorageKey`) or
- * when the parts were written eagerly.
- */
-export const materializeBodyParts = async (
-	materializer: BodyPartMaterializer,
-	args: {
-		accountConfigId: string;
-		accountId: string;
-		mailboxId: string;
-		messageId: string;
-		uid?: number;
-		bodyStorageKey: string | undefined;
-		cue: BodySyncCue | undefined;
-		logger: MaterializeLogger;
-	},
-): Promise<MaterializeResult> => {
-	const { accountConfigId, accountId, mailboxId, messageId, uid } = args;
-	if (!args.bodyStorageKey) return { ready: true };
-
-	try {
-		await materializer.ensureBodyPartsStored(
-			accountConfigId,
-			accountId,
-			messageId,
-			args.bodyStorageKey,
-		);
-		return { ready: true };
-	} catch (error: unknown) {
-		if (!isStorageNotFoundError(error)) throw error;
-
-		args.logger.warn(
-			{ messageId, accountId, mailboxId },
-			"Body object missing on read; re-arming body-sync cue and signalling retry",
-		);
-		await args.cue?.requestBodySync({ accountId, mailboxId, messageId, uid });
-		return { ready: false };
-	}
-};

package/src/message-save-retry.test.ts

@@ -1,90 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import type {
-	AccountItem,
-	IThreadMessageRepository,
-	MailboxItem,
-} from "@remit/data-ports";
-import { MessageSyncService } from "./message-sync.js";
-import { SyncWarningService } from "./sync-warning.js";
-import { eml, FakeImapServer } from "./test-helpers/fake-imap.js";
-import {
-	openStore,
-	type Store,
-	seedAccount,
-	seedMailbox,
-	silentLog,
-} from "./test-helpers/test-store.js";
-
-let store: Store;
-let imap: FakeImapServer;
-let account: AccountItem;
-let inbox: MailboxItem;
-
-beforeEach(async () => {
-	store = await openStore();
-	imap = new FakeImapServer();
-	account = await seedAccount(store);
-	inbox = await seedMailbox(store, account, "INBOX");
-	imap.addFolder("INBOX");
-});
-
-afterEach(() => store.close());
-
-/** The thread store, refusing its first create: the last write of a save. */
-const failingFirstCreate = (
-	inner: IThreadMessageRepository,
-): IThreadMessageRepository => {
-	let refused = false;
-	return Object.assign(Object.create(inner), {
-		create: (...args: Parameters<IThreadMessageRepository["create"]>) => {
-			if (!refused) {
-				refused = true;
-				return Promise.reject(new Error("the thread write failed"));
-			}
-			return inner.create(...args);
-		},
-	});
-};
-
-const syncOnce = (threadMessage: IThreadMessageRepository) => {
-	const connection = imap.connection();
-	return new MessageSyncService(
-		{ getConnection: () => connection, close: async () => {} },
-		store.mailbox,
-		store.mailboxSpecialUse,
-		store.message,
-		store.envelope,
-		store.address,
-		threadMessage,
-		new SyncWarningService(store.syncWarning),
-		silentLog,
-	).syncMessages(inbox.mailboxId, account.accountId, account.accountConfigId);
-};
-
-describe("a message save that fails at its last write", () => {
-	it("is completed by the next round, with one row of each", async () => {
-		imap.deliver(
-			"INBOX",
-			eml({ Subject: "Halfway", "Message-ID": "<halfway@example.test>" }),
-		);
-		const threadMessage = failingFirstCreate(store.threadMessage);
-
-		await syncOnce(threadMessage);
-		await syncOnce(threadMessage);
-
-		const messages = await store.message.listAllByMailbox(inbox.mailboxId);
-		assert.equal(messages.length, 1);
-		const [message] = messages;
-		assert.ok(message);
-		assert.equal(
-			(
-				await store.threadMessage.findAllByMessageId(
-					account.accountConfigId,
-					message.messageId,
-				)
-			).length,
-			1,
-		);
-	});
-});

package/src/message-sync-flags.test.ts

@@ -1,167 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import type {
-	CreateThreadMessageInput,
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMailboxRepository,
-	IMessageRepository,
-	ISyncWarningRepository,
-	IThreadMessageRepository,
-	ThreadMessageItem,
-} from "@remit/data-ports";
-import { MessageCategory, MessageSystemFlag } from "@remit/domain-enums";
-import type { ManagedConnectionFactory } from "./connection-factory.js";
-import { MessageSyncService } from "./message-sync.js";
-import { SyncWarningService } from "./sync-warning.js";
-import { noFolderRoles } from "./test-helpers/folder-roles.js";
-import type { ImapEnvelope } from "./types.js";
-
-// #44: initial sync hardcoded `hasStars: false` on row create, so mail flagged
-// in another client arrived unstarred and never appeared in Flagged. The
-// server's \Flagged keyword is the star; these cover the mapping on create.
-
-const ACCOUNT_CONFIG_ID = "cfg-1";
-const MAILBOX_ID = "mbx-1";
-const MESSAGE_ID = "msg-1";
-
-const envelope: ImapEnvelope = {
-	date: new Date(0).toISOString(),
-	messageId: "<root@example.com>",
-	subject: "Subject",
-	from: [{ name: "Sender", mailbox: "sender", host: "example.com" }],
-	sender: [],
-	replyTo: [],
-	to: [],
-	cc: [],
-	bcc: [],
-	inReplyTo: "",
-};
-
-/**
- * Capture the ThreadMessage create input the sync path builds. Only `create` is
- * exercised; the rest of the port is unreachable from this code path.
- */
-const captureCreate = (): {
-	repo: IThreadMessageRepository;
-	inputs: CreateThreadMessageInput[];
-} => {
-	const inputs: CreateThreadMessageInput[] = [];
-	const repo = {
-		findByMessageId: async () => null,
-		rekeyThread: async () => ({ moved: 0, dropped: 0 }),
-		create: async (input: CreateThreadMessageInput) => {
-			inputs.push(input);
-			return input as unknown as ThreadMessageItem;
-		},
-	} as unknown as IThreadMessageRepository;
-	return { repo, inputs };
-};
-
-const stub = <T>(): T => ({}) as T;
-
-/**
- * `createThreadForMessage` is private to the service — it is only ever reached
- * through a live IMAP fetch. Reach it directly so the flag mapping is covered
- * without standing up a server.
- */
-type CreateThreadForMessage = (
-	threadMessageService: IThreadMessageRepository,
-	messageId: string,
-	mailboxId: string,
-	accountId: string,
-	accountConfigId: string,
-	uid: number,
-	internalDate: number,
-	sentDate: number,
-	envelope: ImapEnvelope,
-	flags: string[],
-	category: ThreadMessageItem["category"],
-	references?: string[],
-	hasAttachment?: boolean,
-) => Promise<void>;
-
-const createThreadWithFlags = async (
-	flags: string[],
-): Promise<CreateThreadMessageInput> => {
-	const service = new MessageSyncService(
-		stub<ManagedConnectionFactory>(),
-		stub<IMailboxRepository>(),
-		noFolderRoles,
-		stub<IMessageRepository>(),
-		{
-			listQueuedStructureRefetches: async () => [],
-		} as unknown as IEnvelopeRepository,
-		stub<IAddressRepository>(),
-		stub<IThreadMessageRepository>(),
-		new SyncWarningService(stub<ISyncWarningRepository>()),
-	);
-	const { repo, inputs } = captureCreate();
-	const now = Date.now();
-
-	await (
-		service as unknown as { createThreadForMessage: CreateThreadForMessage }
-	).createThreadForMessage(
-		repo,
-		MESSAGE_ID,
-		MAILBOX_ID,
-		"acct-1",
-		ACCOUNT_CONFIG_ID,
-		42,
-		now,
-		now,
-		envelope,
-		flags,
-		MessageCategory.uncategorized,
-	);
-
-	assert.equal(inputs.length, 1);
-	const [input] = inputs;
-	assert.ok(input);
-	return input;
-};
-
-describe("message sync maps IMAP flags onto the created ThreadMessage", () => {
-	test("a message carrying \\Flagged is created starred", async () => {
-		const input = await createThreadWithFlags(["\\Flagged"]);
-		assert.equal(input.hasStars, true);
-		assert.equal(input.star, "yellow");
-	});
-
-	test("a message without \\Flagged is created unstarred", async () => {
-		const input = await createThreadWithFlags(["\\Seen"]);
-		assert.equal(input.hasStars, false);
-		assert.equal(input.star, "none");
-	});
-
-	test("\\Flagged and \\Seen are mapped independently", async () => {
-		const input = await createThreadWithFlags(["\\Seen", "\\Flagged"]);
-		assert.equal(input.isRead, true);
-		assert.equal(input.hasStars, true);
-	});
-});
-
-// #79: the mapping above was correct and still shipped broken. The sync path
-// compares a server flag list against these members, so what they hold has to
-// be the spelling IMAP puts on the wire — a leading backslash and all. The
-// published images carried `Flagged`, the member's *name*, because the emitter
-// that generates them was installed unpatched and ate the escape. Every
-// comparison then quietly stopped matching: mail flagged on the server arrived
-// unstarred, and a star set in the app went out as a custom keyword no other
-// client reads. Asserted against literals rather than the enum, because the
-// enum is the thing under test.
-describe("the generated flag members carry the IMAP wire spelling", () => {
-	test("system flags keep their leading backslash", () => {
-		assert.equal(MessageSystemFlag.Flagged, "\\Flagged");
-		assert.equal(MessageSystemFlag.Seen, "\\Seen");
-		assert.equal(MessageSystemFlag.Answered, "\\Answered");
-		assert.equal(MessageSystemFlag.Deleted, "\\Deleted");
-		assert.equal(MessageSystemFlag.Draft, "\\Draft");
-	});
-
-	test("a member's name is never its value", () => {
-		for (const [name, value] of Object.entries(MessageSystemFlag)) {
-			assert.notEqual(value, name);
-		}
-	});
-});