@cosmicdrift/kumiko-samples 0.392.2 → 0.394.0

package/samples/recipes/inbound-mail-triage/README.md

@@ -24,6 +24,18 @@ mail-triage  ← this sample                                  (the app-side cons
 3. The handler-trigger fans the write out to the worker lane; the triage job records `{ from, subject, scope, threadHint }`.
 4. A replay of the same `providerMessageId` reports `duplicate: true`, creates no second row — and the keyed triage store stays at one item.
 
+## Sign-in errors
+
+When the provider rejects the stored login, the supervisor sets the account to `auth_error` and stops fetching. With `inbound-provider-imap` mounted, the mail accounts list offers **Reconnect** on that row: the form `mail-account-reconnect-imap` is prefilled with the stored server settings (never the password), `inbound-provider-imap:write:reconnect-mailbox` checks the new login and puts the same account back to `active`. Threads, sync cursor and seen messages stay, so the next poll continues where the account stopped instead of ingesting the mailbox again. The cases are covered in `inbound-provider-imap/__tests__/reconnect-mailbox.integration.test.ts`; they need greenmail, which this sample's in-memory provider does not.
+
+## Mail content, quarantine and status
+
+Every ingested mail now carries its full text (`bodyText`, at most 32,000 characters, flagged by `bodyTextTruncated`), the original (`.eml`, or `.html` for HTML-only mails) and its attachments as file references; `inbound-mail-foundation:query:message:content` returns them, while `message:list` stays light and never carries the body. Retention removes the mail row but keeps the attachment files. Needs file storage in the app; without it the mail is still imported and the mailbox shows **Unterbrochen** (`file_storage_unavailable`).
+
+A mail the provider cannot parse is set aside in quarantine instead of blocking the mailbox: the rest imports, the sync cursor moves on, the account shows `degraded` with `lastError: message_quarantined` and the count, and `acknowledge-quarantine` clears it. Three failed polls in a row (`connection_failed`, `rate_limited`) also mark the mailbox `degraded` until the next success.
+
+A disconnected mailbox keeps its account id: `reactivate-account` (or connecting the same OAuth address again) puts it back to `active` with its cursor, so nothing is imported twice, and the mail arrives right away instead of at the next poll. Connecting an address that is already connected is refused with 409.
+
 ## Tests
 
 - E2E through `createAllInOneEntrypoint` (HTTP → dispatcher → BullMQ worker lane, no framework-internal shortcuts): connect → ingest → triage item appears.

package/samples/recipes/pdf-audit-export/src/feature.ts

@@ -4,7 +4,9 @@
 // FileRef: renderTablePdf draws the table (pure JS, no browser). The storage
 // write runs in the beforeTransaction phase, so the transaction holds no pool
 // connection while the bytes upload; the handler then only creates the
-// fileRef row from event.prepared.
+// fileRef row from event.prepared. Called from another handler (a nested
+// write) there is no such phase, so the handler renders and stores inside the
+// caller's transaction instead.
 
 import { renderTablePdf } from "@cosmicdrift/kumiko-bundled-features/renderer-pdf";
 import {
@@ -19,6 +21,7 @@ import {
 } from "@cosmicdrift/kumiko-framework/engine";
 import { UnprocessableError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import {
+  createFileRefFromBytes,
   createFileRefFromUploadedBytes,
   uploadFileBytesBeforeTransaction,
 } from "@cosmicdrift/kumiko-framework/files";
@@ -60,6 +63,62 @@ export const pdfAuditExportFeature = defineFeature("pdf-audit-export", (r) => {
   r.entity({ name: "inspection", ...inspectionEntity });
   const { executor: inspectionExecutor } = createEntityExecutor("inspection", inspectionEntity);
 
+  type AuditPayload = { assetName: string; from: string; to: string };
+  type ExecutorUser = Parameters<typeof inspectionExecutor.list>[1];
+  type ExecutorDb = Parameters<typeof inspectionExecutor.list>[2];
+
+  async function renderAudit(payload: AuditPayload, user: ExecutorUser, db: ExecutorDb) {
+    const { assetName, from, to } = payload;
+    const inspections = await inspectionExecutor.list(
+      {
+        filters: [
+          { field: "assetName", op: "eq", value: assetName },
+          { field: "inspectedOn", op: "gte", value: from },
+          { field: "inspectedOn", op: "lte", value: to },
+        ],
+        sort: "inspectedOn",
+        sortDirection: "asc",
+        limit: AUDIT_ROW_LIMIT + 1,
+      },
+      user,
+      db,
+    );
+    // A protocol that silently drops inspections would look complete.
+    if (inspections.rows.length > AUDIT_ROW_LIMIT) {
+      return writeFailure(
+        new UnprocessableError("audit_period_too_large", {
+          details: { limit: AUDIT_ROW_LIMIT },
+        }),
+      );
+    }
+
+    const { pdfBytes } = await renderTablePdf({
+      title: `Prüfprotokoll ${assetName}`,
+      meta: [
+        { label: "Zeitraum", value: `${formatGermanDate(from)} bis ${formatGermanDate(to)}` },
+        { label: "Prüfungen", value: String(inspections.rows.length) },
+      ],
+      columns: [{ header: "Datum" }, { header: "Ergebnis" }, { header: "Prüfer", weight: 2 }],
+      rows: inspections.rows.map((row) => [
+        formatGermanDate(String(row["inspectedOn"])),
+        RESULT_LABELS[z.enum(INSPECTION_RESULTS).parse(row["result"])],
+        String(row["inspector"] ?? ""),
+      ]),
+      emptyText: "Keine Prüfungen im Zeitraum",
+      footerText: `Prüfbericht ${assetName}`,
+      pageLabel: "Seite {page} von {pages}",
+    });
+
+    return {
+      isSuccess: true as const,
+      data: {
+        fileName: `audit-${toFileNameSegment(assetName)}.pdf`,
+        mimeType: "application/pdf",
+        data: pdfBytes,
+      },
+    };
+  }
+
   r.writeHandler({
     name: "inspection:create",
     schema: z.object({
@@ -77,56 +136,20 @@ export const pdfAuditExportFeature = defineFeature("pdf-audit-export", (r) => {
       name: "export-audit",
       schema: z.object({ assetName: z.string().min(1), from: z.iso.date(), to: z.iso.date() }),
       access: access.access,
+      // Nested in another command there is no phase of its own; the handler then does this work itself.
+      beforeTransactionWhenNested: "skip",
       beforeTransaction: async (event, ctx) => {
-        const { assetName, from, to } = event.payload;
-        const inspections = await inspectionExecutor.list(
-          {
-            filters: [
-              { field: "assetName", op: "eq", value: assetName },
-              { field: "inspectedOn", op: "gte", value: from },
-              { field: "inspectedOn", op: "lte", value: to },
-            ],
-            sort: "inspectedOn",
-            sortDirection: "asc",
-            limit: AUDIT_ROW_LIMIT + 1,
-          },
-          event.user,
-          ctx.db,
-        );
-        // A protocol that silently drops inspections would look complete.
-        if (inspections.rows.length > AUDIT_ROW_LIMIT) {
-          return writeFailure(
-            new UnprocessableError("audit_period_too_large", {
-              details: { limit: AUDIT_ROW_LIMIT },
-            }),
-          );
-        }
-
-        const { pdfBytes } = await renderTablePdf({
-          title: `Prüfprotokoll ${assetName}`,
-          meta: [
-            { label: "Zeitraum", value: `${formatGermanDate(from)} bis ${formatGermanDate(to)}` },
-            { label: "Prüfungen", value: String(inspections.rows.length) },
-          ],
-          columns: [{ header: "Datum" }, { header: "Ergebnis" }, { header: "Prüfer", weight: 2 }],
-          rows: inspections.rows.map((row) => [
-            formatGermanDate(String(row["inspectedOn"])),
-            RESULT_LABELS[z.enum(INSPECTION_RESULTS).parse(row["result"])],
-            String(row["inspector"] ?? ""),
-          ]),
-          emptyText: "Keine Prüfungen im Zeitraum",
-          footerText: `Prüfbericht ${assetName}`,
-          pageLabel: "Seite {page} von {pages}",
-        });
-
-        return uploadFileBytesBeforeTransaction(ctx, {
-          fileName: `audit-${toFileNameSegment(assetName)}.pdf`,
-          mimeType: "application/pdf",
-          data: pdfBytes,
-        });
+        const rendered = await renderAudit(event.payload, event.user, ctx.db);
+        if (!rendered.isSuccess) return rendered;
+        return uploadFileBytesBeforeTransaction(ctx, rendered.data);
       },
       handler: async (event, ctx) => {
-        const created = await createFileRefFromUploadedBytes(ctx, event.prepared);
+        const created =
+          event.prepared !== undefined
+            ? await createFileRefFromUploadedBytes(ctx, event.prepared)
+            : await renderAudit(event.payload, event.user, ctx.db).then((rendered) =>
+                rendered.isSuccess ? createFileRefFromBytes(ctx, rendered.data) : rendered,
+              );
         if (!created.isSuccess) return created;
         return { isSuccess: true as const, data: { fileRefId: created.data.id } };
       },

package/packages/bundled-features/src/subscription-dodo/changes.json

@@ -1,14 +0,0 @@
-[
-  {
-    "version": "0.388.0",
-    "type": "improvement",
-    "title": "New subscription provider for Dodo Payments",
-    "detail": "createSubscriptionDodoFeature() registers the \"dodo\" subscription provider (Merchant of Record). It verifies Standard Webhooks signatures, maps Dodo events to the foundation events, creates hosted checkouts and portal sessions, and switches plans in the app through previewPlanSwitch and applyPlanSwitch. Config keys are api-key, webhook-secret, billing-live and environment. Plan switches need a Product Collection in Dodo."
-  },
-  {
-    "version": "0.388.0",
-    "type": "improvement",
-    "title": "dodoEnvSchema declares the Dodo product id slots",
-    "detail": "dodoEnvSchema({ prices: [\"PRO\"] }) adds one optional DODO_PRODUCT_PRO slot per plan next to the API key and webhook key, and checks the pdt_ prefix. It is the counterpart to stripeEnvSchema."
-  }
-]

package/packages/bundled-features/src/subscription-dodo/client.ts

@@ -1,45 +0,0 @@
-// Thin JSON-over-fetch client for the Dodo Payments REST API. All traffic goes
-// through the injected `send`, which defaults to the SSRF-safe egress in
-// feature.ts and is replaced by a mock in tests.
-
-import { parseJsonOrThrow } from "@cosmicdrift/kumiko-framework/utils";
-
-export type DodoSend = (url: string, init?: RequestInit) => Promise<Response>;
-
-export type DodoRequest = {
-  readonly method: "GET" | "POST" | "PATCH";
-  /** Path segments interpolated into it must already be encodeURIComponent'ed. */
-  readonly path: string;
-  readonly query?: Readonly<Record<string, string>>;
-  readonly body?: unknown;
-};
-
-export type DodoTarget = { readonly baseUrl: string; readonly apiKey: string };
-
-// Never carries the response body or the key: both can hold customer data or secrets.
-export class DodoHttpError extends Error {
-  readonly status: number;
-  constructor(request: DodoRequest, status: number) {
-    super(`subscription-dodo: ${request.method} ${request.path} failed with status ${status}`);
-    this.name = "DodoHttpError";
-    this.status = status;
-  }
-}
-
-export function createDodoHttp(send: DodoSend) {
-  return async (target: DodoTarget, request: DodoRequest): Promise<unknown> => {
-    const query = request.query ? `?${new URLSearchParams(request.query).toString()}` : "";
-    const response = await send(`${target.baseUrl}${request.path}${query}`, {
-      method: request.method,
-      headers: {
-        Authorization: `Bearer ${target.apiKey}`,
-        Accept: "application/json",
-        ...(request.body !== undefined && { "Content-Type": "application/json" }),
-      },
-      ...(request.body !== undefined && { body: JSON.stringify(request.body) }),
-    });
-    if (!response.ok) throw new DodoHttpError(request, response.status);
-    const text = await response.text();
-    return text.length === 0 ? null : parseJsonOrThrow<unknown>(text, "subscription-dodo response");
-  };
-}

package/packages/bundled-features/src/subscription-dodo/constants.ts

@@ -1,24 +0,0 @@
-export const SUBSCRIPTION_DODO_FEATURE = "subscription-dodo" as const;
-
-// Must match the path segment in the webhook URL `/api/subscription/webhook/dodo`.
-export const DODO_PROVIDER_NAME = "dodo" as const;
-
-// Config-key short-names, qualified to `subscription-dodo:config:<name>` at
-// registry-build. api-key + webhook-secret are backing:"secrets".
-export const DODO_API_KEY_CONFIG = "api-key" as const;
-export const DODO_WEBHOOK_SECRET_CONFIG = "webhook-secret" as const;
-export const DODO_BILLING_LIVE_CONFIG = "billingLive" as const;
-export const DODO_ENVIRONMENT_CONFIG = "environment" as const;
-
-// Separate from billingLive on purpose: staging runs Dodo's test API with
-// billingLive on, production flips both.
-export const DodoEnvironments = {
-  test: "test",
-  live: "live",
-} as const;
-export type DodoEnvironment = (typeof DodoEnvironments)[keyof typeof DodoEnvironments];
-
-export const DODO_BASE_URLS: Readonly<Record<DodoEnvironment, string>> = {
-  test: "https://test.dodopayments.com",
-  live: "https://live.dodopayments.com",
-};

package/packages/bundled-features/src/subscription-dodo/feature.ts

@@ -1,207 +0,0 @@
-// kumiko-feature-version: 1
-//
-// subscription-dodo — Dodo Payments (merchant of record) plugin for the
-// billing-foundation plugin API. Credentials, the billing-live master switch and
-// the API environment (test | live) are config keys resolved at call time, like
-// subscription-stripe. `apiKey` / `webhookSecret` options are env→secrets bridge
-// fallbacks.
-
-import type { SubscriptionProviderPlugin } from "@cosmicdrift/kumiko-bundled-features/billing-foundation";
-import {
-  access,
-  createSystemConfig,
-  defineFeature,
-  type FeatureDefinition,
-} from "@cosmicdrift/kumiko-framework/engine";
-import { type FeatureWithEnvSchema, featureWithEnvSchema } from "@cosmicdrift/kumiko-framework/env";
-import { egress } from "@cosmicdrift/kumiko-framework/http";
-import * as z from "zod";
-import type { DodoSend } from "./client.ts";
-import {
-  DODO_API_KEY_CONFIG,
-  DODO_BILLING_LIVE_CONFIG,
-  DODO_ENVIRONMENT_CONFIG,
-  DODO_PROVIDER_NAME,
-  DODO_WEBHOOK_SECRET_CONFIG,
-  DodoEnvironments,
-  SUBSCRIPTION_DODO_FEATURE,
-} from "./constants.ts";
-import {
-  createDodoApplyPlanSwitch,
-  createDodoCancelSubscription,
-  createDodoCheckoutSession,
-  createDodoPortalSession,
-  createDodoPreviewPlanSwitch,
-  createDodoPriceCache,
-  createDodoResumeSubscription,
-  createDodoRetrievePrices,
-  createDodoRetrieveSubscription,
-} from "./plugin-methods.ts";
-import { createDodoRuntimes } from "./runtime.ts";
-import { verifyAndParseDodoWebhook } from "./verify-webhook.ts";
-
-/** Bridge contract: both fields are optional fallbacks for the secrets store. */
-export const subscriptionDodoEnvSchema = z.object({
-  DODO_PAYMENTS_API_KEY: z
-    .string()
-    .min(1)
-    .describe("Dodo Payments API key. Bridge-fallback — prefer the secret.")
-    .meta({ kumiko: { pulumi: { secret: true } } })
-    .optional(),
-  DODO_PAYMENTS_WEBHOOK_KEY: z
-    .string()
-    .min(1)
-    .describe(
-      "Dodo Payments webhook signing key (`whsec_...`). Bridge-fallback — prefer the secret.",
-    )
-    .meta({ kumiko: { pulumi: { secret: true } } })
-    .optional(),
-});
-
-type DodoProductEnvShape<TPrice extends string> = {
-  [Key in `DODO_PRODUCT_${TPrice}`]: z.ZodOptional<z.ZodString>;
-};
-
-/** Dodo env block plus one `DODO_PRODUCT_<NAME>` slot per plan product the app
- *  maps to a tier, e.g. `dodoEnvSchema({ prices: ["PRO", "TEAM"] })`.
- *  Shares its bridge fields with `subscriptionDodoEnvSchema`, so spreading
- *  it into `composeEnvSchema({ extend })` next to the mounted feature is no
- *  key clash. */
-export function dodoEnvSchema<const TPrice extends string>(options: {
-  readonly prices: readonly TPrice[];
-}) {
-  const productShape = Object.fromEntries(
-    options.prices.map((price) => [
-      `DODO_PRODUCT_${price}`,
-      z
-        .string()
-        .regex(/^pdt_/, `DODO_PRODUCT_${price} must start with 'pdt_'`)
-        .optional()
-        .describe(`Dodo Payments product id (\`pdt_...\`) of the ${price} plan.`),
-    ]),
-    // @cast-boundary schema-walk — Object.fromEntries widens to an index signature; the entries are exactly one optional string per listed price.
-  ) as DodoProductEnvShape<TPrice>;
-  return z.object({ ...subscriptionDodoEnvSchema.shape, ...productShape });
-}
-
-export type SubscriptionDodoOptions = {
-  /** Bridge-fallback API key; the `api-key` config key wins when set. */
-  readonly apiKey?: string;
-  /** Bridge-fallback webhook secret; the `webhook-secret` config key wins when set. */
-  readonly webhookSecret?: string;
-  /** Dodo product id → app tier name. Products absent here drop the event. */
-  readonly priceToTier?: Readonly<Record<string, string>>;
-  /** Product ids a mode:"payment" checkout may target; empty = one-off checkouts closed. */
-  readonly oneOffPriceIds?: readonly string[];
-  /** HTTP transport; defaults to the SSRF-safe external egress. Test seam. */
-  readonly send?: DodoSend;
-};
-
-// Validated once at feature-build time so a typo fails app startup instead of
-// silently widening or narrowing the one-off allowlist at request time.
-function validateOneOffPriceIds(priceIds: readonly string[]): void {
-  const seen = new Set<string>();
-  for (const priceId of priceIds) {
-    if (priceId.length === 0) {
-      throw new Error("subscription-dodo: oneOffPriceIds must not contain an empty string");
-    }
-    if (seen.has(priceId)) {
-      throw new Error(`subscription-dodo: duplicate oneOffPriceIds entry "${priceId}"`);
-    }
-    seen.add(priceId);
-  }
-}
-
-export function createSubscriptionDodoFeature(
-  options: SubscriptionDodoOptions = {},
-): FeatureWithEnvSchema<FeatureDefinition, typeof subscriptionDodoEnvSchema.shape> {
-  validateOneOffPriceIds(options.oneOffPriceIds ?? []);
-  const feature: FeatureDefinition = defineFeature(SUBSCRIPTION_DODO_FEATURE, (r) => {
-    r.describe(
-      'Dodo Payments provider plugin for `billing-foundation`. Dodo acts as merchant of record: it sells to the customer and issues invoice and VAT, so the consumer-protection texts for this provider come from `consumerProtection.providerTexts`. Reads its API key and webhook secret from system config keys with `backing:"secrets"` (envelope-encrypted in the secrets store under the system tenant), plus a `billingLive` master switch and an `environment` key (test | live). `environment` is its own key because Dodo serves test and live mode from different API hosts and a live key must never hit the test host or the other way round; `billingLive` only decides whether checkouts are offered at all. All four are runtime config, so keys rotate and prod goes live without a redeploy, and the `mask` on each derives the sysadmin settings screen and nav. Mount via `createSubscriptionDodoFeature({ priceToTier })`; the optional `apiKey`/`webhookSecret` options are env to secrets bridge fallbacks (`DODO_PAYMENTS_API_KEY`, `DODO_PAYMENTS_WEBHOOK_KEY`). The plugin always mounts; `createCheckoutSession` throws `feature_disabled` unless `billingLive` is true. Webhooks arrive at `/api/subscription/webhook/dodo` and are verified per the Standard Webhooks spec (HMAC-SHA256 over id, timestamp and the raw body, 5 minute tolerance); events for products outside `priceToTier` or without tenant metadata are dropped. Implements hosted checkout, customer portal, cancel and resume, `retrievePrices` (10-minute TTL cache), `retrieveSubscription` for the sync job, and an in-app plan switch: `previewPlanSwitch` shows the proration before the customer confirms, `applyPlanSwitch` changes the plan without a hosted page and waits for the `plan_changed` webhook to move the tier. A plan switch in Dodo requires all plan products to belong to one Product Collection.',
-    );
-    r.uiHints({
-      displayLabel: "Billing · Dodo Payments",
-      category: "billing",
-      recommended: false,
-    });
-    r.requires({ features: ["billing-foundation"] });
-    r.requires({ features: ["config"] });
-    r.requires({ features: ["secrets"] });
-    r.envSchema(subscriptionDodoEnvSchema);
-
-    const configKeys = r.config({
-      keys: {
-        [DODO_API_KEY_CONFIG]: createSystemConfig("text", {
-          backing: "secrets",
-          write: access.systemAdmin,
-          read: access.admin,
-          mask: { title: "subscription-dodo.api-key", icon: "key", order: 1 },
-        }),
-        [DODO_WEBHOOK_SECRET_CONFIG]: createSystemConfig("text", {
-          backing: "secrets",
-          write: access.systemAdmin,
-          read: access.admin,
-          mask: { title: "subscription-dodo.webhook-secret", icon: "shield", order: 2 },
-        }),
-        [DODO_ENVIRONMENT_CONFIG]: createSystemConfig("select", {
-          default: DodoEnvironments.test,
-          options: [DodoEnvironments.test, DodoEnvironments.live],
-          write: access.systemAdmin,
-          read: access.admin,
-          mask: { title: "subscription-dodo.environment", icon: "server", order: 3 },
-        }),
-        [DODO_BILLING_LIVE_CONFIG]: createSystemConfig("boolean", {
-          default: false,
-          write: access.privileged,
-          read: access.admin,
-          mask: { title: "subscription-dodo.billing-live", icon: "rocket", order: 4 },
-        }),
-      },
-    });
-
-    r.translations({
-      keys: {
-        "subscription-dodo.api-key": { en: "Dodo Payments API key" },
-        "subscription-dodo.webhook-secret": { en: "Dodo Payments webhook secret" },
-        "subscription-dodo.environment": { en: "Dodo Payments environment" },
-        "subscription-dodo.billing-live": { en: "Live billing" },
-        "subscription-dodo.settings": { en: "Dodo Payments" },
-        "screen:subscription-dodo-system.title": { en: "Dodo Payments" },
-      },
-    });
-
-    const priceToTier = options.priceToTier ?? {};
-    const runtimes = createDodoRuntimes({
-      apiKeyHandle: configKeys[DODO_API_KEY_CONFIG],
-      webhookSecretHandle: configKeys[DODO_WEBHOOK_SECRET_CONFIG],
-      billingLiveHandle: configKeys[DODO_BILLING_LIVE_CONFIG],
-      environmentHandle: configKeys[DODO_ENVIRONMENT_CONFIG],
-      send: options.send ?? egress({ kind: "external" }),
-      fallback: {
-        ...(options.apiKey !== undefined && { apiKey: options.apiKey }),
-        ...(options.webhookSecret !== undefined && { webhookSecret: options.webhookSecret }),
-      },
-    });
-
-    const plugin: SubscriptionProviderPlugin = {
-      displayName: "Dodo Payments",
-      verifyAndParseWebhook: verifyAndParseDodoWebhook(runtimes.webhook, { priceToTier }),
-      createCheckoutSession: createDodoCheckoutSession(runtimes.ctx),
-      createPortalSession: createDodoPortalSession(runtimes.ctx),
-      cancelSubscription: createDodoCancelSubscription(runtimes.ctx),
-      resumeSubscription: createDodoResumeSubscription(runtimes.ctx),
-      priceToTier,
-      oneOffPriceIds: options.oneOffPriceIds ?? [],
-      isBillingEnabled: runtimes.ctx.isBillingEnabled,
-      retrievePrices: createDodoRetrievePrices(runtimes.ctx, createDodoPriceCache()),
-      retrieveSubscription: createDodoRetrieveSubscription(runtimes.ctx, { priceToTier }),
-      previewPlanSwitch: createDodoPreviewPlanSwitch(runtimes.ctx),
-      applyPlanSwitch: createDodoApplyPlanSwitch(runtimes.ctx),
-    };
-    r.useExtension("subscriptionProvider", DODO_PROVIDER_NAME, plugin);
-
-    return { configKeys };
-  });
-  return featureWithEnvSchema(feature, subscriptionDodoEnvSchema);
-}

package/packages/bundled-features/src/subscription-dodo/index.ts

@@ -1,16 +0,0 @@
-// Public API of the subscription-dodo bundled feature. The webhook verifier,
-// client and plugin methods are internal to feature.ts.
-
-export {
-  DODO_BASE_URLS,
-  DODO_PROVIDER_NAME,
-  type DodoEnvironment,
-  DodoEnvironments,
-  SUBSCRIPTION_DODO_FEATURE,
-} from "./constants.ts";
-export {
-  createSubscriptionDodoFeature,
-  dodoEnvSchema,
-  type SubscriptionDodoOptions,
-  subscriptionDodoEnvSchema,
-} from "./feature.ts";