@remit/mailbox-service 0.0.62 → 0.0.64

package/package.json

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

package/src/heuristics/senderMismatch.test.ts

@@ -71,7 +71,7 @@ describe("classifyDisplayNameCorrespondence", () => {
 		);
 	});
 
-	it("claims nothing when the display name is the address itself", () => {
+	it("claims nothing when the display name is an address at the sending domain", () => {
 		assert.equal(
 			classifyDisplayNameCorrespondence(
 				"billing@serviceupdatebank.atlassian.net",
@@ -81,6 +81,60 @@ describe("classifyDisplayNameCorrespondence", () => {
 		);
 	});
 
+	it("claims nothing when the display name spells the envelope address itself", () => {
+		assert.equal(
+			classifyDisplayNameCorrespondence("matthijs@ischen.nl", "ischen.nl"),
+			DisplayNameCorrespondence.NoClaim,
+		);
+	});
+
+	it("claims nothing when the display name is an address on a sibling subdomain", () => {
+		assert.equal(
+			classifyDisplayNameCorrespondence(
+				"noreply@example.co.uk",
+				"mail.example.co.uk",
+			),
+			DisplayNameCorrespondence.NoClaim,
+		);
+	});
+
+	it("is a foreign address when the display name spells an address over another domain", () => {
+		assert.equal(
+			classifyDisplayNameCorrespondence(
+				"matthijs@ischen.nl",
+				"secresaludguaviare.gov.co",
+			),
+			DisplayNameCorrespondence.ForeignAddress,
+		);
+	});
+
+	it("is a foreign address when the spelled-out address is decorated with a name", () => {
+		assert.equal(
+			classifyDisplayNameCorrespondence(
+				"Matthijs (matthijs@ischen.nl)",
+				"secresaludguaviare.gov.co",
+			),
+			DisplayNameCorrespondence.ForeignAddress,
+		);
+	});
+
+	it("compares an at sign that spells no address as an ordinary name", () => {
+		assert.equal(
+			classifyDisplayNameCorrespondence(
+				"Support @ InfoMedics",
+				"infomedics.nl",
+			),
+			DisplayNameCorrespondence.Corresponds,
+		);
+		assert.equal(
+			classifyDisplayNameCorrespondence(
+				"Support @ InfoMedics",
+				"serviceupdatebank.atlassian.net",
+			),
+			DisplayNameCorrespondence.Unrelated,
+		);
+	});
+
 	it("does not read the public suffix as a match for a brand containing it", () => {
 		assert.equal(
 			classifyDisplayNameCorrespondence("Netflix", "mailer.example.net"),
@@ -213,6 +267,25 @@ describe("extractSenderMismatch", () => {
 		);
 	});
 
+	it("flags a display name spelling the recipient's own address over a foreign domain", async () => {
+		const parsed = await parse([
+			"From: matthijs@ischen.nl <aramirez@secresaludguaviare.gov.co>",
+			"To: matthijs@ischen.nl",
+			"Subject: Re: factura",
+			"X-HalOne-Spam-Probability: 1",
+			"",
+			"hola",
+		]);
+		assert.equal(
+			extractSenderMismatch(parsed, {
+				fromDomain: "secresaludguaviare.gov.co",
+				spamClassified: true,
+				bulkSender: false,
+			}).displayNameCorrespondence,
+			DisplayNameCorrespondence.ForeignAddress,
+		);
+	});
+
 	it("leaves the display name uncompared for a bulk sender", async () => {
 		const parsed = await parse([
 			"From: Dutch Cycling Weekly <bounce-9f2@mailer.esp.example>",

package/src/heuristics/senderMismatch.ts

@@ -76,6 +76,22 @@ const editDistance = (a: string, b: string): number => {
 	return previous[b.length];
 };
 
+const ADDRESS_SHAPE = /[^\s<>@,;:"]+@([a-z0-9-]+(?:\.[a-z0-9-]+)+)/i;
+
+const registrableDomain = (host: string): string =>
+	getDomain(host) ?? host.toLowerCase();
+
+/**
+ * The registrable domain of the address a display name spells out, or
+ * `undefined` when it holds an `@` without an address behind it — `Bob @ Acme`
+ * asserts no address and is left to the ordinary comparison.
+ */
+const claimedAddressDomain = (displayName: string): string | undefined => {
+	const host = ADDRESS_SHAPE.exec(displayName)?.[1];
+	if (host === undefined) return undefined;
+	return registrableDomain(host);
+};
+
 /**
  * The distance a name of this length may be from a domain label and still be
  * read as an imitation of it. Tight on purpose: an unrelated brand name and an
@@ -109,14 +125,27 @@ const lookalikeThreshold = (length: number): number => {
  * A bounded edit distance is the secondary test, and only reaches names that
  * nearly match a label — `InfoMedics` against `1nfomedics.nl`. It cannot promote
  * an unrelated name on its own.
+ *
+ * A name that spells out an address is decided before any of that. Over the
+ * sending domain it claims nothing — `billing@` shown over
+ * `serviceupdatebank.atlassian.net` names the same party the envelope does.
+ * Over any other registrable domain it is the strongest non-correspondence
+ * signal there is: the message asserts, in the one field the recipient reads,
+ * that it comes from an address that cannot have sent it.
  */
 export const classifyDisplayNameCorrespondence = (
 	displayName: string | undefined,
 	fromDomain: string,
 ): CorrespondenceValue => {
 	const raw = (displayName ?? "").trim();
-	if (raw === "" || raw.includes("@")) {
-		return DisplayNameCorrespondence.NoClaim;
+	if (raw === "") return DisplayNameCorrespondence.NoClaim;
+
+	const claimed = claimedAddressDomain(raw);
+	if (claimed !== undefined) {
+		if (claimed === registrableDomain(fromDomain)) {
+			return DisplayNameCorrespondence.NoClaim;
+		}
+		return DisplayNameCorrespondence.ForeignAddress;
 	}
 
 	const name = normalize(raw);

package/src/mailbox-sync.test.ts

@@ -342,6 +342,152 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 	});
 });
 
+describe("MailboxSyncService.syncMailboxes — a lookalike is not a folder the user keeps mail in (#837)", () => {
+	const namespaces: ImapNamespaces = {
+		personal: [{ prefix: "", delimiter: "/" }],
+		other: [],
+		shared: [],
+	};
+
+	const serverConnection = (
+		folders: Array<{ fullPath: string; attributes: string[] }>,
+	): IImapConnection =>
+		({
+			getNamespaces: async () => namespaces,
+			listMailboxes: async () =>
+				folders.map((folder) => ({
+					fullPath: folder.fullPath,
+					name: folder.fullPath.split("/").pop() ?? folder.fullPath,
+					delimiter: "/",
+					attributes: folder.attributes,
+					parentPath: null,
+				})),
+			getMailboxStatus: async () => ({
+				messages: 0,
+				recent: 0,
+				unseen: 0,
+				uidNext: 1,
+				uidValidity: 1,
+				highestModseq: "0",
+				deletedCount: 0,
+			}),
+		}) as unknown as IImapConnection;
+
+	const buildServices = (
+		existing: Array<{ mailboxId: string; fullPath: string }>,
+	) => {
+		const deleted: string[] = [];
+		const mailboxService = {
+			listByAccount: async () => ({
+				items: existing.map((m) => ({
+					mailboxId: m.mailboxId,
+					fullPath: m.fullPath,
+					uidNext: 1,
+					uidValidity: 1,
+					messageCount: 0,
+					unseenCount: 0,
+					deletedCount: 0,
+					highestModseq: "0",
+					specialUse: undefined,
+					syncStatus: MailboxSyncStatus.synced,
+				})),
+				continuationToken: undefined,
+			}),
+			update: async () => ({}),
+			delete: async (_accountId: string, mailboxId: string) => {
+				deleted.push(mailboxId);
+			},
+			create: async () => ({}),
+		} as unknown as IMailboxRepository;
+
+		const specialUseService = {
+			listByMailboxId: async () => [],
+			deleteByMailboxId: async () => undefined,
+			createMany: async () => undefined,
+		} as unknown as IMailboxSpecialUseRepository;
+
+		return { mailboxService, specialUseService, deleted };
+	};
+
+	const syncWith = async (
+		folders: Array<{ fullPath: string; attributes: string[] }>,
+		existing: Array<{ mailboxId: string; fullPath: string }>,
+	): Promise<string[]> => {
+		const { mailboxService, specialUseService, deleted } =
+			buildServices(existing);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
+		await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection(folders),
+		);
+		return deleted;
+	};
+
+	it("keeps a folder called Deleted beside the folder the server flagged", async () => {
+		// `deleted` and `bin` were Trash names in this file's own copy of the hint
+		// table long after #843 dropped them from the shared one. Every sync of an
+		// account holding a flagged Trash and a user folder called `Deleted` took
+		// the user's folder, and its mail, out of the client.
+		const deleted = await syncWith(
+			[
+				{ fullPath: "INBOX", attributes: [] },
+				{ fullPath: "Trash", attributes: ["\\Trash"] },
+				{ fullPath: "Deleted", attributes: [] },
+				{ fullPath: "Bin", attributes: [] },
+			],
+			[
+				{ mailboxId: "inbox", fullPath: "INBOX" },
+				{ mailboxId: "trash", fullPath: "Trash" },
+				{ mailboxId: "keepsakes", fullPath: "Deleted" },
+				{ mailboxId: "bin", fullPath: "Bin" },
+			],
+		);
+
+		assert.deepEqual(deleted, []);
+	});
+
+	it("still hides the unflagged twin of a folder the server flagged", async () => {
+		const deleted = await syncWith(
+			[
+				{ fullPath: "INBOX", attributes: [] },
+				{ fullPath: "[Gmail]/Trash", attributes: ["\\Trash"] },
+				{ fullPath: "Trash", attributes: [] },
+			],
+			[
+				{ mailboxId: "inbox", fullPath: "INBOX" },
+				{ mailboxId: "gmail-trash", fullPath: "[Gmail]/Trash" },
+				{ mailboxId: "lookalike", fullPath: "Trash" },
+			],
+		);
+
+		assert.deepEqual(deleted, ["lookalike"]);
+	});
+
+	it("keeps a folder that holds a role of its own", async () => {
+		// `all mail` is a conventional name for Archive as well as for All, and the
+		// account already has a flagged Archive. The folder holds the All role, so
+		// it is a folder in its own right rather than a lookalike of Archive.
+		const deleted = await syncWith(
+			[
+				{ fullPath: "INBOX", attributes: [] },
+				{ fullPath: "Archive", attributes: ["\\Archive"] },
+				{ fullPath: "INBOX/All Mail", attributes: [] },
+			],
+			[
+				{ mailboxId: "inbox", fullPath: "INBOX" },
+				{ mailboxId: "archive", fullPath: "Archive" },
+				{ mailboxId: "all-mail", fullPath: "INBOX/All Mail" },
+			],
+		);
+
+		assert.deepEqual(deleted, []);
+	});
+});
+
 /**
  * The folder set can also change under a running sweep: a delete asked for while
  * the account is enumerating lands between the LIST and one folder's STATUS.

package/src/mailbox-sync.ts

@@ -10,9 +10,15 @@ import type {
 	IMailboxSpecialUseRepository,
 	MailboxItem,
 } from "@remit/data-ports";
+import {
+	CANONICAL_ROLES,
+	type CanonicalMailboxRoleValue,
+	ROLE_NAME_HINTS,
+	ROLE_SPECIAL_USE,
+} from "@remit/data-ports/folder-role";
 import {
 	MailboxCursorState,
-	MailboxSpecialUse,
+	type MailboxSpecialUse,
 	MailboxSyncStatus,
 	NamespaceType,
 } from "@remit/domain-enums";
@@ -51,23 +57,27 @@ const areSpecialUseSetsEqual = (
 };
 
 /**
- * Map common folder names to their expected special-use designation.
- * Used to detect duplicate folders (e.g., "Trash" vs "[Gmail]/Trash").
+ * The role a folder's own leaf name is most conventionally for, read from the
+ * one hint table every special-folder lookup shares (`@remit/data-ports`,
+ * #837). A name that several roles list goes to the role that ranks it highest,
+ * so `All Mail` is an All folder rather than a lookalike of Archive.
+ *
+ * A second copy of these names lived here, and it is the one that could destroy
+ * something: it still called `Deleted` and `Bin` Trash names, which #843 dropped
+ * precisely because they are ordinary folders a user keeps mail in — and this
+ * lookup does not merely skip a folder, it deletes the row and everything the
+ * client can see in it.
  */
-const FOLDER_NAME_TO_SPECIAL_USE: Record<string, MailboxSpecialUseValue> = {
-	trash: MailboxSpecialUse.Trash,
-	"deleted items": MailboxSpecialUse.Trash,
-	deleted: MailboxSpecialUse.Trash,
-	bin: MailboxSpecialUse.Trash,
-	drafts: MailboxSpecialUse.Drafts,
-	draft: MailboxSpecialUse.Drafts,
-	sent: MailboxSpecialUse.Sent,
-	"sent items": MailboxSpecialUse.Sent,
-	"sent mail": MailboxSpecialUse.Sent,
-	junk: MailboxSpecialUse.Junk,
-	spam: MailboxSpecialUse.Junk,
-	archive: MailboxSpecialUse.Archive,
-	archives: MailboxSpecialUse.Archive,
+const roleForFolderName = (
+	name: string,
+): CanonicalMailboxRoleValue | undefined => {
+	let best: { role: CanonicalMailboxRoleValue; rank: number } | undefined;
+	for (const role of CANONICAL_ROLES) {
+		const rank = ROLE_NAME_HINTS[role]?.indexOf(name) ?? -1;
+		if (rank < 0) continue;
+		if (!best || rank < best.rank) best = { role, rank };
+	}
+	return best?.role;
 };
 
 /**
@@ -451,8 +461,8 @@ export class MailboxSyncService {
 
 		const mailbox = await this.mailboxService.create(input);
 
-		// Keep the MailboxSpecialUseEntry table in sync — other services (e.g.
-		// MessageMoveService.findTrashMailbox) still query by entry. Denormalized
+		// Keep the MailboxSpecialUseEntry table in sync — every backend and worker
+		// special-folder lookup reads it through MailboxSpecialUseRepo. Denormalized
 		// copy on Mailbox is the read-side optimization, the entries remain the
 		// authoritative join source for cross-mailbox lookups.
 		if (parsed.specialUse.length > 0) {
@@ -653,21 +663,28 @@ export class MailboxSyncService {
 		const folderName = mailbox.fullPath.split(mailbox.delimiter).pop() ?? "";
 		const normalizedName = folderName.toLowerCase();
 
-		// Check if this folder name maps to a special-use designation
-		const expectedSpecialUse = FOLDER_NAME_TO_SPECIAL_USE[normalizedName];
-		if (!expectedSpecialUse) {
+		// Check if this folder name is a conventional name for a role
+		const role = roleForFolderName(normalizedName);
+		if (!role) {
 			return false; // Not a special-use folder name
 		}
 
+		const expectedSpecialUse = ROLE_SPECIAL_USE[role];
+		if (!expectedSpecialUse) {
+			return false; // The role has no SPECIAL-USE flag to be a duplicate of
+		}
+
 		// Check if this mailbox has the special-use attribute
 		const parsed = parseImapAttributes(mailbox.attributes);
-		if (parsed.specialUse.includes(expectedSpecialUse)) {
+		if (parsed.specialUse.some((use) => use === expectedSpecialUse)) {
 			return false; // This IS the canonical folder
 		}
 
 		// Check if another folder already claimed this special-use
-		const claimedPath = claimedSpecialUse.get(expectedSpecialUse);
-		if (!claimedPath) {
+		const claimed = [...claimedSpecialUse].find(
+			([specialUse]) => specialUse === expectedSpecialUse,
+		);
+		if (!claimed) {
 			return false; // No other folder has this special-use
 		}
 
@@ -675,7 +692,7 @@ export class MailboxSyncService {
 		this.log.debug(
 			{
 				fullPath: mailbox.fullPath,
-				claimedPath,
+				claimedPath: claimed[1],
 				specialUse: expectedSpecialUse,
 			},
 			"Skipping duplicate folder",