@remit/imap-worker 0.0.88 → 0.0.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/imap-worker",
-  "version": "0.0.88",
+  "version": "0.0.89",
   "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

@@ -7,6 +7,11 @@
 // text and argument errors are for the person who typed the command.
 import { parseArgs } from "node:util";
 import { emitEvent } from "./emit.js";
+import {
+	setWorkerQueues,
+	sqsWorkerQueues,
+	workerQueueUrlsFromEnv,
+} from "./queues.js";
 
 const HELP = `
 remit-imap-worker - Process IMAP sync events
@@ -204,6 +209,8 @@ const buildEvent = () => {
 
 const event = buildEvent();
 
+setWorkerQueues(sqsWorkerQueues(workerQueueUrlsFromEnv()));
+
 console.log(`Enqueueing ${event.type} event for account ${event.accountId}...`);
 
 emitEvent(event)

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 { emitEvent, SYNC_MESSAGES_PENDING } from "./emit.js";
 import type {
 	FlagPushEvent,
 	SyncMailboxesEvent,
-	SyncMessageBodyEvent,
 	SyncMessagesEvent,
 } from "./events.js";
+import { setWorkerQueues } from "./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 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 sentCommands = () => queue.sent;
 
 beforeEach(() => {
-	sqsMock.reset();
-	sqsMock.on(SendMessageCommand).resolves({});
+	queue = recordingQueue();
+	setWorkerQueues({
+		mailboxes: queue,
+		messages: queue,
+		flags: queue,
+		body: queue,
+		mailboxManagement: queue,
+		messageManagement: queue,
+	});
 	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,24 +122,6 @@ describe("emitEvent on a FIFO queue", () => {
 
 		const [sent] = sentCommands();
 		if (!sent) throw new Error("expected a send");
-		assert.equal(sent.MessageDeduplicationId, bodyOf(sent).eventId);
-	});
-});
-
-describe("emitEvent on a standard queue", () => {
-	it("carries no FIFO parameters", async () => {
-		const event: Emitted<SyncMessageBodyEvent> = {
-			type: "SYNC_MESSAGE_BODY",
-			accountId: "acc-1",
-			mailboxId: "mbx-1",
-			messageIds: ["msg-1"],
-		};
-
-		await emitEvent(event);
-
-		const [sent] = sentCommands();
-		if (!sent) throw new Error("expected a send");
-		assert.equal(sent.MessageGroupId, undefined);
-		assert.equal(sent.MessageDeduplicationId, undefined);
+		assert.equal(sent.deduplicationId, sent.body.eventId);
 	});
 });

package/src/emit.ts

@@ -1,13 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { getClient } from "@remit/backend/client";
+import type { FifoQueueProducer } 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, workerQueues } from "./queues.js";
 
 type EventInput = Omit<ImapEvent, "eventId" | "timestamp">;
 
@@ -15,50 +11,43 @@ 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);
-
-const sqs = createQueueProducer({ queueUrl: mailboxesQueueUrl });
-
-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,
+const queueFor = (
+	type: ImapEvent["type"],
+	queues: WorkerQueues,
+): FifoQueueProducer<ImapEvent> => {
+	switch (type) {
+		case "SYNC_MAILBOXES":
+			return queues.mailboxes;
+		case "SYNC_MESSAGES":
+			return queues.messages;
+		// SYNC_MESSAGE_BODY routes to the single standard body queue (#612).
+		case "SYNC_MESSAGE_BODY":
+			return queues.body;
+		case "MAILBOX_CREATE":
+		case "MAILBOX_RENAME":
+		case "MAILBOX_DELETE":
+			return 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 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 queues.flags;
+	}
 };
 
-/**
- * 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).
@@ -77,33 +66,21 @@ export const emitEvent = async (
 		timestamp: Date.now(),
 	} as ImapEvent;
 
-	const queueUrl = queueUrlMap[event.type];
-	const useFifo = isFifoQueue(queueUrl);
-
-	// ElasticMQ FIFO queues don't support per-message DelaySeconds
-	const useDelay = options?.delaySeconds && !isLocal;
+	const queue = queueFor(event.type, workerQueues());
 
+	// 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 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,
-				}),
-			}),
-		);
+		queue.send({
+			body: fullEvent,
+			groupId: event.accountId,
+			deduplicationId: fullEvent.eventId,
+			...(options?.delaySeconds && { delaySeconds: options.delaySeconds }),
+		});
 	if (fullEvent.type !== "SYNC_MESSAGES") {
 		await send();
 		return;

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 { setWorkerQueues } from "../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,20 @@ const event: DeleteAccountObjectsEvent = {
 };
 
 describe("handleDeleteAccountObjects", () => {
+	beforeEach(() => {
+		queue = recordingQueue();
+		setWorkerQueues({
+			mailboxes: queue,
+			messages: queue,
+			flags: queue,
+			body: queue,
+			mailboxManagement: queue,
+			messageManagement: queue,
+		});
+	});
+
 	afterEach(() => {
 		s3Mock.reset();
-		sqsMock.reset();
 	});
 
 	it("lists and deletes every object under the account prefix in one page", async () => {
@@ -45,7 +60,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 () => {
@@ -80,7 +95,6 @@ describe("handleDeleteAccountObjects", () => {
 
 	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" },
@@ -93,13 +107,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 () => {
@@ -112,6 +123,6 @@ describe("handleDeleteAccountObjects", () => {
 		await handleDeleteAccountObjects(event, noopLogger, () => 120_000);
 
 		assert.equal(s3Mock.commandCalls(ListObjectsV2Command).length, 1);
-		assert.equal(sqsMock.commandCalls(SendMessageCommand).length, 0);
+		assert.equal(queue.sent.length, 0);
 	});
 });

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

@@ -3,17 +3,13 @@ import {
 	ListObjectsV2Command,
 	S3Client,
 } from "@aws-sdk/client-s3";
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import type { Logger } from "@remit/logger";
-import { createQueueProducer } from "@remit/sqs-client/producer";
 import { env } from "expect-env";
 import type { DeleteAccountObjectsEvent } from "../events.js";
+import { workerQueues } from "../queues.js";
 
 const s3 = new S3Client({});
 
-const sqsQueueUrl = env.SQS_QUEUE_URL_MESSAGE_MGMT;
-const sqs = createQueueProducer({ queueUrl: sqsQueueUrl });
-
 const BATCH_SIZE = 1_000;
 const MIN_REMAINING_MS = 30_000;
 
@@ -94,10 +90,5 @@ const reenqueue = async (
 		continuationToken,
 	};
 
-	await sqs.send(
-		new SendMessageCommand({
-			QueueUrl: sqsQueueUrl,
-			MessageBody: JSON.stringify(event),
-		}),
-	);
+	await workerQueues().messageManagement.send({ body: event });
 };

package/src/handlers/placement-push.sqlite.test.ts

@@ -52,7 +52,7 @@ const arrange = async (): Promise<Arranged> => {
 		addressService: w.client.address,
 		mailboxSpecialUseService: w.client.mailboxSpecialUse,
 		mailboxService: w.client.mailbox,
-		sqsQueueUrl: process.env.SQS_QUEUE_URL_MESSAGE_MGMT ?? "",
+		queue: w.client.queues.messageManagement,
 	});
 	return { w, inbox, junk, message, placement };
 };

package/src/handlers/probe-message-id.sqlite.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { afterEach, beforeEach, describe, it, mock } from "node:test";
-import { SQSClient } from "@aws-sdk/client-sqs";
 import type { MailboxItem } from "@remit/data-ports";
+import { recordingQueue } from "@remit/data-ports/recording-queue";
 import {
 	AccountAuthType,
 	ConnectionState,
@@ -171,15 +171,13 @@ describe("the Message-ID the move, delete and copy probes ask with", () => {
 	it("reads the source's Message-ID for a copy", async () => {
 		const sourceId = await syncInbox("<report@example.com>");
 		const archive = await createMailbox("Archive");
-		mock.method(SQSClient.prototype, "send", async () => ({}));
-
 		const copyId = await new MessageMoveService({
 			messageService: messages,
 			mailboxService: mailboxes,
 			mailboxSpecialUseService: repos.mailboxSpecialUse,
 			threadMessageService: threadMessages,
 			addressService: repos.address,
-			sqsQueueUrl: "https://queue.test/messages",
+			queue: recordingQueue(),
 		}).copyMessage(ACCOUNT_CONFIG_ID, sourceId, archive.mailboxId, accountId);
 
 		assert.notEqual(copyId, sourceId);

package/src/handlers/sync-mailboxes.ts

@@ -22,7 +22,6 @@ import {
 	MailConnectionError,
 	type MailCredentials,
 } from "@remit/mailbox-service";
-import { env } from "expect-env";
 import pMap from "p-map";
 import {
 	isAccountDeleted,
@@ -31,6 +30,7 @@ import {
 } from "../account-check.js";
 import { emitEvent } from "../emit.js";
 import type { SyncMailboxesEvent, SyncMessagesEvent } from "../events.js";
+import { workerQueues } from "../queues.js";
 import { withOAuthLifecycle } from "../with-oauth-lifecycle.js";
 import { buildLifecycleDeps } from "../with-oauth-lifecycle-deps.js";
 import { createImportedFolder } from "./imported-folder.js";
@@ -118,7 +118,7 @@ export const syncMailboxes = async (
 			mailboxService,
 			new MailboxQueueService({
 				mailboxService,
-				sqsQueueUrl: env.SQS_QUEUE_URL_MAILBOX_MGMT,
+				queue: workerQueues().mailboxManagement,
 				logger: log,
 			}),
 		),

package/src/handlers/sync-message-body.ts

@@ -142,6 +142,7 @@ export const syncMessageBody = async (
 		flagQueue: flagQueueService,
 		calendarSuggestion: calendarSuggestionService,
 		calendarStore,
+		queues,
 	} = await getClient();
 
 	const account = await accountService.get(accountId);
@@ -156,18 +157,15 @@ export const syncMessageBody = async (
 	// PLACEMENT_MOVE_PUSH rides messageMgmtQueue (issue #1271) — same queue
 	// the general MessageMoveService move/delete/copy machinery uses, not a
 	// dedicated one.
-	const placementMoveQueueUrl = process.env.SQS_QUEUE_URL_MESSAGE_MGMT;
-	const placementMoveService = placementMoveQueueUrl
-		? new PlacementMoveService({
-				messageService,
-				threadMessageService,
-				markerService,
-				addressService,
-				mailboxSpecialUseService,
-				mailboxService,
-				sqsQueueUrl: placementMoveQueueUrl,
-			})
-		: undefined;
+	const placementMoveService = new PlacementMoveService({
+		messageService,
+		threadMessageService,
+		markerService,
+		addressService,
+		mailboxSpecialUseService,
+		mailboxService,
+		queue: queues.messageManagement,
+	});
 
 	await withOAuthLifecycle(
 		buildLifecycleDeps(secrets, accountService),
@@ -220,12 +218,10 @@ export const syncMessageBody = async (
 			// A confident, actionable placement verdict moves mail directly on
 			// body-sync. Safety lives in the verdict itself (only confident,
 			// INBOX/Junk-only) and the movedByRemit loop guard.
-			const placementConfig = placementMoveService
-				? {
-						mailboxSpecialUseService,
-						placementMoveService,
-					}
-				: undefined;
+			const placementConfig = {
+				mailboxSpecialUseService,
+				placementMoveService,
+			};
 
 			// A matched filter's actions (label upsert, exclusive move) apply on
 			// the same body-sync pass, reusing the placement mover for the move