@remit/imap-worker 0.0.14 → 0.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -20,7 +20,7 @@
     "bundle": "esbuild src/index.ts --sourcemap --bundle --platform=node --format=esm --outfile=dist/index.js",
     "cli": "node --env-file=../../localhost-dev-aws.env src/cli.ts",
     "test:typecheck": "tsgo --noEmit",
-    "test:run": "node --env-file=../../localhost-test-unit.env --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=50 --test 'src/**/*.test.ts'",
+    "test:run": "node --env-file=../../localhost-test-unit.env --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=70 --test 'src/**/*.test.ts'",
     "test": "npm run test:typecheck && npm run test:run",
     "dev": "node --import tsx src/e2e-processor-shim.ts"
   },

package/src/handlers/delete-account-objects.test.ts

@@ -1,81 +1,129 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { DeleteAccountObjectsEvent } from "./delete-account-objects.js";
-
-describe("DeleteAccountObjects handler", () => {
-	it("event shape is correct", () => {
-		const event: DeleteAccountObjectsEvent = {
-			type: "DELETE_ACCOUNT_OBJECTS",
-			accountConfigId: "test-account-config-id-12345",
-		};
-
-		assert.equal(event.type, "DELETE_ACCOUNT_OBJECTS");
-		assert.equal(event.accountConfigId, "test-account-config-id-12345");
-		assert.equal(event.continuationToken, undefined);
+import { afterEach, describe, it } from "node:test";
+import {
+	DeleteObjectsCommand,
+	ListObjectsV2Command,
+	S3Client,
+} from "@aws-sdk/client-s3";
+import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import type { Logger } from "@remit/logger-lambda";
+import { mockClient } from "aws-sdk-client-mock";
+import {
+	type DeleteAccountObjectsEvent,
+	handleDeleteAccountObjects,
+} from "./delete-account-objects.js";
+
+const noopLog = {
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {},
+	fatal: () => {},
+	trace: () => {},
+	child: () => noopLog,
+} as unknown as Logger;
+
+const s3Mock = mockClient(S3Client);
+const sqsMock = mockClient(SQSClient);
+
+const event: DeleteAccountObjectsEvent = {
+	type: "DELETE_ACCOUNT_OBJECTS",
+	accountConfigId: "cfg-1",
+};
+
+describe("handleDeleteAccountObjects", () => {
+	afterEach(() => {
+		s3Mock.reset();
+		sqsMock.reset();
 	});
 
-	it("event with continuation token is correct", () => {
-		const event: DeleteAccountObjectsEvent = {
-			type: "DELETE_ACCOUNT_OBJECTS",
-			accountConfigId: "test-account-config-id-12345",
-			continuationToken: "abc123",
-		};
-
-		assert.equal(event.continuationToken, "abc123");
+	it("lists and deletes every object under the account prefix in one page", async () => {
+		s3Mock.on(ListObjectsV2Command).resolves({
+			Contents: [
+				{ Key: "accounts/cfg-1/a.eml" },
+				{ Key: "accounts/cfg-1/b.eml" },
+			],
+			IsTruncated: false,
+		});
+		s3Mock.on(DeleteObjectsCommand).resolves({});
+
+		await handleDeleteAccountObjects(event, noopLog);
+
+		const listCall = s3Mock.commandCalls(ListObjectsV2Command)[0];
+		assert.equal(listCall.args[0].input.Prefix, "accounts/cfg-1/");
+
+		const deleteCall = s3Mock.commandCalls(DeleteObjectsCommand)[0];
+		assert.deepEqual(deleteCall.args[0].input.Delete?.Objects, [
+			{ Key: "accounts/cfg-1/a.eml" },
+			{ Key: "accounts/cfg-1/b.eml" },
+		]);
+		assert.equal(sqsMock.commandCalls(SendMessageCommand).length, 0);
 	});
 
-	it("S3 prefix follows expected pattern", () => {
-		const accountConfigId = "test-account-config-id-12345";
-		const prefix = `accounts/${accountConfigId}/`;
-
-		assert.ok(prefix.startsWith("accounts/"));
-		assert.ok(prefix.endsWith("/"));
-		assert.ok(prefix.includes(accountConfigId));
+	it("follows the continuation token across truncated pages", async () => {
+		s3Mock
+			.on(ListObjectsV2Command)
+			.resolvesOnce({
+				Contents: [{ Key: "accounts/cfg-1/p1.eml" }],
+				IsTruncated: true,
+				NextContinuationToken: "tok-2",
+			})
+			.resolvesOnce({
+				Contents: [{ Key: "accounts/cfg-1/p2.eml" }],
+				IsTruncated: false,
+			});
+		s3Mock.on(DeleteObjectsCommand).resolves({});
+
+		await handleDeleteAccountObjects(event, noopLog);
+
+		const listCalls = s3Mock.commandCalls(ListObjectsV2Command);
+		assert.equal(listCalls.length, 2);
+		assert.equal(listCalls[1]?.args[0].input.ContinuationToken, "tok-2");
+		assert.equal(s3Mock.commandCalls(DeleteObjectsCommand).length, 2);
 	});
 
-	it("batch size calculation respects limit", () => {
-		const BATCH_SIZE = 1_000;
-		const keys = Array.from({ length: 2500 }, (_, i) => `key-${i}`);
+	it("skips the delete call when a page holds no keys", async () => {
+		s3Mock.on(ListObjectsV2Command).resolves({ IsTruncated: false });
 
-		// Simulate batching
-		const batches: string[][] = [];
-		for (let i = 0; i < keys.length; i += BATCH_SIZE) {
-			batches.push(keys.slice(i, i + BATCH_SIZE));
-		}
+		await handleDeleteAccountObjects(event, noopLog);
 
-		assert.equal(batches.length, 3);
-		assert.equal(batches[0].length, 1000);
-		assert.equal(batches[1].length, 1000);
-		assert.equal(batches[2].length, 500);
+		assert.equal(s3Mock.commandCalls(DeleteObjectsCommand).length, 0);
 	});
 
-	it("re-enqueue event preserves continuation token", () => {
-		const accountConfigId = "test-id";
-		const continuationToken = "next-page-token";
-
-		const reenqueueEvent: DeleteAccountObjectsEvent = {
-			type: "DELETE_ACCOUNT_OBJECTS",
-			accountConfigId,
-			continuationToken,
-		};
-
-		const body = JSON.stringify(reenqueueEvent);
-		const parsed = JSON.parse(body) as DeleteAccountObjectsEvent;
-
-		assert.equal(parsed.type, "DELETE_ACCOUNT_OBJECTS");
-		assert.equal(parsed.accountConfigId, accountConfigId);
-		assert.equal(parsed.continuationToken, continuationToken);
+	it("re-enqueues with the continuation token when time is nearly up", async () => {
+		s3Mock.on(ListObjectsV2Command).resolves({ IsTruncated: false });
+		sqsMock.on(SendMessageCommand).resolves({});
+
+		await handleDeleteAccountObjects(
+			{ ...event, continuationToken: "tok-mid" },
+			noopLog,
+			() => 5_000,
+		);
+
+		assert.equal(
+			s3Mock.commandCalls(ListObjectsV2Command).length,
+			0,
+			"bails before starting a new page",
+		);
+		const send = sqsMock.commandCalls(SendMessageCommand)[0];
+		const body = JSON.parse(
+			send?.args[0].input.MessageBody ?? "{}",
+		) as DeleteAccountObjectsEvent;
+		assert.equal(body.type, "DELETE_ACCOUNT_OBJECTS");
+		assert.equal(body.accountConfigId, "cfg-1");
+		assert.equal(body.continuationToken, "tok-mid");
 	});
 
-	it("timeout detection triggers re-enqueue", () => {
-		const MIN_REMAINING_MS = 30_000;
+	it("keeps paging while time remains", async () => {
+		s3Mock.on(ListObjectsV2Command).resolves({
+			Contents: [{ Key: "accounts/cfg-1/x.eml" }],
+			IsTruncated: false,
+		});
+		s3Mock.on(DeleteObjectsCommand).resolves({});
 
-		// Simulate near-timeout scenario
-		const getRemainingTimeMs = () => 25_000;
-		assert.ok(getRemainingTimeMs() < MIN_REMAINING_MS);
+		await handleDeleteAccountObjects(event, noopLog, () => 120_000);
 
-		// Simulate enough time
-		const getRemainingTimeMsOk = () => 60_000;
-		assert.ok(getRemainingTimeMsOk() >= MIN_REMAINING_MS);
+		assert.equal(s3Mock.commandCalls(ListObjectsV2Command).length, 1);
+		assert.equal(sqsMock.commandCalls(SendMessageCommand).length, 0);
 	});
 });

package/src/handlers/message-copy.test.ts

@@ -0,0 +1,262 @@
+import assert from "node:assert/strict";
+import { beforeEach, describe, it } from "node:test";
+import type { Logger } from "@remit/logger-lambda";
+import type { MessageCopyEvent } from "../events.js";
+import { handleMessageCopy, type MessageCopyDeps } from "./message-copy.js";
+
+const noopLog = {
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {},
+	fatal: () => {},
+	trace: () => {},
+	child: () => noopLog,
+} as unknown as Logger;
+
+interface Call {
+	method: string;
+	args: unknown[];
+}
+
+interface Connection {
+	openBox: (
+		path: string,
+		readOnly?: boolean,
+	) => Promise<{ uidvalidity: number }>;
+	copyMessages: (
+		uids: number[],
+		dest: string,
+	) => Promise<{ uidMap: Map<number, number> }>;
+	createMailbox: (path: string) => Promise<void>;
+}
+
+interface Harness {
+	calls: Call[];
+	account: {
+		accountId: string;
+		accountConfigId: string;
+		deletedAt?: number;
+	} | null;
+	mailbox: { mailboxId: string; uidValidity: number; cursorState?: string };
+	connection: Connection;
+	getConnectionCount: number;
+	disconnectCount: number;
+}
+
+let h: Harness;
+
+const record =
+	(method: string) =>
+	async (...args: unknown[]) => {
+		h.calls.push({ method, args });
+	};
+
+const buildConnection = (): Connection => ({
+	openBox: async () => ({ uidvalidity: 1 }),
+	copyMessages: async () => ({ uidMap: new Map([[10, 20]]) }),
+	createMailbox: record("createMailbox") as Connection["createMailbox"],
+});
+
+const fresh = (): Harness => ({
+	calls: [],
+	account: { accountId: "acc-1", accountConfigId: "cfg-1" },
+	mailbox: { mailboxId: "src-mbx", uidValidity: 1, cursorState: undefined },
+	connection: buildConnection(),
+	getConnectionCount: 0,
+	disconnectCount: 0,
+});
+
+const deps = (): MessageCopyDeps =>
+	({
+		getClient: async () => ({
+			account: {
+				get: async (accountId: string) => {
+					h.calls.push({ method: "account.get", args: [accountId] });
+					return h.account;
+				},
+			},
+			message: {
+				updateUid: record("message.updateUid"),
+				update: record("message.update"),
+			},
+			threadMessage: {
+				findByMessageId: async (cfg: string) => ({
+					accountConfigId: cfg,
+					threadMessageId: "tm-1",
+					sentDate: 1,
+					mailboxId: "src-mbx",
+					isRead: false,
+					isDeleted: false,
+					hasStars: false,
+					hasAttachment: false,
+				}),
+				update: record("threadMessage.update"),
+			},
+			mailbox: {
+				get: async () => h.mailbox,
+				update: record("mailbox.update"),
+			},
+			secrets: {},
+		}),
+		buildLifecycleDeps: () => ({}),
+		withOAuthLifecycle: async (
+			_deps: unknown,
+			_account: unknown,
+			_log: unknown,
+			cb: (credentials: unknown) => Promise<void>,
+		) => cb({}),
+		createConnectionScope: () => ({
+			getConnection: async () => {
+				h.getConnectionCount += 1;
+				return h.connection;
+			},
+			disconnect: async () => {
+				h.disconnectCount += 1;
+			},
+		}),
+	}) as unknown as MessageCopyDeps;
+
+const event: MessageCopyEvent = {
+	type: "MESSAGE_COPY",
+	accountId: "acc-1",
+	sourceMessageId: "src-msg",
+	newMessageId: "new-msg",
+	sourceMailboxId: "src-mbx",
+	sourceMailboxPath: "INBOX",
+	destinationMailboxPath: "Archive",
+	destinationMailboxId: "dst-mbx",
+	uid: 10,
+} as MessageCopyEvent;
+
+const called = (method: string): Call[] =>
+	h.calls.filter((c) => c.method === method);
+
+describe("handleMessageCopy", () => {
+	beforeEach(() => {
+		h = fresh();
+	});
+
+	it("writes the new UID, marks the copy synced, and updates the thread row", async () => {
+		await handleMessageCopy(event, noopLog, deps());
+
+		assert.deepEqual(called("message.updateUid")[0]?.args, [
+			"new-msg",
+			20,
+			"dst-mbx",
+		]);
+		const statusUpdate = called("message.update")[0];
+		assert.equal(
+			(statusUpdate?.args[1] as { syncStatus?: string })?.syncStatus,
+			"synced",
+		);
+		assert.equal(called("threadMessage.update").length, 1);
+		assert.equal(h.disconnectCount, 1, "the scope is always disconnected");
+	});
+
+	it("marks the copy failed when the COPYUID response omits the source uid", async () => {
+		h.connection.copyMessages = async () => ({ uidMap: new Map() });
+
+		await handleMessageCopy(event, noopLog, deps());
+
+		assert.equal(called("message.updateUid").length, 0);
+		const update = called("message.update")[0];
+		assert.equal(
+			(update?.args[1] as { syncStatus?: string })?.syncStatus,
+			"failed",
+		);
+		assert.equal(called("threadMessage.update").length, 0);
+	});
+
+	it("returns early without connecting when the account is soft-deleted", async () => {
+		h.account = {
+			accountId: "acc-1",
+			accountConfigId: "cfg-1",
+			deletedAt: Date.now(),
+		};
+
+		await handleMessageCopy(event, noopLog, deps());
+
+		assert.equal(h.getConnectionCount, 0);
+	});
+
+	it("throws when the account no longer exists", async () => {
+		h.account = null;
+
+		await assert.rejects(
+			handleMessageCopy(event, noopLog, deps()),
+			/not found/,
+		);
+	});
+
+	it("skips the copy without opening a connection when the cursor is rebuilding", async () => {
+		h.mailbox = {
+			mailboxId: "src-mbx",
+			uidValidity: 1,
+			cursorState: "rebuilding",
+		};
+
+		await handleMessageCopy(event, noopLog, deps());
+
+		assert.equal(h.getConnectionCount, 0);
+		assert.equal(called("message.updateUid").length, 0);
+	});
+
+	it("pauses quietly when openBox trips a UIDVALIDITY mismatch", async () => {
+		h.connection.openBox = async () => ({ uidvalidity: 999 });
+
+		await handleMessageCopy(event, noopLog, deps());
+
+		assert.equal(
+			(called("mailbox.update")[0]?.args[2] as { cursorState?: string })
+				?.cursorState,
+			"cursor_invalid",
+			"the mismatch trips the mailbox cursor",
+		);
+		assert.equal(called("message.updateUid").length, 0);
+		assert.equal(h.disconnectCount, 1);
+	});
+
+	it("creates the destination and rethrows on a TRYCREATE error", async () => {
+		h.connection.copyMessages = async () => {
+			throw new Error("TRYCREATE: mailbox does not exist");
+		};
+
+		await assert.rejects(
+			handleMessageCopy(event, noopLog, deps()),
+			/TRYCREATE/,
+		);
+
+		assert.equal(called("createMailbox")[0]?.args[0], "Archive");
+		assert.equal(h.getConnectionCount, 2, "reconnects to create the mailbox");
+	});
+
+	it("marks the copy deleted-and-failed when the source is gone on the server", async () => {
+		h.connection.copyMessages = async () => {
+			throw new Error("NONEXISTENT source message");
+		};
+
+		await handleMessageCopy(event, noopLog, deps());
+
+		const update = called("message.update")[0];
+		assert.equal((update?.args[1] as { status?: string })?.status, "deleted");
+		assert.equal(called("createMailbox").length, 0);
+	});
+
+	it("marks failed and rethrows on an unclassified IMAP error", async () => {
+		h.connection.copyMessages = async () => {
+			throw new Error("server exploded");
+		};
+
+		await assert.rejects(
+			handleMessageCopy(event, noopLog, deps()),
+			/server exploded/,
+		);
+
+		const update = called("message.update")[0];
+		assert.equal(
+			(update?.args[1] as { syncStatus?: string })?.syncStatus,
+			"failed",
+		);
+	});
+});

package/src/handlers/message-copy.ts

@@ -12,6 +12,20 @@ import type { MessageCopyEvent } from "../events.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 
+export interface MessageCopyDeps {
+	getClient: typeof getClient;
+	buildLifecycleDeps: typeof buildLifecycleDeps;
+	withOAuthLifecycle: typeof withOAuthLifecycle;
+	createConnectionScope: typeof createConnectionScopeWithCredentials;
+}
+
+const defaultDeps: MessageCopyDeps = {
+	getClient,
+	buildLifecycleDeps,
+	withOAuthLifecycle,
+	createConnectionScope: createConnectionScopeWithCredentials,
+};
+
 /**
  * Handle MESSAGE_COPY events.
  * Executes IMAP COPY command and updates local state with new UID.
@@ -19,7 +33,15 @@ import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 export const handleMessageCopy = async (
 	event: MessageCopyEvent,
 	log: Logger,
+	deps: MessageCopyDeps = defaultDeps,
 ): Promise<void> => {
+	const {
+		getClient,
+		buildLifecycleDeps,
+		withOAuthLifecycle,
+		createConnectionScope: createConnectionScopeWithCredentials,
+	} = deps;
+
 	const {
 		account: accountService,
 		message: messageService,