@remit/mailbox-service 0.0.42 → 0.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/body-sync-auto-read-writeonce.test.ts

@@ -0,0 +1,219 @@
+/**
+ * Issue #499: `Address.flags.unsubscribed` auto-mark-read is a first-
+ * classification decision, like `Message.category` (#355) and the placement
+ * verdict (#383). Re-deriving it on the two shipped re-entrant paths —
+ * `fetchAndGetBody`'s `NoSuchKey` fallback and `syncBodies(..., force: true)`
+ * — undid a user who had deliberately marked such a message unread.
+ *
+ * The re-entrant fixtures below keep `flags.unsubscribed` set, so a regression
+ * that drops the guard shows up as a real `FlagQueueService.markAsRead`
+ * round-trip against a message the user owns, not as a fixture that happens to
+ * disagree with the flag.
+ */
+
+import assert from "node:assert/strict";
+import { Readable } from "node:stream";
+import { describe, it } from "node:test";
+import type {
+	AddressItem,
+	IAddressRepository,
+	IEnvelopeRepository,
+	IMessageRepository,
+	IThreadMessageRepository,
+	MessageItem,
+	UpdateMessageInput,
+} from "@remit/data-ports";
+import type { StorageService } from "@remit/storage-service";
+import { BodySyncService } from "./body-sync.js";
+import type { FlagQueueService } from "./flag-queue.js";
+import type { IImapConnection } from "./types.js";
+
+const UNSUBSCRIBED_SENDER = "newsletter@example.com";
+
+const PLAIN_EML = Buffer.from(
+	[
+		`From: Newsletter <${UNSUBSCRIBED_SENDER}>`,
+		"To: me@example.com",
+		"Subject: This week",
+		"List-Unsubscribe: <mailto:stop@example.com>",
+		"Content-Type: text/plain",
+		"",
+		"body",
+	].join("\r\n"),
+);
+
+interface MarkReadCall {
+	accountConfigId: string;
+	messageId: string;
+	accountId: string;
+}
+
+interface Harness {
+	service: BodySyncService;
+	markReadCalls: MarkReadCall[];
+}
+
+const buildHarness = (
+	message: Partial<MessageItem> & Pick<MessageItem, "messageId">,
+	retrieve: () => Promise<Buffer>,
+): Harness => {
+	const markReadCalls: MarkReadCall[] = [];
+
+	const messageRow = {
+		uid: 1,
+		mailboxId: "mb-inbox",
+		...message,
+	} as unknown as MessageItem;
+
+	const messageService = {
+		get: async () => messageRow,
+		update: async (_messageId: string, input: UpdateMessageInput) => {
+			Object.assign(messageRow, input);
+		},
+	} as unknown as IMessageRepository;
+
+	const threadMessageService = {
+		findAllByMessageId: async () => [
+			{
+				threadMessageId: "tm-1",
+				messageId: message.messageId,
+				mailboxId: messageRow.mailboxId,
+				sentDate: 1,
+				isRead: false,
+				isDeleted: false,
+				hasStars: false,
+				hasAttachment: false,
+			},
+		],
+		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 addressService = {
+		getAddress: async () =>
+			({
+				flags: { unsubscribed: { value: true, setAt: 1 } },
+			}) as unknown as AddressItem,
+		incrementInboundCount: async () => {},
+	} as unknown as IAddressRepository;
+
+	const envelopeService = {
+		listBodyParts: async () => [],
+	} as unknown as IEnvelopeRepository;
+
+	const flagQueueService = {
+		markAsRead: async (
+			accountConfigId: string,
+			messageId: string,
+			accountId: string,
+		) => {
+			markReadCalls.push({ accountConfigId, messageId, accountId });
+		},
+	} as unknown as FlagQueueService;
+
+	const service = new BodySyncService(
+		messageService,
+		storageService,
+		threadMessageService,
+		addressService,
+		envelopeService,
+		{ info: () => {}, error: () => {} },
+		undefined,
+		undefined,
+		undefined,
+		{ flagQueueService },
+	);
+
+	return { service, markReadCalls };
+};
+
+const noSuchKeyError = () =>
+	Object.assign(new Error("missing"), { name: "NoSuchKey" });
+
+const bodyConnection = () =>
+	({
+		openBox: async () => {},
+		fetchMessageBody: async () => PLAIN_EML,
+		async *fetchMessageBodies(uids: number[]) {
+			for (const uid of uids) {
+				yield { uid, source: Readable.from([PLAIN_EML]) };
+			}
+		},
+	}) as unknown as IImapConnection;
+
+describe("unsubscribed auto-mark-read is decided once (issue #499)", () => {
+	it("marks a message read on the pass that first classifies it", async () => {
+		const harness = buildHarness({ messageId: "m-1" }, async () => {
+			throw new Error("no body stored yet; must not retrieve");
+		});
+
+		await harness.service.fetchAndGetBody(
+			"m-1",
+			"acc-1",
+			"cfg-1",
+			"INBOX",
+			async () => bodyConnection(),
+		);
+
+		assert.deepEqual(harness.markReadCalls, [
+			{ accountConfigId: "cfg-1", messageId: "m-1", accountId: "acc-1" },
+		]);
+	});
+
+	it("leaves a manually-unread message alone through the NoSuchKey IMAP re-fetch", async () => {
+		const harness = buildHarness(
+			{ messageId: "m-1", bodyStorageKey: "s3://bodies/m-1" },
+			async () => {
+				throw noSuchKeyError();
+			},
+		);
+
+		await harness.service.fetchAndGetBody(
+			"m-1",
+			"acc-1",
+			"cfg-1",
+			"INBOX",
+			async () => bodyConnection(),
+		);
+
+		assert.deepEqual(
+			harness.markReadCalls,
+			[],
+			"a re-entrant pass must not re-apply auto-read over the user's unread",
+		);
+	});
+
+	it("leaves a manually-unread message alone when syncBodies re-fetches with force", async () => {
+		const harness = buildHarness(
+			{ messageId: "m-1", bodyStorageKey: "s3://bodies/m-1" },
+			async () => {
+				throw new Error("force path must not retrieve from storage");
+			},
+		);
+
+		const result = await harness.service.syncBodies(
+			["m-1"],
+			"acc-1",
+			"cfg-1",
+			"INBOX",
+			async () => bodyConnection(),
+			true,
+		);
+
+		assert.deepEqual(result.syncedMessageIds, ["m-1"]);
+		assert.deepEqual(
+			harness.markReadCalls,
+			[],
+			"a forced re-sync must not re-apply auto-read over the user's unread",
+		);
+	});
+});

package/src/body-sync.ts

@@ -200,6 +200,18 @@ const hasDecidedCategory = (
 const hasDecidedPlacement = (placementDecidedAt: number | undefined): boolean =>
 	placementDecidedAt !== undefined;
 
+/**
+ * Issue #499: whether a completed body-sync pass has already classified this
+ * message. `bodyStorageKey` is written last, once every derivation of that pass
+ * has run, so its presence means the pass that first classified the message
+ * finished. Reads it exactly as `syncBodies`' own skip guard does. The same two
+ * re-entrant paths `hasDecidedCategory` and `hasDecidedPlacement` guard
+ * (`fetchAndGetBody`'s `NoSuchKey` fallback, `syncBodies(..., force: true)`) are
+ * the ones that reach the derivations again with it already set.
+ */
+const hasClassifiedBody = (bodyStorageKey: string | undefined): boolean =>
+	Boolean(bodyStorageKey);
+
 /**
  * Issue #398: `flags.autoArchive` is a filing preference relative to the Inbox.
  * A `leave` verdict reaches it for two unrelated reasons and only one of them
@@ -869,6 +881,12 @@ export class BodySyncService {
 			});
 		}
 
+		// Read once for the two write-once guards below — the auto-read decision
+		// and the category carry-forward. Taken here rather than earlier because
+		// nothing between this point and the Message update writes either field;
+		// the moves above touch `mailboxId` only.
+		const existingMessage = await this.messageService.get(messageId);
+
 		// `flags.unsubscribed` (issue #302, RFC 039 Decision 3): auto-mark-read,
 		// reusing the same FlagQueueService.markAsRead round-trip a manual
 		// mark-as-read goes through — idempotent on a retry (flipFlag no-ops when
@@ -879,6 +897,7 @@ export class BodySyncService {
 			accountId,
 			accountConfigId,
 			parsed,
+			existingMessage.bodyStorageKey,
 		);
 
 		const moved = Boolean(resolved.move || filterMoved);
@@ -907,7 +926,6 @@ export class BodySyncService {
 		// re-entrant paths for placement: `computePlacement` already declined to
 		// recompute a verdict once this field is set, so it is only ever present
 		// here on the pass that first decided it.
-		const existingMessage = await this.messageService.get(messageId);
 		const finalCategory = hasDecidedCategory(existingMessage.category)
 			? existingMessage.category
 			: classification.category;
@@ -1284,14 +1302,22 @@ export class BodySyncService {
 	 * separate expiry mechanism, and no caching of the decision beyond this
 	 * per-message `Address` read. A no-op when body sync was built without an
 	 * {@link UnsubscribeConfig} or the message carries no `From` address.
+	 *
+	 * Write-once per message (issue #499), like the `category` and placement
+	 * derivations alongside it: read state is applied on the pass that first
+	 * classifies a message and never re-decided. A user who marks such a message
+	 * unread afterwards owns it — a re-entrant pass over an already-classified
+	 * body would otherwise silently undo that.
 	 */
 	private async applyUnsubscribedAutoRead(
 		messageId: string,
 		accountId: string,
 		accountConfigId: string,
 		parsed: ParsedMail,
+		storedBodyKey: string | undefined,
 	): Promise<void> {
 		if (!this.unsubscribeConfig) return;
+		if (hasClassifiedBody(storedBodyKey)) return;
 
 		const fromEmail = extractPrimaryFromEmail(parsed);
 		if (!fromEmail) return;