@remit/imap-worker 0.0.86 → 0.0.88

package/src/handlers/flag-push.ts

@@ -1,7 +1,7 @@
 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 type { Logger } from "@remit/logger";
+import { recordImapFailure } from "@remit/logger-lambda/metrics";
 import {
 	guardConnectionCursor,
 	isCursorRebuildNeeded,
@@ -30,20 +30,7 @@ export const FLAG_PUSH_MAX_ATTEMPTS = getFlagPushMaxAttempts();
  * cycle one SQS round trip per sync tick forever instead of surfacing the
  * stall.
  */
-const DEFAULT_FLAG_PUSH_DEFER_MAX_MS = 10 * 60 * 1000;
-
-export const getFlagPushDeferMaxMs = (
-	processEnv: NodeJS.ProcessEnv = process.env,
-): number => {
-	const raw = processEnv.FLAG_PUSH_DEFER_MAX_MS;
-	if (!raw) return DEFAULT_FLAG_PUSH_DEFER_MAX_MS;
-	const parsed = Number.parseInt(raw, 10);
-	return Number.isFinite(parsed) && parsed > 0
-		? parsed
-		: DEFAULT_FLAG_PUSH_DEFER_MAX_MS;
-};
-
-export const FLAG_PUSH_DEFER_MAX_MS = getFlagPushDeferMaxMs();
+export const FLAG_PUSH_DEFER_MAX_MS = 10 * 60 * 1000;
 
 /**
  * Handle FLAG_PUSH events (issue #1273, epic #1281). Drains ONE pending
@@ -75,6 +62,7 @@ export const handleFlagPush = async (
 	event: FlagPushEvent,
 	log: Logger,
 	receiveCount = 1,
+	createConnectionScope = createConnectionScopeWithCredentials,
 ): Promise<void> => {
 	const {
 		account: accountService,
@@ -202,7 +190,7 @@ export const handleFlagPush = async (
 		account,
 		log,
 		async (credentials) => {
-			const scope = createConnectionScopeWithCredentials(account, credentials);
+			const scope = createConnectionScope(account, credentials);
 
 			await scope
 				.getConnection()
@@ -261,8 +249,13 @@ export const handleFlagPush = async (
 					// two terminal outcomes (epic invariant 3) instead of
 					// dead-lettering with no diagnosis.
 					const { outcome } = await resolveExhaustedFlagPushFailure(
-						{ markerService, messageService, threadMessageService, log },
+						{ markerService, messageService, log },
 						{
+							placement: {
+								status: message.status,
+								mailboxId: message.mailboxId,
+								uid: message.uid,
+							},
 							accountId,
 							accountConfigId,
 							messageId,

package/src/handlers/mailbox-management.sqlite.test.ts

@@ -0,0 +1,265 @@
+import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+import type { MailboxItem } from "@remit/data-ports";
+import { MailboxSyncStatus } from "@remit/domain-enums";
+import { imapError } from "@remit/mailbox-service/test-helpers/fake-imap";
+import type { MailboxManagementEvent } from "../events.js";
+import { openStore, type World } from "../test-helpers/test-world.js";
+import { processMailboxManagement } from "./mailbox-management.js";
+
+let store: Awaited<ReturnType<typeof openStore>>;
+
+before(async () => {
+	store = await openStore();
+});
+
+after(() => store.close());
+
+const lastEvent = (w: World, type: string): MailboxManagementEvent => {
+	const event = w
+		.queued()
+		.filter((body) => body.type === type)
+		.at(-1) as unknown as MailboxManagementEvent | undefined;
+	assert.ok(event, `a ${type} was enqueued`);
+	return event;
+};
+
+const run = (w: World, event: MailboxManagementEvent) =>
+	processMailboxManagement(event, w.log, w.scope);
+
+const mailbox = (
+	w: World,
+	mailboxId: string,
+): Promise<MailboxItem | undefined> =>
+	w.client.mailbox
+		.listAllByAccount(w.account.accountId)
+		.then((rows) => rows.find((row) => row.mailboxId === mailboxId));
+
+/** A folder created through the service the API calls, not yet on the server. */
+const requestCreate = async (
+	w: World,
+	path: string,
+	subscribe?: boolean,
+): Promise<{ mailboxId: string; event: MailboxManagementEvent }> => {
+	const created = await w.client.mailboxQueue.createMailbox(
+		{
+			accountId: w.account.accountId,
+			namespacePrefix: "",
+			hierarchyDelimiter: "/",
+			fullPath: path,
+			uidValidity: 0,
+			uidNext: 0,
+			highestModseq: "0",
+			messageCount: 0,
+			unseenCount: 0,
+			deletedCount: 0,
+			totalSize: 0,
+			lastSyncUid: 0,
+			highWaterMarkUid: 0,
+			lastMessageSyncAt: 0,
+		},
+		w.account.accountId,
+		subscribe,
+	);
+	assert.equal(created.outcome, "Created");
+	if (created.outcome !== "Created") throw new Error("path taken");
+	return {
+		mailboxId: created.mailbox.mailboxId,
+		event: lastEvent(w, "MAILBOX_CREATE"),
+	};
+};
+
+describe("creating a folder", () => {
+	it("creates it on the server and settles the row on the server's UIDVALIDITY", async () => {
+		const w = await store.world();
+		const { mailboxId, event } = await requestCreate(w, "Receipts");
+
+		await run(w, event);
+
+		assert.ok(w.imap.hasFolder("Receipts"));
+		const row = await mailbox(w, mailboxId);
+		assert.equal(row?.syncStatus, MailboxSyncStatus.synced);
+		assert.equal(row?.uidValidity, w.imap.uidValidityOf("Receipts"));
+	});
+
+	it("subscribes only when the request asks for it", async () => {
+		const w = await store.world();
+		const quiet = await requestCreate(w, "Quiet");
+		const loud = await requestCreate(w, "Loud", true);
+
+		await run(w, quiet.event);
+		await run(w, loud.event);
+
+		assert.deepEqual(w.imap.commands("SUBSCRIBE"), ["SUBSCRIBE Loud"]);
+	});
+
+	it("settles a folder the server already has as created", async () => {
+		const w = await store.world();
+		const { mailboxId, event } = await requestCreate(w, "Receipts");
+		w.imap.addFolder("Receipts", { uidValidity: 7 });
+
+		await run(w, event);
+
+		assert.equal(
+			(await mailbox(w, mailboxId))?.syncStatus,
+			MailboxSyncStatus.synced,
+		);
+	});
+
+	it("marks the folder failed with the server's reason and acks a refused create", async () => {
+		const w = await store.world();
+		const { mailboxId, event } = await requestCreate(w, "Receipts");
+		w.imap.failNext.CREATE = imapError("NOPERM", "Permission denied");
+
+		await run(w, event);
+
+		const row = await mailbox(w, mailboxId);
+		assert.equal(row?.syncStatus, MailboxSyncStatus.failed);
+		assert.equal(row?.syncFailureReason, "Permission denied");
+	});
+
+	it("marks the folder failed and redelivers when the create fails for another reason", async () => {
+		const w = await store.world();
+		const { mailboxId, event } = await requestCreate(w, "Receipts");
+		w.imap.failNext.CREATE = new Error("Connection reset");
+
+		await assert.rejects(run(w, event), /Connection reset/);
+
+		assert.equal(
+			(await mailbox(w, mailboxId))?.syncStatus,
+			MailboxSyncStatus.failed,
+		);
+	});
+
+	it("acks when the folder row was deleted before the create ran", async () => {
+		const w = await store.world();
+		const { mailboxId, event } = await requestCreate(w, "Receipts");
+		await w.client.mailbox.delete(w.account.accountId, mailboxId);
+
+		await run(w, event);
+	});
+});
+
+describe("renaming a folder", () => {
+	const arrange = async () => {
+		const w = await store.world();
+		const work = await w.folder("Work");
+		const child = await w.folder("Work/Clients");
+		const message = await w.message(child);
+		await w.client.mailboxQueue.renameMailbox(
+			work.mailboxId,
+			"Projects",
+			w.account.accountId,
+		);
+		return { w, work, child, message, event: lastEvent(w, "MAILBOX_RENAME") };
+	};
+
+	it("renames on the server and settles the folder and its children onto the new path", async () => {
+		const { w, work, child, event } = await arrange();
+
+		await run(w, event);
+
+		assert.ok(w.imap.hasFolder("Projects/Clients"));
+		assert.equal((await mailbox(w, work.mailboxId))?.fullPath, "Projects");
+		const settledChild = await mailbox(w, child.mailboxId);
+		assert.equal(settledChild?.fullPath, "Projects/Clients");
+		assert.equal(settledChild?.syncStatus, MailboxSyncStatus.synced);
+	});
+
+	it("removes the folder, its children and their mail when the source is gone on the server", async () => {
+		const { w, work, child, message, event } = await arrange();
+		w.imap.removeFolder("Work");
+		w.imap.removeFolder("Work/Clients");
+
+		await run(w, event);
+
+		assert.equal(await mailbox(w, work.mailboxId), undefined);
+		assert.equal(await mailbox(w, child.mailboxId), undefined);
+		assert.equal(await w.row(message.messageId), undefined);
+	});
+
+	it("keeps the confirmed path and acks a refused rename", async () => {
+		const { w, work, event } = await arrange();
+		w.imap.failNext.RENAME = imapError("NOPERM", "Permission denied");
+
+		await run(w, event);
+
+		const row = await mailbox(w, work.mailboxId);
+		assert.equal(row?.fullPath, "Work");
+		assert.equal(row?.syncStatus, MailboxSyncStatus.failed);
+		assert.ok(w.imap.hasFolder("Work"));
+	});
+
+	it("issues no RENAME when a redelivery finds the rename already settled", async () => {
+		const { w, event } = await arrange();
+		await run(w, event);
+
+		await run(w, event);
+
+		assert.equal(w.imap.commands("RENAME").length, 1);
+	});
+});
+
+describe("deleting a folder", () => {
+	const arrange = async () => {
+		const w = await store.world();
+		const old = await w.folder("Old");
+		const message = await w.message(old);
+		await w.client.mailboxQueue.deleteMailbox(
+			old.mailboxId,
+			w.account.accountId,
+		);
+		return { w, old, message, event: lastEvent(w, "MAILBOX_DELETE") };
+	};
+
+	it("deletes it on the server and removes the folder and its mail", async () => {
+		const { w, old, message, event } = await arrange();
+
+		await run(w, event);
+
+		assert.equal(w.imap.hasFolder("Old"), false);
+		assert.equal(await mailbox(w, old.mailboxId), undefined);
+		assert.equal(await w.row(message.messageId), undefined);
+	});
+
+	it("removes the folder and its mail when the server no longer has it", async () => {
+		const { w, old, message, event } = await arrange();
+		w.imap.removeFolder("Old");
+
+		await run(w, event);
+
+		assert.equal(await mailbox(w, old.mailboxId), undefined);
+		assert.equal(await w.row(message.messageId), undefined);
+	});
+
+	it("marks the folder failed, keeps its mail and acks a refused delete", async () => {
+		const { w, old, message, event } = await arrange();
+		w.imap.failNext.DELETE = imapError("NOPERM", "Permission denied");
+
+		await run(w, event);
+
+		assert.equal(
+			(await mailbox(w, old.mailboxId))?.syncStatus,
+			MailboxSyncStatus.failed,
+		);
+		assert.ok(await w.row(message.messageId));
+		assert.ok(w.imap.hasFolder("Old"));
+	});
+
+	it("issues no DELETE for a folder that is not being deleted", async () => {
+		const w = await store.world();
+		const kept = await w.folder("Kept");
+
+		await run(w, {
+			type: "MAILBOX_DELETE",
+			eventId: "evt-stale",
+			timestamp: Date.now(),
+			accountId: w.account.accountId,
+			mailboxId: kept.mailboxId,
+			path: "Kept",
+		} as MailboxManagementEvent);
+
+		assert.deepEqual(w.imap.commands("DELETE"), []);
+		assert.ok(await mailbox(w, kept.mailboxId));
+	});
+});

package/src/handlers/mailbox-management.ts

@@ -3,7 +3,7 @@ import { refreshFolderAppointmentLabels } from "@remit/backend/folder-role-label
 import type { IMailboxRepository } from "@remit/data-ports";
 import { isNotFoundError, NotFoundError } from "@remit/data-ports/errors";
 import { MailboxSyncStatus } from "@remit/domain-enums";
-import type { Logger } from "@remit/logger-lambda";
+import type { Logger } from "@remit/logger";
 import {
 	FolderGoneUpstreamError,
 	FolderRenameSettleError,
@@ -24,20 +24,6 @@ import type {
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 
-export interface MailboxManagementDeps {
-	getClient: typeof getClient;
-	buildLifecycleDeps: typeof buildLifecycleDeps;
-	withOAuthLifecycle: typeof withOAuthLifecycle;
-	createConnectionScope: typeof createConnectionScopeWithCredentials;
-}
-
-const defaultDeps: MailboxManagementDeps = {
-	getClient,
-	buildLifecycleDeps,
-	withOAuthLifecycle,
-	createConnectionScope: createConnectionScopeWithCredentials,
-};
-
 /**
  * The outcome of a create, written against the state a create in flight is:
  * `pending` with no recorded rename target (D3, D10). Without the absence
@@ -85,15 +71,8 @@ const recordCreateOutcome = async (
 const handleCreate = async (
 	event: MailboxCreateEvent,
 	log: Logger,
-	deps: MailboxManagementDeps,
+	createConnectionScope: typeof createConnectionScopeWithCredentials,
 ): Promise<void> => {
-	const {
-		getClient,
-		buildLifecycleDeps,
-		withOAuthLifecycle,
-		createConnectionScope: createConnectionScopeWithCredentials,
-	} = deps;
-
 	const {
 		account: accountService,
 		mailbox: mailboxService,
@@ -118,7 +97,7 @@ const handleCreate = async (
 		account,
 		log,
 		async (credentials) => {
-			const scope = createConnectionScopeWithCredentials(account, credentials);
+			const scope = createConnectionScope(account, credentials);
 			const managementService = new MailboxManagementService(
 				mailboxService,
 				log,
@@ -209,15 +188,8 @@ const handleCreate = async (
 const handleRename = async (
 	event: MailboxRenameEvent,
 	log: Logger,
-	deps: MailboxManagementDeps,
+	createConnectionScope: typeof createConnectionScopeWithCredentials,
 ): Promise<void> => {
-	const {
-		getClient,
-		buildLifecycleDeps,
-		withOAuthLifecycle,
-		createConnectionScope: createConnectionScopeWithCredentials,
-	} = deps;
-
 	const {
 		account: accountService,
 		accountSetting: accountSettingService,
@@ -246,7 +218,7 @@ const handleRename = async (
 		account,
 		log,
 		async (credentials) => {
-			const scope = createConnectionScopeWithCredentials(account, credentials);
+			const scope = createConnectionScope(account, credentials);
 			const managementService = new MailboxManagementService(
 				mailboxService,
 				log,
@@ -321,8 +293,7 @@ const handleRename = async (
 						// folder's mail. Removing the root row alone is the orphaning
 						// bug: every descendant recorded the same intent (D6) and would
 						// be left `pending` at a path that does not exist, with its mail
-						// stranded out of every reader and still in the search index
-						// (D8).
+						// stranded out of every reader (D8).
 						if (error instanceof FolderGoneUpstreamError) {
 							log.info(
 								{ accountId, mailboxId, oldPath, intent: "rename" },
@@ -387,15 +358,8 @@ const handleRename = async (
 const handleDelete = async (
 	event: MailboxDeleteEvent,
 	log: Logger,
-	deps: MailboxManagementDeps,
+	createConnectionScope: typeof createConnectionScopeWithCredentials,
 ): Promise<void> => {
-	const {
-		getClient,
-		buildLifecycleDeps,
-		withOAuthLifecycle,
-		createConnectionScope: createConnectionScopeWithCredentials,
-	} = deps;
-
 	const {
 		account: accountService,
 		mailbox: mailboxService,
@@ -420,7 +384,7 @@ const handleDelete = async (
 		account,
 		log,
 		async (credentials) => {
-			const scope = createConnectionScopeWithCredentials(account, credentials);
+			const scope = createConnectionScope(account, credentials);
 			const managementService = new MailboxManagementService(
 				mailboxService,
 				log,
@@ -509,14 +473,14 @@ const handleDelete = async (
 export const processMailboxManagement = async (
 	event: MailboxManagementEvent,
 	log: Logger,
-	deps: MailboxManagementDeps = defaultDeps,
+	createConnectionScope = createConnectionScopeWithCredentials,
 ): Promise<void> => {
 	switch (event.type) {
 		case "MAILBOX_CREATE":
-			return handleCreate(event, log, deps);
+			return handleCreate(event, log, createConnectionScope);
 		case "MAILBOX_RENAME":
-			return handleRename(event, log, deps);
+			return handleRename(event, log, createConnectionScope);
 		case "MAILBOX_DELETE":
-			return handleDelete(event, log, deps);
+			return handleDelete(event, log, createConnectionScope);
 	}
 };