@remit/imap-worker 0.0.82 → 0.0.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.82",
+  "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/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