@remit/mailbox-service 0.0.111 → 0.0.113

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-sync-address-spoof.test.ts

@@ -1,293 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	CreateAddressInput,
-	CreateEnvelopeAddressInput,
-	CreateThreadMessageInput,
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMailboxRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MailboxItem,
-	MessageItem,
-	ThreadMessageItem,
-} from "@remit/data-ports";
-import type { ManagedConnectionFactory } from "./connection-factory.js";
-import { type AccountFolderRoles, MessageSyncService } from "./message-sync.js";
-import { NO_FOLDER_ROLES, noFolderRoles } from "./test-helpers/folder-roles.js";
-import type { ImapAddress, ImapEnvelope, ImapMessage } from "./types.js";
-
-const stub = <T>(): T => ({}) as T;
-
-const emptyEnvelope: ImapEnvelope = {
-	date: new Date(0).toISOString(),
-	messageId: "<root@example.com>",
-	subject: "Subject",
-	from: [],
-	sender: [],
-	replyTo: [],
-	to: [],
-	cc: [],
-	bcc: [],
-	inReplyTo: "",
-};
-
-interface Saved {
-	addresses: CreateAddressInput[];
-	envelopeAddresses: CreateEnvelopeAddressInput[];
-	threadMessages: CreateThreadMessageInput[];
-}
-
-const harvest = async (envelope: Partial<ImapEnvelope>): Promise<Saved> => {
-	const saved: Saved = {
-		addresses: [],
-		envelopeAddresses: [],
-		threadMessages: [],
-	};
-
-	const messageService = {
-		upsertWithStatus: async (input: unknown) => ({
-			item: input as MessageItem,
-			created: true,
-		}),
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		create: async (input: CreateThreadMessageInput) => {
-			saved.threadMessages.push(input);
-			return input as unknown as ThreadMessageItem;
-		},
-	} as unknown as IThreadMessageRepository;
-
-	const envelopeService = {
-		upsertEnvelope: async () => {},
-		upsertBodyParts: async () => {},
-	} as unknown as IEnvelopeRepository;
-
-	const addressService = {
-		upsertCorrespondentAddress: async (input: CreateAddressInput) => {
-			saved.addresses.push(input);
-		},
-		upsertEnvelopeAddress: async (input: CreateEnvelopeAddressInput) => {
-			saved.envelopeAddresses.push(input);
-		},
-	} as unknown as IAddressRepository;
-
-	const service = new MessageSyncService(
-		stub<ManagedConnectionFactory>(),
-		stub<IMailboxRepository>(),
-		noFolderRoles,
-		messageService,
-		envelopeService,
-		addressService,
-		threadMessageService,
-	);
-
-	const msg = {
-		uid: 42,
-		seq: 1,
-		size: 100,
-		internalDate: new Date(0),
-		flags: [],
-		envelope: { ...emptyEnvelope, ...envelope },
-	} as unknown as ImapMessage;
-
-	await (
-		service as unknown as {
-			saveMessage: (
-				mailbox: MailboxItem,
-				accountId: string,
-				accountConfigId: string,
-				msg: ImapMessage,
-				roles: AccountFolderRoles,
-			) => Promise<unknown>;
-		}
-	).saveMessage(
-		{ mailboxId: "mbx-1", fullPath: "INBOX" } as MailboxItem,
-		"acct-1",
-		"cfg-1",
-		msg,
-		NO_FOLDER_ROLES,
-	);
-
-	return saved;
-};
-
-const spoof: ImapAddress = {
-	name: "matthijs@ischen.nl",
-	mailbox: "aramirez",
-	host: "secresaludguaviare.gov.co",
-};
-
-const onlyAddress = async (
-	envelope: Partial<ImapEnvelope>,
-): Promise<CreateAddressInput> => {
-	const { addresses } = await harvest(envelope);
-	assert.equal(addresses.length, 1);
-	const [input] = addresses;
-	assert.ok(input);
-	return input;
-};
-
-describe("harvesting an envelope display name", () => {
-	it("drops a name that is an address the row does not own", async () => {
-		const input = await onlyAddress({ from: [spoof] });
-
-		assert.equal(input.displayName, "");
-		assert.equal(input.normalizedEmail, "aramirez@secresaludguaviare.gov.co");
-		assert.equal(
-			input.normalizedCompound,
-			"aramirez@secresaludguaviare.gov.co",
-		);
-	});
-
-	it("keeps what a name says besides the address it claims", async () => {
-		const input = await onlyAddress({
-			from: [{ ...spoof, name: "Matthijs <matthijs@ischen.nl>" }],
-		});
-
-		assert.equal(input.displayName, "Matthijs");
-		assert.equal(
-			input.normalizedCompound,
-			"matthijs aramirez@secresaludguaviare.gov.co",
-		);
-	});
-
-	it("keeps a name a sender wrote its own support address into", async () => {
-		const input = await onlyAddress({
-			from: [
-				{
-					name: "Support (support@acme.com)",
-					mailbox: "noreply",
-					host: "acme.com",
-				},
-			],
-		});
-
-		assert.equal(input.displayName, "Support");
-	});
-
-	it("keeps a name that is the address it labels", async () => {
-		const input = await onlyAddress({
-			from: [
-				{
-					name: "ING@ing-nl-mailing.nl",
-					mailbox: "ing",
-					host: "ing-nl-mailing.nl",
-				},
-			],
-		});
-
-		assert.equal(input.displayName, "ING@ing-nl-mailing.nl");
-		assert.equal(
-			input.normalizedCompound,
-			"ing@ing-nl-mailing.nl ing@ing-nl-mailing.nl",
-		);
-	});
-
-	it("keeps a non-ASCII name that is the address it labels", async () => {
-		const input = await onlyAddress({
-			from: [
-				{ name: "Özcan@example.com", mailbox: "Özcan", host: "example.com" },
-			],
-		});
-
-		assert.equal(input.displayName, "Özcan@example.com");
-	});
-
-	it("keeps an ordinary human name", async () => {
-		const input = await onlyAddress({
-			from: [
-				{ name: "Matthijs van Henten", mailbox: "matthijs", host: "ischen.nl" },
-			],
-		});
-
-		assert.equal(input.displayName, "Matthijs van Henten");
-		assert.equal(
-			input.normalizedCompound,
-			"matthijs van henten matthijs@ischen.nl",
-		);
-	});
-
-	it("drops the name on every harvested envelope role", async () => {
-		const { addresses } = await harvest({
-			from: [spoof],
-			sender: [spoof],
-			replyTo: [spoof],
-			to: [spoof],
-			cc: [spoof],
-			bcc: [spoof],
-		});
-
-		assert.equal(addresses.length, 6);
-		for (const input of addresses) {
-			assert.equal(input.displayName, "");
-		}
-	});
-
-	it("still harvests the address from every envelope role", async () => {
-		const named = (mailbox: string): ImapAddress[] => [
-			{ name: "Someone", mailbox, host: "example.com" },
-		];
-		const { addresses } = await harvest({
-			from: named("from"),
-			sender: named("sender"),
-			replyTo: named("reply-to"),
-			to: named("to"),
-			cc: named("cc"),
-			bcc: named("bcc"),
-		});
-
-		assert.deepEqual(
-			addresses.map((input) => input.normalizedEmail),
-			[
-				"from@example.com",
-				"sender@example.com",
-				"reply-to@example.com",
-				"to@example.com",
-				"cc@example.com",
-				"bcc@example.com",
-			],
-		);
-		for (const input of addresses) {
-			assert.equal(input.displayName, "Someone");
-		}
-	});
-
-	it("drops the name on the envelope the message header renders", async () => {
-		const { envelopeAddresses } = await harvest({ from: [spoof] });
-
-		assert.equal(envelopeAddresses.length, 1);
-		assert.equal(envelopeAddresses[0]?.displayName, "");
-	});
-
-	it("keeps the sender label's text and drops only the address", async () => {
-		const { threadMessages } = await harvest({
-			from: [{ ...spoof, name: "Support <matthijs@ischen.nl>" }],
-		});
-
-		assert.equal(threadMessages[0]?.fromName, "Support");
-	});
-
-	it("drops the sender label the message list shows", async () => {
-		const { threadMessages } = await harvest({ from: [spoof] });
-
-		assert.equal(threadMessages.length, 1);
-		assert.equal(threadMessages[0]?.fromName, undefined);
-		assert.equal(
-			threadMessages[0]?.fromEmail,
-			"aramirez@secresaludguaviare.gov.co",
-		);
-	});
-
-	it("keeps the sender label when it is an ordinary name", async () => {
-		const { threadMessages } = await harvest({
-			from: [
-				{ name: "Alejandro Ramirez", mailbox: "aramirez", host: "example.gov" },
-			],
-		});
-
-		assert.equal(threadMessages[0]?.fromName, "Alejandro Ramirez");
-	});
-});

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

@@ -1,142 +0,0 @@
-/**
- * A ThreadMessage row created for a message that is already classified used to
- * start at `uncategorized` and stay there: `denormalizeCategory` runs at
- * body-sync, and body-sync skips a message whose body is already stored (issue
- * #320). A second mailbox does not produce such a row — the ids are
- * mailbox-independent — but thread-root drift does: the same message re-saved
- * under different `References` mints a second threadId, so a new row for a
- * Message whose category is already decided.
- *
- * The row now carries the category of the Message the same save just wrote.
- * These pin the create input, which is where the threading can go wrong; the
- * stored round-trip belongs to #322's conformance suite. The negative case is
- * here because parameter threading is exactly the change that starts writing the
- * wrong value when a caller's variable is undefined — and `uncategorized` is the
- * declared pending state, never to be folded into `personal` (issue #45).
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	CreateMessageInput,
-	CreateThreadMessageInput,
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMailboxRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MailboxItem,
-	MessageItem,
-	ThreadMessageItem,
-} from "@remit/data-ports";
-import { MessageCategory } from "@remit/domain-enums";
-import type { ManagedConnectionFactory } from "./connection-factory.js";
-import { type AccountFolderRoles, MessageSyncService } from "./message-sync.js";
-import { NO_FOLDER_ROLES, noFolderRoles } from "./test-helpers/folder-roles.js";
-import type { ImapMessage } from "./types.js";
-
-const envelope = {
-	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: "",
-};
-
-const imapMessage = {
-	uid: 42,
-	seq: 1,
-	size: 100,
-	internalDate: new Date(0),
-	flags: [],
-	envelope,
-} as unknown as ImapMessage;
-
-const stub = <T>(): T => ({}) as T;
-
-/**
- * Drive the real save path so the value the ThreadMessage gets is the one the
- * Message write returned, not one a test handed to a private method.
- */
-const saveIntoMailbox = async (
-	storedCategory: MessageItem["category"],
-): Promise<CreateThreadMessageInput> => {
-	const inputs: CreateThreadMessageInput[] = [];
-
-	const messageService = {
-		upsertWithStatus: async (input: CreateMessageInput) => ({
-			item: {
-				...input,
-				category: storedCategory,
-			} as unknown as MessageItem,
-			created: false,
-		}),
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		create: async (input: CreateThreadMessageInput) => {
-			inputs.push(input);
-			return input as unknown as ThreadMessageItem;
-		},
-	} as unknown as IThreadMessageRepository;
-
-	const envelopeService = {
-		upsertEnvelope: async () => {},
-		upsertBodyParts: async () => {},
-	} as unknown as IEnvelopeRepository;
-
-	const addressService = {
-		upsertCorrespondentAddress: async () => {},
-		upsertEnvelopeAddress: async () => {},
-	} as unknown as IAddressRepository;
-
-	const service = new MessageSyncService(
-		stub<ManagedConnectionFactory>(),
-		stub<IMailboxRepository>(),
-		noFolderRoles,
-		messageService,
-		envelopeService,
-		addressService,
-		threadMessageService,
-	);
-
-	await (
-		service as unknown as {
-			saveMessage: (
-				mailbox: MailboxItem,
-				accountId: string,
-				accountConfigId: string,
-				msg: ImapMessage,
-				roles: AccountFolderRoles,
-			) => Promise<unknown>;
-		}
-	).saveMessage(
-		{ mailboxId: "mbx-1", fullPath: "INBOX" } as MailboxItem,
-		"acct-1",
-		"cfg-1",
-		imapMessage,
-		NO_FOLDER_ROLES,
-	);
-
-	assert.equal(inputs.length, 1);
-	const [input] = inputs;
-	assert.ok(input);
-	return input;
-};
-
-describe("a created ThreadMessage carries the Message's category", () => {
-	it("gives a row for an already-classified message that message's category", async () => {
-		const input = await saveIntoMailbox(MessageCategory.newsletter);
-		assert.equal(input.category, MessageCategory.newsletter);
-	});
-
-	it("leaves a row for a new, unclassified message at uncategorized", async () => {
-		const input = await saveIntoMailbox(MessageCategory.uncategorized);
-		assert.equal(input.category, MessageCategory.uncategorized);
-	});
-});