@remit/imap-worker 0.0.81 → 0.0.83

package/package.json

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

package/src/account-check.test.ts

@@ -4,6 +4,7 @@ import type { AccountItem } from "@remit/data-ports";
 import {
 	isAccountDeleted,
 	isAccountReauthRequired,
+	isMailSyncDisabled,
 	isReservedHost,
 	isUnsyncableHost,
 } from "./account-check.js";
@@ -120,3 +121,29 @@ describe("isAccountReauthRequired", () => {
 		);
 	});
 });
+
+describe("isMailSyncDisabled", () => {
+	it("returns false for a mail-only account", () => {
+		assert.equal(
+			isMailSyncDisabled(buildAccount({ syncedServices: ["Mail"] }), log),
+			false,
+		);
+	});
+
+	it("returns false for an account syncing mail and calendar", () => {
+		assert.equal(
+			isMailSyncDisabled(
+				buildAccount({ syncedServices: ["Mail", "Calendar"] }),
+				log,
+			),
+			false,
+		);
+	});
+
+	it("returns true for a calendar-only account", () => {
+		assert.equal(
+			isMailSyncDisabled(buildAccount({ syncedServices: ["Calendar"] }), log),
+			true,
+		);
+	});
+});

package/src/account-check.ts

@@ -1,4 +1,5 @@
 import type { AccountItem } from "@remit/data-ports";
+import { AccountService } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 
 /**
@@ -86,3 +87,15 @@ export const isAccountReauthRequired = (
 	}
 	return false;
 };
+
+export const isMailSyncDisabled = (
+	account: AccountItem,
+	log: Logger,
+): boolean => {
+	if (account.syncedServices.includes(AccountService.Mail)) return false;
+	log.info(
+		{ accountId: account.accountId, syncedServices: account.syncedServices },
+		"Skipping account: mail sync is off",
+	);
+	return true;
+};

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

@@ -711,6 +711,23 @@ describe("processMailboxManagement — a tagged NO the server means as success (
 		assert.equal(called("mailbox.transition").length, 0);
 	});
 
+	it("marks failed and acks when the server refuses the DELETE with NOPERM", async () => {
+		recordDeleteIntent();
+		h.connection.deleteMailbox = async () => {
+			throw Object.assign(new Error("Command failed"), {
+				serverResponseCode: "NOPERM",
+				responseText: "Permission denied",
+			});
+		};
+
+		await assert.doesNotReject(
+			processMailboxManagement(deleteEvent, noopLogger, deps()),
+		);
+		assert.equal(lastSettle().to, "failed");
+		assert.equal(lastSettle().set?.syncFailureReason, "Permission denied");
+		assert.equal(called("mailbox.deleteMailboxWithMail").length, 0);
+	});
+
 	it("still marks failed and rethrows when the server fails for any other reason", async () => {
 		recordDeleteIntent();
 		h.connection.deleteMailbox = async () => {
@@ -747,6 +764,21 @@ describe("processMailboxManagement — a tagged NO the server means as success (
 		assert.equal(lastSettle().to, "synced");
 	});
 
+	it("marks failed with the server's reason and acks when a CREATE is refused", async () => {
+		h.connection.createMailbox = async () => {
+			throw Object.assign(new Error("Command failed"), {
+				serverResponseCode: "NOPERM",
+				responseText: "Permission denied",
+			});
+		};
+
+		await assert.doesNotReject(
+			processMailboxManagement(createEvent, noopLogger, deps()),
+		);
+		assert.equal(lastSettle().to, "failed");
+		assert.equal(lastSettle().set?.syncFailureReason, "Permission denied");
+	});
+
 	it("still marks failed and rethrows when a CREATE fails for any other reason", async () => {
 		h.connection.createMailbox = async () => {
 			throw Object.assign(new Error("Command failed"), {
@@ -781,6 +813,25 @@ describe("processMailboxManagement — a tagged NO the server means as success (
 		]);
 	});
 
+	it("marks failed with the server's reason and acks when a RENAME is refused", async () => {
+		recordRenameIntent();
+		h.connection.renameMailbox = async () => {
+			throw Object.assign(new Error("Command failed"), {
+				serverResponseCode: "CANNOT",
+				responseText: "Can't rename mailbox with its children",
+			});
+		};
+
+		await assert.doesNotReject(
+			processMailboxManagement(renameEvent, noopLogger, deps()),
+		);
+		assert.equal(lastSettle().to, "failed");
+		assert.equal(
+			lastSettle().set?.syncFailureReason,
+			"Can't rename mailbox with its children",
+		);
+	});
+
 	it("still refuses the intent and rethrows when a RENAME fails for any other reason", async () => {
 		recordRenameIntent();
 		h.connection.renameMailbox = async () => {

package/src/handlers/mailbox-management.ts

@@ -9,7 +9,9 @@ import {
 	FolderRenameSettleError,
 	isMailboxAbsentUpstream,
 	isMailboxPresentUpstream,
+	isMailboxRefusedUpstream,
 	MailboxManagementService,
+	upstreamFailureReason,
 } from "@remit/mailbox-service";
 import { isAccountDeleted } from "../account-check.js";
 import { createConnectionScopeWithCredentials } from "../connection-scope.js";
@@ -47,12 +49,13 @@ const recordCreateOutcome = async (
 	accountId: string,
 	mailboxId: string,
 	to: (typeof MailboxSyncStatus)[keyof typeof MailboxSyncStatus],
+	syncFailureReason = "",
 ): Promise<void> => {
 	const written = await mailboxService.transition(accountId, mailboxId, {
 		from: [MailboxSyncStatus.pending],
 		wherePendingPath: null,
 		to,
-		set: {},
+		set: { syncFailureReason },
 	});
 	if (!written) throw new NotFoundError(`Mailbox not found: ${mailboxId}`);
 };
@@ -167,7 +170,15 @@ const handleCreate = async (
 								accountId,
 								mailboxId,
 								MailboxSyncStatus.failed,
+								upstreamFailureReason(error),
 							);
+							if (isMailboxRefusedUpstream(error)) {
+								log.error(
+									{ accountId, mailboxId, path, intent: "create", error },
+									"Mail server refused the create",
+								);
+								return;
+							}
 							throw error;
 						}
 					})
@@ -333,7 +344,22 @@ const handleRename = async (
 							mailboxId,
 							oldPath,
 							newPath,
+							upstreamFailureReason(error),
 						);
+						if (isMailboxRefusedUpstream(error)) {
+							log.error(
+								{
+									accountId,
+									mailboxId,
+									oldPath,
+									newPath,
+									intent: "rename",
+									error,
+								},
+								"Mail server refused the rename",
+							);
+							return;
+						}
 						throw error;
 					})
 					.finally(() => scope.disconnect());
@@ -431,7 +457,11 @@ const handleDelete = async (
 							// worker's backstop is unreachable from it; if something else
 							// reaches it, the honest outcome is `failed`, not `synced` —
 							// the folder was never deleted and nothing was undone.
-							await managementService.failDelete(accountId, mailboxId);
+							await managementService.failDelete(
+								accountId,
+								mailboxId,
+								upstreamFailureReason(error),
+							);
 							if (
 								error instanceof Error &&
 								error.message.includes("Cannot delete INBOX")
@@ -443,6 +473,13 @@ const handleDelete = async (
 								// Don't rethrow — no retry can make this succeed.
 								return;
 							}
+							if (isMailboxRefusedUpstream(error)) {
+								log.error(
+									{ accountId, mailboxId, path, intent: "delete", error },
+									"Mail server refused the delete",
+								);
+								return;
+							}
 							throw error;
 						}
 					})

package/src/handlers/sync-mailboxes.ts

@@ -21,7 +21,11 @@ import {
 	type MailCredentials,
 } from "@remit/mailbox-service";
 import pMap from "p-map";
-import { isAccountDeleted, isUnsyncableHost } from "../account-check.js";
+import {
+	isAccountDeleted,
+	isMailSyncDisabled,
+	isUnsyncableHost,
+} from "../account-check.js";
 import { emitEvent } from "../emit.js";
 import type { SyncMailboxesEvent, SyncMessagesEvent } from "../events.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
@@ -120,6 +124,10 @@ export const syncMailboxes = async (
 		return;
 	}
 
+	if (isMailSyncDisabled(account, log)) {
+		return;
+	}
+
 	// A reserved/never-resolvable IMAP host (RFC 2606) can never connect, so a
 	// sync attempt would retry and dead-letter forever. Skip cleanly — ack the
 	// event without connecting or throwing.

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

@@ -256,6 +256,7 @@ const liveAccount = {
 	accountId: "acc-1",
 	accountConfigId: "acc-cfg-1",
 	imapHost: "localhost",
+	syncedServices: ["Mail"],
 	username: "user@localhost",
 } as unknown as AccountItem;
 
@@ -542,3 +543,25 @@ describe("syncMessages — a delete that lands mid-round (issue #339)", () => {
 		assert.equal(harness.accountUpdates[0]?.syncPhase, "error");
 	});
 });
+
+describe("syncMessages — an account with mail sync off", () => {
+	it("acks the event without connecting and without touching the mailbox", async () => {
+		const { log } = buildLogger();
+		let mailboxReads = 0;
+		const harness = buildSyncDeps({
+			accountGet: async () =>
+				({ ...liveAccount, syncedServices: ["Calendar"] }) as AccountItem,
+			mailboxGet: async () => {
+				mailboxReads += 1;
+				return {};
+			},
+		});
+
+		await assert.doesNotReject(
+			syncMessages(syncEvent("mbx-1"), log, harness.deps),
+		);
+
+		assert.equal(harness.lifecycleCalls, 0);
+		assert.equal(mailboxReads, 0);
+	});
+});

package/src/handlers/sync-messages.ts

@@ -27,7 +27,11 @@ import {
 	type SyncedMessage,
 } from "@remit/mailbox-service";
 import pMap from "p-map";
-import { isAccountDeleted, isUnsyncableHost } from "../account-check.js";
+import {
+	isAccountDeleted,
+	isMailSyncDisabled,
+	isUnsyncableHost,
+} from "../account-check.js";
 import { emitEvent } from "../emit.js";
 import type {
 	FlagPushEvent,
@@ -126,6 +130,10 @@ export const syncMessages = async (
 		return;
 	}
 
+	if (isMailSyncDisabled(account, log)) {
+		return;
+	}
+
 	// A reserved/never-resolvable IMAP host (RFC 2606) can never connect, so a
 	// sync attempt would retry and dead-letter forever. Skip cleanly — ack the
 	// event without connecting or throwing.

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

@@ -0,0 +1,229 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "@remit/backend/client";
+import type { AccountItem } from "@remit/data-ports";
+import {
+	AccountAuthType,
+	AccountService,
+	ConnectionState,
+	MailboxCursorState,
+} from "@remit/domain-enums";
+import {
+	AccountRepo,
+	DrizzleMessageRepository,
+	MailboxRepo,
+} from "@remit/drizzle-service";
+import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
+import type { Logger } from "@remit/logger-lambda";
+import { syncMailboxes } from "./handlers/sync-mailboxes.js";
+import {
+	type SyncMessagesDeps,
+	syncMessages,
+} from "./handlers/sync-messages.js";
+import { runSchedulerTick } from "./scheduler/run-tick.js";
+
+const NOW = 1_700_000_000_000;
+
+const silentLogger: Logger = (() => {
+	const noop = () => {};
+	const stub = {
+		info: noop,
+		warn: noop,
+		error: noop,
+		debug: noop,
+		fatal: noop,
+		trace: noop,
+		child: () => stub,
+	};
+	return stub as unknown as Logger;
+})();
+
+let accounts: AccountRepo;
+let mailboxes: MailboxRepo;
+let messages: DrizzleMessageRepository;
+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);
+	client = {
+		account: accounts,
+		mailbox: mailboxes,
+		message: messages,
+	} as unknown as RemitClient;
+	setClient(client);
+});
+
+afterEach(() => {
+	_resetForTest();
+	close();
+});
+
+const seedSyncedAccount = async (): Promise<{
+	account: AccountItem;
+	mailboxId: string;
+	messageId: string;
+}> => {
+	const account = await accounts.create({
+		accountConfigId: "cfg-1181",
+		username: "person@example.com",
+		email: "person@example.com",
+		authType: AccountAuthType.Password,
+		passwordHash: '{"ciphertext":"x"}',
+		imapHost: "imap.example.com",
+		imapPort: 993,
+		imapTls: true,
+		imapStartTls: false,
+		isActive: true,
+		connectionState: ConnectionState.Authenticated,
+	});
+	const created = await mailboxes.create({
+		accountId: account.accountId,
+		namespacePrefix: "",
+		hierarchyDelimiter: "/",
+		fullPath: "INBOX",
+		uidValidity: 7,
+		uidNext: 4,
+		highestModseq: "42",
+		messageCount: 1,
+		unseenCount: 0,
+		deletedCount: 0,
+		totalSize: 10,
+		lastSyncUid: 3,
+		highWaterMarkUid: 3,
+		lastMessageSyncAt: NOW,
+		cursorState: MailboxCursorState.normal,
+	} as Parameters<MailboxRepo["create"]>[0]);
+	if (created.outcome !== "Created") throw new Error("INBOX path taken");
+	const mailbox = created.mailbox;
+	const messageId = randomUUID();
+	await messages.create({
+		messageId,
+		mailboxId: mailbox.mailboxId,
+		uid: 3,
+		sequenceNumber: 1,
+		rfc822Size: 10,
+		internalDate: NOW,
+		envelopeId: randomUUID(),
+		rootBodyPartId: randomUUID(),
+		status: "active",
+		syncStatus: "synced",
+	});
+	return { account, mailboxId: mailbox.mailboxId, messageId };
+};
+
+const tick = async (): Promise<{ enqueued: number; accountIds: string[] }> => {
+	const sent: SendMessageCommand[] = [];
+	const sqsClient = {
+		send: async (command: SendMessageCommand) => {
+			sent.push(command);
+			return {};
+		},
+	} as unknown as SQSClient;
+	const result = await runSchedulerTick({
+		accountService: accounts,
+		sqsClient,
+		queueUrl: "https://queue.test/mailboxes",
+		log: silentLogger,
+		tickIntervalMs: 60_000,
+		offlineIntervalMs: 0,
+		now: NOW,
+	});
+	return {
+		enqueued: result.enqueued,
+		accountIds: sent.map(
+			(command) => JSON.parse(command.input.MessageBody ?? "{}").accountId,
+		),
+	};
+};
+
+const setServices = (
+	accountId: string,
+	syncedServices: AccountItem["syncedServices"],
+) => accounts.update(accountId, { syncedServices });
+
+describe("turning mail sync off and on again", () => {
+	it("stops every mail sync entry point and keeps the stored mail", async () => {
+		const { account, mailboxId, messageId } = await seedSyncedAccount();
+		const storedMailboxes = await mailboxes.listAllByAccount(account.accountId);
+		const storedMessage = await messages.get(messageId);
+
+		await setServices(account.accountId, [AccountService.Calendar]);
+
+		assert.deepEqual(await tick(), { enqueued: 0, accountIds: [] });
+
+		await syncMailboxes(
+			{
+				type: "SYNC_MAILBOXES",
+				eventId: "evt-mailboxes",
+				timestamp: NOW,
+				accountId: account.accountId,
+			},
+			silentLogger,
+		);
+
+		let lifecycleCalls = 0;
+		const deps = {
+			getClient: async () => client,
+			buildLifecycleDeps: () => ({}),
+			withOAuthLifecycle: async () => {
+				lifecycleCalls += 1;
+			},
+		} as unknown as SyncMessagesDeps;
+		await syncMessages(
+			{
+				type: "SYNC_MESSAGES",
+				eventId: "evt-messages",
+				timestamp: NOW,
+				accountId: account.accountId,
+				mailboxId,
+			},
+			silentLogger,
+			deps,
+		);
+		assert.equal(lifecycleCalls, 0);
+
+		assert.deepEqual(
+			await mailboxes.listAllByAccount(account.accountId),
+			storedMailboxes,
+		);
+		assert.deepEqual(await messages.get(messageId), storedMessage);
+		assert.equal(
+			(await accounts.get(account.accountId)).connectionState,
+			ConnectionState.Authenticated,
+		);
+	});
+
+	it("resumes from the stored markers when mail is turned back on", async () => {
+		const { account, messageId } = await seedSyncedAccount();
+		const storedMailboxes = await mailboxes.listAllByAccount(account.accountId);
+		const storedMessage = await messages.get(messageId);
+
+		await setServices(account.accountId, [AccountService.Calendar]);
+		await tick();
+		await setServices(account.accountId, [
+			AccountService.Mail,
+			AccountService.Calendar,
+		]);
+
+		assert.deepEqual(await tick(), {
+			enqueued: 1,
+			accountIds: [account.accountId],
+		});
+		assert.deepEqual(
+			await mailboxes.listAllByAccount(account.accountId),
+			storedMailboxes,
+		);
+		assert.deepEqual(await messages.get(messageId), storedMessage);
+	});
+});

package/src/scheduler/attachment-sweep.test.ts

@@ -43,6 +43,7 @@ const eligibleAccount = (accountId: string) =>
 		email: `${accountId}@example.com`,
 		username: accountId,
 		authType: "password",
+		syncedServices: ["Mail"],
 		imapHost: "imap.example.com",
 		imapPort: 993,
 		imapTls: true,

package/src/scheduler/run-tick.test.ts

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
 import type { AccountItem, AccountSchedulerPage } from "@remit/data-ports";
+import { AccountService } from "@remit/domain-enums";
 import type { Logger } from "@remit/logger-lambda";
 import { runSchedulerTick } from "./run-tick.js";
 
@@ -62,6 +63,7 @@ const baseAccount = (overrides: Partial<AccountItem>): AccountItem =>
 		smtpTls: false,
 		smtpStartTls: true,
 		smtpUsername: "",
+		syncedServices: [AccountService.Mail],
 		isActive: true,
 		connectionState: "authenticated",
 		createdAt: NOW - 1_000_000,
@@ -364,3 +366,50 @@ describe("the attachment sweep inside a tick", () => {
 		assert.equal(result.sweepFailed, 0);
 	});
 });
+
+describe("runSchedulerTick and the account's synced services", () => {
+	const tickWith = async (syncedServices: AccountItem["syncedServices"]) => {
+		const accountService = fakeAccountService([
+			{
+				items: [baseAccount({ accountId: "acct_1", syncedServices })],
+				cursor: null,
+			},
+		]);
+		const { sqsClient, sent } = fakeSqsClient();
+		const result = await runSchedulerTick({
+			accountService,
+			sqsClient,
+			queueUrl: "https://queue.test/mailboxes",
+			log: createNoopLogger(),
+			tickIntervalMs: TICK_INTERVAL_MS,
+			offlineIntervalMs: OFFLINE_INTERVAL_MS,
+			now: NOW,
+		});
+		return { result, sent };
+	};
+
+	it("enqueues mail sync for a mail-only account", async () => {
+		const { result, sent } = await tickWith([AccountService.Mail]);
+
+		assert.equal(result.enqueued, 1);
+		assert.equal(sent.length, 1);
+	});
+
+	it("enqueues mail sync for an account syncing mail and calendar", async () => {
+		const { result, sent } = await tickWith([
+			AccountService.Mail,
+			AccountService.Calendar,
+		]);
+
+		assert.equal(result.enqueued, 1);
+		assert.equal(sent.length, 1);
+	});
+
+	it("skips a calendar-only account", async () => {
+		const { result, sent } = await tickWith([AccountService.Calendar]);
+
+		assert.equal(result.enqueued, 0);
+		assert.equal(result.skipped, 1);
+		assert.equal(sent.length, 0);
+	});
+});

package/src/scheduler/run-tick.ts

@@ -10,6 +10,7 @@ import pMap from "p-map";
 import {
 	isAccountDeleted,
 	isAccountReauthRequired,
+	isMailSyncDisabled,
 	isUnsyncableHost,
 } from "../account-check.js";
 import {
@@ -78,6 +79,7 @@ const silentLogger: Logger = (() => {
 
 const isEligible = (account: AccountItem): boolean => {
 	if (isAccountDeleted(account, silentLogger)) return false;
+	if (isMailSyncDisabled(account, silentLogger)) return false;
 	if (isUnsyncableHost(account, silentLogger)) return false;
 	if (isAccountReauthRequired(account, silentLogger)) return false;
 	// An account storing no credential can only produce a sync that fails at