@remit/imap-worker 0.0.88 → 0.0.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.88",
+  "version": "0.0.90",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -53,11 +53,11 @@
     "@remit/domain-enums": "*",
     "@remit/mail-oauth-service": "*",
     "@remit/secrets-service": "*",
-    "@aws-sdk/client-sqs": "*",
-    "@aws-sdk/client-ssm": "*",
-    "expect-env": "*",
-    "p-map": "*",
-    "@types/aws-lambda": "*"
+    "@aws-sdk/client-sqs": "^3.1090.0",
+    "@aws-sdk/client-ssm": "^3.1090.0",
+    "expect-env": "^1.0.1",
+    "p-map": "^2.1.0",
+    "@types/aws-lambda": "^8.10.162"
   },
   "license": "MIT",
   "publishConfig": {

package/src/cli.ts

@@ -6,7 +6,8 @@
 // in npm-scripts/docker-bundle.mjs). Do not route it through the logger — usage
 // text and argument errors are for the person who typed the command.
 import { parseArgs } from "node:util";
-import { emitEvent } from "./emit.js";
+import { createEmitEvent } from "./emit.js";
+import { sqsWorkerQueues, workerQueueUrlsFromEnv } from "./queues.js";
 
 const HELP = `
 remit-imap-worker - Process IMAP sync events
@@ -206,7 +207,7 @@ const event = buildEvent();
 
 console.log(`Enqueueing ${event.type} event for account ${event.accountId}...`);
 
-emitEvent(event)
+createEmitEvent(sqsWorkerQueues(workerQueueUrlsFromEnv()))(event)
 	.then(() => {
 		console.log("Event enqueued successfully");
 		process.exit(0);

package/src/credential-less-sync-fence.test.ts

@@ -18,7 +18,7 @@ import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { after, describe, it } from "node:test";
 import { fileURLToPath } from "node:url";
-import { buildSyncMailboxesCommand } from "@remit/backend/trigger-sync";
+import { buildSyncMailboxesMessage } from "@remit/backend/trigger-sync";
 import type { AccountItem } from "@remit/data-ports";
 import { ConnectionState } from "@remit/domain-enums";
 import {
@@ -33,7 +33,6 @@ import {
 } from "./with-oauth-lifecycle.js";
 
 const QUEUE_NAME = "remit-mailboxes.fifo";
-const QUEUE_URL = `http://localhost:9324/000000000000/${QUEUE_NAME}`;
 const ACCOUNT_ID = "acct_imported";
 const T0 = 1_700_000_000_000;
 
@@ -69,15 +68,12 @@ const importedAccount = {
 } as unknown as AccountItem;
 
 const enqueueSync = (store: QueueStore, now: number): void => {
-	const command = buildSyncMailboxesCommand({
-		queueUrl: QUEUE_URL,
-		accountId: ACCOUNT_ID,
-	});
+	const message = buildSyncMailboxesMessage({ accountId: ACCOUNT_ID });
 	store.sendMessage({
 		queueName: QUEUE_NAME,
-		body: command.input.MessageBody ?? "",
-		groupId: command.input.MessageGroupId,
-		deduplicationId: command.input.MessageDeduplicationId,
+		body: JSON.stringify(message.body),
+		groupId: message.groupId,
+		deduplicationId: message.deduplicationId,
 		now,
 	});
 };

package/src/e2e-processor-shim.ts

@@ -7,7 +7,7 @@ import {
 } from "@aws-sdk/client-sqs";
 import { createLogger } from "@remit/logger";
 import { installNodeLogger } from "@remit/logger-lambda/node";
-import { createQueueProducer } from "@remit/sqs-client/producer";
+import { createSqsClient } from "@remit/sqs-client/producer";
 import type { Context, SQSBatchResponse, SQSEvent } from "aws-lambda";
 import { env } from "expect-env";
 import { handler } from "./index.js";
@@ -101,7 +101,7 @@ if (cluster.isPrimary) {
 
 	const maxMessages = 10; // SQS API limit
 
-	const sqs = createQueueProducer({ queueUrl });
+	const sqs = createSqsClient({ queueUrl });
 
 	let isShuttingDown = false;
 

package/src/emit.test.ts

@@ -1,53 +1,42 @@
 import assert from "node:assert/strict";
-import { afterEach, before, beforeEach, describe, it } from "node:test";
-import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import { afterEach, beforeEach, describe, it } from "node:test";
 import {
 	_resetForTest,
 	type RemitClient,
 	setClient,
 } from "@remit/backend/client";
+import {
+	type RecordingQueue,
+	recordingQueue,
+} from "@remit/data-ports/recording-queue";
 import { MailboxLockRepo } from "@remit/drizzle-service";
 import { createShippedSqliteDb } from "@remit/drizzle-service/test-sqlite";
-import { mockClient } from "aws-sdk-client-mock";
-import type * as Emit from "./emit.js";
+import {
+	createEmitEvent,
+	type EmitEvent,
+	SYNC_MESSAGES_PENDING,
+} from "./emit.js";
 import type {
 	FlagPushEvent,
 	SyncMailboxesEvent,
 	SyncMessageBodyEvent,
 	SyncMessagesEvent,
 } from "./events.js";
+import { workerQueuesOn } from "./test-helpers/worker-queues.js";
 
 type Emitted<T> = Omit<T, "eventId" | "timestamp">;
 
-// The queue urls are read once, at import. Point them at FIFO queues first —
-// this suite is about what emitEvent puts on a FIFO queue, which is what both
-// the self-host stack and the deployed stack run (deploy/vps/queues.json).
-const fifo = (name: string) =>
-	`https://sqs.eu-west-1.amazonaws.com/0/test-${name}.fifo`;
-
-const sqsMock = mockClient(SQSClient);
-
-let emitEvent: typeof Emit.emitEvent;
-let SYNC_MESSAGES_PENDING: typeof Emit.SYNC_MESSAGES_PENDING;
 let locks: MailboxLockRepo;
 let closeStore: () => void;
+let queue: RecordingQueue;
 
-const sentCommands = (): SendMessageCommand["input"][] =>
-	sqsMock.commandCalls(SendMessageCommand).map((call) => call.args[0].input);
+const sentCommands = () => queue.sent;
 
-const bodyOf = (input: SendMessageCommand["input"]): Record<string, unknown> =>
-	JSON.parse(input.MessageBody ?? "{}") as Record<string, unknown>;
-
-before(async () => {
-	process.env.SQS_QUEUE_URL_MAILBOXES = fifo("mailboxes");
-	process.env.SQS_QUEUE_URL_MESSAGES = fifo("messages");
-	process.env.SQS_QUEUE_URL_FLAGS = fifo("flags");
-	({ emitEvent, SYNC_MESSAGES_PENDING } = await import("./emit.js"));
-});
+const emitEvent: EmitEvent = (event) =>
+	createEmitEvent(workerQueuesOn(queue))(event);
 
 beforeEach(() => {
-	sqsMock.reset();
-	sqsMock.on(SendMessageCommand).resolves({});
+	queue = recordingQueue();
 	const store = createShippedSqliteDb();
 	closeStore = store.close;
 	locks = new MailboxLockRepo(store.db);
@@ -71,8 +60,8 @@ describe("emitEvent on a FIFO queue", () => {
 
 		const [sent] = sentCommands();
 		if (!sent) throw new Error("expected a send");
-		assert.equal(sent.MessageGroupId, "acc-1");
-		assert.equal(sent.MessageDeduplicationId, bodyOf(sent).eventId);
+		assert.equal(sent.groupId, "acc-1");
+		assert.equal(sent.deduplicationId, sent.body.eventId);
 	});
 
 	// Issue #37: every SYNC_MESSAGES for a mailbox carried one dedup id, so
@@ -94,16 +83,13 @@ describe("emitEvent on a FIFO queue", () => {
 			"acc-1",
 			"mbx-1",
 			SYNC_MESSAGES_PENDING,
-			String(bodyOf(first).eventId),
+			String(first.body.eventId),
 		);
 		await emitEvent(event);
 
 		const sent = sentCommands();
 		assert.equal(sent.length, 2);
-		assert.notEqual(
-			sent[0]?.MessageDeduplicationId,
-			sent[1]?.MessageDeduplicationId,
-		);
+		assert.notEqual(sent[0]?.deduplicationId, sent[1]?.deduplicationId);
 	});
 
 	it("lets a second sync of the same account's mailbox list through", async () => {
@@ -117,10 +103,7 @@ describe("emitEvent on a FIFO queue", () => {
 
 		const sent = sentCommands();
 		assert.equal(sent.length, 2);
-		assert.notEqual(
-			sent[0]?.MessageDeduplicationId,
-			sent[1]?.MessageDeduplicationId,
-		);
+		assert.notEqual(sent[0]?.deduplicationId, sent[1]?.deduplicationId);
 	});
 
 	// A FIFO queue without content-based deduplication rejects a send carrying
@@ -139,12 +122,12 @@ describe("emitEvent on a FIFO queue", () => {
 
 		const [sent] = sentCommands();
 		if (!sent) throw new Error("expected a send");
-		assert.equal(sent.MessageDeduplicationId, bodyOf(sent).eventId);
+		assert.equal(sent.deduplicationId, sent.body.eventId);
 	});
 });
 
 describe("emitEvent on a standard queue", () => {
-	it("carries no FIFO parameters", async () => {
+	it("sends a body sync with no group or deduplication id", async () => {
 		const event: Emitted<SyncMessageBodyEvent> = {
 			type: "SYNC_MESSAGE_BODY",
 			accountId: "acc-1",
@@ -156,7 +139,7 @@ describe("emitEvent on a standard queue", () => {
 
 		const [sent] = sentCommands();
 		if (!sent) throw new Error("expected a send");
-		assert.equal(sent.MessageGroupId, undefined);
-		assert.equal(sent.MessageDeduplicationId, undefined);
+		assert.equal(sent.groupId, undefined);
+		assert.equal(sent.deduplicationId, undefined);
 	});
 });

package/src/emit.ts

@@ -1,140 +1,115 @@
 import { randomUUID } from "node:crypto";
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { getClient } from "@remit/backend/client";
+import type { FifoQueueProducer, QueueProducer } from "@remit/data-ports";
 import { recordImapFailure } from "@remit/logger-lambda/metrics";
-import {
-	createQueueProducer,
-	isLocalEndpoint,
-} from "@remit/sqs-client/producer";
-import { env } from "expect-env";
 import type { ImapEvent } from "./events.js";
+import type { WorkerQueues } from "./queues.js";
 
 type EventInput = Omit<ImapEvent, "eventId" | "timestamp">;
 
-export const SYNC_MESSAGES_PENDING = "SYNC_MESSAGES_PENDING";
-
-const SYNC_MESSAGES_PENDING_TTL_SECONDS = 300;
-
-const mailboxesQueueUrl = env.SQS_QUEUE_URL_MAILBOXES;
-const messagesQueueUrl = env.SQS_QUEUE_URL_MESSAGES;
-// SYNC_MESSAGE_BODY events route to the single standard body queue (#612). It is
-// a standard (non-FIFO) queue, so isFifoQueue() below skips the FIFO
-// MessageGroupId/dedup parameters automatically.
-const bodyQueueUrl = env.SQS_QUEUE_URL_BODY;
-const flagsQueueUrl = env.SQS_QUEUE_URL_FLAGS;
-const mailboxMgmtQueueUrl = env.SQS_QUEUE_URL_MAILBOX_MGMT;
-const messageMgmtQueueUrl = env.SQS_QUEUE_URL_MESSAGE_MGMT;
-
-const isLocal = isLocalEndpoint(mailboxesQueueUrl);
+export type EmitEvent = (event: EventInput) => Promise<void>;
 
-const sqs = createQueueProducer({ queueUrl: mailboxesQueueUrl });
+type Send = (event: ImapEvent) => Promise<void>;
 
-const queueUrlMap: Record<ImapEvent["type"], string> = {
-	SYNC_MAILBOXES: mailboxesQueueUrl,
-	SYNC_MESSAGES: messagesQueueUrl,
-	SYNC_MESSAGE_BODY: bodyQueueUrl,
-	MAILBOX_CREATE: mailboxMgmtQueueUrl,
-	MAILBOX_RENAME: mailboxMgmtQueueUrl,
-	MAILBOX_DELETE: mailboxMgmtQueueUrl,
-	MESSAGE_DELETE: messageMgmtQueueUrl,
-	MESSAGE_MOVE: messageMgmtQueueUrl,
-	MESSAGE_COPY: messageMgmtQueueUrl,
-	EMPTY_TRASH: messageMgmtQueueUrl,
-	APPEND_SENT_MESSAGE: messageMgmtQueueUrl,
-	// Rides messageMgmtQueue (issue #1271) rather than a dedicated queue — its
-	// payload carries only our message id (never a UID, unlike the legacy
-	// MESSAGE_MOVE event); per-event-type payload shape, same queue.
-	PLACEMENT_MOVE_PUSH: messageMgmtQueueUrl,
-	// Rides the existing flags queue (issue #1273) — this is imap-worker's OWN
-	// re-arm hint (the periodic per-mailbox sync tick catching up a marker
-	// stuck `pending`), distinct from `FlagPushService`'s user-facing hint
-	// (remit-mailbox-service, sent from the API on its own SQS client onto
-	// SQS_QUEUE_URL). Both land on a queue this worker already consumes;
-	// dispatch is by `type`, not by which queue delivered the message.
-	FLAG_PUSH: flagsQueueUrl,
-};
-
-/**
- * Check if queue URL is a FIFO queue (ends with .fifo)
- */
-const isFifoQueue = (queueUrl: string): boolean => queueUrl.endsWith(".fifo");
-
-export interface EmitEventOptions {
-	/**
-	 * Delay delivery of the message by this many seconds (0-900).
-	 * Useful for retry backoff to avoid overwhelming IMAP servers.
-	 */
-	delaySeconds?: number;
-}
+// The deduplication id is the event's own id, so the queue suppresses a
+// re-send of one event (the retry SQS's own idempotency guard is for) and
+// nothing else. A shared id per account or per mailbox instead made the
+// 5-minute window a rate limiter: the second sync of a mailbox within five
+// minutes was discarded before any worker saw it, so mail that arrived after
+// a sync could not be fetched until the window elapsed (issue #37).
+const fifo =
+	(queue: FifoQueueProducer<ImapEvent>): Send =>
+	(event) =>
+		queue.send({
+			body: event,
+			groupId: event.accountId,
+			deduplicationId: event.eventId,
+		});
 
-export const emitEvent = async (
-	event: EventInput,
-	options?: EmitEventOptions,
-) => {
-	const fullEvent: ImapEvent = {
-		...event,
-		eventId: randomUUID(),
-		timestamp: Date.now(),
-	} as ImapEvent;
+const standard =
+	(queue: QueueProducer<ImapEvent>): Send =>
+	(event) =>
+		queue.send({ body: event });
 
-	const queueUrl = queueUrlMap[event.type];
-	const useFifo = isFifoQueue(queueUrl);
+export const SYNC_MESSAGES_PENDING = "SYNC_MESSAGES_PENDING";
 
-	// ElasticMQ FIFO queues don't support per-message DelaySeconds
-	const useDelay = options?.delaySeconds && !isLocal;
+const SYNC_MESSAGES_PENDING_TTL_SECONDS = 300;
 
-	const send = () =>
-		sqs.send(
-			new SendMessageCommand({
-				QueueUrl: queueUrl,
-				MessageBody: JSON.stringify(fullEvent),
-				// Delay delivery for retry backoff (skip for local ElasticMQ)
-				...(useDelay && { DelaySeconds: options.delaySeconds }),
-				// FIFO queue parameters — only set if the queue is FIFO. The
-				// deduplication id is the event's own id, so the queue suppresses a
-				// re-send of one event (the retry SQS's own idempotency guard is for)
-				// and nothing else. A shared id per account or per mailbox instead made
-				// the 5-minute window a rate limiter: the second sync of a mailbox
-				// within five minutes was discarded before any worker saw it, so mail
-				// that arrived after a sync could not be fetched until the window
-				// elapsed (issue #37).
-				...(useFifo && {
-					MessageGroupId: event.accountId,
-					MessageDeduplicationId: fullEvent.eventId,
-				}),
-			}),
-		);
-	if (fullEvent.type !== "SYNC_MESSAGES") {
-		await send();
-		return;
+const senderFor = (type: ImapEvent["type"], queues: WorkerQueues): Send => {
+	switch (type) {
+		case "SYNC_MAILBOXES":
+			return fifo(queues.mailboxes);
+		case "SYNC_MESSAGES":
+			return fifo(queues.messages);
+		// SYNC_MESSAGE_BODY routes to the single standard body queue (#612).
+		case "SYNC_MESSAGE_BODY":
+			return standard(queues.body);
+		case "MAILBOX_CREATE":
+		case "MAILBOX_RENAME":
+		case "MAILBOX_DELETE":
+			return standard(queues.mailboxManagement);
+		case "MESSAGE_DELETE":
+		case "MESSAGE_MOVE":
+		case "MESSAGE_COPY":
+		case "EMPTY_TRASH":
+		case "APPEND_SENT_MESSAGE":
+		// Rides messageMgmtQueue (issue #1271) rather than a dedicated queue — its
+		// payload carries only our message id (never a UID, unlike the legacy
+		// MESSAGE_MOVE event); per-event-type payload shape, same queue.
+		case "PLACEMENT_MOVE_PUSH":
+			return standard(queues.messageManagement);
+		// Rides the existing flags queue (issue #1273) — this is imap-worker's OWN
+		// re-arm hint (the periodic per-mailbox sync tick catching up a marker
+		// stuck `pending`), distinct from `FlagPushService`'s user-facing hint
+		// sent from the API onto the sync queue. Both land on a queue this worker
+		// already consumes; dispatch is by `type`, not by which queue delivered
+		// the message.
+		case "FLAG_PUSH":
+			return fifo(queues.flags);
 	}
+};
 
-	const { mailboxLock } = await getClient();
-	const { accountId, mailboxId, eventId } = fullEvent;
-	const previous = await mailboxLock.get(
-		accountId,
-		mailboxId,
-		SYNC_MESSAGES_PENDING,
-	);
-	const acquired = await mailboxLock.tryAcquireLock(
-		mailboxId,
-		SYNC_MESSAGES_PENDING,
-		accountId,
-		eventId,
-		SYNC_MESSAGES_PENDING_TTL_SECONDS,
-	);
-	if (!acquired) return;
-	if (previous && previous.ttl < Math.floor(Date.now() / 1000)) {
-		recordImapFailure("SYNC_PENDING_EXPIRED", "other");
-	}
+export const createEmitEvent =
+	(queues: WorkerQueues): EmitEvent =>
+	async (event) => {
+		const fullEvent: ImapEvent = {
+			...event,
+			eventId: randomUUID(),
+			timestamp: Date.now(),
+		} as ImapEvent;
 
-	await send().catch(async (error: unknown) => {
-		await mailboxLock.releaseLock(
+		const send = () => senderFor(fullEvent.type, queues)(fullEvent);
+		if (fullEvent.type !== "SYNC_MESSAGES") {
+			await send();
+			return;
+		}
+
+		const { mailboxLock } = await getClient();
+		const { accountId, mailboxId, eventId } = fullEvent;
+		const previous = await mailboxLock.get(
 			accountId,
 			mailboxId,
 			SYNC_MESSAGES_PENDING,
+		);
+		const acquired = await mailboxLock.tryAcquireLock(
+			mailboxId,
+			SYNC_MESSAGES_PENDING,
+			accountId,
 			eventId,
+			SYNC_MESSAGES_PENDING_TTL_SECONDS,
 		);
-		throw error;
-	});
-};
+		if (!acquired) return;
+		if (previous && previous.ttl < Math.floor(Date.now() / 1000)) {
+			recordImapFailure("SYNC_PENDING_EXPIRED", "other");
+		}
+
+		await send().catch(async (error: unknown) => {
+			await mailboxLock.releaseLock(
+				accountId,
+				mailboxId,
+				SYNC_MESSAGES_PENDING,
+				eventId,
+			);
+			throw error;
+		});
+	};

package/src/events.ts

@@ -232,26 +232,8 @@ export interface DeleteAccountObjectsEvent {
 	continuationToken?: string;
 }
 
-/**
- * Sent by the account-deletion fanout worker once per accountId under a
- * deleted AccountConfig. The actual stop semantics already happen via the
- * account-tombstone fence (`isActive=false` + `deletedAt`) flipped by the
- * deletion API: any in-flight or future event for the account is dropped
- * by `isAccountDeleted`. This event exists as an explicit signal in the
- * cascade contract — when the imap-worker grows real per-account drain or
- * connection-teardown semantics it hangs off this hook.
- */
-export interface ImapWorkerStopEvent {
-	type: "IMAP_WORKER_STOP";
-	accountConfigId: string;
-	accountId: string;
-}
-
 /** Union of all event types the worker can process (including non-IMAP ones). */
-export type WorkerEvent =
-	| ImapEvent
-	| DeleteAccountObjectsEvent
-	| ImapWorkerStopEvent;
+export type WorkerEvent = ImapEvent | DeleteAccountObjectsEvent;
 
 export type MessageManagementEvent =
 	| MessageDeleteEvent

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

@@ -1,18 +1,22 @@
 import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
+import { afterEach, beforeEach, describe, it } from "node:test";
 import {
 	DeleteObjectsCommand,
 	ListObjectsV2Command,
 	S3Client,
 } from "@aws-sdk/client-s3";
-import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
+import {
+	type RecordingQueue,
+	recordingQueue,
+} from "@remit/data-ports/recording-queue";
 import { noopLogger } from "@remit/logger";
 import { mockClient } from "aws-sdk-client-mock";
 import type { DeleteAccountObjectsEvent } from "../events.js";
+import { workerQueuesOn } from "../test-helpers/worker-queues.js";
 import { handleDeleteAccountObjects } from "./delete-account-objects.js";
 
 const s3Mock = mockClient(S3Client);
-const sqsMock = mockClient(SQSClient);
+let queue: RecordingQueue;
 
 const event: DeleteAccountObjectsEvent = {
 	type: "DELETE_ACCOUNT_OBJECTS",
@@ -20,9 +24,12 @@ const event: DeleteAccountObjectsEvent = {
 };
 
 describe("handleDeleteAccountObjects", () => {
+	beforeEach(() => {
+		queue = recordingQueue();
+	});
+
 	afterEach(() => {
 		s3Mock.reset();
-		sqsMock.reset();
 	});
 
 	it("lists and deletes every object under the account prefix in one page", async () => {
@@ -35,7 +42,7 @@ describe("handleDeleteAccountObjects", () => {
 		});
 		s3Mock.on(DeleteObjectsCommand).resolves({});
 
-		await handleDeleteAccountObjects(event, noopLogger);
+		await handleDeleteAccountObjects(event, noopLogger, workerQueuesOn(queue));
 
 		const listCall = s3Mock.commandCalls(ListObjectsV2Command)[0];
 		assert.equal(listCall.args[0].input.Prefix, "accounts/cfg-1/");
@@ -45,7 +52,7 @@ describe("handleDeleteAccountObjects", () => {
 			{ Key: "accounts/cfg-1/a.eml" },
 			{ Key: "accounts/cfg-1/b.eml" },
 		]);
-		assert.equal(sqsMock.commandCalls(SendMessageCommand).length, 0);
+		assert.equal(queue.sent.length, 0);
 	});
 
 	it("follows the continuation token across truncated pages", async () => {
@@ -62,7 +69,7 @@ describe("handleDeleteAccountObjects", () => {
 			});
 		s3Mock.on(DeleteObjectsCommand).resolves({});
 
-		await handleDeleteAccountObjects(event, noopLogger);
+		await handleDeleteAccountObjects(event, noopLogger, workerQueuesOn(queue));
 
 		const listCalls = s3Mock.commandCalls(ListObjectsV2Command);
 		assert.equal(listCalls.length, 2);
@@ -73,18 +80,18 @@ describe("handleDeleteAccountObjects", () => {
 	it("skips the delete call when a page holds no keys", async () => {
 		s3Mock.on(ListObjectsV2Command).resolves({ IsTruncated: false });
 
-		await handleDeleteAccountObjects(event, noopLogger);
+		await handleDeleteAccountObjects(event, noopLogger, workerQueuesOn(queue));
 
 		assert.equal(s3Mock.commandCalls(DeleteObjectsCommand).length, 0);
 	});
 
 	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" },
 			noopLogger,
+			workerQueuesOn(queue),
 			() => 5_000,
 		);
 
@@ -93,13 +100,10 @@ describe("handleDeleteAccountObjects", () => {
 			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");
+		const body = queue.sent[0]?.body;
+		assert.equal(body?.type, "DELETE_ACCOUNT_OBJECTS");
+		assert.equal(body?.accountConfigId, "cfg-1");
+		assert.equal(body?.continuationToken, "tok-mid");
 	});
 
 	it("keeps paging while time remains", async () => {
@@ -109,9 +113,14 @@ describe("handleDeleteAccountObjects", () => {
 		});
 		s3Mock.on(DeleteObjectsCommand).resolves({});
 
-		await handleDeleteAccountObjects(event, noopLogger, () => 120_000);
+		await handleDeleteAccountObjects(
+			event,
+			noopLogger,
+			workerQueuesOn(queue),
+			() => 120_000,
+		);
 
 		assert.equal(s3Mock.commandCalls(ListObjectsV2Command).length, 1);
-		assert.equal(sqsMock.commandCalls(SendMessageCommand).length, 0);
+		assert.equal(queue.sent.length, 0);
 	});
 });