@remit/imap-worker 0.0.85 → 0.0.87

package/src/handlers/sync-message-body.ts

@@ -1,7 +1,8 @@
 import { getClient } from "@remit/backend/client";
 import { isNotFoundError } from "@remit/data-ports/errors";
-import type { Logger } from "@remit/logger-lambda";
-import { recordImapFailure } from "@remit/logger-lambda";
+import { SYNC_WARNING_SURFACE_ATTEMPTS } from "@remit/data-ports/sync-warning-state";
+import type { Logger } from "@remit/logger";
+import { recordImapFailure } from "@remit/logger-lambda/metrics";
 import {
 	BodySyncService,
 	guardConnectionCursor,
@@ -12,6 +13,7 @@ import {
 	QuarantineService,
 	resolveExhaustedBodySyncFailures,
 	resolveFolderPlacement,
+	SyncWarningService,
 } from "@remit/mailbox-service";
 import { buildFilterConfig } from "@remit/mailbox-service/filter-config";
 import { attemptBudget } from "@remit/sqs-client/attempt-budget";
@@ -31,7 +33,12 @@ const bodySyncEnabledParameterName = env.BODY_SYNC_ENABLED_PARAMETER_NAME;
 
 export const getBodySyncMaxAttempts = (
 	processEnv: NodeJS.ProcessEnv = process.env,
-): number => attemptBudget("BODY_SYNC_MAX_ATTEMPTS", 3, processEnv);
+): number =>
+	attemptBudget(
+		"BODY_SYNC_MAX_ATTEMPTS",
+		SYNC_WARNING_SURFACE_ATTEMPTS,
+		processEnv,
+	);
 
 export const BODY_SYNC_MAX_ATTEMPTS = getBodySyncMaxAttempts();
 
@@ -81,6 +88,7 @@ export const syncMessageBody = async (
 	event: SyncMessageBodyEvent,
 	log: Logger,
 	receiveCount = 1,
+	createConnectionScope = createConnectionScopeWithCredentials,
 ): Promise<void> => {
 	const { accountId, mailboxId } = event;
 
@@ -125,15 +133,15 @@ export const syncMessageBody = async (
 		envelope: envelopeService,
 		placementMove: markerService,
 		filter: filterService,
-		filterAnchor: filterAnchorService,
 		messageLabel: messageLabelService,
 		storage,
 		secrets,
 		mailboxSpecialUse: mailboxSpecialUseRepository,
 		quarantine: quarantineRepository,
+		syncWarning: syncWarningRepository,
 		flagQueue: flagQueueService,
 		calendarSuggestion: calendarSuggestionService,
-		calendarUnitOfWork,
+		calendarStore,
 	} = await getClient();
 
 	const account = await accountService.get(accountId);
@@ -156,6 +164,7 @@ export const syncMessageBody = async (
 				markerService,
 				addressService,
 				mailboxSpecialUseService,
+				mailboxService,
 				sqsQueueUrl: placementMoveQueueUrl,
 			})
 		: undefined;
@@ -205,7 +214,7 @@ export const syncMessageBody = async (
 			// warm container skips TCP+TLS+LOGIN+SELECT; a dead pooled connection is
 			// liveness-checked and replaced inside borrowWarmConnection.
 			const borrowed = borrowWarmConnection(accountId, () =>
-				createConnectionScopeWithCredentials(account, credentials),
+				createConnectionScope(account, credentials),
 			);
 
 			// A confident, actionable placement verdict moves mail directly on
@@ -220,12 +229,11 @@ export const syncMessageBody = async (
 
 			// A matched filter's actions (label upsert, exclusive move) apply on
 			// the same body-sync pass, reusing the placement mover for the move
-			// (RFC 034 Decision 3.1). The env-provisioned embedder lets a semantic
-			// (anchor-only) filter match here instead of being silently skipped.
+			// (RFC 034 Decision 3.1).
 			const filterConfig = buildFilterConfig({
 				filterService,
-				filterAnchorService,
 				messageLabelService,
+				mailboxService,
 				placementMoveService,
 			});
 
@@ -235,6 +243,7 @@ export const syncMessageBody = async (
 				threadMessageService,
 				addressService,
 				envelopeService,
+				new SyncWarningService(syncWarningRepository),
 				log,
 				placementConfig,
 				filterConfig,
@@ -252,7 +261,7 @@ export const syncMessageBody = async (
 				{ flagQueueService },
 				// An invitation becomes a card the first time the message is seen,
 				// alongside the filters that run on the same pass (issue #1033).
-				{ calendarSuggestionService, calendarUnitOfWork, filterService },
+				{ calendarSuggestionService, calendarStore, filterService },
 			);
 
 			// Guard at the openBox choke point (epic #1281 invariants 3 & 5). The
@@ -274,7 +283,9 @@ export const syncMessageBody = async (
 			// against the SAME borrowed connection, so the mailbox stays open
 			// across the two — the connection is only released once both are done.
 			const folder = {
+				mailboxId: mailbox.mailboxId,
 				fullPath: mailbox.fullPath,
+				uidValidity: mailbox.uidValidity,
 				placement: await resolveFolderPlacement(
 					mailboxSpecialUseService,
 					accountId,
@@ -315,7 +326,6 @@ export const syncMessageBody = async (
 				const { brokenMessageIds } = await resolveExhaustedBodySyncFailures(
 					{
 						messageService,
-						threadMessageService,
 						storageService: storage,
 						log,
 					},

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

@@ -0,0 +1,183 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+import type { SyncMessagesEvent } from "../events.js";
+import { openStore, type World } from "../test-helpers/test-world.js";
+import { drainPendingFlagPushes, syncMessages } from "./sync-messages.js";
+
+let store: Awaited<ReturnType<typeof openStore>>;
+
+before(async () => {
+	store = await openStore();
+});
+
+after(() => store.close());
+
+const syncEvent = (w: World, mailboxId: string): SyncMessagesEvent => ({
+	type: "SYNC_MESSAGES",
+	accountId: w.account.accountId,
+	mailboxId,
+	eventId: `evt-${mailboxId}`,
+	timestamp: Date.now(),
+});
+
+const sync = async (w: World, mailboxId: string): Promise<number> => {
+	await syncMessages(syncEvent(w, mailboxId), w.log, w.connectionFactory);
+	return w.imap.connections;
+};
+
+describe("which SYNC_MESSAGES events reach the server", () => {
+	it("a live mailbox does", async () => {
+		const w = await store.world();
+		const inbox = await w.folder("INBOX");
+
+		assert.equal(await sync(w, inbox.mailboxId), 1);
+	});
+
+	// Issue #287: a NotFoundError at the head of the account's FIFO group
+	// stalled every later event for the account.
+	it("a mailbox whose row is gone is acked without connecting", async () => {
+		const w = await store.world();
+		const old = await w.folder("Old");
+		await w.client.mailbox.delete(w.account.accountId, old.mailboxId);
+
+		assert.equal(await sync(w, old.mailboxId), 0);
+	});
+
+	it("a mailbox being deleted is acked without connecting", async () => {
+		const w = await store.world();
+		const old = await w.folder("Old");
+		await w.client.mailboxQueue.deleteMailbox(
+			old.mailboxId,
+			w.account.accountId,
+		);
+
+		assert.equal(await sync(w, old.mailboxId), 0);
+	});
+
+	it("a mailbox not yet created on the server is acked without connecting", async () => {
+		const w = await store.world();
+		const created = await w.client.mailboxQueue.createMailbox(
+			{
+				accountId: w.account.accountId,
+				namespacePrefix: "",
+				hierarchyDelimiter: "/",
+				fullPath: "Receipts",
+				uidValidity: 0,
+				uidNext: 0,
+				highestModseq: "0",
+				messageCount: 0,
+				unseenCount: 0,
+				deletedCount: 0,
+				totalSize: 0,
+				lastSyncUid: 0,
+				highWaterMarkUid: 0,
+				lastMessageSyncAt: 0,
+			},
+			w.account.accountId,
+		);
+		if (created.outcome !== "Created") throw new Error("path taken");
+
+		assert.equal(await sync(w, created.mailbox.mailboxId), 0);
+	});
+});
+
+// Issue #339: a delete asked for while the round is in flight lands inside
+// the guard, and the round then fails deeper on a folder that is gone.
+describe("a folder deleted while its sync is in flight", () => {
+	it("resolves the event and records no error phase on the account", async () => {
+		const w = await store.world();
+		const old = await w.folder("Old");
+		const connectionFactory = () => {
+			const factory = w.connectionFactory();
+			const connection = factory.getConnection();
+			const openBox = connection.openBox;
+			let first = true;
+			connection.openBox = async (path, readOnly) => {
+				if (first) {
+					first = false;
+					await w.client.mailboxQueue.deleteMailbox(
+						old.mailboxId,
+						w.account.accountId,
+					);
+					w.imap.removeFolder("Old");
+				}
+				return openBox(path, readOnly);
+			};
+			return { getConnection: () => connection, close: factory.close };
+		};
+
+		await syncMessages(syncEvent(w, old.mailboxId), w.log, connectionFactory);
+
+		const account = await w.client.account.get(w.account.accountId);
+		assert.notEqual(account.syncPhase, "error");
+	});
+});
+
+describe("drainPendingFlagPushes (issue #1273)", () => {
+	const marker = (w: World, mailboxId: string, messageId: string) =>
+		w.client.flagPush.put({
+			messageId,
+			flagName: "\\Seen",
+			accountId: w.account.accountId,
+			accountConfigId: w.account.accountConfigId,
+			mailboxId,
+			operation: "add",
+		});
+
+	it("re-arms the markers stuck before their wake-up and leaves the ones a driver owns", async () => {
+		const w = await store.world();
+		const inbox = await w.folder("INBOX");
+		await marker(w, inbox.mailboxId, "msg-pending");
+		await marker(w, inbox.mailboxId, "msg-queued");
+		await w.client.flagPush.updateState("msg-queued", "\\Seen", "queued");
+		await marker(w, inbox.mailboxId, "msg-processing");
+		await w.client.flagPush.updateState(
+			"msg-processing",
+			"\\Seen",
+			"processing",
+		);
+
+		await drainPendingFlagPushes(
+			w.client.flagPush,
+			w.account,
+			inbox.mailboxId,
+			w.log,
+		);
+
+		assert.deepEqual(
+			w
+				.queued()
+				.filter((body) => body.type === "FLAG_PUSH")
+				.map((body) => body.messageId),
+			["msg-pending"],
+		);
+	});
+
+	it("keeps re-arming the others when one re-arm fails, and says so loudly", async () => {
+		const w = await store.world();
+		const inbox = await w.folder("INBOX");
+		await marker(w, inbox.mailboxId, "will-fail");
+		await marker(w, inbox.mailboxId, "will-succeed");
+		const armed: string[] = [];
+
+		await drainPendingFlagPushes(
+			w.client.flagPush,
+			w.account,
+			inbox.mailboxId,
+			w.log,
+			async (event) => {
+				const { messageId } = event as unknown as { messageId: string };
+				if (messageId === "will-fail") throw new Error("queue down");
+				armed.push(messageId);
+			},
+		);
+
+		assert.deepEqual(armed, ["will-succeed"]);
+		assert.equal(
+			w.logs.filter(
+				(line) => line.fields.alert === "flag_push_drain_rearm_failed",
+			).length,
+			1,
+		);
+	});
+});

package/src/handlers/sync-messages.ts

@@ -10,21 +10,24 @@ import type {
 	IMessageFlagRepository,
 	IMessageRepository,
 	IQuarantineRepository,
+	ISyncWarningRepository,
 	IThreadMessageRepository,
-	IUnitOfWork,
 } from "@remit/data-ports";
 import { isNotFoundError } from "@remit/data-ports/errors";
 import { SyncPhase } from "@remit/domain-enums";
-import { type Logger, recordImapFailure } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
+import { recordImapFailure } from "@remit/logger-lambda/metrics";
 import { RefreshTokenError } from "@remit/mail-oauth-service";
 import {
 	createManagedConnectionFactory,
 	isMailboxMutationInFlight,
 	MailConnectionError,
 	type MailCredentials,
+	type ManagedConnectionFactory,
 	MessageSyncService,
 	QuarantineService,
 	type SyncedMessage,
+	SyncWarningService,
 } from "@remit/mailbox-service";
 import pMap from "p-map";
 import {
@@ -32,7 +35,7 @@ import {
 	isMailSyncDisabled,
 	isUnsyncableHost,
 } from "../account-check.js";
-import { emitEvent } from "../emit.js";
+import { emitEvent, SYNC_MESSAGES_PENDING } from "../emit.js";
 import type {
 	FlagPushEvent,
 	SyncMessageBodyEvent,
@@ -59,22 +62,22 @@ export const batchSyncedMessages = (
 	return batches;
 };
 
-export interface SyncMessagesDeps {
-	getClient: typeof getClient;
-	withOAuthLifecycle: typeof withOAuthLifecycle;
-	buildLifecycleDeps: typeof buildLifecycleDeps;
-}
-
-const defaultDeps: SyncMessagesDeps = {
-	getClient,
-	withOAuthLifecycle,
-	buildLifecycleDeps,
-};
+export const managedConnectionFor = (
+	account: Pick<AccountItem, "username" | "imapHost" | "imapPort" | "imapTls">,
+	credentials: MailCredentials,
+): ManagedConnectionFactory =>
+	createManagedConnectionFactory({
+		user: account.username,
+		credentials,
+		host: account.imapHost,
+		port: account.imapPort,
+		tls: account.imapTls,
+	});
 
 export const syncMessages = async (
 	event: SyncMessagesEvent,
 	log: Logger,
-	deps: SyncMessagesDeps = defaultDeps,
+	createConnectionFactory = managedConnectionFor,
 ): Promise<void> => {
 	log.info(
 		{
@@ -95,11 +98,18 @@ export const syncMessages = async (
 		mailboxLock: mailboxLockService,
 		mailboxSpecialUse: mailboxSpecialUseService,
 		quarantine: quarantineService,
+		syncWarning: syncWarningRepository,
 		flagPush: flagPushMarkerService,
 		messageFlag: messageFlagService,
-		unitOfWork,
 		secrets,
-	} = await deps.getClient();
+	} = await getClient();
+
+	await mailboxLockService.releaseLock(
+		event.accountId,
+		event.mailboxId,
+		SYNC_MESSAGES_PENDING,
+		event.eventId,
+	);
 
 	// A deleted account never has its DDB row purged in lockstep with the queued
 	// SYNC_MESSAGES triggers, so a trigger can outlive its account. The lookup
@@ -174,8 +184,8 @@ export const syncMessages = async (
 	// withOAuthLifecycle owns the reauth/ACK contract (skip-if-reauth, resolve
 	// credentials, flip on terminal auth failure, rethrow transient). The
 	// mailbox lock and the actual sync run inside the wrapper callback.
-	await deps.withOAuthLifecycle(
-		deps.buildLifecycleDeps(secrets, accountService),
+	await withOAuthLifecycle(
+		buildLifecycleDeps(secrets, accountService),
 		account,
 		log,
 		async (credentials) => {
@@ -189,7 +199,7 @@ export const syncMessages = async (
 						await syncMailboxMessages(
 							event,
 							account,
-							credentials,
+							createConnectionFactory(account, credentials),
 							{
 								accountService,
 								mailboxService,
@@ -199,9 +209,9 @@ export const syncMessages = async (
 								threadMessageService,
 								mailboxSpecialUseService,
 								quarantineService,
+								syncWarningRepository,
 								flagPushMarkerService,
 								messageFlagService,
-								unitOfWork,
 							},
 							log,
 						);
@@ -277,9 +287,9 @@ interface SyncDeps {
 	threadMessageService: IThreadMessageRepository;
 	mailboxSpecialUseService: IMailboxSpecialUseRepository;
 	quarantineService: IQuarantineRepository;
+	syncWarningRepository: ISyncWarningRepository;
 	flagPushMarkerService: IMessageFlagPushRepository;
 	messageFlagService: IMessageFlagRepository;
-	unitOfWork?: IUnitOfWork;
 }
 
 // Bounds concurrent SQS sends while re-arming stuck flag-push markers —
@@ -357,7 +367,7 @@ export const drainPendingFlagPushes = async (
 const syncMailboxMessages = async (
 	event: SyncMessagesEvent,
 	account: AccountItem,
-	credentials: MailCredentials,
+	connectionFactory: ManagedConnectionFactory,
 	deps: SyncDeps,
 	log: Logger,
 ): Promise<void> => {
@@ -370,20 +380,11 @@ const syncMailboxMessages = async (
 		threadMessageService,
 		mailboxSpecialUseService,
 		quarantineService,
+		syncWarningRepository,
 		flagPushMarkerService,
 		messageFlagService,
-		unitOfWork,
 	} = deps;
 
-	// Create a managed connection factory that caches and reuses the connection
-	const connectionFactory = createManagedConnectionFactory({
-		user: account.username,
-		credentials,
-		host: account.imapHost,
-		port: account.imapPort,
-		tls: account.imapTls,
-	});
-
 	// Get the mailbox - it must exist (should have been created by mailbox sync)
 	const mailbox = await mailboxService.get(account.accountId, event.mailboxId);
 	const mailboxId = mailbox.mailboxId;
@@ -402,8 +403,8 @@ const syncMailboxMessages = async (
 		envelopeService,
 		addressService,
 		threadMessageService,
+		new SyncWarningService(syncWarningRepository),
 		log,
-		unitOfWork,
 		flagPushMarkerService,
 		messageFlagService,
 		new QuarantineService(

package/src/index.ts

@@ -1,15 +1,17 @@
+import { createLogger } from "@remit/logger";
 import {
-	createLogger,
 	queueNameFromEventSource,
 	recordImapFailure,
 	recordQueueEvent,
-	withTelemetry,
-} from "@remit/logger-lambda";
+} from "@remit/logger-lambda/metrics";
+import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
 import type { SQSBatchResponse, SQSEvent, SQSHandler } from "aws-lambda";
 import type { WorkerEvent } from "./events.js";
 import { imapFailureKind } from "./failure-kind.js";
 import { processEvent } from "./processor.js";
 
+installNodeLogger();
+
 const log = createLogger();
 
 /**

package/src/mail-sync-selection.sqlite.test.ts

@@ -17,15 +17,14 @@ import {
 import {
 	AccountRepo,
 	DrizzleMessageRepository,
+	MailboxLockRepo,
 	MailboxRepo,
+	SearchIndex,
 } from "@remit/drizzle-service";
 import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import { syncMailboxes } from "./handlers/sync-mailboxes.js";
-import {
-	type SyncMessagesDeps,
-	syncMessages,
-} from "./handlers/sync-messages.js";
+import { syncMessages } from "./handlers/sync-messages.js";
 import { runSchedulerTick } from "./scheduler/run-tick.js";
 
 const NOW = 1_700_000_000_000;
@@ -47,19 +46,25 @@ const silentLogger: Logger = (() => {
 let accounts: AccountRepo;
 let mailboxes: MailboxRepo;
 let messages: DrizzleMessageRepository;
+let locks: MailboxLockRepo;
 let client: RemitClient;
 let close: () => void;
 
 beforeEach(() => {
 	const store = createShippedSqliteDb();
 	close = store.close;
-	accounts = new AccountRepo(store.db);
-	mailboxes = new MailboxRepo(store.db);
-	messages = new DrizzleMessageRepository(store.db as never);
+	accounts = new AccountRepo(store.db, store.db);
+	mailboxes = new MailboxRepo(store.db, new SearchIndex(store.db, store.db));
+	messages = new DrizzleMessageRepository(
+		store.db as never,
+		new SearchIndex(store.db as never, store.db as never),
+	);
+	locks = new MailboxLockRepo(store.db);
 	client = {
 		account: accounts,
 		mailbox: mailboxes,
 		message: messages,
+		mailboxLock: locks,
 	} as unknown as RemitClient;
 	setClient(client);
 });
@@ -131,6 +136,7 @@ const tick = async (): Promise<{ enqueued: number; accountIds: string[] }> => {
 		},
 	} as unknown as SQSClient;
 	const result = await runSchedulerTick({
+		redriveStrandedPlacements: async () => 0,
 		accountService: accounts,
 		sqsClient,
 		queueUrl: "https://queue.test/mailboxes",
@@ -172,14 +178,7 @@ describe("turning mail sync off and on again", () => {
 			silentLogger,
 		);
 
-		let lifecycleCalls = 0;
-		const deps = {
-			getClient: async () => client,
-			buildLifecycleDeps: () => ({}),
-			withOAuthLifecycle: async () => {
-				lifecycleCalls += 1;
-			},
-		} as unknown as SyncMessagesDeps;
+		let connections = 0;
 		await syncMessages(
 			{
 				type: "SYNC_MESSAGES",
@@ -189,9 +188,12 @@ describe("turning mail sync off and on again", () => {
 				mailboxId,
 			},
 			silentLogger,
-			deps,
+			() => {
+				connections += 1;
+				throw new Error("a sync that is off must not connect");
+			},
 		);
-		assert.equal(lifecycleCalls, 0);
+		assert.equal(connections, 0);
 
 		assert.deepEqual(
 			await mailboxes.listAllByAccount(account.accountId),