@remit/mailbox-service 0.0.35 → 0.0.37

package/package.json

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

package/src/filters/match.test.ts

@@ -228,14 +228,17 @@ describe("cosineSimilarity", () => {
 });
 
 describe("selectMoveWinner", () => {
-	const filter = (filterId: string, ruleChangedAt: number): FilterItem =>
-		({ filterId, ruleChangedAt }) as FilterItem;
+	const filter = (
+		filterId: string,
+		actionChangedAt: number,
+		ruleChangedAt = actionChangedAt,
+	): FilterItem => ({ filterId, actionChangedAt, ruleChangedAt }) as FilterItem;
 
 	it("returns undefined with no candidates", () => {
 		assert.equal(selectMoveWinner([]), undefined);
 	});
 
-	it("picks the most-recently-changed filter", () => {
+	it("picks the most-recently action-changed filter", () => {
 		const winner = selectMoveWinner([
 			filter("a", 100),
 			filter("b", 300),
@@ -244,7 +247,7 @@ describe("selectMoveWinner", () => {
 		assert.equal(winner?.filterId, "b");
 	});
 
-	it("tie-breaks on filterId when ruleChangedAt is identical", () => {
+	it("tie-breaks on filterId when actionChangedAt is identical", () => {
 		const winner = selectMoveWinner([
 			filter("a", 100),
 			filter("c", 100),
@@ -252,6 +255,23 @@ describe("selectMoveWinner", () => {
 		]);
 		assert.equal(winner?.filterId, "c");
 	});
+
+	it("ignores a ruleChangedAt-only bump — extending scope/expiry alone must not promote a filter to move-winner (reader #384)", () => {
+		// filter A's predicate/action last changed at 10:00 (actionChangedAt).
+		// filter B was created at 09:00 and never had its predicate/action
+		// touched since, but a user extended its expiry at 11:00 — bumping only
+		// its ruleChangedAt (RFC 034 Decision 3.2 / #294), not what it matches or
+		// does. B must not out-rank A.
+		const filterA = filter("filter-a", 10_00);
+		const filterB = filter("filter-b", 9_00, 11_00);
+
+		const winner = selectMoveWinner([filterA, filterB]);
+		assert.equal(
+			winner?.filterId,
+			"filter-a",
+			"A still wins: its actionChangedAt (10:00) beats B's (09:00), even though B's ruleChangedAt (11:00) is later",
+		);
+	});
 });
 
 describe("buildMatchText", () => {

package/src/filters/match.ts

@@ -134,10 +134,14 @@ export const cosineSimilarity = (
 };
 
 /**
- * The move a message ends in when several filters matched: the most-recently
- * *changed* filter wins (RFC 034 Decision 3.2), tie-broken on `filterId` for the
- * unreachable identical-timestamp case. `ruleChangedAt` — not `updatedAt` — is
- * the signal, so a cosmetic rename never flips an exclusive move.
+ * The move a message ends in when several filters matched: the filter whose
+ * predicate or action was most recently *changed* wins (RFC 034 Decision 3.2),
+ * tie-broken on `filterId` for the unreachable identical-timestamp case.
+ * `actionChangedAt` — not `ruleChangedAt` — is the signal: `ruleChangedAt` also
+ * bumps on a scope/expiry-only edit (reader #266), which changes a filter's
+ * lifecycle, not what it matches or does, and must not reorder exclusive-move
+ * precedence (reader #384). Nor is it `updatedAt`, so a cosmetic rename never
+ * flips an exclusive move either.
  */
 export const selectMoveWinner = (
 	candidates: readonly FilterItem[],
@@ -148,12 +152,12 @@ export const selectMoveWinner = (
 			winner = candidate;
 			continue;
 		}
-		if (candidate.ruleChangedAt > winner.ruleChangedAt) {
+		if (candidate.actionChangedAt > winner.actionChangedAt) {
 			winner = candidate;
 			continue;
 		}
 		if (
-			candidate.ruleChangedAt === winner.ruleChangedAt &&
+			candidate.actionChangedAt === winner.actionChangedAt &&
 			candidate.filterId > winner.filterId
 		) {
 			winner = candidate;

package/src/mailbox-sync.test.ts

@@ -11,7 +11,10 @@ import {
 	MailboxSyncStatus,
 } from "@remit/domain-enums";
 import { parseImapAttributes } from "./attribute-mapper.js";
-import { MailboxSyncService } from "./mailbox-sync.js";
+import { type MailboxSyncLogger, MailboxSyncService } from "./mailbox-sync.js";
+
+const silentLogger: MailboxSyncLogger = { info: () => {}, debug: () => {} };
+
 import type { IImapConnection, ImapNamespaces } from "./types.js";
 
 describe("parseImapAttributes – locale invariance (#194)", () => {
@@ -121,7 +124,11 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 
 	it("trips cursor_invalid when the STATUS sweep observes a changed UIDVALIDITY", async () => {
 		const { mailboxService, specialUseService, updateCalls } = buildServices(1);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 		const connection = buildConnection(2);
 
 		await service.syncMailboxes({ accountId: "acc-1" }, connection);
@@ -136,7 +143,11 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 
 	it("does not write anything when UIDVALIDITY (and everything else) is unchanged", async () => {
 		const { mailboxService, specialUseService, updateCalls } = buildServices(1);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 		const connection = buildConnection(1);
 
 		await service.syncMailboxes({ accountId: "acc-1" }, connection);
@@ -150,7 +161,11 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 		// the server's current value would step it over every change message sync
 		// had not yet applied.
 		const { mailboxService, specialUseService, updateCalls } = buildServices(1);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 		const connection = buildConnection(2, "99999");
 
 		await service.syncMailboxes({ accountId: "acc-1" }, connection);
@@ -162,7 +177,11 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 
 	it("does not sweep-write a mailbox whose only difference is the server mod-sequence", async () => {
 		const { mailboxService, specialUseService, updateCalls } = buildServices(1);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 		const connection = buildConnection(1, "4242");
 
 		await service.syncMailboxes({ accountId: "acc-1" }, connection);
@@ -175,7 +194,11 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 			1,
 			MailboxCursorState.cursor_invalid,
 		);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 		const connection = buildConnection(2);
 
 		await service.syncMailboxes({ accountId: "acc-1" }, connection);
@@ -273,7 +296,11 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 				syncStatus: MailboxSyncStatus.pending,
 			},
 		]);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 
 		const result = await service.syncMailboxes(
 			{ accountId: "acc-1" },
@@ -299,7 +326,11 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 				syncStatus: MailboxSyncStatus.synced,
 			},
 		]);
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 
 		const result = await service.syncMailboxes(
 			{ accountId: "acc-1" },
@@ -419,7 +450,11 @@ describe("MailboxSyncService.syncMailboxes — a folder leaving mid-sweep (#339)
 				doomedSyncStatus: syncStatus,
 			});
 			const { connection, statusPaths } = buildConnection(async () => status());
-			const service = new MailboxSyncService(mailboxService, specialUseService);
+			const service = new MailboxSyncService(
+				mailboxService,
+				specialUseService,
+				silentLogger,
+			);
 
 			await service.syncMailboxes({ accountId: "acc-1" }, connection);
 
@@ -439,7 +474,11 @@ describe("MailboxSyncService.syncMailboxes — a folder leaving mid-sweep (#339)
 			if (path === "Doomed") throw new Error("Mailbox doesn't exist: Doomed");
 			return status();
 		});
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 
 		await assert.doesNotReject(
 			service.syncMailboxes({ accountId: "acc-1" }, connection),
@@ -460,7 +499,11 @@ describe("MailboxSyncService.syncMailboxes — a folder leaving mid-sweep (#339)
 			if (path === "Doomed") throw new Error("connection reset by peer");
 			return status();
 		});
-		const service = new MailboxSyncService(mailboxService, specialUseService);
+		const service = new MailboxSyncService(
+			mailboxService,
+			specialUseService,
+			silentLogger,
+		);
 
 		await assert.rejects(
 			service.syncMailboxes({ accountId: "acc-1" }, connection),

package/src/mailbox-sync.ts

@@ -77,19 +77,45 @@ export interface SyncAccountInfo {
 	accountId: string;
 }
 
+/**
+ * Logger interface for MailboxSyncService.
+ *
+ * `info` is reserved here for the three mailbox lifecycle events — created,
+ * updated, deleted — and is the argued exception to `plugins/no-logger-info.grit`
+ * that the rest of this repo writes as a suppression. (The plugin matches the
+ * bare `logger` identifier, so it does not see an injected logger; the reasoning
+ * is written out instead of being silently absent.) A folder disappearing from
+ * someone's mail is destructive and irreversible from this service's side, and
+ * the only record that this process did it is the line it writes. That must not
+ * sit below the default threshold.
+ *
+ * Everything else this service has to say — a special-use flag it synced, a
+ * duplicate folder it skipped — is a routine trace and goes to `debug`.
+ */
+export interface MailboxSyncLogger {
+	info(obj: Record<string, unknown>, msg: string): void;
+	debug(obj: Record<string, unknown>, msg: string): void;
+}
+
 /**
  * Service for synchronizing mailbox metadata between IMAP and the data backend.
  */
 export class MailboxSyncService {
 	private mailboxService: IMailboxRepository;
 	private specialUseService: IMailboxSpecialUseRepository;
+	private log: MailboxSyncLogger;
 
+	// Required, with no no-op default: the lines below are the only record that a
+	// mailbox was created or destroyed, and a default would let the next call site
+	// lose them with no error and no failing test.
 	constructor(
 		mailboxService: IMailboxRepository,
 		specialUseService: IMailboxSpecialUseRepository,
+		logger: MailboxSyncLogger,
 	) {
 		this.mailboxService = mailboxService;
 		this.specialUseService = specialUseService;
+		this.log = logger;
 	}
 
 	/**
@@ -146,8 +172,13 @@ export class MailboxSyncService {
 							account.accountId,
 							existing.mailboxId,
 						);
-						console.info(
-							`Deleted non-selectable mailbox: ${existing.mailboxId} (${existing.fullPath})`,
+						this.log.info(
+							{
+								mailboxId: existing.mailboxId,
+								fullPath: existing.fullPath,
+								reason: "non-selectable",
+							},
+							"Deleted mailbox",
 						);
 						result.deleted++;
 					}
@@ -164,8 +195,13 @@ export class MailboxSyncService {
 							account.accountId,
 							existing.mailboxId,
 						);
-						console.info(
-							`Deleted duplicate special-use mailbox: ${existing.mailboxId} (${existing.fullPath})`,
+						this.log.info(
+							{
+								mailboxId: existing.mailboxId,
+								fullPath: existing.fullPath,
+								reason: "duplicate-special-use",
+							},
+							"Deleted mailbox",
 						);
 						result.deleted++;
 					}
@@ -238,8 +274,13 @@ export class MailboxSyncService {
 			// pending rows to the create/rename flow that owns them.
 			if (existing.syncStatus === MailboxSyncStatus.pending) continue;
 			await this.mailboxService.delete(account.accountId, existing.mailboxId);
-			console.info(
-				`Deleted mailbox: ${existing.mailboxId} (${existing.fullPath})`,
+			this.log.info(
+				{
+					mailboxId: existing.mailboxId,
+					fullPath: existing.fullPath,
+					reason: "not-on-server",
+				},
+				"Deleted mailbox",
 			);
 			result.deleted++;
 		}
@@ -419,12 +460,18 @@ export class MailboxSyncService {
 				mailbox.mailboxId,
 				parsed.specialUse,
 			);
-			console.info(
-				`Created mailbox: ${mailbox.mailboxId} (${mailboxInfo.fullPath}) [special-use: ${parsed.specialUse.join(", ")}]`,
+			this.log.info(
+				{
+					mailboxId: mailbox.mailboxId,
+					fullPath: mailboxInfo.fullPath,
+					specialUse: parsed.specialUse,
+				},
+				"Created mailbox",
 			);
 		} else {
-			console.info(
-				`Created mailbox: ${mailbox.mailboxId} (${mailboxInfo.fullPath})`,
+			this.log.info(
+				{ mailboxId: mailbox.mailboxId, fullPath: mailboxInfo.fullPath },
+				"Created mailbox",
 			);
 		}
 
@@ -504,8 +551,13 @@ export class MailboxSyncService {
 				`specialUse: [${(existing.specialUse ?? []).join(",")}] -> [${parsed.specialUse.join(",")}]`,
 			);
 
-		console.info(
-			`Updating mailbox: ${existing.mailboxId} (${mailboxInfo.fullPath}) [${changes.join(", ")}]`,
+		this.log.info(
+			{
+				mailboxId: existing.mailboxId,
+				fullPath: mailboxInfo.fullPath,
+				changes,
+			},
+			"Updating mailbox",
 		);
 
 		// Update mailbox with fresh status. ElectroDB rejects empty sets, so we
@@ -557,8 +609,9 @@ export class MailboxSyncService {
 
 		if (parsed.specialUse.length > 0) {
 			await this.specialUseService.createMany(mailboxId, parsed.specialUse);
-			console.info(
-				`Synced special-use for ${mailboxInfo.fullPath}: ${parsed.specialUse.join(", ")}`,
+			this.log.debug(
+				{ fullPath: mailboxInfo.fullPath, specialUse: parsed.specialUse },
+				"Synced special-use",
 			);
 		}
 	};
@@ -619,8 +672,13 @@ export class MailboxSyncService {
 		}
 
 		// This is a duplicate - another folder has the attribute
-		console.info(
-			`Skipping duplicate folder "${mailbox.fullPath}" - "${claimedPath}" has \\${expectedSpecialUse} attribute`,
+		this.log.debug(
+			{
+				fullPath: mailbox.fullPath,
+				claimedPath,
+				specialUse: expectedSpecialUse,
+			},
+			"Skipping duplicate folder",
 		);
 		return true;
 	};