@remit/mailbox-service 0.0.49 → 0.0.50

package/package.json

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

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

@@ -14,7 +14,11 @@ import type {
 	UpdateMailboxInput,
 	UpdateThreadMessageInput,
 } from "@remit/data-ports";
-import { MailboxCursorState, MessageSystemFlag } from "@remit/domain-enums";
+import {
+	MailboxCursorState,
+	MessageKeywordFlag,
+	MessageSystemFlag,
+} from "@remit/domain-enums";
 import type { ManagedConnectionFactory } from "./connection-factory.js";
 import type { FlagPushService } from "./flag-push.js";
 import { FlagQueueService } from "./flag-queue.js";
@@ -112,6 +116,8 @@ interface Harness {
 	/** The canonical flag record after the round. */
 	flagStore: Set<string>;
 	messageFlagService: IMessageFlagRepository;
+	/** Method names invoked on the top-level address repository. */
+	addressCalls: string[];
 }
 
 const buildHarness = (options: HarnessOptions): Harness => {
@@ -241,12 +247,29 @@ const buildHarness = (options: HarnessOptions): Harness => {
 		},
 	} as unknown as IMessageFlagRepository;
 
+	// The existing-message path (applyChange -> applyServerFlags) never
+	// touches this repository. Recording every call, rather than leaving the
+	// stub as `{}`, is what makes "$Junk stays message state" an assertion
+	// instead of an assumption a future change could silently break.
+	const addressCalls: string[] = [];
+	const addressRepository = new Proxy(
+		{},
+		{
+			get:
+				(_target, prop: string) =>
+				(..._args: unknown[]) => {
+					addressCalls.push(prop);
+					throw new Error(`unexpected IAddressRepository.${prop} call`);
+				},
+		},
+	) as IAddressRepository;
+
 	const service = new MessageSyncService(
 		connectionFactory,
 		mailboxService,
 		{} as IMessageRepository,
 		{} as IEnvelopeRepository,
-		{} as IAddressRepository,
+		addressRepository,
 		threadMessageService,
 		logger,
 		unitOfWork,
@@ -263,6 +286,7 @@ const buildHarness = (options: HarnessOptions): Harness => {
 		errors,
 		flagStore,
 		messageFlagService,
+		addressCalls,
 	};
 };
 
@@ -603,6 +627,71 @@ describe("MessageSyncService CHANGEDSINCE path", () => {
 	});
 });
 
+// $Junk/$NotJunk mirroring (report-spam epic, message-state slice). This
+// mailbox is never remit-only — Apple Mail or another IMAP client is
+// routinely connected too — so a keyword another client set is message
+// state only. It must never become a standing rule about the sender.
+describe("MessageSyncService mirrors $Junk/$NotJunk keywords", () => {
+	it("mirrors a server-side $Junk into the canonical flag record", async () => {
+		const harness = buildHarness({
+			mailbox: mailbox(),
+			supportsCondstore: true,
+			changed: [serverMessage({ flags: [MessageKeywordFlag.Junk] })],
+			storedRows: [storedRow()],
+			storedFlags: [],
+		});
+
+		await syncOnce(harness);
+
+		assert.ok(harness.flagStore.has(MessageKeywordFlag.Junk));
+	});
+
+	it("mirrors a server-side $NotJunk into the canonical flag record", async () => {
+		const harness = buildHarness({
+			mailbox: mailbox(),
+			supportsCondstore: true,
+			changed: [serverMessage({ flags: [MessageKeywordFlag.NotJunk] })],
+			storedRows: [storedRow()],
+			storedFlags: [],
+		});
+
+		await syncOnce(harness);
+
+		assert.ok(harness.flagStore.has(MessageKeywordFlag.NotJunk));
+	});
+
+	it("leaves $Junk alone while its local flip is still owed to IMAP", async () => {
+		const harness = buildHarness({
+			mailbox: mailbox(),
+			supportsCondstore: true,
+			// Server has not seen the local flip yet.
+			changed: [serverMessage({ flags: [] })],
+			storedRows: [storedRow()],
+			storedFlags: [MessageKeywordFlag.Junk],
+			pendingFlags: new Set([MessageKeywordFlag.Junk]),
+		});
+
+		await syncOnce(harness);
+
+		assert.ok(harness.flagStore.has(MessageKeywordFlag.Junk));
+	});
+
+	it("mirroring $Junk leaves the sender's Address record completely untouched", async () => {
+		const harness = buildHarness({
+			mailbox: mailbox(),
+			supportsCondstore: true,
+			changed: [serverMessage({ flags: [MessageKeywordFlag.Junk] })],
+			storedRows: [storedRow()],
+			storedFlags: [],
+		});
+
+		await syncOnce(harness);
+
+		assert.ok(harness.flagStore.has(MessageKeywordFlag.Junk));
+		assert.deepEqual(harness.addressCalls, []);
+	});
+});
+
 describe("MessageSyncService without CONDSTORE", () => {
 	it("falls back to full enumeration and never issues CHANGEDSINCE", async () => {
 		const harness = buildHarness({

package/src/message-sync.ts

@@ -23,6 +23,7 @@ import {
 import {
 	AddressRole,
 	MailboxCursorState,
+	MessageKeywordFlag,
 	MessageSystemFlag,
 	StarColor,
 } from "@remit/domain-enums";
@@ -1025,8 +1026,9 @@ export class MessageSyncService {
 	}
 
 	/**
-	 * Bring a stored row's read and star state in line with the server's
-	 * flags.
+	 * Bring a stored row's read and star state, and the $Junk/$NotJunk
+	 * keywords on the canonical MessageFlag record, in line with the
+	 * server's flags.
 	 *
 	 * A field with a pending outbound push is left alone: the user flipped it
 	 * locally, IMAP has not been told yet, and the server's answer is
@@ -1073,6 +1075,17 @@ export class MessageSyncService {
 			}
 		}
 
+		await this.mirrorKeywordFlag(
+			existing.messageId,
+			MessageKeywordFlag.Junk,
+			flags,
+		);
+		await this.mirrorKeywordFlag(
+			existing.messageId,
+			MessageKeywordFlag.NotJunk,
+			flags,
+		);
+
 		if (Object.keys(updates).length === 0) return;
 
 		// MessageFlag is the canonical flag record — `FlagQueueService` reads it
@@ -1157,6 +1170,32 @@ export class MessageSyncService {
 		return marker !== null;
 	}
 
+	/**
+	 * Mirror one RFC 5788 keyword ($Junk / $NotJunk) from the server into the
+	 * canonical MessageFlag record, guarded the same way as the system flags:
+	 * a pending local push wins over the server's known-stale answer.
+	 *
+	 * This mailbox is never remit-only — Apple Mail or another IMAP client is
+	 * routinely connected too — so the keyword is message state, nothing
+	 * more. It never reaches the Address model: reading another client's
+	 * keyword as a standing rule about the sender is the exact fight this
+	 * mirror must not pick.
+	 */
+	private async mirrorKeywordFlag(
+		messageId: string,
+		flagName: string,
+		serverFlags: string[],
+	): Promise<void> {
+		if (!this.messageFlagService) return;
+		if (await this.hasPendingPush(messageId, flagName)) return;
+
+		const present = serverFlags.includes(flagName);
+		const hasFlag = await this.messageFlagService.hasFlag(messageId, flagName);
+		if (hasFlag === present) return;
+
+		await this.setMessageFlag(messageId, flagName, present);
+	}
+
 	/**
 	 * Fetch a batch of messages using the managed connection.
 	 * Assumes mailbox is already open from fetchUidsToSync.