@remit/imap-worker 0.0.1

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

@@ -0,0 +1,141 @@
+/**
+ * A SYNC_MESSAGES trigger can outlive its account: deletion does not purge the
+ * already-queued triggers in lockstep, so a trigger can reference an account
+ * whose DDB row is gone. The lookup then raises NotFoundError. That error can
+ * never succeed on retry, so it would retry to maxReceiveCount and poison the
+ * messages DLQ forever (issue #911).
+ *
+ * Contract under test:
+ *  - missing account (get throws NotFoundError) -> acked + WARN, never thrown
+ *  - soft-deleted account (deletedAt set)       -> acked, never thrown
+ *  - healthy account                            -> proceeds past the gate (the
+ *      handler does real work and fails without a live IMAP server) — proving a
+ *      healthy trigger is NOT silently dropped
+ *  - transient error (a non-NotFound error)     -> propagates, so SQS retries
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it, mock } from "node:test";
+import {
+	_resetForTest,
+	_setClientForTest,
+	type RemitClient,
+} from "@remit/backend/client";
+import type { AccountItem } from "@remit/data-ports";
+import type { Logger } from "@remit/logger-lambda";
+import type { SyncMessagesEvent } from "../events.js";
+import { syncMessages } from "./sync-messages.js";
+
+const notFoundError = (message: string): Error => {
+	const error = new Error(message);
+	error.name = "NotFoundError";
+	return error;
+};
+
+const setAccountGet = (get: () => Promise<AccountItem>): void => {
+	_setClientForTest({ account: { get } } as unknown as RemitClient);
+};
+
+interface WarnRecord {
+	fields: Record<string, unknown>;
+	message: string;
+}
+
+const recordingLogger = (warns: WarnRecord[]): Logger => {
+	const noop = () => {};
+	const log = {
+		info: noop,
+		warn: (fields: Record<string, unknown>, message: string) => {
+			warns.push({ fields, message });
+		},
+		error: noop,
+		debug: noop,
+		fatal: noop,
+		trace: noop,
+		child: () => log,
+	} as unknown as Logger;
+	return log;
+};
+
+const healthyAccount = (): AccountItem =>
+	({
+		accountId: "acct-live",
+		accountConfigId: "acfg-live",
+		connectionState: "authenticated",
+		username: "alice@imap.example.com",
+		imapHost: "imap.example.com",
+		imapPort: 993,
+		imapTls: true,
+	}) as unknown as AccountItem;
+
+const deletedAccount = (): AccountItem =>
+	({
+		...healthyAccount(),
+		accountId: "acct-deleted",
+		deletedAt: Date.now(),
+	}) as unknown as AccountItem;
+
+const event = (accountId: string): SyncMessagesEvent =>
+	({
+		type: "SYNC_MESSAGES",
+		accountId,
+		mailboxId: "mbox-1",
+		eventId: "evt-1",
+		timestamp: 0,
+	}) as SyncMessagesEvent;
+
+afterEach(() => {
+	mock.restoreAll();
+	_resetForTest();
+});
+
+describe("syncMessages deleted/missing account drop (#911)", () => {
+	it("acks and warns when the account no longer exists", async () => {
+		setAccountGet(async () => {
+			throw notFoundError("Account not found: acct-gone");
+		});
+		const warns: WarnRecord[] = [];
+
+		await assert.doesNotReject(() =>
+			syncMessages(event("acct-gone"), recordingLogger(warns)),
+		);
+
+		const warn = warns.find((w) =>
+			w.message.includes("account no longer exists"),
+		);
+		assert.ok(warn, "expected a WARN for the missing account");
+		assert.equal(warn.fields.accountId, "acct-gone");
+		assert.equal(warn.fields.mailboxId, "mbox-1");
+		assert.equal(warn.fields.eventId, "evt-1");
+	});
+
+	it("acks a soft-deleted account without throwing", async () => {
+		setAccountGet(async () => deletedAccount());
+
+		await assert.doesNotReject(() =>
+			syncMessages(event("acct-deleted"), recordingLogger([])),
+		);
+	});
+
+	it("proceeds past the gate for a healthy account (not silently dropped)", async () => {
+		setAccountGet(async () => healthyAccount());
+
+		// No live IMAP server, so a healthy account must reach real work and fail
+		// there — the not-found gate must not swallow it as a clean ack.
+		await assert.rejects(() =>
+			syncMessages(event("acct-live"), recordingLogger([])),
+		);
+	});
+
+	it("propagates a transient error so SQS retries", async () => {
+		const transient = new Error("ProvisionedThroughputExceededException");
+		setAccountGet(async () => {
+			throw transient;
+		});
+
+		await assert.rejects(
+			() => syncMessages(event("acct-live"), recordingLogger([])),
+			transient,
+		);
+	});
+});

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

@@ -0,0 +1,204 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	AccountItem,
+	IMessageFlagPushRepository,
+} from "@remit/data-ports";
+import type { Logger } from "@remit/logger-lambda";
+import { drainPendingFlagPushes } from "./sync-messages.js";
+
+const buildLogger = (): {
+	log: Logger;
+	infos: Array<{ fields: Record<string, unknown>; msg: string }>;
+	errors: Array<{ fields: Record<string, unknown>; msg: string }>;
+} => {
+	const infos: Array<{ fields: Record<string, unknown>; msg: string }> = [];
+	const errors: Array<{ fields: Record<string, unknown>; msg: string }> = [];
+	const log = {
+		info: (fields: Record<string, unknown>, msg: string) => {
+			infos.push({ fields, msg });
+		},
+		error: (fields: Record<string, unknown>, msg: string) => {
+			errors.push({ fields, msg });
+		},
+		warn: () => {},
+		debug: () => {},
+		fatal: () => {},
+		trace: () => {},
+		child: () => log,
+	} as unknown as Logger;
+	return { log, infos, errors };
+};
+
+const account = {
+	accountId: "acc-1",
+	accountConfigId: "acc-cfg-1",
+} as unknown as AccountItem;
+
+const marker = (overrides: Partial<Record<string, unknown>> = {}) => ({
+	messageId: "msg-1",
+	flagName: "\\Seen",
+	accountId: "acc-1",
+	accountConfigId: "acc-cfg-1",
+	mailboxId: "mbx-1",
+	operation: "add",
+	state: "pending",
+	createdAt: 1,
+	updatedAt: 1,
+	...overrides,
+});
+
+describe("drainPendingFlagPushes — periodic per-mailbox re-arm (issue #1273)", () => {
+	it("re-emits FLAG_PUSH for every marker stuck in `pending` (crash between local write and enqueue)", async () => {
+		const markerService = {
+			listByMailboxId: async () => [marker()],
+		} as unknown as IMessageFlagPushRepository;
+
+		const emitted: unknown[] = [];
+		const { log } = buildLogger();
+
+		await drainPendingFlagPushes(
+			markerService,
+			account,
+			"mbx-1",
+			log,
+			async (event) => {
+				emitted.push(event);
+			},
+		);
+
+		assert.equal(emitted.length, 1);
+		assert.deepEqual(emitted[0], {
+			type: "FLAG_PUSH",
+			accountId: "acc-1",
+			accountConfigId: "acc-cfg-1",
+			messageId: "msg-1",
+			flagName: "\\Seen",
+		});
+	});
+
+	it("does NOT re-arm markers already queued or processing — a live driver already owns them", async () => {
+		const markerService = {
+			listByMailboxId: async () => [
+				marker({ messageId: "queued-msg", state: "queued" }),
+				marker({ messageId: "processing-msg", state: "processing" }),
+			],
+		} as unknown as IMessageFlagPushRepository;
+
+		const emitted: unknown[] = [];
+		const { log } = buildLogger();
+
+		await drainPendingFlagPushes(
+			markerService,
+			account,
+			"mbx-1",
+			log,
+			async (event) => {
+				emitted.push(event);
+			},
+		);
+
+		assert.equal(emitted.length, 0);
+	});
+
+	it("is a no-op when no markers exist for the mailbox", async () => {
+		const markerService = {
+			listByMailboxId: async () => [],
+		} as unknown as IMessageFlagPushRepository;
+
+		const emitted: unknown[] = [];
+		const { log, infos } = buildLogger();
+
+		await drainPendingFlagPushes(
+			markerService,
+			account,
+			"mbx-1",
+			log,
+			async (event) => {
+				emitted.push(event);
+			},
+		);
+
+		assert.equal(emitted.length, 0);
+		assert.equal(infos.length, 0);
+	});
+
+	it("re-arms multiple stuck markers for the same mailbox (per-field, independent)", async () => {
+		const markerService = {
+			listByMailboxId: async () => [
+				marker({ flagName: "\\Seen" }),
+				marker({ flagName: "\\Flagged" }),
+			],
+		} as unknown as IMessageFlagPushRepository;
+
+		const emitted: unknown[] = [];
+		const { log } = buildLogger();
+
+		await drainPendingFlagPushes(
+			markerService,
+			account,
+			"mbx-1",
+			log,
+			async (event) => {
+				emitted.push(event);
+			},
+		);
+
+		assert.equal(emitted.length, 2);
+	});
+
+	it("a re-arm (SQS) failure is caught per-marker and logged loudly — never thrown", async () => {
+		const markerService = {
+			listByMailboxId: async () => [marker()],
+		} as unknown as IMessageFlagPushRepository;
+
+		const { log, errors } = buildLogger();
+
+		await assert.doesNotReject(
+			drainPendingFlagPushes(markerService, account, "mbx-1", log, async () => {
+				throw Object.assign(new Error("queue down"), { code: "ECONNREFUSED" });
+			}),
+		);
+
+		const alerted = errors.find(
+			(e) => e.fields.alert === "flag_push_drain_rearm_failed",
+		);
+		assert.ok(
+			alerted,
+			"expected an alertable flag_push_drain_rearm_failed log",
+		);
+	});
+
+	it("a re-arm failure for one marker does not stop the others from being re-armed", async () => {
+		const markerService = {
+			listByMailboxId: async () => [
+				marker({ messageId: "will-fail", flagName: "\\Seen" }),
+				marker({ messageId: "will-succeed", flagName: "\\Flagged" }),
+			],
+		} as unknown as IMessageFlagPushRepository;
+
+		const emitted: unknown[] = [];
+		const { log } = buildLogger();
+
+		await drainPendingFlagPushes(
+			markerService,
+			account,
+			"mbx-1",
+			log,
+			async (event) => {
+				if (
+					(event as unknown as { messageId: string }).messageId === "will-fail"
+				) {
+					throw new Error("queue down");
+				}
+				emitted.push(event);
+			},
+		);
+
+		assert.equal(emitted.length, 1);
+		assert.equal(
+			(emitted[0] as { messageId: string }).messageId,
+			"will-succeed",
+		);
+	});
+});