@remit/mailbox-service 0.0.111 → 0.0.112

package/src/body-sync-category-writeonce.test.ts

@@ -1,234 +0,0 @@
-/**
- * RFC 034 Decision 3.1: `Message.category` is written once and never mutated
- * after — RFC 030's message-list GSI sort key depends on it never churning.
- *
- * The re-entrant paths — `fetchAndGetBody`'s `NoSuchKey` fallback and
- * `syncBodies(..., force: true)` — are now body-only re-stores (issue #1011):
- * `applyPostStoreSteps(isReStore: true)` skips the entire decision pass and
- * writes only `bodyStorageKey`, so the existing category on the row is never
- * touched. Each test below feeds a re-store a body that would classify
- * differently, so a regression that drops the isReStore skip shows up as the
- * category field appearing in the update input (or changing on the row).
- */
-
-import assert from "node:assert/strict";
-import { Readable } from "node:stream";
-import { describe, it } from "node:test";
-import type {
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MessageItem,
-	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 { BodySyncService } from "./body-sync.js";
-import type { IImapConnection } from "./types.js";
-
-const LINKEDIN_EML = Buffer.from(
-	[
-		"From: LinkedIn <messages-noreply@linkedin.com>",
-		"To: me@example.com",
-		"Subject: You have a new invitation",
-		"Content-Type: text/plain",
-		"",
-		"invitation",
-	].join("\r\n"),
-);
-
-const PERSONAL_EML = Buffer.from(
-	[
-		"From: Alex <alex@example.com>",
-		"To: me@example.com",
-		"Subject: Dinner Friday?",
-		"Content-Type: text/plain",
-		"",
-		"Are you free Friday night?",
-	].join("\r\n"),
-);
-
-interface Harness {
-	service: BodySyncService;
-	message: MessageItem;
-	messageUpdates: Array<{ messageId: string; input: UpdateMessageInput }>;
-}
-
-const buildHarness = (
-	message: Partial<MessageItem> & Pick<MessageItem, "messageId">,
-	retrieve: () => Promise<Buffer>,
-): Harness => {
-	const messageUpdates: Array<{
-		messageId: string;
-		input: UpdateMessageInput;
-	}> = [];
-
-	const messageRow = {
-		uid: 1,
-		mailboxId: "mb-1",
-		...message,
-	} as unknown as MessageItem;
-
-	const messageService = {
-		get: async () => messageRow,
-		update: async (messageId: string, input: UpdateMessageInput) => {
-			messageUpdates.push({ messageId, input });
-			Object.assign(messageRow, input);
-		},
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		findAllByMessageId: async () => [
-			{
-				threadMessageId: "tm-1",
-				messageId: message.messageId,
-				mailboxId: "mb-1",
-				sentDate: 1,
-				isRead: false,
-				isDeleted: false,
-				hasStars: false,
-				hasAttachment: false,
-				category: MessageCategory.uncategorized,
-			},
-		],
-		update: async () => {},
-	} as unknown as IThreadMessageRepository;
-
-	const storageService = {
-		retrieve,
-		storeMessageBody: async () => ({ uri: `s3://bodies/${message.messageId}` }),
-		storeMessageBodyStream: async () => ({
-			uri: `s3://bodies/${message.messageId}`,
-		}),
-		storeParsedBody: async () => {},
-		listBodyParts: async () => [],
-	} as unknown as StorageService;
-
-	const service = new BodySyncService(
-		messageService,
-		storageService,
-		threadMessageService,
-		{
-			getAddress: async () => {
-				throw new NotFoundError("Address not found");
-			},
-			incrementInboundCount: async () => {},
-		} as unknown as IAddressRepository,
-		{ listBodyParts: async () => [] } as unknown as IEnvelopeRepository,
-		{ info: () => {}, error: () => {} },
-	);
-
-	return { service, message: messageRow, messageUpdates };
-};
-
-const noSuchKeyError = () =>
-	Object.assign(new Error("missing"), {
-		name: "NoSuchKey",
-	});
-
-describe("Message.category survives a re-entrant classification pass", () => {
-	it("keeps the existing category through the NoSuchKey IMAP re-fetch", async () => {
-		const harness = buildHarness(
-			{
-				messageId: "m-1",
-				bodyStorageKey: "s3://bodies/m-1",
-				category: MessageCategory.marketing,
-			},
-			async () => {
-				throw noSuchKeyError();
-			},
-		);
-
-		const connection = {
-			openBox: async () => {},
-			fetchMessageBody: async () => LINKEDIN_EML,
-		} as unknown as IImapConnection;
-
-		await harness.service.fetchAndGetBody(
-			"m-1",
-			"acc-1",
-			"cfg-1",
-			{ fullPath: "INBOX", placement: "inbox" },
-			async () => connection,
-		);
-
-		assert.equal(harness.messageUpdates.length, 1);
-		// Re-store writes only bodyStorageKey — category is untouched on the row.
-		assert.equal(harness.messageUpdates[0].input.category, undefined);
-		assert.deepEqual(Object.keys(harness.messageUpdates[0].input).sort(), [
-			"bodyStorageKey",
-		]);
-		assert.equal(harness.message.category, MessageCategory.marketing);
-	});
-
-	it("keeps the existing category when syncBodies re-fetches with force", async () => {
-		const harness = buildHarness(
-			{
-				messageId: "m-1",
-				bodyStorageKey: "s3://bodies/m-1",
-				category: MessageCategory.marketing,
-			},
-			async () => {
-				throw new Error("force path must not retrieve from storage");
-			},
-		);
-
-		const connection = {
-			openBox: async () => {},
-			async *fetchMessageBodies(uids: number[]) {
-				for (const uid of uids) {
-					yield { uid, source: Readable.from([LINKEDIN_EML]) };
-				}
-			},
-		} as unknown as IImapConnection;
-
-		const result = await harness.service.syncBodies(
-			["m-1"],
-			"acc-1",
-			"cfg-1",
-			{ fullPath: "INBOX", placement: "inbox" },
-			async () => connection,
-			true,
-		);
-
-		assert.deepEqual(result.syncedMessageIds, ["m-1"]);
-		assert.equal(harness.messageUpdates.length, 1);
-		// Re-store writes only bodyStorageKey — category is untouched on the row.
-		assert.equal(harness.messageUpdates[0].input.category, undefined);
-		assert.deepEqual(Object.keys(harness.messageUpdates[0].input).sort(), [
-			"bodyStorageKey",
-		]);
-		assert.equal(harness.message.category, MessageCategory.marketing);
-	});
-
-	it("still writes the category on a first classification", async () => {
-		const harness = buildHarness(
-			{ messageId: "m-1", category: MessageCategory.uncategorized },
-			async () => {
-				throw new Error("no body stored yet; must not retrieve");
-			},
-		);
-
-		const connection = {
-			openBox: async () => {},
-			fetchMessageBody: async () => PERSONAL_EML,
-		} as unknown as IImapConnection;
-
-		await harness.service.fetchAndGetBody(
-			"m-1",
-			"acc-1",
-			"cfg-1",
-			{ fullPath: "INBOX", placement: "inbox" },
-			async () => connection,
-		);
-
-		assert.equal(harness.messageUpdates.length, 1);
-		assert.equal(
-			harness.messageUpdates[0].input.category,
-			MessageCategory.personal,
-		);
-		assert.equal(harness.message.category, MessageCategory.personal);
-	});
-});

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

@@ -1,237 +0,0 @@
-/**
- * The read path (describeMessage / getRawMessage → fetchAndGetBody) and the
- * imap-worker sync path share BodySyncService.applyPostStoreSteps, so a body
- * materialized by a read must run the account's standing filters — the same
- * move and marker the sync path writes. The backend wires `filterConfig` into
- * its BodySyncService for exactly this (create-remit-client.ts); without it a
- * message opened before background body-sync is classified but never
- * filter-moved (issue #223).
- *
- * These drive fetchAndGetBody with a matching literal filter and assert the
- * move and the `filterMove` marker — and that the marker is written only for a
- * real relocation: a message already sitting in the filter's destination
- * matches by content but was not moved by Remit, so it must get no marker (and
- * no spurious "Moved by Remit" badge with a no-op Undo).
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	FilterItem,
-	IAddressRepository,
-	IEnvelopeRepository,
-	IFilterAnchorRepository,
-	IFilterRepository,
-	IMessageLabelRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MessageItem,
-	UpdateMessageInput,
-} from "@remit/data-ports";
-import { NotFoundError } from "@remit/data-ports/errors";
-import {
-	FilterClauseField,
-	FilterMatchOperator,
-	FilterState,
-} from "@remit/domain-enums";
-import type { StorageService } from "@remit/storage-service";
-import { BodySyncService } from "./body-sync.js";
-import { NO_ACTION } from "./filters/match.js";
-import type { FilterConfig } from "./filters/pipeline.js";
-import type { PlacementMoveService } from "./placement-move.js";
-import type { IImapConnection } from "./types.js";
-
-const INVITATION_EML = Buffer.from(
-	[
-		"From: Someone <someone@example.com>",
-		"To: me@example.com",
-		"Subject: You have a new invitation to Travel",
-		"Content-Type: text/plain",
-		"",
-		"details",
-	].join("\r\n"),
-);
-
-interface MoveCall {
-	messageId: string;
-	destinationMailboxId: string;
-}
-
-interface Harness {
-	service: BodySyncService;
-	messageUpdates: Array<{ messageId: string; input: UpdateMessageInput }>;
-	moves: MoveCall[];
-}
-
-/** A standing literal filter that moves subjects containing "invitation" to `destinationMailboxId`. */
-const buildFilter = (destinationMailboxId: string): FilterItem =>
-	({
-		filterId: "flt-1",
-		accountConfigId: "cfg-1",
-		name: "Invitations",
-		scope: "Standing",
-		state: FilterState.Active,
-		hasAnchor: false,
-		ruleChangedAt: 1,
-		matchOperator: FilterMatchOperator.And,
-		literalClauses: [{ field: FilterClauseField.Subject, value: "invitation" }],
-		actionLabelId: NO_ACTION,
-		actionMailboxId: destinationMailboxId,
-		createdAt: 1,
-		updatedAt: 1,
-	}) as unknown as FilterItem;
-
-const buildHarness = (
-	message: Pick<MessageItem, "messageId" | "mailboxId">,
-	filter: FilterItem,
-): Harness => {
-	const messageUpdates: Array<{
-		messageId: string;
-		input: UpdateMessageInput;
-	}> = [];
-	const moves: MoveCall[] = [];
-
-	const messageService = {
-		get: async (messageId: string) => ({
-			messageId,
-			mailboxId: message.mailboxId,
-			uid: 1,
-		}),
-		update: async (messageId: string, input: UpdateMessageInput) => {
-			messageUpdates.push({ messageId, input });
-		},
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		findAllByMessageId: async () => [
-			{
-				threadMessageId: "tm-1",
-				sentDate: 1,
-				mailboxId: message.mailboxId,
-				isRead: false,
-				isDeleted: false,
-				hasStars: false,
-				hasAttachment: false,
-			},
-		],
-		update: async () => {},
-	} as unknown as IThreadMessageRepository;
-
-	const storageService = {
-		storeMessageBody: async () => ({ uri: "s3://bodies/m-1" }),
-		storeParsedBody: async () => {},
-		listBodyParts: async () => [],
-	} as unknown as StorageService;
-
-	const addressService = {
-		getAddress: async () => {
-			throw new NotFoundError("Address not found");
-		},
-		incrementInboundCount: async () => {},
-	} as unknown as IAddressRepository;
-
-	const envelopeService = {
-		listBodyParts: async () => [],
-	} as unknown as IEnvelopeRepository;
-
-	const placementMoveService = {
-		moveMessage: async (
-			_accountConfigId: string,
-			messageId: string,
-			destinationMailboxId: string,
-		) => {
-			moves.push({ messageId, destinationMailboxId });
-		},
-	} as unknown as PlacementMoveService;
-
-	const filterConfig: FilterConfig = {
-		filterService: {
-			listByAccountAndState: async () => [filter],
-			refreshExpiry: async (f: FilterItem) => f,
-		} as unknown as IFilterRepository,
-		filterAnchorService: {
-			get: async () => undefined,
-		} as unknown as IFilterAnchorRepository,
-		messageLabelService: {
-			apply: async () => {},
-		} as unknown as IMessageLabelRepository,
-		placementMoveService,
-	};
-
-	const service = new BodySyncService(
-		messageService,
-		storageService,
-		threadMessageService,
-		addressService,
-		envelopeService,
-		{ info: () => {} },
-		undefined,
-		filterConfig,
-	);
-
-	return { service, messageUpdates, moves };
-};
-
-const readBody = async (service: BodySyncService, mailboxPath = "INBOX") => {
-	const connection = {
-		openBox: async () => {},
-		fetchMessageBody: async () => INVITATION_EML,
-	} as unknown as IImapConnection;
-	return service.fetchAndGetBody(
-		"m-1",
-		"acc-1",
-		"cfg-1",
-		{ fullPath: mailboxPath, placement: "other" },
-		async () => connection,
-	);
-};
-
-describe("body-sync read-path standing filter", () => {
-	it("runs the standing filter on a read-path body backfill and records the move + marker", async () => {
-		const harness = buildHarness(
-			{ messageId: "m-1", mailboxId: "mb-inbox" },
-			buildFilter("mb-travel"),
-		);
-
-		await readBody(harness.service);
-
-		// (a) the move fired to the filter's destination
-		assert.deepEqual(harness.moves, [
-			{ messageId: "m-1", destinationMailboxId: "mb-travel" },
-		]);
-
-		// (b) the emitted update carries the marker with the correct source/dest
-		assert.equal(harness.messageUpdates.length, 1);
-		const { input } = harness.messageUpdates[0];
-		assert.equal(input.movedByRemit, true);
-		assert.deepEqual(
-			{
-				filterId: input.filterMove?.filterId,
-				sourceMailboxId: input.filterMove?.sourceMailboxId,
-				destinationMailboxId: input.filterMove?.destinationMailboxId,
-			},
-			{
-				filterId: "flt-1",
-				sourceMailboxId: "mb-inbox",
-				destinationMailboxId: "mb-travel",
-			},
-		);
-	});
-
-	it("writes no marker when the message already sits in the filter's destination", async () => {
-		// Matches the filter by content, but is already in the destination (a
-		// server-side rule delivered it there, or the user filed it). Remit moved
-		// nothing — no marker, no movedByRemit, so no badge and no no-op Undo.
-		const harness = buildHarness(
-			{ messageId: "m-1", mailboxId: "mb-travel" },
-			buildFilter("mb-travel"),
-		);
-
-		await readBody(harness.service);
-
-		assert.equal(harness.messageUpdates.length, 1);
-		const { input } = harness.messageUpdates[0];
-		assert.equal(input.filterMove, undefined);
-		assert.equal(input.movedByRemit, undefined);
-	});
-});

package/src/body-sync-message-gone.test.ts

@@ -1,139 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	IAddressRepository,
-	IEnvelopeRepository,
-	IMessageRepository,
-	IThreadMessageRepository,
-	MessageItem,
-	PlacementPredicate,
-} from "@remit/data-ports";
-import {
-	MessageGoneFromServerError,
-	MessagePlacementUnsettledError,
-} from "@remit/data-ports/errors";
-import type { StorageService } from "@remit/storage-service";
-import { BodySyncService } from "./body-sync.js";
-import type { IImapConnection } from "./types.js";
-
-const MESSAGE_ID = "m-gone";
-
-interface Scenario {
-	status: MessageItem["status"];
-	rowStillMatches?: boolean;
-	serverStillLists?: boolean;
-}
-
-const readUnstoredMessage = async ({
-	status,
-	rowStillMatches = true,
-	serverStillLists = false,
-}: Scenario) => {
-	const predicates: PlacementPredicate[] = [];
-	const deletedMessages: string[] = [];
-	const deletedThreadMessages: string[] = [];
-
-	const messageService = {
-		get: async () =>
-			({
-				messageId: MESSAGE_ID,
-				mailboxId: "mb-inbox",
-				uid: 42,
-				status,
-			}) as unknown as MessageItem,
-		deleteIfPlacement: async (
-			messageId: string,
-			expected: PlacementPredicate,
-		) => {
-			predicates.push(expected);
-			if (!rowStillMatches) return false;
-			deletedMessages.push(messageId);
-			return true;
-		},
-	} as unknown as IMessageRepository;
-
-	const threadMessageService = {
-		findAllByMessageId: async () => [
-			{ accountConfigId: "cfg-1", threadMessageId: "tm-1" },
-		],
-		deleteMany: async (keys: { threadMessageId: string }[]) => {
-			deletedThreadMessages.push(...keys.map((key) => key.threadMessageId));
-		},
-	} as unknown as IThreadMessageRepository;
-
-	const service = new BodySyncService(
-		messageService,
-		{} as unknown as StorageService,
-		threadMessageService,
-		{} as unknown as IAddressRepository,
-		{} as unknown as IEnvelopeRepository,
-		{ info: () => {}, error: () => {} },
-	);
-
-	const connection = {
-		openBox: async () => {},
-		fetchMessageBody: async () => null,
-		fetchMessages: async () => [],
-		search: async () => (serverStillLists ? [42] : []),
-	} as unknown as IImapConnection;
-
-	const outcome = await service
-		.fetchAndGetBody(
-			MESSAGE_ID,
-			"acc-1",
-			"cfg-1",
-			{ fullPath: "INBOX", placement: "inbox" },
-			async () => connection,
-		)
-		.then(
-			() => assert.fail("expected the read to be refused"),
-			(error: unknown) => error,
-		);
-
-	return { outcome, predicates, deletedMessages, deletedThreadMessages };
-};
-
-describe("reading a message the mail server no longer holds", () => {
-	it("answers 404 and removes the settled row with its thread entries", async () => {
-		const { outcome, predicates, deletedMessages, deletedThreadMessages } =
-			await readUnstoredMessage({ status: "active" });
-
-		assert.ok(outcome instanceof MessageGoneFromServerError);
-		assert.equal(outcome.statusCode, 404);
-		assert.deepEqual(predicates, [
-			{ status: "active", mailboxId: "mb-inbox", uid: 42 },
-		]);
-		assert.deepEqual(deletedMessages, [MESSAGE_ID]);
-		assert.deepEqual(deletedThreadMessages, ["tm-1"]);
-	});
-
-	it("answers 409 and deletes nothing while our own move is in flight", async () => {
-		const { outcome, predicates, deletedThreadMessages } =
-			await readUnstoredMessage({ status: "moving" });
-
-		assert.ok(outcome instanceof MessagePlacementUnsettledError);
-		assert.equal(outcome.statusCode, 409);
-		assert.deepEqual(predicates, []);
-		assert.deepEqual(deletedThreadMessages, []);
-	});
-
-	it("answers 409 and keeps the thread entries when the row changed after it was read", async () => {
-		const { outcome, deletedMessages, deletedThreadMessages } =
-			await readUnstoredMessage({ status: "active", rowStillMatches: false });
-
-		assert.ok(outcome instanceof MessagePlacementUnsettledError);
-		assert.deepEqual(deletedMessages, []);
-		assert.deepEqual(deletedThreadMessages, []);
-	});
-
-	it("fails loudly and deletes nothing when the server still lists the UID", async () => {
-		const { outcome, predicates } = await readUnstoredMessage({
-			status: "active",
-			serverStillLists: true,
-		});
-
-		assert.ok(outcome instanceof Error);
-		assert.ok(!(outcome instanceof MessageGoneFromServerError));
-		assert.deepEqual(predicates, []);
-	});
-});