@remit/account-worker 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/account-worker",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/config.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { afterEach, describe, it } from "node:test";
 import { AwsQueryProtocol } from "@aws-sdk/core/protocols";
-import { getSqsClient } from "./config.js";
+import { getImapWorkerQueueUrl, getSqsClient } from "./config.js";
 
 // The queue URL a self-hosted compose stack hands the account worker
 // (deploy/vps/remit.env.template). It is a plain http:// URL that is not
@@ -35,3 +35,25 @@ describe("getSqsClient", () => {
 		assert.notEqual(getSqsClient(composeQueueUrl), getSqsClient(awsQueueUrl));
 	});
 });
+
+describe("getImapWorkerQueueUrl", () => {
+	// The imap-worker stop queue is optional: the self-host compose stacks do not
+	// provision it, and reading it through expect-env would throw and abort the
+	// deletion fanout before it ever reached the finalize step. It must yield
+	// undefined when unset so the fanout can skip the (no-op) stop signal.
+	const prev = process.env.SQS_QUEUE_URL_IMAP_WORKER;
+	afterEach(() => {
+		if (prev === undefined) delete process.env.SQS_QUEUE_URL_IMAP_WORKER;
+		else process.env.SQS_QUEUE_URL_IMAP_WORKER = prev;
+	});
+
+	it("returns undefined when the var is unset instead of throwing", () => {
+		delete process.env.SQS_QUEUE_URL_IMAP_WORKER;
+		assert.equal(getImapWorkerQueueUrl(), undefined);
+	});
+
+	it("returns the configured value when set", () => {
+		process.env.SQS_QUEUE_URL_IMAP_WORKER = "http://queue/imap-worker";
+		assert.equal(getImapWorkerQueueUrl(), "http://queue/imap-worker");
+	});
+});

package/src/config.ts

@@ -28,8 +28,14 @@ export const getSqsClient = (queueUrl: string): SQSClient => {
 // sites.
 export const getSearchIndexQueueUrl = (): string =>
 	env.SQS_QUEUE_URL_SEARCH_INDEX;
-export const getImapWorkerQueueUrl = (): string =>
-	env.SQS_QUEUE_URL_IMAP_WORKER;
+// Optional, and read through `process.env` rather than expect-env so an unset
+// var yields undefined instead of throwing. IMAP_WORKER_STOP is a no-op
+// acknowledgement in the cascade contract — the account tombstone fence is what
+// actually halts the worker — so a deployment that never provisions a dedicated
+// imap-worker stop queue (the self-host compose stacks) skips the signal rather
+// than failing the whole fanout. AWS sets the var and keeps sending it.
+export const getImapWorkerQueueUrl = (): string | undefined =>
+	process.env.SQS_QUEUE_URL_IMAP_WORKER;
 export const getAccountFinalizeQueueUrl = (): string =>
 	env.SQS_QUEUE_URL_ACCOUNT_FINALIZE;
 export const getAccountPurgeDeleteQueueUrl = (): string =>

package/src/handlers/account-fanout.test.ts

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { SQSClient } from "@aws-sdk/client-sqs";
+import type { Logger } from "@remit/logger-lambda";
+import type { CascadeServices } from "../cascade.js";
+import type { AccountDeleteEvent } from "../events.js";
+import { processAccountFanout } from "./account-fanout.js";
+
+const noopLog = {
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {},
+	fatal: () => {},
+	trace: () => {},
+	child: () => noopLog,
+} as unknown as Logger;
+
+// A CascadeServices fake with one account and no data: enough for
+// enumerateCascadeEntities to yield a single Account row (so the stop-signal
+// loop has one accountId to iterate) without standing up a database.
+const buildServices = (): CascadeServices =>
+	({
+		accountConfigService: {
+			get: async () => ({ userId: "user-1" }),
+			describe: async () => ({
+				account: [{ accountId: "acc-1" }],
+				address: [],
+			}),
+		},
+		accountService: {
+			describe: async () => ({ mailbox: [] }),
+		},
+		messageService: {
+			listAllByMailbox: async () => [],
+			describe: async () => ({}),
+		},
+		outboxMessageService: { listByAccount: async () => ({ items: [] }) },
+		mailboxLockService: { listByAccount: async () => [] },
+		messagePlacementMoveService: { listByAccountId: async () => [] },
+		messageFlagPushService: { listByAccountId: async () => [] },
+		threadMessageService: { listAllByAccount: async () => [] },
+		accountSettingService: { listByAccountConfig: async () => [] },
+		filterService: { listByAccountConfig: async () => [] },
+		filterAnchorService: { get: async () => null },
+		labelService: { listByAccountConfig: async () => [] },
+		messageLabelService: { listByLabelId: async () => [] },
+	}) as unknown as CascadeServices;
+
+interface SentMessage {
+	queueUrl: string | undefined;
+	body: { type?: string; accountId?: string };
+}
+
+const recordingSqs = (sent: SentMessage[]): SQSClient =>
+	({
+		send: async (command: {
+			input: { QueueUrl?: string; MessageBody?: string };
+		}) => {
+			sent.push({
+				queueUrl: command.input.QueueUrl,
+				body: JSON.parse(command.input.MessageBody ?? "{}"),
+			});
+			return {};
+		},
+	}) as unknown as SQSClient;
+
+const deleteEvent: AccountDeleteEvent = {
+	type: "AccountDelete",
+	accountConfigId: "cfg-1",
+};
+
+describe("processAccountFanout — imap-worker stop signal on account delete", () => {
+	const prev = process.env.SQS_QUEUE_URL_IMAP_WORKER;
+	afterEach(() => {
+		if (prev === undefined) delete process.env.SQS_QUEUE_URL_IMAP_WORKER;
+		else process.env.SQS_QUEUE_URL_IMAP_WORKER = prev;
+	});
+
+	it("skips the stop signal when no imap-worker queue is configured, still enqueuing finalize", async () => {
+		delete process.env.SQS_QUEUE_URL_IMAP_WORKER;
+		const sent: SentMessage[] = [];
+
+		await processAccountFanout(deleteEvent, noopLog, {
+			services: buildServices(),
+			sqs: recordingSqs(sent),
+			signOut: async () => {},
+			accountFinalizeQueueUrl: "http://queue/finalize",
+		});
+
+		const stops = sent.filter((m) => m.body.type === "IMAP_WORKER_STOP");
+		const finalize = sent.filter(
+			(m) => m.body.type === "FinalizeAccountDelete",
+		);
+		assert.equal(stops.length, 0, "no stop signal without a configured queue");
+		assert.equal(finalize.length, 1, "finalize is still enqueued");
+	});
+
+	it("enqueues one stop signal per account when a queue is configured", async () => {
+		const sent: SentMessage[] = [];
+
+		await processAccountFanout(deleteEvent, noopLog, {
+			services: buildServices(),
+			sqs: recordingSqs(sent),
+			signOut: async () => {},
+			imapWorkerQueueUrl: "http://queue/imap",
+			accountFinalizeQueueUrl: "http://queue/finalize",
+		});
+
+		const stops = sent.filter((m) => m.body.type === "IMAP_WORKER_STOP");
+		assert.equal(stops.length, 1, "one stop signal for the single account");
+		assert.equal(stops[0]?.queueUrl, "http://queue/imap");
+		assert.equal(stops[0]?.body.accountId, "acc-1");
+		assert.equal(
+			sent.filter((m) => m.body.type === "FinalizeAccountDelete").length,
+			1,
+		);
+	});
+});

package/src/handlers/account-fanout.ts

@@ -98,22 +98,33 @@ const processAccountDelete = async (
 		.filter((e) => e.entityType === "Account")
 		.map((e) => e.key.accountId);
 
-	for (const accountId of accountIds) {
-		await sqsFor(imapWorkerQueueUrl).send(
-			new SendMessageCommand({
-				QueueUrl: imapWorkerQueueUrl,
-				MessageBody: JSON.stringify({
-					type: "IMAP_WORKER_STOP",
-					accountConfigId,
-					accountId,
+	// IMAP_WORKER_STOP is a no-op acknowledgement — the account tombstone fence
+	// (isActive=false + deletedAt) is what actually halts the worker. Deployments
+	// that provision a dedicated imap-worker stop queue get the signal; the
+	// self-host stacks, which do not, skip it and let the fence do the work.
+	if (imapWorkerQueueUrl) {
+		for (const accountId of accountIds) {
+			await sqsFor(imapWorkerQueueUrl).send(
+				new SendMessageCommand({
+					QueueUrl: imapWorkerQueueUrl,
+					MessageBody: JSON.stringify({
+						type: "IMAP_WORKER_STOP",
+						accountConfigId,
+						accountId,
+					}),
 				}),
-			}),
+			);
+		}
+		log.info(
+			{ accountConfigId, count: accountIds.length },
+			"Enqueued imap-worker stop signals",
+		);
+	} else {
+		log.info(
+			{ accountConfigId, count: accountIds.length },
+			"No imap-worker stop queue configured; skipping stop signals (tombstone fence halts the worker)",
 		);
 	}
-	log.info(
-		{ accountConfigId, count: accountIds.length },
-		"Enqueued imap-worker stop signals",
-	);
 
 	await signOut(userId, log);
 

package/src/poller.ts

@@ -9,11 +9,14 @@ import { fanoutHandler, finalizeHandler } from "./index.js";
  * CI (see AGENTS.md worker roster notes). This is the standalone
  * production entrypoint for the dedicated image.
  *
- * The fanout worker's Cognito sign-out and the finalize worker's CloudFront
- * invalidation are AWS-only calls with no portable counterpart yet — on a
- * non-AWS deployment those specific steps of the deletion cascade will
- * error if account deletion is exercised. That is a pre-existing gap in
- * the application code, not something this packaging change fixes.
+ * The deployment-specific steps of the cascade — sign-out, content
+ * invalidation, storage cleanup, and the row cascade — resolve through the
+ * deletion capabilities seam (deletion-capabilities.ts): AWS runs Cognito
+ * global sign-out and CloudFront invalidation; the relational self-host
+ * backends run the no-op counterparts and a filesystem/Drizzle cascade. The
+ * imap-worker stop signal is a no-op acknowledgement whose queue is optional,
+ * skipped where it is not provisioned. Account deletion completes on every
+ * deployment flavor.
  */
 const log = createLogger();