@remit/backend 0.0.143 → 0.0.144

package/dist/src/handlers/filter.js

@@ -0,0 +1,103 @@
+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,
+    accountConfigId: item.accountConfigId,
+    name: item.name,
+    scope: item.scope,
+    expiresAt: item.expiresAt,
+    state: item.state,
+    disabledReason: item.disabledReason,
+    ruleChangedAt: item.ruleChangedAt,
+    actionChangedAt: item.actionChangedAt,
+    matchOperator: item.matchOperator,
+    literalClauses: item.literalClauses,
+    actionLabelId: item.actionLabelId,
+    actionMailboxId: item.actionMailboxId,
+    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);
+        const { accountId } = context.request.params;
+        const { continuationToken } = context.request.query;
+        const page = unwrap(await listFilters(await getClient(), accountConfigId, {
+            accountId,
+            continuationToken,
+        }));
+        return {
+            items: page.items.map(toFilterResponse),
+            continuationToken: page.continuationToken,
+        };
+    },
+    FilterOperations_createFilter: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { accountId } = context.request.params;
+        const filter = context.request.requestBody;
+        const userId = requireUserId(event);
+        const client = await getClient();
+        const created = unwrap(await createFilter({
+            account: client.account,
+            mailbox: client.mailbox,
+            filter: client.filter,
+            organizeJobRequest: client.organizeJobRequest,
+            sqsQueueUrl: env.SQS_QUEUE_URL_ACCOUNT_FANOUT,
+            logger,
+        }, { accountConfigId, userId }, { accountId, filter }));
+        return {
+            ...toFilterResponse(created.filter),
+            organizeJobId: created.organizeJob.organizeJobId,
+        };
+    },
+};
+export const FilterDetailOperations = {
+    FilterDetailOperations_getFilter: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { accountId, filterId } = context.request.params;
+        const client = await getClient();
+        const account = await client.account.get(accountId);
+        unwrap(ownedAccount(account, accountConfigId, "read"));
+        const { filter } = client;
+        const item = await filter.get(accountConfigId, filterId);
+        const refreshed = await filter.refreshExpiry(item);
+        return toFilterResponse(refreshed);
+    },
+    FilterDetailOperations_updateFilter: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { accountId, filterId } = context.request.params;
+        const patch = context.request.requestBody;
+        const updated = await updateFilter(await getClient(), accountConfigId, {
+            accountId,
+            filterId,
+            patch,
+        });
+        return toFilterResponse(unwrap(updated));
+    },
+    FilterDetailOperations_deleteFilter: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { accountId, filterId } = context.request.params;
+        const client = await getClient();
+        const account = await client.account.get(accountId);
+        unwrap(ownedAccount(account, accountConfigId, "act"));
+        const { filter } = client;
+        await filter.delete(accountConfigId, filterId);
+        return { statusCode: 204 };
+    },
+};

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,40 @@
+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";
+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, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { accountId, role } = context.request.params;
+        const body = context.request.requestBody;
+        const { account, accountSetting, mailbox } = await getClient();
+        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,2 @@
+import type { OperationHandler, OperationIds } from "../types.js";
+export declare const handlers: Record<OperationIds, OperationHandler<any>>;

package/dist/src/handlers/index.js

@@ -0,0 +1,60 @@
+import { AccountDetailOperations, AccountOperations } from "./account.js";
+import { MicrosoftOAuthOperations } 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 { 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";
+// biome-ignore lint/suspicious/noExplicitAny: Types are narrowed downstream
+export const handlers = {
+    ...MeOperations,
+    ...ConfigOperations,
+    ...SystemOperations,
+    ...AccountOperations,
+    ...AccountDetailOperations,
+    ...MicrosoftOAuthOperations,
+    ...MailboxOperations,
+    ...MailboxDetailOperations,
+    ...FolderRoleOperations,
+    ...FilterOperations,
+    ...FilterDetailOperations,
+    ...LabelOperations,
+    ...LabelDetailOperations,
+    ...OrganizeOperations,
+    ...OrganizeJobDetailOperations,
+    ...CalendarOperations,
+    ...CalendarDetailOperations,
+    ...CalendarFeedDetailOperations,
+    ...CalendarFeedOperations,
+    ...CalendarEventOperations,
+    ...CalendarEventDetailOperations,
+    ...CalendarFreeBusyOperations,
+    ...TrashOperations,
+    ...SyncOperations,
+    ...ThreadDetailOperations,
+    ...UnifiedThreadOperations,
+    ...ThreadOperations,
+    ...MessageOperations,
+    ...MessageBulkOperations,
+    ...OutboxOperations,
+    ...OutboxDetailOperations,
+    ...OutboxAttachmentOperations,
+    ...AddressOperations,
+    ...AddressDetailOperations,
+    ...CalendarSuggestionOperations,
+    ...MessageCalendarSuggestionOperations,
+    ...CalendarSuggestionActionOperations,
+};

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>>;