@remit/account-worker 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/account-worker",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -41,12 +41,12 @@
     "@remit/sqs-client": "*",
     "@remit/storage-service": "*",
     "@remit/electrodb-entities": "*",
-    "@aws-sdk/client-sqs": "*",
-    "archiver": "*",
-    "electrodb": "*",
-    "expect-env": "*",
-    "@types/archiver": "*",
-    "@types/aws-lambda": "*"
+    "@aws-sdk/client-sqs": "^3.1090.0",
+    "archiver": "^8.0.0",
+    "electrodb": "^3.9.1",
+    "expect-env": "^1.0.1",
+    "@types/archiver": "^8.0.0",
+    "@types/aws-lambda": "^8.10.162"
   },
   "devDependencies": {
     "@aws-sdk/core": "*",

package/src/config.ts

@@ -1,44 +1,42 @@
-import type { SQSClient } from "@aws-sdk/client-sqs";
 import { getClient } from "@remit/backend/client";
-import { createQueueProducer } from "@remit/sqs-client/producer";
+import type { GroupedQueueProducer, QueueProducer } from "@remit/data-ports";
+import {
+	createGroupedQueueProducer,
+	createStandardQueueProducer,
+} from "@remit/sqs-client/producer";
 import type { StorageService } from "@remit/storage-service";
 import { createStorageService } from "@remit/storage-service/s3";
 import { env } from "expect-env";
 import type { CascadeServices } from "./cascade.js";
-
-// A client per queue URL, resolved at send time rather than at import. The
-// endpoint and wire protocol are derived from the URL, so a self-hosted stack
-// (http://queue:9324/...) gets the query protocol its queue server speaks while
-// real SQS keeps the default. Building at import is not an option: the queue
-// URLs are read lazily for the reason given below.
-const sqsClients = new Map<string, SQSClient>();
-
-export const getSqsClient = (queueUrl: string): SQSClient => {
-	const existing = sqsClients.get(queueUrl);
-	if (existing) return existing;
-	const client = createQueueProducer({ queueUrl });
-	sqsClients.set(queueUrl, client);
-	return client;
-};
+import type {
+	AccountDataPurgeFinalizeEvent,
+	AccountFinalizeEvent,
+} from "./events.js";
 
 // SQS env vars are lazy-evaluated. The fanout worker needs them at handler time;
 // the finalize worker imports `getCascadeServices` from this module but talks to
 // no queue, so its Lambda doesn't carry the env vars. Eager evaluation here would
 // crash finalize at module load — getters defer the read to the fanout-only call
 // sites.
-// 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 =>
 	env.SQS_QUEUE_URL_ACCOUNT_PURGE_DELETE;
 
+export interface FanoutQueues {
+	accountFinalize: QueueProducer<AccountFinalizeEvent>;
+	accountPurgeDelete: GroupedQueueProducer<AccountDataPurgeFinalizeEvent>;
+}
+
+export const sqsFanoutQueues = (): FanoutQueues => ({
+	accountFinalize: createStandardQueueProducer({
+		queueUrl: getAccountFinalizeQueueUrl(),
+	}),
+	accountPurgeDelete: createGroupedQueueProducer({
+		queueUrl: getAccountPurgeDeleteQueueUrl(),
+	}),
+});
+
 // The RemitClient is resolved lazily and cached, not at module load: the
 // DynamoDB backend is injected by the composition root before the first cascade
 // runs, so building at import time would race the registration.

package/src/events.ts

@@ -1,74 +1,11 @@
-import type { ThreadMessageItem } from "@remit/data-ports";
-
-type MessageCategoryValue = ThreadMessageItem["category"];
-
-export type AccountDeleteEvent = {
-	type: "AccountDelete";
-	accountConfigId: string;
-};
-
-/**
- * Per-account hard-delete. Purges ONE mail account's data (mailboxes,
- * messages, body parts, thread messages, S3 objects) while
- * keeping the AccountConfig/tenant and any sibling accounts intact. Emitted
- * by the API on `deleteAccount`; consumed by the fanout worker.
- */
-export type AccountDataPurgeEvent = {
-	type: "AccountDataPurge";
-	accountId: string;
-	accountConfigId: string;
-};
-
-export type AccountExportEvent = {
-	type: "AccountExport";
-	accountConfigId: string;
-	accountExportRequestId: string;
-};
-
-/**
- * A "all like these" back-apply job (RFC 034, #1278). Rides the same
- * account-fanout queue as export: the API writes a Pending OrganizeJobRequest
- * row and enqueues this; the fanout worker matches the corpus and applies the
- * action, driving the row to Complete/Failed. Never creates a Filter row.
- */
-export type OrganizeJobEvent = {
-	type: "OrganizeJob";
-	accountConfigId: string;
-	organizeJobId: string;
-};
-
-/**
- * Retroactive half of a sender-category override (#415, RFC 039 Decision 3).
- * Rides the same account-fanout queue as the organize back-apply: the API
- * enqueues one when `Address.flags.category` is SET, and the fanout worker
- * re-labels a bounded recent batch of that sender's already-classified mail.
- * A CLEAR never enqueues one: reverting to auto-classification says nothing
- * about what the classifier would have answered, and re-deriving it would need
- * every message's body back.
- *
- * `category` and `categorySetAt` together name WHICH set this job was fired
- * for, and the worker refuses a job whose set no longer stands on the Address.
- * That check is what the standard queue's semantics make necessary rather than
- * merely tidy: delivery is at-least-once and unordered, so without it a job
- * that fails and redelivers after the user has corrected the category re-labels
- * those 500 messages back to the superseded one, leaving the flag and the mail
- * permanently disagreeing with nothing to reconcile them.
- */
-export type SenderCategoryBackApplyEvent = {
-	type: "SenderCategoryBackApply";
-	accountConfigId: string;
-	addressId: string;
-	normalizedEmail: string;
-	category: MessageCategoryValue;
-	categorySetAt: number;
-};
-
-export type AccountFanoutEvent =
-	| AccountDeleteEvent
-	| AccountDataPurgeEvent
-	| AccountExportEvent
-	| OrganizeJobEvent
-	| SenderCategoryBackApplyEvent;
+export type {
+	AccountDataPurgeEvent,
+	AccountDeleteEvent,
+	AccountExportEvent,
+	AccountFanoutEvent,
+	OrganizeJobEvent,
+	SenderCategoryBackApplyEvent,
+} from "@remit/data-ports";
 
 export type AccountDeleteFinalizeEvent = {
 	type: "FinalizeAccountDelete";

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

@@ -1,108 +1,37 @@
 import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import type { SQSClient } from "@aws-sdk/client-sqs";
+import { describe, it } from "node:test";
+import { recordingQueue } from "@remit/data-ports/recording-queue";
 import { noopLogger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
 import type { AccountDeleteEvent } from "../events.js";
 import { processAccountFanout } from "./account-fanout.js";
 
-// 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 () => [] },
-		labelService: { listByAccountConfig: async () => [] },
-		messageLabelService: { listByLabelId: async () => [] },
+		accountConfigService: { get: async () => ({ userId: "user-1" }) },
 	}) 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, noopLogger, {
-			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[] = [];
+describe("processAccountFanout on account delete", () => {
+	it("enqueues the finalize step", async () => {
+		const accountFinalize = recordingQueue();
 
 		await processAccountFanout(deleteEvent, noopLogger, {
+			queues: {
+				accountFinalize,
+				accountPurgeDelete: recordingQueue().grouped,
+			},
 			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,
+		assert.deepEqual(
+			accountFinalize.sent.map((m) => m.body.type),
+			["FinalizeAccountDelete"],
 		);
 	});
 });

package/src/handlers/account-fanout.ts

@@ -1,4 +1,3 @@
-import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
 import { createLogger, type Logger } from "@remit/logger";
 import {
 	queueNameFromEventSource,
@@ -7,13 +6,10 @@ import {
 import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
 import type { SQSBatchResponse, SQSEvent, SQSHandler } from "aws-lambda";
 import type { CascadeServices } from "../cascade.js";
-import { enumerateCascadeEntities } from "../cascade.js";
 import {
-	getAccountFinalizeQueueUrl,
-	getAccountPurgeDeleteQueueUrl,
+	type FanoutQueues,
 	getCascadeServices,
-	getImapWorkerQueueUrl,
-	getSqsClient,
+	sqsFanoutQueues,
 } from "../config.js";
 import {
 	type DeletionCapabilities,
@@ -32,36 +28,22 @@ import { processSenderCategoryBackApply } from "./sender-category-backapply.js";
 installNodeLogger();
 
 export interface ProcessAccountFanoutDeps {
+	queues: FanoutQueues;
 	services?: CascadeServices;
-	sqs?: SQSClient;
 	signOut?: DeletionCapabilities["signOut"];
-	imapWorkerQueueUrl?: string;
-	accountFinalizeQueueUrl?: string;
-	accountPurgeDeleteQueueUrl?: string;
 }
 
-/**
- * Fanout step of the account-deletion cascade. Read-only: enumerates the
- * AccountConfig's data and dispatches downstream work — per-account
- * imap-worker stops, a sign-out, and the finalize
- * enqueue. Throws on any non-swallowable error so SQS partial batch-failure
- * retries the whole record.
- */
 export const processAccountFanout = async (
 	event: AccountFanoutEvent,
 	log: Logger,
-	deps: ProcessAccountFanoutDeps = {},
+	deps: ProcessAccountFanoutDeps,
 ): Promise<void> => {
 	const services = deps.services ?? (await getCascadeServices());
-	const sqsFor = (queueUrl: string): SQSClient =>
-		deps.sqs ?? getSqsClient(queueUrl);
 
 	if (event.type === "AccountDataPurge") {
 		await processAccountDataPurge(event, log, {
 			services,
-			sqs: deps.sqs,
-			accountPurgeDeleteQueueUrl:
-				deps.accountPurgeDeleteQueueUrl ?? getAccountPurgeDeleteQueueUrl(),
+			queue: deps.queues.accountPurgeDelete,
 		});
 		return;
 	}
@@ -81,81 +63,42 @@ export const processAccountFanout = async (
 		return;
 	}
 
-	await processAccountDelete(event, log, services, sqsFor, deps);
+	await processAccountDelete(event, log, services, deps);
 };
 
 const processAccountDelete = async (
 	event: AccountDeleteEvent,
 	log: Logger,
 	services: CascadeServices,
-	sqsFor: (queueUrl: string) => SQSClient,
 	deps: ProcessAccountFanoutDeps,
 ): Promise<void> => {
 	const { accountConfigId } = event;
 	const signOut = deps.signOut ?? (await getDeletionCapabilities()).signOut;
-	const imapWorkerQueueUrl = deps.imapWorkerQueueUrl ?? getImapWorkerQueueUrl();
-	const accountFinalizeQueueUrl =
-		deps.accountFinalizeQueueUrl ?? getAccountFinalizeQueueUrl();
+	const { accountFinalize } = deps.queues;
 
 	const accountConfig =
 		await services.accountConfigService.get(accountConfigId);
 	const userId = accountConfig.userId;
 
-	const { entities, messageIds: _messageIds } = await enumerateCascadeEntities(
-		accountConfigId,
-		services,
-		log,
-	);
-
-	const accountIds = entities
-		.filter((e) => e.entityType === "Account")
-		.map((e) => e.key.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)",
-		);
-	}
-
 	await signOut(userId, log);
 
 	const finalizeEvent: AccountFinalizeEvent = {
 		type: "FinalizeAccountDelete",
 		accountConfigId,
 	};
-	await sqsFor(accountFinalizeQueueUrl).send(
-		new SendMessageCommand({
-			QueueUrl: accountFinalizeQueueUrl,
-			MessageBody: JSON.stringify(finalizeEvent),
-		}),
-	);
+	await accountFinalize.send({ body: finalizeEvent });
 	log.info({ accountConfigId }, "Enqueued finalize event");
 };
 
 const log = createLogger();
 
+let fanoutQueues: FanoutQueues | null = null;
+
+const composedQueues = (): FanoutQueues => {
+	fanoutQueues ??= sqsFanoutQueues();
+	return fanoutQueues;
+};
+
 export const handler: SQSHandler = withTelemetry(
 	async (event: SQSEvent): Promise<SQSBatchResponse> => {
 		const batchItemFailures: { itemIdentifier: string }[] = [];
@@ -171,7 +114,9 @@ export const handler: SQSHandler = withTelemetry(
 			);
 
 			const start = Date.now();
-			const failed = await processAccountFanout(fanoutEvent, log)
+			const failed = await processAccountFanout(fanoutEvent, log, {
+				queues: composedQueues(),
+			})
 				.then(() => false)
 				.catch((error) => {
 					log.error(

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

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import type { SQSClient } from "@aws-sdk/client-sqs";
+import {
+	type RecordingQueue,
+	recordingQueue,
+} from "@remit/data-ports/recording-queue";
 import { noopLogger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
 import type { AccountDataPurgeEvent } from "../events.js";
@@ -9,26 +12,6 @@ import {
 	processAccountDataPurge,
 } from "./account-purge.js";
 
-interface Sent {
-	queueUrl: string | undefined;
-	body: Record<string, unknown>;
-}
-
-const recordingSqs = (sent: Sent[]): SQSClient =>
-	({
-		send: async (command: {
-			input: { QueueUrl?: string; MessageBody?: string };
-		}) => {
-			sent.push({
-				queueUrl: command.input.QueueUrl,
-				body: command.input.MessageBody
-					? JSON.parse(command.input.MessageBody)
-					: {},
-			});
-			return {};
-		},
-	}) as unknown as SQSClient;
-
 const buildServices = (
 	manifest: Array<{
 		threadMessageId: string;
@@ -54,25 +37,21 @@ const event: AccountDataPurgeEvent = {
 	accountConfigId: "cfg-1",
 };
 
-const baseDeps = (
-	sent: Sent[],
-	overrides: Partial<ProcessPurgeFanoutDeps> = {},
-): ProcessPurgeFanoutDeps => ({
+const baseDeps = (queue: RecordingQueue): ProcessPurgeFanoutDeps => ({
 	services: buildServices([
 		{ threadMessageId: "tm-1", messageId: "msg-1", mailboxId: "mbx-1" },
 		{ threadMessageId: "tm-2", messageId: "msg-2", mailboxId: "mbx-1" },
 	]),
-	sqs: recordingSqs(sent),
-	accountPurgeDeleteQueueUrl: "http://queue/purge",
-	...overrides,
+	queue: queue.grouped,
 });
 
 describe("processAccountDataPurge", () => {
 	it("enqueues a subtrees batch and one container leftover", async () => {
-		const sent: Sent[] = [];
-		await processAccountDataPurge(event, noopLogger, baseDeps(sent));
+		const queue = recordingQueue();
+		await processAccountDataPurge(event, noopLogger, baseDeps(queue));
 
-		const finalize = sent.filter((m) => m.queueUrl === "http://queue/purge");
+		const finalize = queue.sent;
+		assert.ok(finalize.every((m) => m.groupId === "cfg-1"));
 		const kinds = finalize.map((m) => m.body.kind);
 		assert.deepEqual(kinds, ["subtrees", "container"]);
 		assert.equal(
@@ -83,23 +62,23 @@ describe("processAccountDataPurge", () => {
 	});
 
 	it("drops manifest rows outside the account's mailbox set", async () => {
-		const sent: Sent[] = [];
+		const queue = recordingQueue();
 		await processAccountDataPurge(event, noopLogger, {
-			...baseDeps(sent),
+			...baseDeps(queue),
 			services: buildServices([
 				{ threadMessageId: "tm-1", messageId: "msg-1", mailboxId: "mbx-1" },
 				{ threadMessageId: "tm-9", messageId: "msg-9", mailboxId: "other" },
 			]),
 		});
 
-		const subtrees = sent.find((m) => m.body.kind === "subtrees");
+		const subtrees = queue.sent.find((m) => m.body.kind === "subtrees");
 		assert.equal((subtrees?.body.items as unknown[])?.length, 1);
 	});
 
 	it("no-ops when the account is already gone", async () => {
-		const sent: Sent[] = [];
+		const queue = recordingQueue();
 		await processAccountDataPurge(event, noopLogger, {
-			...baseDeps(sent),
+			...baseDeps(queue),
 			services: {
 				accountService: {
 					describe: async () => {
@@ -112,14 +91,18 @@ describe("processAccountDataPurge", () => {
 			} as unknown as CascadeServices,
 		});
 
-		assert.equal(sent.length, 0, "nothing enqueued for a missing account");
+		assert.equal(
+			queue.sent.length,
+			0,
+			"nothing enqueued for a missing account",
+		);
 	});
 
 	it("rethrows a non-NotFound describe error", async () => {
-		const sent: Sent[] = [];
+		const queue = recordingQueue();
 		await assert.rejects(
 			processAccountDataPurge(event, noopLogger, {
-				...baseDeps(sent),
+				...baseDeps(queue),
 				services: {
 					accountService: {
 						describe: async () => {

package/src/handlers/account-purge.ts

@@ -1,11 +1,7 @@
-import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
+import type { GroupedQueueProducer } from "@remit/data-ports";
 import type { Logger } from "@remit/logger";
 import type { CascadeServices } from "../cascade.js";
-import {
-	getAccountPurgeDeleteQueueUrl,
-	getCascadeServices,
-	getSqsClient,
-} from "../config.js";
+import { getCascadeServices } from "../config.js";
 import type {
 	AccountDataPurgeEvent,
 	AccountDataPurgeFinalizeEvent,
@@ -13,9 +9,8 @@ import type {
 } from "../events.js";
 
 export interface ProcessPurgeFanoutDeps {
+	queue: GroupedQueueProducer<AccountDataPurgeFinalizeEvent>;
 	services?: CascadeServices;
-	sqs?: SQSClient;
-	accountPurgeDeleteQueueUrl?: string;
 }
 
 /**
@@ -36,20 +31,13 @@ const SUBTREE_BATCH_SIZE = 100;
  * window; beyond it, the worker's deletes are no-ops on already-gone rows.
  */
 const enqueuePurgeFinalize = async (
-	sqs: SQSClient,
-	queueUrl: string,
+	queue: GroupedQueueProducer<AccountDataPurgeFinalizeEvent>,
 	accountId: string,
 	accountConfigId: string,
 	items: AccountDataPurgeSubtreeItem[],
 ): Promise<void> => {
-	const send = (event: AccountDataPurgeFinalizeEvent): Promise<unknown> =>
-		sqs.send(
-			new SendMessageCommand({
-				QueueUrl: queueUrl,
-				MessageBody: JSON.stringify(event),
-				MessageGroupId: accountConfigId,
-			}),
-		);
+	const send = (event: AccountDataPurgeFinalizeEvent): Promise<void> =>
+		queue.send({ body: event, groupId: accountConfigId });
 
 	for (let i = 0; i < items.length; i += SUBTREE_BATCH_SIZE) {
 		await send({
@@ -90,12 +78,10 @@ const enqueuePurgeFinalize = async (
 export const processAccountDataPurge = async (
 	event: AccountDataPurgeEvent,
 	log: Logger,
-	deps: ProcessPurgeFanoutDeps = {},
+	deps: ProcessPurgeFanoutDeps,
 ): Promise<void> => {
 	const { accountId, accountConfigId } = event;
 	const services = deps.services ?? (await getCascadeServices());
-	const accountPurgeDeleteQueueUrl =
-		deps.accountPurgeDeleteQueueUrl ?? getAccountPurgeDeleteQueueUrl();
 
 	let mailboxIds: Set<string>;
 	try {
@@ -121,13 +107,7 @@ export const processAccountDataPurge = async (
 			messageId: tm.messageId,
 		}));
 
-	await enqueuePurgeFinalize(
-		deps.sqs ?? getSqsClient(accountPurgeDeleteQueueUrl),
-		accountPurgeDeleteQueueUrl,
-		accountId,
-		accountConfigId,
-		items,
-	);
+	await enqueuePurgeFinalize(deps.queue, accountId, accountConfigId, items);
 	log.info(
 		{
 			accountConfigId,

package/src/handlers/organize-job.test.ts

@@ -8,6 +8,7 @@ import {
 } from "@remit/backend/organize";
 import type { FilterItem } from "@remit/data-ports";
 import { NotFoundError } from "@remit/data-ports/errors";
+import { recordingQueue } from "@remit/data-ports/recording-queue";
 import {
 	createSqliteRepositories,
 	type DrizzleThreadMessageRepository,
@@ -39,6 +40,7 @@ const jobClient = (
 	literalClauses: Array<{ field: string; value: string }>,
 ): RemitClient =>
 	({
+		queues: { messageManagement: recordingQueue() },
 		organizeJobRequest: {
 			get: async () => ({
 				organizeJobId: "job-1",

package/src/config.test.ts

@@ -1,54 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { AwsQueryProtocol } from "@aws-sdk/core/protocols";
-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
-// localhost, which is exactly the case the endpoint heuristic used to miss.
-const composeQueueUrl =
-	"http://queue:9324/000000000000/remit-account-purge-delete.fifo";
-const awsQueueUrl =
-	"https://sqs.eu-west-1.amazonaws.com/123456789012/remit-account-purge-delete.fifo";
-
-describe("getSqsClient", () => {
-	// Regression: the account-deletion cascade sends through this client. It
-	// used to be built once at import with no endpoint and no protocol, so on a
-	// self-hosted stack every cascade send went to real SQS instead of the local
-	// queue server and account deletion never completed.
-	it("selects the query protocol and the queue origin for a compose-stack queue URL", async () => {
-		const client = getSqsClient(composeQueueUrl);
-		assert.equal(client.config.protocol instanceof AwsQueryProtocol, true);
-		const endpoint = await client.config.endpoint?.();
-		assert.equal(endpoint?.hostname, "queue");
-		assert.equal(endpoint?.port, 9324);
-	});
-
-	it("leaves the default protocol and endpoint for a real SQS queue URL", async () => {
-		const client = getSqsClient(awsQueueUrl);
-		assert.equal(client.config.protocol instanceof AwsQueryProtocol, false);
-		assert.equal(client.config.endpoint, undefined);
-	});
-
-	it("reuses one client per queue URL and keeps distinct queues apart", () => {
-		assert.equal(getSqsClient(composeQueueUrl), getSqsClient(composeQueueUrl));
-		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);
-	});
-});