@remit/backend 0.0.144 → 0.0.146

package/dist/src/handlers/config.js

@@ -2,22 +2,13 @@ import { importConfig, pendingImportOf, readConfigForExport, } from "@remit/conf
 import { ConfigNotEmptyError, NotFoundError } from "@remit/data-ports/errors";
 import { logger } from "@remit/logger";
 import { hasStoredCredential, } from "@remit/mailbox-service/account-credentials";
-import { env } from "expect-env";
-import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { exportIdentity } from "../service/export-identity.js";
 import { fireAndForget } from "../service/fire-and-forget.js";
-import { sqsClient } from "../service/sqs.js";
-import { triggerAccountSync } from "../service/trigger-sync.js";
+import { triggerAccountSync, } from "../service/trigger-sync.js";
 import { toAccountResponse } from "./account-guards.js";
 import { groupAccountOverrides, } from "./account-overrides.js";
 import { groupSignaturesByAccount, } from "./account-signature.js";
 import { groupFolderAppointmentsByAccount, resolveFolderAppointments, writeFolderRoleAppointment, } from "./folder-role-appointments.js";
-const defaultConfigSyncTriggerDeps = () => ({
-    sqsClient,
-    queueUrl: env.SQS_QUEUE_URL,
-    logger,
-});
 /**
  * Fire-and-forget sync trigger for the accounts surfaced by GET /config.
  *
@@ -44,11 +35,10 @@ const defaultConfigSyncTriggerDeps = () => ({
  * credential rather than `connectionState`, which stays `credentials_missing`
  * until a connect succeeds — see `hasStoredCredential`.
  */
-export const triggerConfigLoadSyncs = async (accountConfigId, accounts, deps = defaultConfigSyncTriggerDeps()) => {
+export const triggerConfigLoadSyncs = async (accountConfigId, accounts, deps) => {
     await Promise.all(accounts.filter(hasStoredCredential).map(({ accountId }) => fireAndForget(async () => {
         const { eventId } = await triggerAccountSync({
-            sqsClient: deps.sqsClient,
-            queueUrl: deps.queueUrl,
+            queue: deps.queue,
             accountId,
         });
         deps.logger.info({ accountId, eventId }, "Sync triggered on config load");
@@ -68,7 +58,6 @@ const toAccountConfigResponse = (config) => ({
     createdAt: config.createdAt,
     updatedAt: config.updatedAt,
 });
-const buildCommit = () => process.env.REMIT_WORKER_SHA || process.env.GITHUB_SHA || "dev";
 /**
  * Returned by GET /config when no AccountConfig row exists yet for this user.
  * GET must never mutate state, so instead of creating a row we synthesize a
@@ -76,9 +65,8 @@ const buildCommit = () => process.env.REMIT_WORKER_SHA || process.env.GITHUB_SHA
  * The POST account-creation flow will materialize the real row when the user
  * adds their first account.
  */
-const emptyConfigResponse = (accountConfigId, event) => {
+const emptyConfigResponse = (accountConfigId, userId, commit) => {
     const now = Date.now();
-    const userId = getSubFromEvent(event) ?? accountConfigId;
     return {
         accountConfig: {
             accountConfigId,
@@ -88,14 +76,13 @@ const emptyConfigResponse = (accountConfigId, event) => {
             updatedAt: now,
         },
         accounts: [],
-        buildCommit: buildCommit(),
+        buildCommit: commit,
     };
 };
 export const ConfigOperations = {
-    ConfigOperations_getConfig: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const client = await getClient();
+    ConfigOperations_getConfig: async (_context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const client = ctx.client;
         const description = await client.accountConfig
             .describe(accountConfigId)
             .catch((err) => {
@@ -104,11 +91,11 @@ export const ConfigOperations = {
             throw err;
         });
         if (!description || description.accountConfig.length === 0) {
-            return emptyConfigResponse(accountConfigId, event);
+            return emptyConfigResponse(accountConfigId, ctx.identity.sub, ctx.config.commit);
         }
         const accountConfig = description.accountConfig[0];
         if (!accountConfig) {
-            return emptyConfigResponse(accountConfigId, event);
+            return emptyConfigResponse(accountConfigId, ctx.identity.sub, ctx.config.commit);
         }
         // Filter out deleted accounts (tombstone pattern)
         const activeAccounts = description.account.filter((acc) => acc.deletedAt === undefined);
@@ -135,35 +122,36 @@ export const ConfigOperations = {
         // triggerConfigLoadSyncs swallows nothing — it logs each failure loudly
         // with an alertable structured field — but it also never rejects, so the
         // `void` here cannot leak an unhandled rejection into a later request.
-        void triggerConfigLoadSyncs(accountConfigId, activeAccounts);
+        void triggerConfigLoadSyncs(accountConfigId, activeAccounts, {
+            queue: ctx.client.queues.sync,
+            logger,
+        });
         // An import that named folders IMAP had not produced yet rides the config
         // read rather than a route of its own, so nothing has to poll for it.
         const pendingImport = pendingImportOf(await client.configImport.listByAccountConfig(accountConfigId));
         return {
             accountConfig: toAccountConfigResponse(accountConfig),
             ...(pendingImport ? { pendingImport } : {}),
-            buildCommit: buildCommit(),
+            buildCommit: ctx.config.commit,
             accounts: activeAccounts.map((acc) => toAccountResponse(acc, signatureOf(acc.accountId), overridesOf(acc.accountId), resolveFolderAppointments(appointmentsByAccount.get(acc.accountId) ?? new Map(), mailboxesByAccount.get(acc.accountId) ?? []))),
         };
     },
-    ConfigOperations_exportConfig: async (_context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
-        const client = await getClient();
-        const document = await readConfigForExport(client, accountConfigId, exportIdentity());
+    ConfigOperations_exportConfig: async (_context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
+        const client = ctx.client;
+        const document = await readConfigForExport(client, accountConfigId, exportIdentity(ctx.config));
         return { schemaVersion: document.schemaVersion, document };
     },
-    ConfigOperations_importConfig: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    ConfigOperations_importConfig: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const body = (context.request.requestBody ?? {});
-        const client = await getClient();
+        const client = ctx.client;
         const outcome = await importConfig({
             repositories: client,
             appointFolderRole: (configId, accountId, role, mailboxId, lastKnownPath) => writeFolderRoleAppointment(client.accountSetting, configId, accountId, role, mailboxId, lastKnownPath),
         }, {
             accountConfigId,
-            userId: getSubFromEvent(event) ?? accountConfigId,
+            userId: ctx.identity.sub,
             document: body.document,
             mode: body.mode ?? "validate",
             onExisting: body.onExisting ?? "abort",

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

@@ -1,3 +1,16 @@
-import type { FilterDetailOperationIds, FilterOperationIds, OperationHandler } from "../types.js";
-export declare const FilterOperations: Record<FilterOperationIds, OperationHandler<FilterOperationIds>>;
-export declare const FilterDetailOperations: Record<FilterDetailOperationIds, OperationHandler<FilterDetailOperationIds>>;
+import type { CreateFilterResponse } from "@remit/api-openapi-types";
+import type { HandlerContext } from "../types.js";
+export declare const FilterOperations: {
+    FilterOperations_listFilters: (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.FilterResponse[];
+        continuationToken: string | undefined;
+    }>;
+    FilterOperations_createFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"accountFanout">) => Promise<CreateFilterResponse>;
+};
+export declare const FilterDetailOperations: {
+    FilterDetailOperations_getFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_updateFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_deleteFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        statusCode: number;
+    }>;
+};

package/dist/src/handlers/filter.js

@@ -1,8 +1,5 @@
 import { logger } from "@remit/logger";
 import { createFilter, listFilters, ownedAccount, updateFilter, } from "@remit/mailbox-service";
-import { env } from "expect-env";
-import { getAccountConfigIdFromEvent, getSubFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { unwrap } from "../service/refusal.js";
 const toFilterResponse = (item) => ({
     filterId: item.filterId,
@@ -21,20 +18,12 @@ const toFilterResponse = (item) => ({
     createdAt: item.createdAt,
     updatedAt: item.updatedAt,
 });
-const requireUserId = (event) => {
-    const userId = getSubFromEvent(event);
-    if (!userId) {
-        throw new Error("Missing Cognito `sub`: cannot attribute an organize job to a user");
-    }
-    return userId;
-};
 export const FilterOperations = {
-    FilterOperations_listFilters: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    FilterOperations_listFilters: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
         const { continuationToken } = context.request.query;
-        const page = unwrap(await listFilters(await getClient(), accountConfigId, {
+        const page = unwrap(await listFilters(ctx.client, accountConfigId, {
             accountId,
             continuationToken,
         }));
@@ -43,19 +32,18 @@ export const FilterOperations = {
             continuationToken: page.continuationToken,
         };
     },
-    FilterOperations_createFilter: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    FilterOperations_createFilter: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId } = context.request.params;
         const filter = context.request.requestBody;
-        const userId = requireUserId(event);
-        const client = await getClient();
+        const userId = ctx.identity.sub;
+        const client = ctx.client;
         const created = unwrap(await createFilter({
             account: client.account,
             mailbox: client.mailbox,
             filter: client.filter,
             organizeJobRequest: client.organizeJobRequest,
-            sqsQueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
+            queue: client.queues.accountFanout,
             logger,
         }, { accountConfigId, userId }, { accountId, filter }));
         return {
@@ -65,11 +53,10 @@ export const FilterOperations = {
     },
 };
 export const FilterDetailOperations = {
-    FilterDetailOperations_getFilter: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    FilterDetailOperations_getFilter: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, filterId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "read"));
         const { filter } = client;
@@ -77,23 +64,21 @@ export const FilterDetailOperations = {
         const refreshed = await filter.refreshExpiry(item);
         return toFilterResponse(refreshed);
     },
-    FilterDetailOperations_updateFilter: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    FilterDetailOperations_updateFilter: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, filterId } = context.request.params;
         const patch = context.request.requestBody;
-        const updated = await updateFilter(await getClient(), accountConfigId, {
+        const updated = await updateFilter(ctx.client, accountConfigId, {
             accountId,
             filterId,
             patch,
         });
         return toFilterResponse(unwrap(updated));
     },
-    FilterDetailOperations_deleteFilter: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    FilterDetailOperations_deleteFilter: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, filterId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "act"));
         const { filter } = client;

package/dist/src/handlers/folder-role.js

@@ -1,6 +1,4 @@
 import { folderInAccount, ownedAccount, settledFolder, } from "@remit/mailbox-service";
-import { getAccountConfigIdFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { unwrap } from "../service/refusal.js";
 import { toAccountResponse } from "./account-guards.js";
 import { loadAccountOverrides } from "./account-overrides.js";
@@ -14,12 +12,11 @@ import { resolveAccountFolderAppointments, writeFolderRoleAppointment, } from ".
  * the role back to unfilled.
  */
 export const FolderRoleOperations = {
-    FolderRoleOperations_appointFolderRole: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    FolderRoleOperations_appointFolderRole: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, role } = context.request.params;
         const body = context.request.requestBody;
-        const { account, accountSetting, mailbox } = await getClient();
+        const { account, accountSetting, mailbox } = ctx.client;
         const existing = await account.get(accountId);
         unwrap(ownedAccount(existing, accountConfigId, "act"));
         let lastKnownPath;

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

@@ -1,2 +1,187 @@
-import type { OperationHandler, OperationIds } from "../types.js";
-export declare const handlers: Record<OperationIds, OperationHandler<any>>;
+import type { OperationHandler, PublicOperationHandler } from "../types.js";
+export declare const handlers: {
+    CalendarSuggestionActionOperations_acceptCalendarSuggestion: OperationHandler<import("../types.js").CalendarSuggestionActionOperationIds>;
+    CalendarSuggestionActionOperations_declineCalendarSuggestion: OperationHandler<import("../types.js").CalendarSuggestionActionOperationIds>;
+    CalendarSuggestionActionOperations_dismissCalendarSuggestion: OperationHandler<import("../types.js").CalendarSuggestionActionOperationIds>;
+    CalendarSuggestionActionOperations_reopenCalendarSuggestion: OperationHandler<import("../types.js").CalendarSuggestionActionOperationIds>;
+    MessageCalendarSuggestionOperations_listMessageCalendarSuggestions: OperationHandler<"MessageCalendarSuggestionOperations_listMessageCalendarSuggestions">;
+    CalendarSuggestionOperations_listCalendarSuggestions: OperationHandler<"CalendarSuggestionOperations_listCalendarSuggestions">;
+    AddressDetailOperations_updateAddress: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").Components.Schemas.AddressResponse>;
+    AddressOperations_searchAddresses: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.AddressResponse[];
+        continuationToken: string | undefined;
+    }>;
+    OutboxAttachmentOperations_completeOutboxAttachment: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OutboxAttachmentResponse | import("./outbox-attachment.js").RejectionResponse>;
+    OutboxDetailOperations_getOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxDetailOperations_updateOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxDetailOperations_deleteOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<{
+        statusCode: number;
+    }>;
+    OutboxDetailOperations_sendOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxDetailOperations_mintOutboxAttachment: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").MintOutboxAttachmentResponse | import("./outbox-attachment.js").RejectionResponse>;
+    OutboxOperations_createOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxOperations_listOutboxMessages: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: never[];
+        continuationToken: null;
+    } | {
+        items: import("@remit/api-openapi-types").Components.Schemas.OutboxMessageResponse[];
+        continuationToken: string | undefined;
+    }>;
+    MessageBulkOperations_updateFlags: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_deleteMessages: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_moveMessages: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_copyMessages: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_updateMessageLabels: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_reportSpam: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("./message.js").SpamReportBulkOutcome>;
+    MessageBulkOperations_notSpam: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("./message.js").SpamReportBulkOutcome>;
+    MessageOperations_describeMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").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: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync" | "messageManagement">) => Promise<{
+        raw: string;
+    }>;
+    MessageOperations_updateMessageFlags: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        messageId: string;
+        isRead: boolean;
+        isStarred: boolean;
+    }>;
+    ThreadOperations_listThreads: OperationHandler<import("../types.js").ThreadOperationIds>;
+    ThreadOperations_searchThreads: OperationHandler<import("../types.js").ThreadOperationIds>;
+    UnifiedThreadOperations_listAllThreads: OperationHandler<"UnifiedThreadOperations_listAllThreads">;
+    ThreadDetailOperations_listThreadMessages: OperationHandler<"ThreadDetailOperations_listThreadMessages">;
+    SyncOperations_triggerSync: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        triggered: boolean;
+        message: string;
+    }>;
+    SyncOperations_getSyncStatus: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        accountId: string;
+        syncPhase: "error" | "idle" | "discovering_mailboxes" | "syncing_inbox" | "syncing_others" | "complete" | undefined;
+        mailboxCountTotal: number | undefined;
+        mailboxCountSynced: number | undefined;
+        lastSyncAt: number | undefined;
+        mailboxes: import("./sync-progress.js").MailboxSyncProgress[];
+    }>;
+    TrashOperations_emptyTrash: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        deletedCount: number;
+    }>;
+    CalendarFreeBusyOperations_listCalendarFreeBusy: OperationHandler<"CalendarFreeBusyOperations_listCalendarFreeBusy">;
+    CalendarEventDetailOperations_getCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
+    CalendarEventDetailOperations_updateCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
+    CalendarEventDetailOperations_deleteCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
+    CalendarEventOperations_listCalendarEvents: OperationHandler<import("../types.js").CalendarEventOperationIds>;
+    CalendarEventOperations_createCalendarEvent: OperationHandler<import("../types.js").CalendarEventOperationIds>;
+    CalendarDetailOperations_getCalendarFeed: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
+    CalendarDetailOperations_putCalendarFeed: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
+    CalendarDetailOperations_revokeCalendarFeed: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
+    CalendarDetailOperations_getCalendar: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
+    CalendarDetailOperations_updateCalendar: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
+    CalendarDetailOperations_deleteCalendar: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
+    CalendarOperations_listCalendars: OperationHandler<import("../types.js").CalendarOperationIds>;
+    CalendarOperations_createCalendar: OperationHandler<import("../types.js").CalendarOperationIds>;
+    OrganizeJobDetailOperations_getOrganizeJob: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OrganizeJobResponse>;
+    OrganizeOperations_createOrganizeJob: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").CreateOrganizeJobResponse>;
+    OrganizeOperations_previewOrganize: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OrganizePreviewResponse>;
+    LabelDetailOperations_getLabel: OperationHandler<import("../types.js").LabelDetailOperationIds>;
+    LabelDetailOperations_updateLabel: OperationHandler<import("../types.js").LabelDetailOperationIds>;
+    LabelDetailOperations_deleteLabel: OperationHandler<import("../types.js").LabelDetailOperationIds>;
+    LabelOperations_listLabels: OperationHandler<import("../types.js").LabelOperationIds>;
+    LabelOperations_createLabel: OperationHandler<import("../types.js").LabelOperationIds>;
+    FilterDetailOperations_getFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_updateFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_deleteFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        statusCode: number;
+    }>;
+    FilterOperations_listFilters: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.FilterResponse[];
+        continuationToken: string | undefined;
+    }>;
+    FilterOperations_createFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").CreateFilterResponse>;
+    FolderRoleOperations_appointFolderRole: OperationHandler<"FolderRoleOperations_appointFolderRole">;
+    MailboxDetailOperations_getMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").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: import("../types.js").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: import("../types.js").HandlerContext<"sync">) => Promise<{
+        statusCode: number;
+    }>;
+    MailboxOperations_listMailboxes: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").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: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MicrosoftOAuthOperations_microsoftOAuthStart: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        authorizationUrl: string;
+    }>;
+    AccountDetailOperations_updateAccount: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").AccountResponse>;
+    AccountDetailOperations_deleteAccount: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").DeleteAccountResponse>;
+    AccountOperations_createAccount: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").AccountResponse>;
+    AccountOperations_testConnection: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").TestConnectionResponse>;
+    SystemOperations_getSystemUpdate: OperationHandler<import("../types.js").SystemOperationIds>;
+    SystemOperations_applySystemUpdate: OperationHandler<import("../types.js").SystemOperationIds>;
+    ConfigOperations_getConfig: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").ConfigDescriptionResponse>;
+    ConfigOperations_exportConfig: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        schemaVersion: number;
+        document: import("@remit/config-format").ReaderConfigDocument;
+    }>;
+    ConfigOperations_importConfig: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").ConfigImportReport>;
+    MeOperations_listVipSuggestions: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").VipSuggestionsResponse>;
+    MeOperations_listQuarantine: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").QuarantineListResponse>;
+    MeOperations_deleteMe: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").DeleteAccountConfigResponse>;
+    MeOperations_createExport: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").CreateExportResponse>;
+    MeOperations_getExport: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").AccountExportRequestResponse>;
+};
+export declare const publicHandlers: {
+    MicrosoftOAuthOperations_microsoftOAuthCallback: PublicOperationHandler<"sync">;
+    CalendarFeedOperations_getCalendarFeedIcal: PublicOperationHandler;
+};

package/dist/src/handlers/index.js

@@ -1,9 +1,9 @@
 import { AccountDetailOperations, AccountOperations } from "./account.js";
-import { MicrosoftOAuthOperations } from "./account-oauth.js";
+import { MicrosoftOAuthOperations, microsoftOAuthCallback, } from "./account-oauth.js";
 import { AddressDetailOperations, AddressOperations } from "./address.js";
 import { CalendarDetailOperations, CalendarOperations } from "./calendar.js";
 import { CalendarEventDetailOperations, CalendarEventOperations, CalendarFreeBusyOperations, } from "./calendar-event.js";
-import { CalendarFeedDetailOperations, CalendarFeedOperations, } from "./calendar-feed.js";
+import { CalendarFeedDetailOperations, getCalendarFeedIcal, } from "./calendar-feed.js";
 import { CalendarSuggestionActionOperations, CalendarSuggestionOperations, MessageCalendarSuggestionOperations, } from "./calendar-suggestion.js";
 import { ConfigOperations } from "./config.js";
 import { FilterDetailOperations, FilterOperations } from "./filter.js";
@@ -18,7 +18,6 @@ import { SyncOperations } from "./sync.js";
 import { SystemOperations } from "./system-update.js";
 import { ThreadDetailOperations, ThreadOperations } from "./thread.js";
 import { UnifiedThreadOperations } from "./unified-threads.js";
-// biome-ignore lint/suspicious/noExplicitAny: Types are narrowed downstream
 export const handlers = {
     ...MeOperations,
     ...ConfigOperations,
@@ -38,7 +37,6 @@ export const handlers = {
     ...CalendarOperations,
     ...CalendarDetailOperations,
     ...CalendarFeedDetailOperations,
-    ...CalendarFeedOperations,
     ...CalendarEventOperations,
     ...CalendarEventDetailOperations,
     ...CalendarFreeBusyOperations,
@@ -58,3 +56,7 @@ export const handlers = {
     ...MessageCalendarSuggestionOperations,
     ...CalendarSuggestionActionOperations,
 };
+export const publicHandlers = {
+    MicrosoftOAuthOperations_microsoftOAuthCallback: microsoftOAuthCallback,
+    CalendarFeedOperations_getCalendarFeedIcal: getCalendarFeedIcal,
+};

package/dist/src/handlers/label.js

@@ -1,6 +1,4 @@
 import { ownedAccount } from "@remit/mailbox-service";
-import { getAccountConfigIdFromEvent } from "../auth.js";
-import { getClient } from "../service/data-client.js";
 import { unwrap } from "../service/refusal.js";
 /**
  * Every filter in the account whose action applies this label (issue #26). The
@@ -39,12 +37,11 @@ export const deleteLabelWithCascade = async (deps, accountConfigId, labelId) =>
     await deps.label.delete(accountConfigId, labelId);
 };
 export const LabelOperations = {
-    LabelOperations_listLabels: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    LabelOperations_listLabels: 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 page = await client.label.listPageByAccountConfig(accountConfigId, {
@@ -61,12 +58,11 @@ export const LabelOperations = {
             continuationToken: page.continuationToken,
         };
     },
-    LabelOperations_createLabel: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    LabelOperations_createLabel: 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;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "act"));
         const label = await client.label.create({
@@ -78,34 +74,31 @@ export const LabelOperations = {
     },
 };
 export const LabelDetailOperations = {
-    LabelDetailOperations_getLabel: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    LabelDetailOperations_getLabel: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, labelId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "read"));
         const label = await client.label.get(accountConfigId, labelId);
         const filters = await findFiltersForLabel(client, accountConfigId, labelId);
         return toLabelResponse(label, filters.length);
     },
-    LabelDetailOperations_updateLabel: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    LabelDetailOperations_updateLabel: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, labelId } = context.request.params;
         const body = context.request.requestBody;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "act"));
         const updated = await client.label.update(accountConfigId, labelId, body);
         const filters = await findFiltersForLabel(client, accountConfigId, labelId);
         return toLabelResponse(updated, filters.length);
     },
-    LabelDetailOperations_deleteLabel: async (context, ...args) => {
-        const event = args[0];
-        const accountConfigId = getAccountConfigIdFromEvent(event);
+    LabelDetailOperations_deleteLabel: async (context, ctx) => {
+        const accountConfigId = ctx.identity.accountConfigId;
         const { accountId, labelId } = context.request.params;
-        const client = await getClient();
+        const client = ctx.client;
         const account = await client.account.get(accountId);
         unwrap(ownedAccount(account, accountConfigId, "act"));
         await deleteLabelWithCascade(client, accountConfigId, labelId);