@remit/backend 0.0.144 → 0.0.146

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

@@ -1,7 +1,7 @@
 import type { RenameMailboxInput } from "@remit/api-openapi-types";
 import type { IAccountSettingRepository, MailboxItem } from "@remit/data-ports";
 import { type FolderPathDeps } from "@remit/mailbox-service";
-import type { MailboxDetailOperationIds, MailboxOperationIds, OperationHandler, TrashOperationIds } from "../types.js";
+import type { HandlerContext } from "../types.js";
 /**
  * The mute flag and the display-name override are user preferences that live
  * in per-mailbox AccountSetting rows (RFC 032), not on the Mailbox entity.
@@ -18,6 +18,22 @@ export type MailboxPatchClient = FolderPathDeps & {
     accountSetting: Pick<IAccountSettingRepository, "get" | "upsert" | "delete">;
 };
 export declare const applyMailboxPatch: (client: MailboxPatchClient, accountConfigId: string, mailboxId: string, accountId: string, body: RenameMailboxInput) => Promise<MailboxItem>;
-export declare const MailboxOperations: Record<MailboxOperationIds, OperationHandler<MailboxOperationIds>>;
-export declare const MailboxDetailOperations: Record<MailboxDetailOperationIds, OperationHandler<MailboxDetailOperationIds>>;
-export declare const TrashOperations: Record<TrashOperationIds, OperationHandler<TrashOperationIds>>;
+export declare const MailboxOperations: {
+    MailboxOperations_listMailboxes: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.MailboxResponse[];
+        continuationToken: string | undefined;
+    }>;
+    MailboxOperations_createMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+};
+export declare const MailboxDetailOperations: {
+    MailboxDetailOperations_getMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MailboxDetailOperations_renameMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MailboxDetailOperations_deleteMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        statusCode: number;
+    }>;
+};
+export declare const TrashOperations: {
+    TrashOperations_emptyTrash: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        deletedCount: number;
+    }>;
+};

package/dist/src/handlers/mailbox.js

@@ -1,9 +1,7 @@
 import { BadRequestError, ConflictError } from "@remit/data-ports/errors";
 import { MessageSystemFlag } from "@remit/domain-enums";
 import { changeFolderPath, createFolder, folderInAccount, folderInFlight, ownedAccount, ownedFolder, } from "@remit/mailbox-service";
-import { getAccountConfigIdFromEvent } from "../auth.js";
 import { applyPendingMoveCountPrediction, } from "../derive/pendingMoveCounts.js";
-import { getClient } from "../service/data-client.js";
 import { unwrap } from "../service/refusal.js";
 import { applyMailboxOverrideChanges, loadMailboxOverrides, loadMailboxOverridesForConfig, } from "./account-overrides.js";
 import { assertNoBindings, loadMailboxBindings } from "./mailbox-bindings.js";
@@ -100,12 +98,11 @@ const toMailboxResponse = (mailbox, overrides = {}) => ({
     updatedAt: mailbox.updatedAt,
 });
 export const MailboxOperations = {
-    MailboxOperations_listMailboxes: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MailboxOperations_listMailboxes: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
         const { continuationToken } = context.request.query;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "read"));
         const result = await client.mailbox.listByAccount(accountId, {
@@ -129,13 +126,12 @@ export const MailboxOperations = {
             continuationToken: result.continuationToken,
         };
     },
-    MailboxOperations_createMailbox: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MailboxOperations_createMailbox: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
         const { namespaceType, fullPath } = context.request
             .requestBody;
-        const created = await createFolder(await getClient(), accountConfigId, {
+        const created = await createFolder(ctx.client, accountConfigId, {
             accountId,
             namespaceType,
             fullPath,
@@ -148,11 +144,10 @@ export const MailboxOperations = {
     },
 };
 export const MailboxDetailOperations = {
-    MailboxDetailOperations_getMailbox: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MailboxDetailOperations_getMailbox: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, mailboxId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "read"));
         const mailbox = await client.mailbox.get(accountId, mailboxId);
@@ -166,21 +161,19 @@ export const MailboxDetailOperations = {
         const adjusted = applyPendingMoveCountPrediction([mailbox], pendingMoves, pendingUnseenFlagPushes)[0] ?? mailbox;
         return toMailboxResponse(adjusted, overrides);
     },
-    MailboxDetailOperations_renameMailbox: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MailboxDetailOperations_renameMailbox: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, mailboxId } = context.request.params;
         const body = context.request.requestBody;
-        const client = await getClient();
+        const client = ctx.client;
         const mailbox = await applyMailboxPatch(client, accountConfigId, mailboxId, accountId, body);
         const overrides = await loadMailboxOverrides(client.accountSetting, accountConfigId, mailboxId);
         return toMailboxResponse(mailbox, overrides);
     },
-    MailboxDetailOperations_deleteMailbox: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MailboxDetailOperations_deleteMailbox: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, mailboxId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "act"));
         const mailbox = await client.mailbox.get(accountId, mailboxId);
@@ -203,11 +196,10 @@ export const MailboxDetailOperations = {
     },
 };
 export const TrashOperations = {
-    TrashOperations_emptyTrash: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    TrashOperations_emptyTrash: 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, "act"));
         // The service resolves Trash, marks the rows and counts them, all off one

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

@@ -1,2 +1,10 @@
-import type { MeOperationIds, OperationHandler } from "../types.js";
-export declare const MeOperations: Record<MeOperationIds, OperationHandler<MeOperationIds>>;
+import type { AccountExportRequestResponse, CreateExportResponse, DeleteAccountConfigResponse, QuarantineListResponse, VipSuggestionsResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
+import type { HandlerContext } from "../types.js";
+export declare const MeOperations: {
+    MeOperations_listVipSuggestions: (_context: Context, ctx: HandlerContext) => Promise<VipSuggestionsResponse>;
+    MeOperations_listQuarantine: (_context: Context, ctx: HandlerContext) => Promise<QuarantineListResponse>;
+    MeOperations_deleteMe: (context: Context, ctx: HandlerContext<"accountFanout">) => Promise<DeleteAccountConfigResponse>;
+    MeOperations_createExport: (_context: Context, ctx: HandlerContext<"accountFanout">) => Promise<CreateExportResponse>;
+    MeOperations_getExport: (context: Context, ctx: HandlerContext) => Promise<AccountExportRequestResponse>;
+};

package/dist/src/handlers/me.js

@@ -1,26 +1,19 @@
-import { SendMessageCommand } from "@aws-sdk/client-sqs";
 import { BadRequestError, NotFoundError } from "@remit/data-ports/errors";
 import { SYNC_WARNING_SURFACE_ATTEMPTS } from "@remit/data-ports/sync-warning-state";
 import { logger } from "@remit/logger";
-import { env } from "expect-env";
-import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
-import { sqsClient } from "../service/sqs.js";
 import { toVipSuggestionEntry } from "./vip-suggestions.js";
 const DOWNLOAD_URL_TTL_SECONDS = 60 * 60;
 const SURFACED_WARNING_CAP = 200;
 export const MeOperations = {
-    MeOperations_listVipSuggestions: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const { address } = await getClient();
+    MeOperations_listVipSuggestions: async (_context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { address } = ctx.client;
         const items = await address.listSuggestedVips({ accountConfigId });
         return { suggestions: items.map(toVipSuggestionEntry) };
     },
-    MeOperations_listQuarantine: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const { quarantine, syncWarning } = await getClient();
+    MeOperations_listQuarantine: async (_context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { quarantine, syncWarning } = ctx.client;
         const [entries, warnings] = await Promise.all([
             quarantine.listByAccountConfigId(accountConfigId),
             syncWarning.listSurfacedByAccountConfigId(accountConfigId, SYNC_WARNING_SURFACE_ATTEMPTS, SURFACED_WARNING_CAP),
@@ -31,21 +24,18 @@ export const MeOperations = {
             warningsTotal: warnings.total,
         };
     },
-    MeOperations_deleteMe: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const { confirmEmail } = JSON.parse(event.body ?? "{}");
-        const callerEmail = event.requestContext?.authorizer?.claims?.email;
+    MeOperations_deleteMe: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const { confirmEmail } = context.request
+            .requestBody;
+        const callerEmail = ctx.identity.email;
         if (typeof confirmEmail !== "string" || confirmEmail.trim() === "") {
             throw new BadRequestError("confirmEmail is required");
         }
-        if (!callerEmail) {
-            throw new BadRequestError("Account email claim missing from token");
-        }
         if (confirmEmail.toLowerCase() !== callerEmail.toLowerCase()) {
             throw new BadRequestError("confirmEmail does not match your account email");
         }
-        const { accountConfig } = await getClient();
+        const { accountConfig } = ctx.client;
         try {
             await accountConfig.update(accountConfigId, {
                 state: "deleting",
@@ -64,14 +54,9 @@ export const MeOperations = {
             }
             throw err;
         }
-        const queueUrl = env.SQS_QUEUE_URL_ACCOUNT_FANOUT;
-        await sqsClient.send(new SendMessageCommand({
-            QueueUrl: queueUrl,
-            MessageBody: JSON.stringify({
-                type: "AccountDelete",
-                accountConfigId,
-            }),
-        }));
+        await ctx.client.queues.accountFanout.send({
+            body: { type: "AccountDelete", accountConfigId },
+        });
         // biome-ignore lint/plugin/no-logger-info: account deletion is an audit-grade signal
         logger.info({ accountConfigId }, "Account deletion initiated");
         return {
@@ -79,27 +64,22 @@ export const MeOperations = {
             message: "Account deletion initiated",
         };
     },
-    MeOperations_createExport: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const userId = getSubFromEvent(event);
-        if (!userId) {
-            throw new Error("Missing Cognito `sub`: cannot attribute an export request to a user");
-        }
-        const { accountExportRequest } = await getClient();
+    MeOperations_createExport: async (_context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const userId = ctx.identity.sub;
+        const { accountExportRequest } = ctx.client;
         const exportRequest = await accountExportRequest.create({
             accountConfigId,
             userId,
             state: "Pending",
         });
-        await sqsClient.send(new SendMessageCommand({
-            QueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
-            MessageBody: JSON.stringify({
+        await ctx.client.queues.accountFanout.send({
+            body: {
                 type: "AccountExport",
                 accountConfigId,
                 accountExportRequestId: exportRequest.accountExportRequestId,
-            }),
-        }));
+            },
+        });
         // biome-ignore lint/plugin/no-logger-info: account export is an audit-grade signal
         logger.info({
             accountConfigId,
@@ -110,11 +90,10 @@ export const MeOperations = {
             exportId: exportRequest.accountExportRequestId,
         };
     },
-    MeOperations_getExport: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    MeOperations_getExport: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const exportId = context.request.params.exportId;
-        const { accountExportRequest, storage } = await getClient();
+        const { accountExportRequest, storage } = ctx.client;
         const exportRequest = await accountExportRequest.get(exportId);
         if (exportRequest.accountConfigId !== accountConfigId) {
             throw new NotFoundError(`Export not found: ${exportId}`);

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

@@ -1,6 +1,7 @@
 import type { BodyPartResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
 import { type ContentSigner } from "../derive/contentSignature.js";
-import type { MessageBulkOperationIds, MessageOperationIds, OperationHandler } from "../types.js";
+import type { HandlerContext } from "../types.js";
 export declare const isStorageNotFoundError: (error: unknown) => boolean;
 /**
  * Decode the raw `.eml` bytes into a string for inspection. RFC822/MIME
@@ -26,9 +27,7 @@ export declare const extractAccountIdsFromBodyKey: (uri: string) => {
  * populating `contentUrl` from the CloudFront distribution domain. Pure
  * function so the URL-construction contract can be pinned in tests without
  * standing up the full handler. The contract requires every `contentUrl`
- * to be a real URL (#299) — `getContentDeliveryDomain` throws when the
- * Lambda env is missing the domain, and this function expects a non-empty
- * string from the caller.
+ * to be a real URL (#299), so the API refuses to start without the domain.
  */
 export interface BodyPartLike {
     bodyPartId: string;
@@ -80,5 +79,78 @@ export declare const GENERIC_FAILURE_REASON = "This message could not be process
  * regardless of batch size.
  */
 export declare const settleSpamReportBulk: (messageIds: string[], run: (messageId: string) => Promise<void>) => Promise<SpamReportBulkOutcome>;
-export declare const MessageOperations: Record<MessageOperationIds, OperationHandler<MessageOperationIds>>;
-export declare const MessageBulkOperations: Record<MessageBulkOperationIds, OperationHandler<MessageBulkOperationIds>>;
+export declare const MessageOperations: {
+    MessageOperations_describeMessage: (context: Context, ctx: HandlerContext<"sync" | "messageManagement" | "body">) => Promise<{
+        message: {
+            spamReport?: {
+                reportedAt: number;
+            } | undefined;
+            labels?: {
+                labelId: string;
+                name: string;
+                color: "Default" | "Red" | "Orange" | "Yellow" | "Green" | "Teal" | "Blue" | "Purple" | "Gray";
+            }[] | undefined;
+            autoMoved?: import("@remit/api-openapi-types").Components.Schemas.AutoMovedInfo | undefined;
+            messageId: string;
+            mailboxId: string;
+            uid: number;
+            rfc822Size: number;
+            internalDate: number;
+            messageIdHeader: string | undefined;
+            authenticity: {
+                fromDomain: string;
+                dkimMismatch: boolean;
+                dkimDomain?: string | undefined;
+                displayNameCorrespondence?: "Corresponds" | "Lookalike" | "ForeignAddress" | "Unrelated" | "NoClaim" | undefined;
+                offDomainLinkDomains?: string[] | undefined;
+                signerDomain?: string | undefined;
+                envelopeDomain?: string | undefined;
+                signerMessageCount?: number | undefined;
+                signerFirstSeenAt?: number | undefined;
+            } | undefined;
+            status: "active" | "deleting" | "deleted" | "moving";
+            syncStatus: "failed" | "synced" | "pending" | "abandoned";
+            abandonedMutation: "none" | "move" | "delete" | "copy";
+        };
+        envelope: import("@remit/api-openapi-types").Components.Schemas.EnvelopeResponse;
+        flags: string[];
+        bodyParts: import("@remit/api-openapi-types").Components.Schemas.BodyPartResponse[];
+        references: {
+            messageIdValue: string;
+            referenceType: string;
+            referenceOrder: number;
+        }[];
+    }>;
+    MessageOperations_getRawMessage: (context: Context, ctx: HandlerContext<"sync" | "messageManagement">) => Promise<{
+        raw: string;
+    }>;
+    MessageOperations_updateMessageFlags: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        messageId: string;
+        isRead: boolean;
+        isStarred: boolean;
+    }>;
+};
+export declare const MessageBulkOperations: {
+    MessageBulkOperations_updateFlags: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_deleteMessages: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_moveMessages: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_copyMessages: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_updateMessageLabels: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_reportSpam: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<SpamReportBulkOutcome>;
+    MessageBulkOperations_notSpam: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<SpamReportBulkOutcome>;
+};

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

@@ -1,10 +1,16 @@
-import type { OrganizeInput } from "@remit/api-openapi-types";
+import type { CreateOrganizeJobResponse, OrganizeInput, OrganizeJobResponse, OrganizePreviewResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
 import { type OrganizePredicate } from "../service/organize.js";
-import type { OperationHandler, OrganizeJobDetailOperationIds, OrganizeOperationIds } from "../types.js";
+import type { HandlerContext } from "../types.js";
 /**
  * Normalize the request body into the flattened predicate the job row and the
  * 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: {
+    OrganizeOperations_createOrganizeJob: (context: Context, ctx: HandlerContext<"accountFanout">) => Promise<CreateOrganizeJobResponse>;
+    OrganizeOperations_previewOrganize: (context: Context, ctx: HandlerContext) => Promise<OrganizePreviewResponse>;
+};
+export declare const OrganizeJobDetailOperations: {
+    OrganizeJobDetailOperations_getOrganizeJob: (context: Context, ctx: HandlerContext) => Promise<OrganizeJobResponse>;
+};