@remit/backend 0.0.143 → 0.0.145

package/dist/src/handlers/folder-role-appointments.d.ts

@@ -0,0 +1,68 @@
+import type { FolderAppointment } from "@remit/api-openapi-types";
+import type { AccountSettingItem, IAccountSettingRepository, IMailboxRepository } from "@remit/data-ports";
+import { CANONICAL_ROLES, type CanonicalMailboxRoleValue, type RoleMailboxCandidate } from "@remit/data-ports/folder-role";
+/**
+ * RFC 032 exclusive-folder-appointment (#976): a per-account role→mailbox map.
+ * Each row is a `FolderRoleAppointment#<accountId>#<role>` AccountSetting (RFC
+ * 032 settings tiers), so a role can never be persisted twice for one account —
+ * writing it replaces whichever mailbox previously held it. This module owns
+ * that persistence; the read side is `resolveRoleForAccount`
+ * (`@remit/data-ports/folder-role`), the same rule every special-folder lookup
+ * in the backend and the workers goes through.
+ *
+ * A second row, `FolderRoleAppointmentLabel#<accountId>#<role>`, records the
+ * path the appointed mailbox had at the time (#887), so a folder another client
+ * later deletes can still be named back to the user. It is display only: it
+ * lives beside the appointment rather than inside it precisely so the
+ * repository that resolves roles composes one name and cannot reach the other.
+ */
+export { CANONICAL_ROLES };
+/** One role's persisted appointment: the choice, plus the path it was made on. */
+export interface PersistedFolderAppointment {
+    mailboxId: string;
+    lastKnownPath?: string;
+}
+/**
+ * Group every persisted folder-role appointment in one config-wide settings
+ * read (e.g. GET /config's already-loaded `listByAccountConfig` result) by
+ * accountId, then by role. Mirrors `groupAccountOverrides` / `groupMailboxOverrides`.
+ */
+export declare const groupFolderAppointmentsByAccount: (settings: AccountSettingItem[]) => Map<string, Map<string, PersistedFolderAppointment>>;
+/**
+ * Load one account's persisted appointments by reading each role's row
+ * directly (mirrors `loadMailboxOverrides`'s three-get pattern). Used by the
+ * create/update account handlers, which only ever need a single account.
+ */
+export declare const loadFolderAppointmentsForAccount: (accountSetting: Pick<IAccountSettingRepository, "get">, accountConfigId: string, accountId: string) => Promise<Map<string, PersistedFolderAppointment>>;
+/**
+ * Persist (or clear) one role's appointment. `mailboxId: null` deletes the row
+ * — the role goes back to unfilled (RFC 032 settings tiers: absence is unset).
+ * A value upserts it, replacing whatever mailbox the role pointed at before;
+ * there is no second row a duplicate could live in.
+ *
+ * The label row moves with it, so a path recorded for a previous choice can
+ * never be shown against the current one.
+ */
+export declare const writeFolderRoleAppointment: (accountSetting: Pick<IAccountSettingRepository, "upsert" | "delete">, accountConfigId: string, accountId: string, role: CanonicalMailboxRoleValue, mailboxId: string | null, lastKnownPath?: string) => Promise<void>;
+/**
+ * Resolve the full appointment set for one account, each entry saying where it
+ * came from: the user's persisted choice when set, else the server's
+ * SPECIAL-USE flag, else the reserved INBOX name, else a name proposal. A
+ * choice naming a mailbox the account no longer holds resolves to whatever the
+ * account would have had without it, and says so — the user's decision is
+ * surfaced as broken rather than quietly discarded. Always one entry per
+ * `CANONICAL_ROLES` member (RFC 032 settings tiers: total, never a sparse
+ * array).
+ */
+export declare const resolveFolderAppointments: (persisted: ReadonlyMap<string, PersistedFolderAppointment>, mailboxes: readonly RoleMailboxCandidate[]) => FolderAppointment[];
+/**
+ * End-to-end resolution for one account: load its persisted appointments and
+ * its mailboxes, then resolve. The single entry point every handler that
+ * builds an AccountResponse calls (create/update account, GET /config's
+ * per-account fan-out mirrors this with a pre-loaded settings batch instead —
+ * see `groupFolderAppointmentsByAccount` — to avoid an N+1 settings read).
+ */
+export declare const resolveAccountFolderAppointments: (client: {
+    mailbox: Pick<IMailboxRepository, "listAllByAccount">;
+    accountSetting: Pick<IAccountSettingRepository, "get">;
+}, accountConfigId: string, accountId: string) => Promise<FolderAppointment[]>;

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

@@ -0,0 +1,168 @@
+import { CANONICAL_ROLES, composeFolderRoleAppointmentLabelName, composeFolderRoleAppointmentName, parseFolderRoleAppointmentLabelName, parseFolderRoleAppointmentName, resolveRoleForAccount, } from "@remit/data-ports/folder-role";
+import { FolderAppointmentSource } from "@remit/domain-enums";
+/**
+ * RFC 032 exclusive-folder-appointment (#976): a per-account role→mailbox map.
+ * Each row is a `FolderRoleAppointment#<accountId>#<role>` AccountSetting (RFC
+ * 032 settings tiers), so a role can never be persisted twice for one account —
+ * writing it replaces whichever mailbox previously held it. This module owns
+ * that persistence; the read side is `resolveRoleForAccount`
+ * (`@remit/data-ports/folder-role`), the same rule every special-folder lookup
+ * in the backend and the workers goes through.
+ *
+ * A second row, `FolderRoleAppointmentLabel#<accountId>#<role>`, records the
+ * path the appointed mailbox had at the time (#887), so a folder another client
+ * later deletes can still be named back to the user. It is display only: it
+ * lives beside the appointment rather than inside it precisely so the
+ * repository that resolves roles composes one name and cannot reach the other.
+ */
+export { CANONICAL_ROLES };
+const stringValueOf = (item) => {
+    const { value } = item;
+    return value.kind === "String" ? value.value : undefined;
+};
+/**
+ * Group every persisted folder-role appointment in one config-wide settings
+ * read (e.g. GET /config's already-loaded `listByAccountConfig` result) by
+ * accountId, then by role. Mirrors `groupAccountOverrides` / `groupMailboxOverrides`.
+ */
+export const groupFolderAppointmentsByAccount = (settings) => {
+    const byAccount = new Map();
+    for (const setting of settings) {
+        const target = parseFolderRoleAppointmentName(setting.name);
+        if (!target)
+            continue;
+        const mailboxId = stringValueOf(setting);
+        if (mailboxId === undefined)
+            continue;
+        const roles = byAccount.get(target.accountId) ??
+            new Map();
+        roles.set(target.role, { mailboxId });
+        byAccount.set(target.accountId, roles);
+    }
+    for (const setting of settings) {
+        const target = parseFolderRoleAppointmentLabelName(setting.name);
+        if (!target)
+            continue;
+        const lastKnownPath = stringValueOf(setting);
+        if (lastKnownPath === undefined)
+            continue;
+        const appointment = byAccount.get(target.accountId)?.get(target.role);
+        if (!appointment)
+            continue;
+        appointment.lastKnownPath = lastKnownPath;
+    }
+    return byAccount;
+};
+/**
+ * Load one account's persisted appointments by reading each role's row
+ * directly (mirrors `loadMailboxOverrides`'s three-get pattern). Used by the
+ * create/update account handlers, which only ever need a single account.
+ */
+export const loadFolderAppointmentsForAccount = async (accountSetting, accountConfigId, accountId) => {
+    const entries = await Promise.all(CANONICAL_ROLES.map(async (role) => {
+        const appointment = await accountSetting.get(accountConfigId, composeFolderRoleAppointmentName(accountId, role));
+        const mailboxId = appointment ? stringValueOf(appointment) : undefined;
+        if (mailboxId === undefined)
+            return [role, undefined];
+        const label = await accountSetting.get(accountConfigId, composeFolderRoleAppointmentLabelName(accountId, role));
+        const lastKnownPath = label ? stringValueOf(label) : undefined;
+        return [
+            role,
+            lastKnownPath === undefined
+                ? { mailboxId }
+                : { mailboxId, lastKnownPath },
+        ];
+    }));
+    const roles = new Map();
+    for (const [role, appointment] of entries) {
+        if (appointment)
+            roles.set(role, appointment);
+    }
+    return roles;
+};
+/**
+ * Persist (or clear) one role's appointment. `mailboxId: null` deletes the row
+ * — the role goes back to unfilled (RFC 032 settings tiers: absence is unset).
+ * A value upserts it, replacing whatever mailbox the role pointed at before;
+ * there is no second row a duplicate could live in.
+ *
+ * The label row moves with it, so a path recorded for a previous choice can
+ * never be shown against the current one.
+ */
+export const writeFolderRoleAppointment = async (accountSetting, accountConfigId, accountId, role, mailboxId, lastKnownPath) => {
+    const name = composeFolderRoleAppointmentName(accountId, role);
+    const labelName = composeFolderRoleAppointmentLabelName(accountId, role);
+    if (mailboxId === null) {
+        await accountSetting.delete(accountConfigId, name);
+        await accountSetting.delete(accountConfigId, labelName);
+        return;
+    }
+    await accountSetting.upsert({
+        accountConfigId,
+        name,
+        value: { kind: "String", value: mailboxId },
+    });
+    if (lastKnownPath === undefined) {
+        await accountSetting.delete(accountConfigId, labelName);
+        return;
+    }
+    await accountSetting.upsert({
+        accountConfigId,
+        name: labelName,
+        value: { kind: "String", value: lastKnownPath },
+    });
+};
+const SOURCE_BY_KIND = {
+    appointed: FolderAppointmentSource.Appointed,
+    flagged: FolderAppointmentSource.Flagged,
+    reserved: FolderAppointmentSource.Reserved,
+    proposed: FolderAppointmentSource.Proposed,
+};
+const toFolderAppointment = (role, resolution, lastKnownPath) => {
+    if (resolution.kind === "appointment_stale") {
+        const { fallback } = resolution;
+        return {
+            role,
+            source: FolderAppointmentSource.Stale,
+            mailboxId: fallback.kind === "none" ? undefined : fallback.mailbox.mailboxId,
+            staleAppointmentMailboxId: resolution.appointedMailboxId,
+            staleAppointmentPath: lastKnownPath,
+        };
+    }
+    if (resolution.kind === "none") {
+        return { role, source: FolderAppointmentSource.None };
+    }
+    return {
+        role,
+        source: SOURCE_BY_KIND[resolution.kind],
+        mailboxId: resolution.mailbox.mailboxId,
+    };
+};
+/**
+ * Resolve the full appointment set for one account, each entry saying where it
+ * came from: the user's persisted choice when set, else the server's
+ * SPECIAL-USE flag, else the reserved INBOX name, else a name proposal. A
+ * choice naming a mailbox the account no longer holds resolves to whatever the
+ * account would have had without it, and says so — the user's decision is
+ * surfaced as broken rather than quietly discarded. Always one entry per
+ * `CANONICAL_ROLES` member (RFC 032 settings tiers: total, never a sparse
+ * array).
+ */
+export const resolveFolderAppointments = (persisted, mailboxes) => CANONICAL_ROLES.map((role) => {
+    const appointment = persisted.get(role);
+    return toFolderAppointment(role, resolveRoleForAccount(role, mailboxes, appointment?.mailboxId), appointment?.lastKnownPath);
+});
+/**
+ * End-to-end resolution for one account: load its persisted appointments and
+ * its mailboxes, then resolve. The single entry point every handler that
+ * builds an AccountResponse calls (create/update account, GET /config's
+ * per-account fan-out mirrors this with a pre-loaded settings batch instead —
+ * see `groupFolderAppointmentsByAccount` — to avoid an N+1 settings read).
+ */
+export const resolveAccountFolderAppointments = async (client, accountConfigId, accountId) => {
+    const [persisted, mailboxes] = await Promise.all([
+        loadFolderAppointmentsForAccount(client.accountSetting, accountConfigId, accountId),
+        client.mailbox.listAllByAccount(accountId),
+    ]);
+    return resolveFolderAppointments(persisted, mailboxes);
+};

package/dist/src/handlers/folder-role-labels.d.ts

@@ -0,0 +1,26 @@
+import type { IAccountSettingRepository } from "@remit/data-ports";
+/**
+ * The label row beside each role appointment records the path its folder had at
+ * the time (#887), so a folder another client later deletes can still be named
+ * back to the user. It is display only, and it lives here rather than beside
+ * the appointment writer because that writer is guarded as the only writer of
+ * the appointment row itself.
+ *
+ * A rename keeps every mailboxId, so an appointment survives it — but the path
+ * recorded beside it still names where the folder was. Move the labels with the
+ * branch, or a later third-party delete names a path the user has not seen
+ * since the rename.
+ *
+ * Driven by the settle, not by the intent: under D2 the row keeps the path the
+ * mail server holds until the rename lands, so a label moved when the intent
+ * was recorded would name a path that does not exist — permanently, if the
+ * rename then fails.
+ *
+ * The renamed folder is matched by id; its descendants are matched by the path
+ * each label already holds.
+ */
+export declare const refreshFolderAppointmentLabels: (accountSetting: Pick<IAccountSettingRepository, "get" | "upsert">, accountConfigId: string, accountId: string, renamed: {
+    mailboxId: string;
+    oldPath: string;
+    newPath: string;
+}, delimiter: string) => Promise<void>;

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

@@ -0,0 +1,40 @@
+import { composeFolderRoleAppointmentLabelName, } from "@remit/data-ports/folder-role";
+import { rebaseMailboxPath } from "@remit/data-ports/mailbox-name";
+import { loadFolderAppointmentsForAccount } from "./folder-role-appointments.js";
+/**
+ * The label row beside each role appointment records the path its folder had at
+ * the time (#887), so a folder another client later deletes can still be named
+ * back to the user. It is display only, and it lives here rather than beside
+ * the appointment writer because that writer is guarded as the only writer of
+ * the appointment row itself.
+ *
+ * A rename keeps every mailboxId, so an appointment survives it — but the path
+ * recorded beside it still names where the folder was. Move the labels with the
+ * branch, or a later third-party delete names a path the user has not seen
+ * since the rename.
+ *
+ * Driven by the settle, not by the intent: under D2 the row keeps the path the
+ * mail server holds until the rename lands, so a label moved when the intent
+ * was recorded would name a path that does not exist — permanently, if the
+ * rename then fails.
+ *
+ * The renamed folder is matched by id; its descendants are matched by the path
+ * each label already holds.
+ */
+export const refreshFolderAppointmentLabels = async (accountSetting, accountConfigId, accountId, renamed, delimiter) => {
+    const persisted = await loadFolderAppointmentsForAccount(accountSetting, accountConfigId, accountId);
+    for (const [role, appointment] of persisted) {
+        const moved = appointment.mailboxId === renamed.mailboxId
+            ? renamed.newPath
+            : appointment.lastKnownPath === undefined
+                ? undefined
+                : rebaseMailboxPath(appointment.lastKnownPath, renamed.oldPath, renamed.newPath, delimiter);
+        if (moved === undefined || moved === appointment.lastKnownPath)
+            continue;
+        await accountSetting.upsert({
+            accountConfigId,
+            name: composeFolderRoleAppointmentLabelName(accountId, role),
+            value: { kind: "String", value: moved },
+        });
+    }
+};

package/dist/src/handlers/folder-role.d.ts

@@ -0,0 +1,9 @@
+import type { FolderRoleOperationIds, OperationHandler } from "../types.js";
+/**
+ * RFC 032 exclusive-folder-appointment (#976): the single write operation for
+ * the per-account role map. `appoint(role, mailboxId)` sets `map[role]` —
+ * there is no second place a duplicate appointment could live, so writing a
+ * role replaces whichever mailbox previously held it. `mailboxId: null` clears
+ * the role back to unfilled.
+ */
+export declare const FolderRoleOperations: Record<FolderRoleOperationIds, OperationHandler<FolderRoleOperationIds>>;

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

@@ -0,0 +1,37 @@
+import { folderInAccount, ownedAccount, settledFolder, } from "@remit/mailbox-service";
+import { unwrap } from "../service/refusal.js";
+import { toAccountResponse } from "./account-guards.js";
+import { loadAccountOverrides } from "./account-overrides.js";
+import { loadSignatureForAccount } from "./account-signature.js";
+import { resolveAccountFolderAppointments, writeFolderRoleAppointment, } from "./folder-role-appointments.js";
+/**
+ * RFC 032 exclusive-folder-appointment (#976): the single write operation for
+ * the per-account role map. `appoint(role, mailboxId)` sets `map[role]` —
+ * there is no second place a duplicate appointment could live, so writing a
+ * role replaces whichever mailbox previously held it. `mailboxId: null` clears
+ * the role back to unfilled.
+ */
+export const FolderRoleOperations = {
+    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 } = ctx.client;
+        const existing = await account.get(accountId);
+        unwrap(ownedAccount(existing, accountConfigId, "act"));
+        let lastKnownPath;
+        if (body.mailboxId) {
+            const target = await mailbox.get(accountId, body.mailboxId);
+            unwrap(folderInAccount(target, accountId, "act"));
+            unwrap(settledFolder(target));
+            lastKnownPath = target.fullPath;
+        }
+        await writeFolderRoleAppointment(accountSetting, accountConfigId, accountId, role, body.mailboxId ?? null, lastKnownPath);
+        const [signature, overrides, folderAppointments] = await Promise.all([
+            loadSignatureForAccount(accountSetting, accountConfigId, accountId),
+            loadAccountOverrides(accountSetting, accountConfigId, accountId),
+            resolveAccountFolderAppointments({ mailbox, accountSetting }, accountConfigId, accountId),
+        ]);
+        return toAccountResponse(existing, signature, overrides, folderAppointments);
+    },
+};

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

@@ -0,0 +1,88 @@
+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: OperationHandler<"AddressDetailOperations_updateAddress", "accountFanout">;
+    AddressOperations_searchAddresses: OperationHandler<"AddressOperations_searchAddresses", "accountFanout">;
+    OutboxAttachmentOperations_completeOutboxAttachment: OperationHandler<"OutboxAttachmentOperations_completeOutboxAttachment", "smtp">;
+    OutboxDetailOperations_getOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
+    OutboxDetailOperations_updateOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
+    OutboxDetailOperations_deleteOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
+    OutboxDetailOperations_mintOutboxAttachment: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
+    OutboxDetailOperations_sendOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
+    OutboxOperations_createOutboxMessage: OperationHandler<import("../types.js").OutboxOperationIds, "smtp">;
+    OutboxOperations_listOutboxMessages: OperationHandler<import("../types.js").OutboxOperationIds, "smtp">;
+    MessageBulkOperations_copyMessages: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageBulkOperations_deleteMessages: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageBulkOperations_updateFlags: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageBulkOperations_updateMessageLabels: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageBulkOperations_moveMessages: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageBulkOperations_notSpam: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageBulkOperations_reportSpam: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
+    MessageOperations_describeMessage: OperationHandler<import("../types.js").MessageOperationIds, "body" | "sync" | "messageManagement">;
+    MessageOperations_updateMessageFlags: OperationHandler<import("../types.js").MessageOperationIds, "body" | "sync" | "messageManagement">;
+    MessageOperations_getRawMessage: OperationHandler<import("../types.js").MessageOperationIds, "body" | "sync" | "messageManagement">;
+    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: OperationHandler<import("../types.js").SyncOperationIds, "sync">;
+    SyncOperations_getSyncStatus: OperationHandler<import("../types.js").SyncOperationIds, "sync">;
+    TrashOperations_emptyTrash: OperationHandler<"TrashOperations_emptyTrash", "sync">;
+    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: OperationHandler<"OrganizeJobDetailOperations_getOrganizeJob", "accountFanout">;
+    OrganizeOperations_createOrganizeJob: OperationHandler<import("../types.js").OrganizeOperationIds, "accountFanout">;
+    OrganizeOperations_previewOrganize: OperationHandler<import("../types.js").OrganizeOperationIds, "accountFanout">;
+    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: OperationHandler<import("../types.js").FilterDetailOperationIds, "accountFanout">;
+    FilterDetailOperations_updateFilter: OperationHandler<import("../types.js").FilterDetailOperationIds, "accountFanout">;
+    FilterDetailOperations_deleteFilter: OperationHandler<import("../types.js").FilterDetailOperationIds, "accountFanout">;
+    FilterOperations_listFilters: OperationHandler<import("../types.js").FilterOperationIds, "accountFanout">;
+    FilterOperations_createFilter: OperationHandler<import("../types.js").FilterOperationIds, "accountFanout">;
+    FolderRoleOperations_appointFolderRole: OperationHandler<"FolderRoleOperations_appointFolderRole">;
+    MailboxDetailOperations_getMailbox: OperationHandler<import("../types.js").MailboxDetailOperationIds, "sync">;
+    MailboxDetailOperations_renameMailbox: OperationHandler<import("../types.js").MailboxDetailOperationIds, "sync">;
+    MailboxDetailOperations_deleteMailbox: OperationHandler<import("../types.js").MailboxDetailOperationIds, "sync">;
+    MailboxOperations_listMailboxes: OperationHandler<import("../types.js").MailboxOperationIds, "sync">;
+    MailboxOperations_createMailbox: OperationHandler<import("../types.js").MailboxOperationIds, "sync">;
+    MicrosoftOAuthOperations_microsoftOAuthStart: OperationHandler<import("../types.js").MicrosoftOAuthOperationIds, "sync">;
+    AccountDetailOperations_updateAccount: OperationHandler<import("../types.js").AccountDetailOperationIds, "sync" | "accountFanout">;
+    AccountDetailOperations_deleteAccount: OperationHandler<import("../types.js").AccountDetailOperationIds, "sync" | "accountFanout">;
+    AccountOperations_createAccount: OperationHandler<import("../types.js").AccountOperationIds, "sync" | "accountFanout">;
+    AccountOperations_testConnection: OperationHandler<import("../types.js").AccountOperationIds, "sync" | "accountFanout">;
+    SystemOperations_getSystemUpdate: OperationHandler<import("../types.js").SystemOperationIds>;
+    SystemOperations_applySystemUpdate: OperationHandler<import("../types.js").SystemOperationIds>;
+    ConfigOperations_getConfig: OperationHandler<import("../types.js").ConfigOperationIds, "sync">;
+    ConfigOperations_exportConfig: OperationHandler<import("../types.js").ConfigOperationIds, "sync">;
+    ConfigOperations_importConfig: OperationHandler<import("../types.js").ConfigOperationIds, "sync">;
+    MeOperations_deleteMe: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
+    MeOperations_createExport: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
+    MeOperations_getExport: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
+    MeOperations_listQuarantine: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
+    MeOperations_listVipSuggestions: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
+};
+export declare const publicHandlers: {
+    MicrosoftOAuthOperations_microsoftOAuthCallback: PublicOperationHandler<"sync">;
+    CalendarFeedOperations_getCalendarFeedIcal: PublicOperationHandler;
+};

package/dist/src/handlers/index.js

@@ -0,0 +1,62 @@
+import { AccountDetailOperations, AccountOperations } from "./account.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, getCalendarFeedIcal, } from "./calendar-feed.js";
+import { CalendarSuggestionActionOperations, CalendarSuggestionOperations, MessageCalendarSuggestionOperations, } from "./calendar-suggestion.js";
+import { ConfigOperations } from "./config.js";
+import { FilterDetailOperations, FilterOperations } from "./filter.js";
+import { FolderRoleOperations } from "./folder-role.js";
+import { LabelDetailOperations, LabelOperations } from "./label.js";
+import { MailboxDetailOperations, MailboxOperations, TrashOperations, } from "./mailbox.js";
+import { MeOperations } from "./me.js";
+import { MessageBulkOperations, MessageOperations } from "./message.js";
+import { OrganizeJobDetailOperations, OrganizeOperations } from "./organize.js";
+import { OutboxAttachmentOperations, OutboxDetailOperations, OutboxOperations, } from "./outbox.js";
+import { SyncOperations } from "./sync.js";
+import { SystemOperations } from "./system-update.js";
+import { ThreadDetailOperations, ThreadOperations } from "./thread.js";
+import { UnifiedThreadOperations } from "./unified-threads.js";
+export const handlers = {
+    ...MeOperations,
+    ...ConfigOperations,
+    ...SystemOperations,
+    ...AccountOperations,
+    ...AccountDetailOperations,
+    ...MicrosoftOAuthOperations,
+    ...MailboxOperations,
+    ...MailboxDetailOperations,
+    ...FolderRoleOperations,
+    ...FilterOperations,
+    ...FilterDetailOperations,
+    ...LabelOperations,
+    ...LabelDetailOperations,
+    ...OrganizeOperations,
+    ...OrganizeJobDetailOperations,
+    ...CalendarOperations,
+    ...CalendarDetailOperations,
+    ...CalendarFeedDetailOperations,
+    ...CalendarEventOperations,
+    ...CalendarEventDetailOperations,
+    ...CalendarFreeBusyOperations,
+    ...TrashOperations,
+    ...SyncOperations,
+    ...ThreadDetailOperations,
+    ...UnifiedThreadOperations,
+    ...ThreadOperations,
+    ...MessageOperations,
+    ...MessageBulkOperations,
+    ...OutboxOperations,
+    ...OutboxDetailOperations,
+    ...OutboxAttachmentOperations,
+    ...AddressOperations,
+    ...AddressDetailOperations,
+    ...CalendarSuggestionOperations,
+    ...MessageCalendarSuggestionOperations,
+    ...CalendarSuggestionActionOperations,
+};
+export const publicHandlers = {
+    MicrosoftOAuthOperations_microsoftOAuthCallback: microsoftOAuthCallback,
+    CalendarFeedOperations_getCalendarFeedIcal: getCalendarFeedIcal,
+};

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

@@ -0,0 +1,43 @@
+import type { CreateLabelInput, FilterItem, LabelItem, UpdateLabelInput } from "@remit/data-ports";
+import type { LabelDetailOperationIds, LabelOperationIds, OperationHandler } from "../types.js";
+/**
+ * Minimal label-service surface the CRUD handlers need — declared as a `Pick`
+ * so tests can stub it without a live table.
+ */
+export interface LabelCrudDeps {
+    label: {
+        create(input: CreateLabelInput): Promise<LabelItem>;
+        get(accountConfigId: string, labelId: string): Promise<LabelItem>;
+        update(accountConfigId: string, labelId: string, input: UpdateLabelInput): Promise<LabelItem>;
+        delete(accountConfigId: string, labelId: string): Promise<void>;
+        listPageByAccountConfig(accountConfigId: string, options?: {
+            limit?: number;
+            continuationToken?: string;
+        }): Promise<{
+            items: LabelItem[];
+            continuationToken: string | undefined;
+        }>;
+    };
+    filter: {
+        listByAccountConfig(accountConfigId: string): Promise<FilterItem[]>;
+        delete(accountConfigId: string, filterId: string): Promise<void>;
+    };
+    messageLabel: {
+        removeAllByLabelId(accountConfigId: string, labelId: string): Promise<void>;
+    };
+}
+/**
+ * Every filter in the account whose action applies this label (issue #26). The
+ * count backs `LabelResponse.filterCount`; the list backs the cascade delete.
+ */
+export declare const findFiltersForLabel: (deps: Pick<LabelCrudDeps, "filter">, accountConfigId: string, labelId: string) => Promise<FilterItem[]>;
+/**
+ * Delete a label and cascade in both directions (issue #26): every filter
+ * whose `actionLabelId` is this label is deleted outright — never left
+ * dangling, never blocking the delete — and every `MessageLabel` row for it is
+ * removed. The label row itself is deleted last so a failure mid-cascade never
+ * leaves the label gone while its filters or applied-to-messages still exist.
+ */
+export declare const deleteLabelWithCascade: (deps: LabelCrudDeps, accountConfigId: string, labelId: string) => Promise<void>;
+export declare const LabelOperations: Record<LabelOperationIds, OperationHandler<LabelOperationIds>>;
+export declare const LabelDetailOperations: Record<LabelDetailOperationIds, OperationHandler<LabelDetailOperationIds>>;