@remit/mailbox-service 0.0.111 → 0.0.113

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

@@ -1,158 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import type {
-	CreateThreadMessageInput,
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMailboxRepository,
-	IMessageRepository,
-	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 { 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 = {
-		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,
-	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>(),
-		stub<IEnvelopeRepository>(),
-		stub<IAddressRepository>(),
-		stub<IThreadMessageRepository>(),
-	);
-	const { repo, inputs } = captureCreate();
-	const now = Date.now();
-
-	await (
-		service as unknown as { createThreadForMessage: CreateThreadForMessage }
-	).createThreadForMessage(
-		repo,
-		MESSAGE_ID,
-		MAILBOX_ID,
-		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);
-		}
-	});
-});

package/src/message-sync-junk-harvest.test.ts

@@ -1,244 +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,
-	addressSightingIn,
-	MessageSyncService,
-} from "./message-sync.js";
-import { folderRoles, NO_JUNK_ROLES } from "./test-helpers/folder-roles.js";
-import type { ImapEnvelope, ImapMessage } from "./types.js";
-
-const stub = <T>(): T => ({}) as T;
-
-const envelope: ImapEnvelope = {
-	date: new Date(0).toISOString(),
-	messageId: "<root@example.com>",
-	subject: "Subject",
-	from: [{ name: "Pharma Deals", mailbox: "sales", host: "pharma.example" }],
-	sender: [],
-	replyTo: [],
-	to: [{ name: "", mailbox: "victim", host: "ischen.nl" }],
-	cc: [],
-	bcc: [],
-	inReplyTo: "",
-};
-
-interface Saved {
-	correspondents: CreateAddressInput[];
-	junk: CreateAddressInput[];
-	neutral: CreateAddressInput[];
-	envelopeAddresses: CreateEnvelopeAddressInput[];
-	reconciled: string[];
-}
-
-const mailboxAt = (fullPath: string): MailboxItem =>
-	({
-		mailboxId: `mbx-${fullPath}`,
-		fullPath,
-		hierarchyDelimiter: "/",
-	}) as MailboxItem;
-
-/**
- * Save one message into `mailbox`, with the account holding `role` in that same
- * folder. `undefined` is an account whose Junk and Trash are elsewhere.
- */
-const save = async (
-	mailbox: MailboxItem,
-	role?: "Junk" | "Trash",
-): Promise<Saved> => {
-	const saved: Saved = {
-		correspondents: [],
-		junk: [],
-		neutral: [],
-		envelopeAddresses: [],
-		reconciled: [],
-	};
-
-	const messageService = {
-		upsertWithStatus: async (input: unknown) => ({
-			item: input as MessageItem,
-			created: true,
-		}),
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		create: async (input: CreateThreadMessageInput) =>
-			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.correspondents.push(input);
-		},
-		upsertJunkAddress: async (input: CreateAddressInput) => {
-			saved.junk.push(input);
-		},
-		upsertAddress: async (input: CreateAddressInput) => {
-			saved.neutral.push(input);
-		},
-		upsertEnvelopeAddress: async (input: CreateEnvelopeAddressInput) => {
-			saved.envelopeAddresses.push(input);
-		},
-		reconcileJunkOnlyForMessage: async (messageId: string) => {
-			saved.reconciled.push(messageId);
-		},
-	} as unknown as IAddressRepository;
-
-	const service = new MessageSyncService(
-		stub<ManagedConnectionFactory>(),
-		stub<IMailboxRepository>(),
-		folderRoles(
-			role === "Junk"
-				? { junkMailboxId: mailbox.mailboxId }
-				: role === "Trash"
-					? { trashMailboxId: mailbox.mailboxId }
-					: {},
-		),
-		messageService,
-		envelopeService,
-		addressService,
-		threadMessageService,
-	);
-
-	const msg = {
-		uid: 42,
-		seq: 1,
-		size: 100,
-		internalDate: new Date(0),
-		flags: [],
-		envelope,
-	} as unknown as ImapMessage;
-
-	await (
-		service as unknown as {
-			saveMessage: (
-				mailbox: MailboxItem,
-				accountId: string,
-				accountConfigId: string,
-				msg: ImapMessage,
-				roles: AccountFolderRoles,
-			) => Promise<unknown>;
-		}
-	).saveMessage(mailbox, "acct-1", "cfg-1", msg, {
-		junkMailboxId: role === "Junk" ? mailbox.mailboxId : null,
-		trashMailboxId: role === "Trash" ? mailbox.mailboxId : null,
-		configJunkRoles: NO_JUNK_ROLES,
-	});
-
-	return saved;
-};
-
-const emails = (inputs: Array<{ normalizedEmail: string }>): string[] =>
-	inputs.map((input) => input.normalizedEmail);
-
-const BOTH = ["sales@pharma.example", "victim@ischen.nl"];
-
-describe("what a mailbox says about the addresses on its messages", () => {
-	const ROLES = (junk: string | null, trash: string | null) => ({
-		junkMailboxId: junk,
-		trashMailboxId: trash,
-		configJunkRoles: NO_JUNK_ROLES,
-	});
-
-	it("reads the folder the account appointed, not the folder’s name", () => {
-		// The account appointed `INBOX/Rubbish` as Junk. A second folder called
-		// `Spam` is an ordinary folder, and its senders are correspondents —
-		// a role belongs to one folder (RFC 032), so a name cannot claim it.
-		const roles = ROLES("mbx-rubbish", null);
-		assert.equal(addressSightingIn("mbx-rubbish", roles), "junk");
-		assert.equal(addressSightingIn("mbx-spam", roles), "correspondent");
-	});
-
-	it("keeps a message in Trash from deciding either way", () => {
-		assert.equal(
-			addressSightingIn("mbx-trash", ROLES(null, "mbx-trash")),
-			"discarded",
-		);
-	});
-
-	it("reads an account with neither role as all correspondents", () => {
-		assert.equal(
-			addressSightingIn("mbx-anything", ROLES(null, null)),
-			"correspondent",
-		);
-	});
-
-	it("harvests every envelope address of an ordinary message", async () => {
-		const saved = await save(mailboxAt("INBOX"));
-
-		assert.deepEqual(emails(saved.correspondents), BOTH);
-		assert.equal(saved.junk.length, 0);
-		assert.equal(saved.neutral.length, 0);
-	});
-
-	it("withholds every envelope address of a message in Junk", async () => {
-		const saved = await save(mailboxAt("INBOX/Rubbish"), "Junk");
-
-		assert.deepEqual(emails(saved.junk), BOTH);
-		assert.equal(saved.correspondents.length, 0);
-	});
-
-	it("still records the envelope a message in Junk renders", async () => {
-		const saved = await save(mailboxAt("INBOX/Rubbish"), "Junk");
-
-		assert.deepEqual(emails(saved.envelopeAddresses), BOTH);
-	});
-
-	it("leaves the identity of an envelope address to the store", async () => {
-		const saved = await save(mailboxAt("INBOX"));
-
-		assert.ok(saved.envelopeAddresses.length > 0);
-		for (const envelopeAddress of saved.envelopeAddresses) {
-			assert.ok(!("envelopeAddressId" in envelopeAddress));
-		}
-	});
-
-	it("keeps a message in Trash from deciding either way", async () => {
-		const saved = await save(mailboxAt("Trash"), "Trash");
-
-		assert.deepEqual(emails(saved.neutral), BOTH);
-		assert.equal(saved.correspondents.length, 0);
-		assert.equal(saved.junk.length, 0);
-	});
-
-	it("re-asks every sighting of a sender a message in Junk carries", async () => {
-		const saved = await save(mailboxAt("INBOX/Rubbish"), "Junk");
-
-		assert.equal(saved.reconciled.length, 1);
-		assert.deepEqual(saved.reconciled, [saved.envelopeAddresses[0].messageId]);
-	});
-
-	it("asks nothing of a sender met on live mail", async () => {
-		const inbox = await save(mailboxAt("INBOX"));
-		const trash = await save(mailboxAt("Trash"), "Trash");
-
-		assert.deepEqual(inbox.reconciled, []);
-		assert.deepEqual(trash.reconciled, []);
-	});
-
-	it("harvests the same message once an ordinary folder holds it", async () => {
-		await save(mailboxAt("INBOX/Rubbish"), "Junk");
-		const moved = await save(mailboxAt("INBOX"));
-
-		assert.deepEqual(emails(moved.correspondents), BOTH);
-	});
-});