@remit/mailbox-service 0.0.112 → 0.0.113

package/src/spam-report.test.ts

@@ -1,329 +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 { MessagePlacementUnsettledError } from "@remit/data-ports/errors";
-import { deriveAddressId } from "@remit/data-ports/id";
-import { AddressRole, MessageKeywordFlag } from "@remit/domain-enums";
-import { FlagPushService } from "./flag-push.js";
-import { MessageMoveService } from "./message-move.js";
-import {
-	MoveNotSettledError,
-	NoJunkMailboxError,
-	SpamReportService,
-} from "./spam-report.js";
-import { eml, FakeImapServer } from "./test-helpers/fake-imap.js";
-import {
-	arriveAt,
-	captureQueue,
-	openStore,
-	type QueueCapture,
-	type QueuedEvent,
-	type Store,
-	seedAccount,
-	seedMailbox,
-	seedMessage,
-} from "./test-helpers/test-store.js";
-
-const SENDER = "sender@example.com";
-
-let store: Store;
-let capture: QueueCapture;
-let queue: QueuedEvent[];
-let imap: FakeImapServer;
-let account: AccountItem;
-let inbox: MailboxItem;
-let junk: MailboxItem | undefined;
-let other: MailboxItem;
-
-beforeEach(async () => {
-	capture = captureQueue();
-	queue = capture.sent;
-	store = await openStore();
-	imap = new FakeImapServer();
-	account = await seedAccount(store);
-	inbox = await seedMailbox(store, account, "INBOX");
-	other = await seedMailbox(store, account, "Other");
-	junk = await seedMailbox(store, account, "Junk", { specialUse: "Junk" });
-	for (const mailbox of await store.mailbox.listAllByAccount(
-		account.accountId,
-	)) {
-		imap.addFolder(mailbox.fullPath);
-	}
-});
-
-afterEach(async () => {
-	capture.restore();
-	await store.close();
-});
-
-const userMoves = () =>
-	new MessageMoveService({
-		messageService: store.message,
-		mailboxService: store.mailbox,
-		mailboxSpecialUseService: store.mailboxSpecialUse,
-		threadMessageService: store.threadMessage,
-		addressService: store.address,
-		sqsQueueUrl: "http://localhost:9324/000000000000/remit-messages.fifo",
-	});
-
-const spam = () =>
-	new SpamReportService({
-		messageService: store.message,
-		addressService: store.address,
-		accountService: store.account,
-		mailboxSpecialUseService: store.mailboxSpecialUse,
-		messageMoveService: new MessageMoveService({
-			messageService: store.message,
-			mailboxService: store.mailbox,
-			mailboxSpecialUseService: store.mailboxSpecialUse,
-			threadMessageService: store.threadMessage,
-			addressService: store.address,
-			sqsQueueUrl: "http://localhost:9324/000000000000/remit-messages.fifo",
-			moveSettleTimeoutMs: 30,
-			moveSettlePollMs: 5,
-		}),
-		flagPushService: new FlagPushService({
-			markerService: store.flagPush,
-			sqsQueueUrl: "https://sqs.test/flags",
-		}),
-		moveSettleTimeoutMs: 30,
-		moveSettlePollMs: 5,
-	});
-
-const arrive = (mailbox: MailboxItem = inbox, from = `Sender <${SENDER}>`) =>
-	arriveAt(store, imap, account, mailbox, eml({ From: from }));
-
-const params = (messageId: string) => ({
-	accountConfigId: account.accountConfigId,
-	accountId: account.accountId,
-	messageId,
-	setBy: "user-1",
-});
-
-const report = (messageId: string) => spam().reportSpam(params(messageId));
-
-const undo = (messageId: string) => spam().notSpam(params(messageId));
-
-const sender = (email = SENDER) =>
-	store.address.getAddress(
-		account.accountConfigId,
-		deriveAddressId(account.accountConfigId, email),
-	);
-
-const settle = async (messageId: string) => {
-	const row = await store.message.get(messageId);
-	await store.message.updateUid(messageId, row.uid + 100, row.mailboxId);
-};
-
-const moves = () => queue.filter((event) => event.body.type === "MESSAGE_MOVE");
-
-const row = (messageId: string) => store.message.get(messageId);
-
-describe("SpamReportService.reportSpam", () => {
-	it("blocks the sender, moves the message to Junk and owes the server $Junk", async () => {
-		const messageId = await arrive();
-
-		await report(messageId);
-
-		const blocked = (await sender()).flags.blocked;
-		assert.equal(blocked?.value, true);
-		assert.equal(blocked?.setBy, "user-1");
-		const moved = await row(messageId);
-		assert.equal(moved.mailboxId, junk?.mailboxId);
-		assert.ok((moved.spamReport?.reportedAt ?? 0) > 0);
-		assert.equal(moves().length, 1);
-		assert.equal(
-			(await store.flagPush.find(messageId, MessageKeywordFlag.Junk))
-				?.operation,
-			"add",
-		);
-	});
-
-	it("keeps the block when the move fails", async () => {
-		const messageId = await arrive();
-		capture.answer(async () => {
-			throw new Error("SQS unavailable");
-		});
-
-		await assert.rejects(report(messageId), /SQS unavailable/);
-
-		assert.equal((await sender()).flags.blocked?.value, true);
-	});
-
-	it("moves once under a double press, and refuses a press inside the first move's flight", async () => {
-		const messageId = await arrive();
-		await report(messageId);
-
-		await assert.rejects(
-			report(messageId),
-			(error: unknown) =>
-				error instanceof MessagePlacementUnsettledError &&
-				error.publicApiError?.details?.reason === "in_flight",
-		);
-		await settle(messageId);
-		await report(messageId);
-
-		assert.equal(moves().length, 1);
-	});
-
-	it("moves mail forged from the account's own address without blocking the account", async () => {
-		const messageId = await arrive(inbox, `Me <${account.email}>`);
-
-		await report(messageId);
-
-		assert.equal((await sender(account.email)).flags.blocked, undefined);
-		assert.equal((await row(messageId)).mailboxId, junk?.mailboxId);
-	});
-
-	it("blocks a sender that was never harvested into the address book", async () => {
-		const messageId = await arrive();
-		await store.address.deleteAddress(
-			account.accountConfigId,
-			deriveAddressId(account.accountConfigId, SENDER),
-		);
-
-		await report(messageId);
-
-		assert.equal((await sender()).flags.blocked?.value, true);
-		assert.equal((await row(messageId)).mailboxId, junk?.mailboxId);
-	});
-
-	it("refuses to mint an address row for a sender with no @", async () => {
-		const { message } = await seedMessage(store, account, inbox, 9);
-		await store.address.upsertEnvelopeAddress({
-			messageId: message.messageId,
-			addressId: deriveAddressId(account.accountConfigId, "no-at-sign"),
-			displayName: "",
-			normalizedEmail: "no-at-sign",
-			addressRole: AddressRole.From,
-			addressOrder: 0,
-		});
-
-		await assert.rejects(
-			report(message.messageId),
-			/not a usable email address/,
-		);
-
-		assert.deepEqual(
-			await store.address.getAddress(account.accountConfigId, [
-				deriveAddressId(account.accountConfigId, "no-at-sign"),
-			]),
-			[],
-		);
-	});
-
-	it("keeps the junkOnly mark that withholds the sender from autocomplete", async () => {
-		const messageId = await arrive(junk);
-
-		await report(messageId);
-
-		const flags = (await sender()).flags;
-		assert.equal(flags.blocked?.value, true);
-		assert.equal(flags.junkOnly?.value, true);
-	});
-
-	it("names the missing Junk folder and changes nothing", async () => {
-		await store.mailboxSpecialUse.deleteByMailboxId(junk?.mailboxId as string);
-		await store.mailbox.delete(account.accountId, junk?.mailboxId as string);
-		junk = undefined;
-		const messageId = await arrive();
-
-		await assert.rejects(
-			report(messageId),
-			(error: unknown) =>
-				error instanceof NoJunkMailboxError &&
-				/no Junk folder/.test(error.message) &&
-				/Create one/.test(error.message),
-		);
-
-		assert.equal((await sender()).flags.blocked, undefined);
-		const untouched = await row(messageId);
-		assert.equal(untouched.mailboxId, inbox.mailboxId);
-		assert.equal(untouched.spamReport, undefined);
-		assert.equal(queue.length, 0);
-	});
-});
-
-describe("SpamReportService.notSpam", () => {
-	it("restores the original folder and lifts the block without granting trust", async () => {
-		const messageId = await arrive();
-		await report(messageId);
-		await settle(messageId);
-
-		await undo(messageId);
-
-		const restored = await row(messageId);
-		assert.equal(restored.mailboxId, inbox.mailboxId);
-		assert.equal(restored.spamReport, undefined);
-		const flags = (await sender()).flags;
-		assert.equal(flags.blocked, undefined);
-		assert.equal(flags.wellknown, undefined);
-		assert.equal(flags.vip, undefined);
-	});
-
-	it("mints no address row for a sender that was never harvested", async () => {
-		const messageId = await arrive(junk);
-		await store.address.deleteAddress(
-			account.accountConfigId,
-			deriveAddressId(account.accountConfigId, SENDER),
-		);
-
-		await undo(messageId);
-
-		assert.deepEqual(
-			await store.address.getAddress(account.accountConfigId, [
-				deriveAddressId(account.accountConfigId, SENDER),
-			]),
-			[],
-		);
-	});
-
-	it("leaves mail an earlier, unrelated move filed in Junk where it is", async () => {
-		const messageId = await arrive(other);
-		await userMoves().moveMessage(
-			account.accountConfigId,
-			messageId,
-			junk?.mailboxId as string,
-			account.accountId,
-		);
-		await settle(messageId);
-		queue.length = 0;
-
-		await report(messageId);
-		await undo(messageId);
-
-		assert.equal((await row(messageId)).mailboxId, junk?.mailboxId);
-		assert.equal((await sender()).flags.blocked, undefined);
-	});
-
-	it("still restores after a second report, and a second undo moves nothing", async () => {
-		const messageId = await arrive();
-		await report(messageId);
-		await settle(messageId);
-		await report(messageId);
-
-		await undo(messageId);
-		await undo(messageId);
-
-		const restored = await row(messageId);
-		assert.equal(restored.mailboxId, inbox.mailboxId);
-		assert.equal(restored.originalMailboxId, undefined);
-		assert.equal(moves().length, 2);
-	});
-
-	it("refuses to restore before the move settled, but still lifts the block", async () => {
-		const messageId = await arrive();
-		await report(messageId);
-
-		await assert.rejects(undo(messageId), (error: unknown) => {
-			assert.ok(error instanceof MoveNotSettledError);
-			assert.match(error.message, /has not settled yet/);
-			return true;
-		});
-
-		assert.equal((await sender()).flags.blocked, undefined);
-		const unmoved = await row(messageId);
-		assert.equal(unmoved.mailboxId, junk?.mailboxId);
-		assert.ok((unmoved.spamReport?.reportedAt ?? 0) > 0);
-	});
-});

package/src/spam-report.ts

@@ -1,357 +0,0 @@
-import type {
-	IAccountRepository,
-	IAddressRepository,
-	IMailboxSpecialUseRepository,
-	IMessageRepository,
-} from "@remit/data-ports";
-import { deriveAddressId } from "@remit/data-ports/id";
-import { AddressRole, MessageKeywordFlag } from "@remit/domain-enums";
-import type { FlagPushService } from "./flag-push.js";
-import type { MessageMoveService } from "./message-move.js";
-import {
-	isPlacementUnsettled,
-	waitForPlacementToSettle,
-} from "./placement-settled.js";
-
-export interface SpamReportLogger {
-	info(obj: Record<string, unknown>, msg: string): void;
-	error(obj: Record<string, unknown>, msg: string): void;
-}
-
-/**
- * The one designed, user-facing outcome of `notSpam`'s R2 wait timing out —
- * distinct from any other failure so a caller surfacing failures to the user
- * (the bulk handlers in packages/backend) can allowlist this specific,
- * pre-written message instead of relaying an arbitrary thrown error's text.
- */
-export class MoveNotSettledError extends Error {
-	constructor(messageId: string) {
-		super(
-			`Message ${messageId}'s move to Junk has not settled yet; try again in a moment.`,
-		);
-		this.name = "MoveNotSettledError";
-	}
-}
-
-/**
- * The account advertises no Junk folder and has none under any conventional
- * name, so there is nowhere to file the report. A designed, user-facing
- * outcome — the user has to create the folder, and no amount of retrying
- * changes that — so it carries its own text through the bulk handler's
- * allowlist rather than being flattened to the generic retry copy.
- */
-export class NoJunkMailboxError extends Error {
-	constructor() {
-		super(
-			"This account has no Junk folder. Create one named Junk or Spam in your mail provider, then report this message again.",
-		);
-		this.name = "NoJunkMailboxError";
-	}
-}
-
-const noopLogger: SpamReportLogger = {
-	info: () => {},
-	error: () => {},
-};
-
-const DEFAULT_MOVE_SETTLE_TIMEOUT_MS = 5_000;
-const DEFAULT_MOVE_SETTLE_POLL_MS = 250;
-
-export interface SpamReportConfig {
-	messageService: IMessageRepository;
-	addressService: IAddressRepository;
-	accountService: IAccountRepository;
-	mailboxSpecialUseService: IMailboxSpecialUseRepository;
-	messageMoveService: MessageMoveService;
-	flagPushService: FlagPushService;
-	logger?: SpamReportLogger;
-	/** How long `notSpam` waits for a still-in-flight move before giving up. */
-	moveSettleTimeoutMs?: number;
-	moveSettlePollMs?: number;
-}
-
-export interface SpamReportParams {
-	accountConfigId: string;
-	accountId: string;
-	messageId: string;
-	setBy?: string;
-}
-
-export class SpamReportService {
-	private messageService: IMessageRepository;
-	private addressService: IAddressRepository;
-	private accountService: IAccountRepository;
-	private mailboxSpecialUseService: IMailboxSpecialUseRepository;
-	private messageMoveService: MessageMoveService;
-	private flagPushService: FlagPushService;
-	private log: SpamReportLogger;
-	private moveSettleTimeoutMs: number;
-	private moveSettlePollMs: number;
-
-	constructor(config: SpamReportConfig) {
-		this.messageService = config.messageService;
-		this.addressService = config.addressService;
-		this.accountService = config.accountService;
-		this.mailboxSpecialUseService = config.mailboxSpecialUseService;
-		this.messageMoveService = config.messageMoveService;
-		this.flagPushService = config.flagPushService;
-		this.log = config.logger ?? noopLogger;
-		this.moveSettleTimeoutMs =
-			config.moveSettleTimeoutMs ?? DEFAULT_MOVE_SETTLE_TIMEOUT_MS;
-		this.moveSettlePollMs =
-			config.moveSettlePollMs ?? DEFAULT_MOVE_SETTLE_POLL_MS;
-	}
-
-	/**
-	 * The sender to act on. `addressId` is derived rather than read off the
-	 * envelope row so it always names the row `ensureSenderAddress` writes and
-	 * the harvester writes — one derivation, one row, whatever the envelope
-	 * happens to carry.
-	 */
-	private resolveFromAddress = async (
-		accountConfigId: string,
-		messageId: string,
-	): Promise<{
-		addressId: string;
-		normalizedEmail: string;
-		displayName: string;
-	}> => {
-		const description = await this.messageService.describe(messageId);
-		const from = description.envelopeAddress.find(
-			(a) => a.addressRole === AddressRole.From,
-		);
-		if (!from) {
-			throw new Error(`Message ${messageId} has no From address to act on`);
-		}
-		return {
-			addressId: deriveAddressId(accountConfigId, from.normalizedEmail),
-			normalizedEmail: from.normalizedEmail,
-			displayName: from.displayName ?? "",
-		};
-	};
-
-	/**
-	 * The list form answers `[]` for a row that is not there, where the single
-	 * form throws — absence is a case both callers handle, not a fault.
-	 */
-	private senderIsKnown = async (
-		accountConfigId: string,
-		addressId: string,
-	): Promise<boolean> => {
-		const [known] = await this.addressService.getAddress(accountConfigId, [
-			addressId,
-		]);
-		return known !== undefined;
-	};
-
-	/**
-	 * Blocking a sender owns the row it writes to. Harvesting is what ordinarily
-	 * creates it, but a message whose harvest never landed — or whose row was
-	 * taken by a cascade — still has a sender the user is entitled to block, and
-	 * a missing row used to abort report-spam before the message ever reached
-	 * Junk. The id is the harvester's own derivation, so this converges on the
-	 * one row rather than minting a parallel one.
-	 *
-	 * A row that already exists is left exactly as it stands. Reporting spam is
-	 * evidence about the sender, never about the account's standing record of
-	 * them: an upsert here would carry whatever the upsert path does on
-	 * conflict — today a display name chosen by the spammer, and any flag a
-	 * later sighting-clearing rule hangs off it — into an operation that means
-	 * the opposite.
-	 */
-	private ensureSenderAddress = async (
-		accountConfigId: string,
-		from: { addressId: string; normalizedEmail: string; displayName: string },
-	): Promise<void> => {
-		const separator = from.normalizedEmail.lastIndexOf("@");
-		const localPart = from.normalizedEmail.slice(0, separator);
-		const domain = from.normalizedEmail.slice(separator + 1);
-		if (separator < 0 || localPart.length === 0 || domain.length === 0) {
-			throw new Error(
-				`Sender address ${from.normalizedEmail} is not a usable email address`,
-			);
-		}
-		if (await this.senderIsKnown(accountConfigId, from.addressId)) return;
-		await this.addressService.upsertAddress({
-			addressId: from.addressId,
-			accountConfigId,
-			localPart,
-			domain,
-			normalizedEmail: from.normalizedEmail,
-			normalizedCompound:
-				`${from.displayName.toLowerCase()} ${from.normalizedEmail}`.trim(),
-			displayName: from.displayName,
-		});
-	};
-
-	reportSpam = async (params: SpamReportParams): Promise<void> => {
-		const { accountConfigId, accountId, messageId, setBy } = params;
-		const now = Date.now();
-
-		// Resolved before anything is written: with nowhere to file the report,
-		// the operation cannot happen, and a blocked sender plus a `spamReport`
-		// stamp on a message still sitting in the inbox is a report that half
-		// happened. Fail here and the press changed nothing.
-		const junkMailbox =
-			await this.mailboxSpecialUseService.findJunkMailbox(accountId);
-		if (!junkMailbox) {
-			this.log.error({ accountId, messageId }, "No Junk mailbox for account");
-			throw new NoJunkMailboxError();
-		}
-
-		const from = await this.resolveFromAddress(accountConfigId, messageId);
-		const account = await this.accountService.get(accountId);
-		const isOwnAddress =
-			from.normalizedEmail.toLowerCase() === account.email.toLowerCase();
-
-		if (!isOwnAddress) {
-			await this.ensureSenderAddress(accountConfigId, from);
-			await this.addressService.mergeFlags(accountConfigId, from.addressId, {
-				blocked: { value: true, setAt: now, setBy },
-			});
-		}
-
-		// Captured before this call writes anything: `before.spamReport` tells
-		// apart the two reasons the message can already be in Junk. If it is
-		// already set, a PREVIOUS report-spam press put it there and owns
-		// `originalMailboxId` — that value is exactly what Undo needs and must
-		// survive a repeated press. Only when it is absent is the message in
-		// Junk for some unrelated reason (a provider filter, a manual move),
-		// making any `originalMailboxId` on the row stale.
-		const before = await this.messageService.get(messageId);
-		const hadSpamReportAlready = Boolean(before.spamReport);
-
-		await this.messageService.update(messageId, {
-			spamReport: { reportedAt: now },
-		});
-
-		const alreadyInJunk = before.mailboxId === junkMailbox.mailboxId;
-
-		await this.messageMoveService.moveMessage(
-			accountConfigId,
-			messageId,
-			junkMailbox.mailboxId,
-			accountId,
-		);
-
-		if (alreadyInJunk && before.originalMailboxId && !hadSpamReportAlready) {
-			// moveMessage's same-mailbox guard no-opped — it never touches
-			// originalMailboxId, so a stale value left by some earlier, unrelated
-			// move would otherwise survive and send a later notSpam to the wrong
-			// folder. This report-spam action established no move of its own.
-			//
-			// A transition off the row this call read (imap-mutations R3): the pair
-			// being cleared belongs to a placement, and a lane that has claimed the
-			// row since keeps its own — its settle manages the pair.
-			await this.messageService.transitionPlacement(
-				messageId,
-				{
-					status: before.status,
-					mailboxId: before.mailboxId,
-					uid: before.uid,
-				},
-				{ originalMailboxId: null, originalUid: null },
-			);
-		}
-
-		await this.flagPushService.flip({
-			accountId,
-			accountConfigId,
-			messageId,
-			mailboxId: junkMailbox.mailboxId,
-			flagName: MessageKeywordFlag.Junk,
-			operation: "add",
-		});
-
-		this.log.info(
-			{
-				accountId,
-				messageId,
-				addressId: from.addressId,
-				junkMailboxId: junkMailbox.mailboxId,
-				skippedBlock: isOwnAddress,
-			},
-			"Reported message as spam",
-		);
-	};
-
-	notSpam = async (params: SpamReportParams): Promise<void> => {
-		const { accountConfigId, accountId, messageId } = params;
-
-		// Unblocking a sender the account has no row for is already true, and
-		// minting one here would put an address nothing ever harvested into the
-		// address book — the withdrawal of a judgement is not a sighting.
-		const from = await this.resolveFromAddress(accountConfigId, messageId);
-		if (await this.senderIsKnown(accountConfigId, from.addressId)) {
-			await this.addressService.mergeFlags(accountConfigId, from.addressId, {
-				blocked: null,
-			});
-		}
-
-		const message = await this.messageService.get(messageId);
-
-		if (message.originalMailboxId) {
-			// Only wait on the move's settlement when there is actually a
-			// dependent write to make (the restore below) — a move in flight for
-			// an unrelated reason is not this operation's concern.
-			const settled = await waitForPlacementToSettle(
-				this.messageService,
-				messageId,
-				{
-					timeoutMs: this.moveSettleTimeoutMs,
-					pollMs: this.moveSettlePollMs,
-				},
-			);
-			if (isPlacementUnsettled(settled)) {
-				throw new MoveNotSettledError(messageId);
-			}
-
-			await this.messageMoveService.restoreMessage(
-				accountConfigId,
-				messageId,
-				accountId,
-			);
-
-			// Re-read, then clear against what was read. The restore just wrote a
-			// placement, so the row here is not the one above; predicating on it is
-			// what keeps this from erasing a pair some other lane is relying on
-			// (imap-mutations R3).
-			const restored = await this.messageService.get(messageId);
-			await this.messageService.transitionPlacement(
-				messageId,
-				{
-					status: restored.status,
-					mailboxId: restored.mailboxId,
-					uid: restored.uid,
-				},
-				{ originalMailboxId: null, originalUid: null },
-			);
-		}
-
-		const current = await this.messageService.get(messageId);
-
-		await this.flagPushService.flip({
-			accountId,
-			accountConfigId,
-			messageId,
-			mailboxId: current.mailboxId,
-			flagName: MessageKeywordFlag.Junk,
-			operation: "remove",
-		});
-		await this.flagPushService.flip({
-			accountId,
-			accountConfigId,
-			messageId,
-			mailboxId: current.mailboxId,
-			flagName: MessageKeywordFlag.NotJunk,
-			operation: "add",
-		});
-
-		await this.messageService.clearSpamReport(messageId);
-
-		this.log.info(
-			{ accountId, messageId, addressId: from.addressId },
-			"Undid spam report",
-		);
-	};
-}