@remit/backend 0.0.144 → 0.0.145

package/dist/src/handlers/message.js

@@ -4,12 +4,10 @@ import { ContentDisposition, MediaType, MessageCategory, SenderTrust, } from "@r
 import { logger } from "@remit/logger";
 import { guardConnectionCursor, isCursorRebuildNeeded, isMessageBodySyncBroken, MailboxCursorPausedError, MoveNotSettledError, materializeBodyParts, NoJunkMailboxError, ownedMessages, resolveFolderPlacement, settledFolder, } from "@remit/mailbox-service";
 import { isStorageNotFoundError as isStorageNotFoundErrorFromService, parseStorageUri, } from "@remit/storage-service";
-import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
 import { deriveAutoMoved } from "../derive/autoMoved.js";
 import { getContentSigner, } from "../derive/contentSignature.js";
-import { buildContentUrl, getContentDeliveryDomain, } from "../derive/contentUrl.js";
+import { buildContentUrl } from "../derive/contentUrl.js";
 import { deriveSenderTrust } from "../derive/senderTrust.js";
-import { getClient } from "../service/data-client.js";
 import { unwrap } from "../service/refusal.js";
 export const isStorageNotFoundError = (error) => isStorageNotFoundErrorFromService(error);
 /**
@@ -144,11 +142,10 @@ export const settleSpamReportBulk = async (messageIds, run) => {
     };
 };
 export const MessageOperations = {
-    MessageOperations_describeMessage: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageOperations_describeMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const ownedAccountId = unwrap(await ownedMessages(client, [messageId], accountConfigId, "read"));
         const description = await client.message.describe(messageId);
         const message = description.message[0];
@@ -335,11 +332,11 @@ export const MessageOperations = {
             logger,
         });
         const bodyParts = buildBodyPartResponses(bodyPartRows, {
-            contentDeliveryDomain: getContentDeliveryDomain(),
+            contentDeliveryDomain: ctx.config.contentDeliveryDomain,
             accountConfigId,
             accountId,
             messageId,
-            sign: getContentSigner(),
+            sign: getContentSigner(ctx.config),
         });
         const references = description.messageReference.map((ref) => ({
             messageIdValue: ref.messageIdValue,
@@ -354,11 +351,10 @@ export const MessageOperations = {
             references,
         };
     },
-    MessageOperations_getRawMessage: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageOperations_getRawMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         // Cross-tenant ownership guard. Returning raw RFC822 bytes is sensitive,
         // so resolve the owning account and prove the caller owns it BEFORE any
         // storage read or backfill. `read` mode throws NotFoundError (→ 404) on a
@@ -421,12 +417,11 @@ export const MessageOperations = {
         const body = await client.storage.retrieve(stored.bodyStorageKey);
         return { raw: decodeRawEml(body) };
     },
-    MessageOperations_updateMessageFlags: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageOperations_updateMessageFlags: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageId } = context.request.params;
         const { isRead, isStarred, starColor } = context.request.requestBody;
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, [messageId], accountConfigId, "act"));
         // FlagQueueService handles: MessageFlag + ThreadMessage updates + SQS event
         const result = await client.flagQueue.updateFlags(accountConfigId, messageId, accountId, {
@@ -442,15 +437,14 @@ export const MessageOperations = {
     },
 };
 export const MessageBulkOperations = {
-    MessageBulkOperations_updateFlags: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_updateFlags: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds, isRead, isStarred, starColor } = context.request
             .requestBody;
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
         // FlagQueueService handles: MessageFlag + ThreadMessage updates + SQS events
         // Process each message individually (same pattern as moveMessages)
@@ -466,14 +460,13 @@ export const MessageBulkOperations = {
             failureCount: 0,
         };
     },
-    MessageBulkOperations_deleteMessages: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_deleteMessages: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds, permanent } = context.request.requestBody;
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
         // MessageMoveService handles: Message + ThreadMessage updates + SQS events
         const { refusedMessageIds } = await client.messageMove.deleteMessages(accountConfigId, messageIds, accountId, {
@@ -489,15 +482,14 @@ export const MessageBulkOperations = {
             failureCount: refusedMessageIds.length,
         };
     },
-    MessageBulkOperations_moveMessages: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_moveMessages: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds, destinationMailboxId } = context.request
             .requestBody;
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
         // Destination must belong to the same (caller-owned) account, and must be
         // a folder the mail server has settled: the row records the destination
@@ -515,15 +507,14 @@ export const MessageBulkOperations = {
             failureCount: 0,
         };
     },
-    MessageBulkOperations_copyMessages: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_copyMessages: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds, destinationMailboxId } = context.request
             .requestBody;
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
         // Destination must belong to the same (caller-owned) account, and must be
         // a folder the mail server has settled: the row records the destination
@@ -541,14 +532,13 @@ export const MessageBulkOperations = {
             failureCount: 0,
         };
     },
-    MessageBulkOperations_updateMessageLabels: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_updateMessageLabels: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds, labelId, action } = context.request.requestBody;
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
         // Scoped by accountConfigId (RFC 030) — a foreign labelId 404s here rather
         // than silently applying to messages under someone else's label.
@@ -574,17 +564,16 @@ export const MessageBulkOperations = {
             failureCount: 0,
         };
     },
-    MessageBulkOperations_reportSpam: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_reportSpam: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds: requestedIds } = context.request.requestBody;
         const messageIds = [...new Set(requestedIds)];
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
-        const setBy = getSubFromEvent(event) ?? accountConfigId;
+        const setBy = ctx.identity.sub;
         return settleSpamReportBulk(messageIds, (messageId) => client.spamReport.reportSpam({
             accountConfigId,
             accountId,
@@ -592,15 +581,14 @@ export const MessageBulkOperations = {
             setBy,
         }));
     },
-    MessageBulkOperations_notSpam: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MessageBulkOperations_notSpam: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { messageIds: requestedIds } = context.request.requestBody;
         const messageIds = [...new Set(requestedIds)];
         if (messageIds.length === 0) {
             return { successCount: 0, failureCount: 0 };
         }
-        const client = await getClient();
+        const client = ctx.client;
         const accountId = unwrap(await ownedMessages(client, messageIds, accountConfigId, "act"));
         return settleSpamReportBulk(messageIds, (messageId) => client.spamReport.notSpam({ accountConfigId, accountId, messageId }));
     },

package/dist/src/handlers/organize.d.ts

@@ -6,5 +6,5 @@ import type { OperationHandler, OrganizeJobDetailOperationIds, OrganizeOperation
  * matcher share.
  */
 export declare const predicateFromInput: (input: OrganizeInput) => OrganizePredicate;
-export declare const OrganizeOperations: Record<OrganizeOperationIds, OperationHandler<OrganizeOperationIds>>;
-export declare const OrganizeJobDetailOperations: Record<OrganizeJobDetailOperationIds, OperationHandler<OrganizeJobDetailOperationIds>>;
+export declare const OrganizeOperations: Record<OrganizeOperationIds, OperationHandler<OrganizeOperationIds, "accountFanout">>;
+export declare const OrganizeJobDetailOperations: Record<OrganizeJobDetailOperationIds, OperationHandler<OrganizeJobDetailOperationIds, "accountFanout">>;

package/dist/src/handlers/organize.js

@@ -1,9 +1,6 @@
 import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
 import { logger } from "@remit/logger";
 import { ownedAccount, queueOrganizeJob, } from "@remit/mailbox-service";
-import { env } from "expect-env";
-import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { buildOrganizeMatchDeps, matchOrganize, ORGANIZE_MATCH_LIMIT, organizePredicateRejection, } from "../service/organize.js";
 import { unwrap } from "../service/refusal.js";
 /**
@@ -55,20 +52,16 @@ const requestedJob = async (client, owner, input) => {
     return { ...owner, predicate };
 };
 export const OrganizeOperations = {
-    OrganizeOperations_createOrganizeJob: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OrganizeOperations_createOrganizeJob: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
         const input = context.request.requestBody;
-        const userId = getSubFromEvent(event);
-        if (!userId) {
-            throw new Error("Missing Cognito `sub`: cannot attribute an organize job to a user");
-        }
-        const client = await getClient();
+        const userId = ctx.identity.sub;
+        const client = ctx.client;
         await assertAccount(client, accountId, accountConfigId, "act");
         const job = await queueOrganizeJob({
             organizeJobRequest: client.organizeJobRequest,
-            sqsQueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
+            queue: client.queues.accountFanout,
             logger,
         }, await requestedJob(client, { accountConfigId, userId }, input));
         return {
@@ -77,12 +70,11 @@ export const OrganizeOperations = {
             state: job.state,
         };
     },
-    OrganizeOperations_previewOrganize: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OrganizeOperations_previewOrganize: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
         const input = context.request.requestBody;
-        const client = await getClient();
+        const client = ctx.client;
         await assertAccount(client, accountId, accountConfigId, "read");
         if (input.filterId) {
             throw new BadRequestError("Preview takes a rule, not a saved filter. Run the filter to apply it.");
@@ -97,11 +89,10 @@ export const OrganizeOperations = {
     },
 };
 export const OrganizeJobDetailOperations = {
-    OrganizeJobDetailOperations_getOrganizeJob: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OrganizeJobDetailOperations_getOrganizeJob: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, organizeJobId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         await assertAccount(client, accountId, accountConfigId, "read");
         const job = await client.organizeJobRequest.get(organizeJobId);
         if (job.accountConfigId !== accountConfigId) {

package/dist/src/handlers/outbox-attachment.d.ts

@@ -1,7 +1,9 @@
 import type { MintOutboxAttachmentResponse, OutboxAttachmentRejection, OutboxAttachmentResponse } from "@remit/api-openapi-types";
 import type { OutboxAttachmentItem } from "@remit/data-ports";
 import type { Context } from "openapi-backend";
-export declare const toOutboxAttachmentResponse: (item: OutboxAttachmentItem) => OutboxAttachmentResponse;
+import type { ApiConfig } from "../config/api-config.js";
+import type { HandlerContext } from "../types.js";
+export declare const toOutboxAttachmentResponse: (config: ApiConfig) => (item: OutboxAttachmentItem) => OutboxAttachmentResponse;
 interface RejectionResponse {
     statusCode: number;
     body: OutboxAttachmentRejection;
@@ -12,12 +14,12 @@ interface RejectionResponse {
  * lets the upload live on its own fleet and keeps this operation under any
  * payload ceiling the REST tier has.
  */
-export declare const mintOutboxAttachment: (context: Context, ...args: unknown[]) => Promise<MintOutboxAttachmentResponse | RejectionResponse>;
+export declare const mintOutboxAttachment: (context: Context, ctx: HandlerContext) => Promise<MintOutboxAttachmentResponse | RejectionResponse>;
 /**
  * Confirm the upload landed. The size in the response is read back from
  * storage — on a deployment where the browser PUT straight to block storage
  * this call is the first the API hears of the bytes, and the client's word for
  * how many there are is not evidence.
  */
-export declare const completeOutboxAttachment: (context: Context, ...args: unknown[]) => Promise<OutboxAttachmentResponse | RejectionResponse>;
+export declare const completeOutboxAttachment: (context: Context, ctx: HandlerContext) => Promise<OutboxAttachmentResponse | RejectionResponse>;
 export {};

package/dist/src/handlers/outbox-attachment.js

@@ -1,9 +1,7 @@
 import { OutboxAttachmentRejectionReason } from "@remit/domain-enums";
 import { outboxAttachmentContentId } from "@remit/mailbox-service/outbox-attachment-content";
-import { getAccountConfigIdFromEvent } from "../auth.js";
 import { getContentSigner } from "../derive/contentSignature.js";
-import { buildStorageContentUrl, getContentDeliveryDomain, } from "../derive/contentUrl.js";
-import { getClient } from "../service/data-client.js";
+import { buildStorageContentUrl } from "../derive/contentUrl.js";
 // Every error body the API emits carries a `code` (issue #371). A refusal here
 // is one kind, so the code is one value and `reason` says which refusal it was.
 const ATTACHMENT_REJECTED_CODE = "attachment_rejected";
@@ -12,7 +10,7 @@ const TOO_LARGE = new Set([
     OutboxAttachmentRejectionReason.MessageTooLarge,
     OutboxAttachmentRejectionReason.TooManyAttachments,
 ]);
-export const toOutboxAttachmentResponse = (item) => ({
+export const toOutboxAttachmentResponse = (config) => (item) => ({
     outboxAttachmentId: item.outboxAttachmentId,
     outboxMessageId: item.outboxMessageId,
     filename: item.filename,
@@ -21,9 +19,9 @@ export const toOutboxAttachmentResponse = (item) => ({
     state: item.state,
     contentId: outboxAttachmentContentId(item.outboxAttachmentId),
     contentUrl: buildStorageContentUrl({
-        domain: getContentDeliveryDomain(),
+        domain: config.contentDeliveryDomain,
         storageKey: item.storageKey,
-        sign: getContentSigner(),
+        sign: getContentSigner(config),
     }),
 });
 const refuse = (detail) => ({
@@ -42,12 +40,11 @@ const refuse = (detail) => ({
  * lets the upload live on its own fleet and keeps this operation under any
  * payload ceiling the REST tier has.
  */
-export const mintOutboxAttachment = async (context, ...args) => {
-    const event = args[0];
-    const accountConfigId = getAccountConfigIdFromEvent(event);
+export const mintOutboxAttachment = async (context, ctx) => {
+    const accountConfigId = ctx.identity.accountConfigId;
     const { outboxMessageId } = context.request.params;
     const input = context.request.requestBody;
-    const client = await getClient();
+    const client = ctx.client;
     const result = await client.outboxAttachment.mint({
         accountConfigId,
         outboxMessageId,
@@ -65,11 +62,10 @@ export const mintOutboxAttachment = async (context, ...args) => {
  * this call is the first the API hears of the bytes, and the client's word for
  * how many there are is not evidence.
  */
-export const completeOutboxAttachment = async (context, ...args) => {
-    const event = args[0];
-    const accountConfigId = getAccountConfigIdFromEvent(event);
+export const completeOutboxAttachment = async (context, ctx) => {
+    const accountConfigId = ctx.identity.accountConfigId;
     const { outboxMessageId, outboxAttachmentId } = context.request.params;
-    const client = await getClient();
+    const client = ctx.client;
     const result = await client.outboxAttachment.complete({
         accountConfigId,
         outboxMessageId,
@@ -77,5 +73,5 @@ export const completeOutboxAttachment = async (context, ...args) => {
     });
     if (result.outcome === "Rejected")
         return refuse(result.rejection);
-    return toOutboxAttachmentResponse(result.attachment);
+    return toOutboxAttachmentResponse(ctx.config)(result.attachment);
 };

package/dist/src/handlers/outbox.d.ts

@@ -1,4 +1,4 @@
 import type { OperationHandler, OutboxAttachmentOperationIds, OutboxDetailOperationIds, OutboxOperationIds } from "../types.js";
-export declare const OutboxOperations: Record<OutboxOperationIds, OperationHandler<OutboxOperationIds>>;
-export declare const OutboxDetailOperations: Record<OutboxDetailOperationIds, OperationHandler<OutboxDetailOperationIds>>;
-export declare const OutboxAttachmentOperations: Record<OutboxAttachmentOperationIds, OperationHandler<OutboxAttachmentOperationIds>>;
+export declare const OutboxOperations: Record<OutboxOperationIds, OperationHandler<OutboxOperationIds, "smtp">>;
+export declare const OutboxDetailOperations: Record<OutboxDetailOperationIds, OperationHandler<OutboxDetailOperationIds, "smtp">>;
+export declare const OutboxAttachmentOperations: Record<OutboxAttachmentOperationIds, OperationHandler<OutboxAttachmentOperationIds, "smtp">>;

package/dist/src/handlers/outbox.js

@@ -1,9 +1,7 @@
 import { ForbiddenError } from "@remit/data-ports/errors";
-import { getAccountConfigIdFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { completeOutboxAttachment, mintOutboxAttachment, toOutboxAttachmentResponse, } from "./outbox-attachment.js";
-const toOutboxMessageResponse = (item, attachments = []) => ({
-    attachments: attachments.map(toOutboxAttachmentResponse),
+const toOutboxMessageResponse = (config, item, attachments = []) => ({
+    attachments: attachments.map(toOutboxAttachmentResponse(config)),
     outboxMessageId: item.outboxMessageId,
     accountId: item.accountId,
     fromAddress: item.fromAddress,
@@ -23,11 +21,10 @@ const toOutboxMessageResponse = (item, attachments = []) => ({
     updatedAt: item.updatedAt,
 });
 export const OutboxOperations = {
-    OutboxOperations_createOutboxMessage: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const input = JSON.parse(event.body ?? "{}");
-        const client = await getClient();
+    OutboxOperations_createOutboxMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const input = context.request.requestBody;
+        const client = ctx.client;
         const account = await client.account.get(input.accountId);
         if (account.accountConfigId !== accountConfigId) {
             throw new ForbiddenError(`Account ${input.accountId} not in account config`);
@@ -47,7 +44,7 @@ export const OutboxOperations = {
                 inReplyTo: input.inReplyTo,
                 references: input.references,
             });
-            return toOutboxMessageResponse(outbox);
+            return toOutboxMessageResponse(ctx.config, outbox);
         }
         const outbox = await client.outboxQueue.createDraft({
             accountId: input.accountId,
@@ -62,41 +59,38 @@ export const OutboxOperations = {
             inReplyTo: input.inReplyTo,
             references: input.references,
         });
-        return toOutboxMessageResponse(outbox);
+        return toOutboxMessageResponse(ctx.config, outbox);
     },
-    OutboxOperations_listOutboxMessages: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OutboxOperations_listOutboxMessages: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { continuationToken } = context.request.query;
-        const client = await getClient();
+        const client = ctx.client;
         const accounts = await client.account.listAllByAccountConfig(accountConfigId);
         if (accounts.length === 0) {
             return { items: [], continuationToken: null };
         }
         const result = await client.outboxMessage.listByAccounts(accounts.map((account) => account.accountId), { continuationToken });
         return {
-            items: result.items.map((item) => toOutboxMessageResponse(item)),
+            items: result.items.map((item) => toOutboxMessageResponse(ctx.config, item)),
             continuationToken: result.continuationToken,
         };
     },
 };
 export const OutboxDetailOperations = {
-    OutboxDetailOperations_getOutboxMessage: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OutboxDetailOperations_getOutboxMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { outboxMessageId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         // Default mode "read": the scoped get refuses a foreign message with
         // NotFound (404, no existence leak) — no separate check needed.
         const outbox = await client.outboxMessage.get(accountConfigId, outboxMessageId);
-        return toOutboxMessageResponse(outbox, await client.outboxAttachment.listFor(accountConfigId, outboxMessageId));
+        return toOutboxMessageResponse(ctx.config, outbox, await client.outboxAttachment.listFor(accountConfigId, outboxMessageId));
     },
-    OutboxDetailOperations_updateOutboxMessage: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OutboxDetailOperations_updateOutboxMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { outboxMessageId } = context.request.params;
         const input = context.request.requestBody;
-        const client = await getClient();
+        const client = ctx.client;
         // updateDraft's own scoped get uses mode "act": a foreign message is
         // denied with Forbidden (403), not feigned as NotFound.
         const updated = await client.outboxQueue.updateDraft(accountConfigId, outboxMessageId, {
@@ -115,27 +109,25 @@ export const OutboxDetailOperations = {
         if (input.attachmentIds !== undefined) {
             await client.outboxAttachment.retainOnly(accountConfigId, updated.accountId, outboxMessageId, input.attachmentIds);
         }
-        return toOutboxMessageResponse(updated, await client.outboxAttachment.listFor(accountConfigId, outboxMessageId));
+        return toOutboxMessageResponse(ctx.config, updated, await client.outboxAttachment.listFor(accountConfigId, outboxMessageId));
     },
-    OutboxDetailOperations_deleteOutboxMessage: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OutboxDetailOperations_deleteOutboxMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { outboxMessageId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         // deleteDraft's own scoped get uses mode "act": a foreign message is
         // denied with Forbidden (403), not feigned as NotFound.
         await client.outboxQueue.deleteDraft(accountConfigId, outboxMessageId);
         return { statusCode: 204 };
     },
-    OutboxDetailOperations_sendOutboxMessage: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    OutboxDetailOperations_sendOutboxMessage: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { outboxMessageId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         // send's own scoped get uses mode "act": a foreign message is denied
         // with Forbidden (403), not feigned as NotFound.
         const sent = await client.outboxQueue.send(accountConfigId, outboxMessageId);
-        return toOutboxMessageResponse(sent);
+        return toOutboxMessageResponse(ctx.config, sent);
     },
     OutboxDetailOperations_mintOutboxAttachment: mintOutboxAttachment,
 };

package/dist/src/handlers/sync.d.ts

@@ -1,9 +1,9 @@
-import type { SQSClient } from "@aws-sdk/client-sqs";
+import type { FifoQueueProducer } from "@remit/data-ports";
 import { type FireAndForgetLogger } from "../service/fire-and-forget.js";
+import { type SyncMailboxesEvent } from "../service/trigger-sync.js";
 import type { OperationHandler, SyncOperationIds } from "../types.js";
 interface SyncTriggerDeps {
-    sqsClient: SQSClient;
-    queueUrl: string;
+    queue: FifoQueueProducer<SyncMailboxesEvent>;
     logger: FireAndForgetLogger & {
         info: (fields: Record<string, unknown>, message: string) => void;
     };
@@ -23,6 +23,6 @@ interface SyncTriggerDeps {
  * loudly with the alertable structured fields, and resolves to void. A genuine
  * account-lookup / ownership failure still propagates and 500s as normal.
  */
-export declare const triggerSyncSafe: (accountId: string, accountConfigId: string, deps?: SyncTriggerDeps) => Promise<void>;
-export declare const SyncOperations: Record<SyncOperationIds, OperationHandler<SyncOperationIds>>;
+export declare const triggerSyncSafe: (accountId: string, accountConfigId: string, deps: SyncTriggerDeps) => Promise<void>;
+export declare const SyncOperations: Record<SyncOperationIds, OperationHandler<SyncOperationIds, "sync">>;
 export {};

package/dist/src/handlers/sync.js

@@ -1,18 +1,9 @@
 import { logger } from "@remit/logger";
 import { ownedAccount } from "@remit/mailbox-service";
-import { env } from "expect-env";
-import { getAccountConfigIdFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { fireAndForget, } from "../service/fire-and-forget.js";
 import { unwrap } from "../service/refusal.js";
-import { sqsClient } from "../service/sqs.js";
-import { triggerAccountSync } from "../service/trigger-sync.js";
+import { triggerAccountSync, } from "../service/trigger-sync.js";
 import { toMailboxSyncProgress } from "./sync-progress.js";
-const defaultSyncTriggerDeps = () => ({
-    sqsClient,
-    queueUrl: env.SQS_QUEUE_URL,
-    logger,
-});
 /**
  * Fire-and-forget enqueue for the POST /sync kick.
  *
@@ -28,11 +19,10 @@ const defaultSyncTriggerDeps = () => ({
  * loudly with the alertable structured fields, and resolves to void. A genuine
  * account-lookup / ownership failure still propagates and 500s as normal.
  */
-export const triggerSyncSafe = async (accountId, accountConfigId, deps = defaultSyncTriggerDeps()) => {
+export const triggerSyncSafe = async (accountId, accountConfigId, deps) => {
     await fireAndForget(async () => {
         const { eventId } = await triggerAccountSync({
-            sqsClient: deps.sqsClient,
-            queueUrl: deps.queueUrl,
+            queue: deps.queue,
             accountId,
             // POST /sync asks for a sync of this account by name — the refresh
             // control, pull-to-refresh, and the client's automatic poll all land
@@ -49,23 +39,24 @@ export const triggerSyncSafe = async (accountId, accountConfigId, deps = default
     });
 };
 export const SyncOperations = {
-    SyncOperations_triggerSync: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    SyncOperations_triggerSync: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
-        const account = await (await getClient()).account.get(accountId);
+        const account = await ctx.client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "act"));
-        void triggerSyncSafe(account.accountId, accountConfigId);
+        void triggerSyncSafe(account.accountId, accountConfigId, {
+            queue: ctx.client.queues.sync,
+            logger,
+        });
         return {
             triggered: true,
             message: `Sync triggered for account ${accountId}`,
         };
     },
-    SyncOperations_getSyncStatus: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    SyncOperations_getSyncStatus: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "read"));
         // Collect all mailboxes (read-only — does not write or contend with sync lock)