@remit/imap-worker 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/handlers/sync-messages.test.ts

@@ -147,6 +147,45 @@ describe("drainPendingFlagPushes — periodic per-mailbox re-arm (issue #1273)",
 		assert.equal(emitted.length, 2);
 	});
 
+	/**
+	 * Markers persisted before the system-flag wire-format fix carry the
+	 * unprefixed spelling (`Seen`, not `\Seen`) the enum emitter used to
+	 * produce. The drain re-arms from the stored `marker.flagName` and never
+	 * from the enum, and `handleFlagPush` threads that same value through
+	 * `find`/`updateState`/`delete` — so a marker written under the old
+	 * spelling still matches itself and drains to completion. No migration,
+	 * no orphans.
+	 */
+	it("re-arms a marker persisted under the pre-fix unprefixed spelling verbatim", async () => {
+		const markerService = {
+			listByMailboxId: async () => [
+				marker({ messageId: "legacy-msg", flagName: "Seen" }),
+				marker({ messageId: "legacy-star", flagName: "Flagged" }),
+			],
+		} as unknown as IMessageFlagPushRepository;
+
+		const emitted: Array<{ messageId: string; flagName: string }> = [];
+		const { log } = buildLogger();
+
+		await drainPendingFlagPushes(
+			markerService,
+			account,
+			"mbx-1",
+			log,
+			async (event) => {
+				emitted.push(event as unknown as (typeof emitted)[number]);
+			},
+		);
+
+		assert.deepEqual(
+			emitted.map((e) => [e.messageId, e.flagName]),
+			[
+				["legacy-msg", "Seen"],
+				["legacy-star", "Flagged"],
+			],
+		);
+	});
+
 	it("a re-arm (SQS) failure is caught per-marker and logged loudly — never thrown", async () => {
 		const markerService = {
 			listByMailboxId: async () => [marker()],

package/src/handlers/sync-messages.ts

@@ -6,6 +6,7 @@ import type {
 	IEnvelopeRepository,
 	IMailboxRepository,
 	IMessageFlagPushRepository,
+	IMessageFlagRepository,
 	IMessageRepository,
 	IThreadMessageRepository,
 	IUnitOfWork,
@@ -70,6 +71,7 @@ export const syncMessages = async (
 		threadMessage: threadMessageService,
 		mailboxLock: mailboxLockService,
 		flagPush: flagPushMarkerService,
+		messageFlag: messageFlagService,
 		unitOfWork,
 		secrets,
 	} = await getClient();
@@ -137,6 +139,7 @@ export const syncMessages = async (
 								addressService,
 								threadMessageService,
 								flagPushMarkerService,
+								messageFlagService,
 								unitOfWork,
 							},
 							log,
@@ -179,6 +182,7 @@ interface SyncDeps {
 	addressService: IAddressRepository;
 	threadMessageService: IThreadMessageRepository;
 	flagPushMarkerService: IMessageFlagPushRepository;
+	messageFlagService: IMessageFlagRepository;
 	unitOfWork?: IUnitOfWork;
 }
 
@@ -269,6 +273,7 @@ const syncMailboxMessages = async (
 		addressService,
 		threadMessageService,
 		flagPushMarkerService,
+		messageFlagService,
 		unitOfWork,
 	} = deps;
 
@@ -300,6 +305,8 @@ const syncMailboxMessages = async (
 		threadMessageService,
 		log,
 		unitOfWork,
+		flagPushMarkerService,
+		messageFlagService,
 	);
 
 	// Connect once, reuse for the entire sync operation
@@ -331,6 +338,16 @@ const syncMailboxMessages = async (
 		);
 	}
 
+	// A stalled cursor is the one failure on this path that produces no error:
+	// unapplicable messages are caught and held back, so the round returns
+	// normally, the SQS record is deleted, and neither redrive nor the DLQ ever
+	// engages. Without this metric the mailbox stops syncing behind a worker
+	// that looks healthy. It is emitted as a count so a sustained non-zero
+	// value alarms, per-mailbox detail being in the accompanying ERROR log.
+	if (result.cursorStalled) {
+		metrics.addMetric("imapSyncCursorStalled", MetricUnit.Count, 1);
+	}
+
 	// Emit body sync events for the messages we just synced. Each event carries
 	// messageId+uid pairs so the consumer issues one ranged FETCH per batch
 	// without re-resolving UIDs. messageIds stays populated for backward compat.