@pleaseai/emulate-autumn 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# @pleaseai/emulate-autumn
+
+[Autumn](https://useautumn.com) billing API emulator for local development and CI.
+
+Implements the v1 RPC-style API autumn-js speaks (`/v1/<group>.<method>`): `customers.get_or_create`/`update`/`list`, `balances.track`/`check`, `plans.list`, `billing.attach`/`open_customer_portal`, plus a hosted checkout page that settles card-required trials and paid plans. Tested against the real `autumn-js` SDK.
+
+Ported from the [UsefulSoftwareCo/emulate](https://github.com/UsefulSoftwareCo/emulate) fork.
+
+## Install
+
+```bash
+npm install @pleaseai/emulate-autumn
+```
+
+Usually you do not install this directly — run it through the `@pleaseai/emulate` CLI.
+
+## Start
+
+```bash
+npx @pleaseai/emulate --service autumn
+```
+
+A single service starts on the base port (default `4000`); use `-p <port>` to change it.
+
+## Auth
+
+Any `am_`-prefixed bearer token is accepted as the secret key:
+
+```bash
+curl -X POST http://localhost:4000/v1/customers.get_or_create \
+  -H "Authorization: Bearer am_test_emulate" \
+  -H "Content-Type: application/json" \
+  -d '{"customer_id": "org_demo"}'
+```
+
+Or point the SDK at the emulator:
+
+```ts
+import { Autumn } from 'autumn-js'
+
+const autumn = new Autumn({ secretKey: 'am_test_emulate', serverURL: 'http://localhost:4000' })
+```
+
+## Seed Config
+
+```yaml
+autumn:
+  plans:
+    - id: free
+      name: Free
+      auto_enable: true
+      items:
+        - feature_id: executions
+          included: 100
+    - id: pro
+      name: Pro
+      price:
+        amount: 20
+        interval: month
+      items:
+        - feature_id: executions
+          included: 10000
+  customers:
+    - id: org_demo
+      subscriptions:
+        - plan_id: pro
+          status: active
+```

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+import { Entity, Collection, Store, ServicePlugin } from '@emulators/core';
+
+interface AutumnSubscription {
+    /** Stable subscription id (e.g. `sub_emulate_1`). */
+    id?: string;
+    plan_id: string;
+    /** `active` | `trialing` | `scheduled` | `canceled`. */
+    status: string;
+    started_at?: number;
+    current_period_start?: number | null;
+    current_period_end?: number | null;
+    trial_ends_at?: number | null;
+    canceled_at?: number | null;
+    quantity?: number;
+    [key: string]: unknown;
+}
+interface AutumnCustomer extends Entity {
+    customer_id: string;
+    name: string | null;
+    email: string | null;
+    subscriptions: AutumnSubscription[];
+    /**
+     * Plan ids whose free trial this customer has already consumed. Once used,
+     *  the plan's `trial_available` flips to false (Autumn offers a trial once).
+     */
+    trials_used?: string[];
+}
+interface AutumnTrackEvent extends Entity {
+    customer_id: string;
+    feature_id: string;
+    value: number;
+}
+interface AutumnPlanItem {
+    feature_id: string;
+    included?: number;
+    unlimited?: boolean;
+    price?: unknown;
+}
+interface AutumnPlan extends Entity {
+    plan_id: string;
+    name: string;
+    add_on: boolean;
+    auto_enable: boolean;
+    price: {
+        amount: number;
+        interval: string;
+    } | null;
+    free_trial: {
+        duration_length: number;
+        duration_type: string;
+        card_required: boolean;
+    } | null;
+    items: AutumnPlanItem[];
+    /** Rank used to classify an attach as upgrade vs downgrade (low to high). */
+    order: number;
+}
+/**
+ * A checkout session opened by `billing.attach` for a plan that needs payment
+ *  (a price, or a card-required trial). Mirrors the real flow: the browser is
+ *  redirected to a hosted checkout page; completing it sends the browser back
+ *  to `success_url`, but the subscription only activates once the asynchronous
+ *  Stripe webhook is processed, modelled here by `settle`.
+ */
+interface AutumnCheckout extends Entity {
+    session_id: string;
+    customer_id: string;
+    plan_id: string;
+    success_url: string;
+    /**
+     * `pending` (checkout open) to `completed` (browser paid, webhook in flight)
+     *  to `settled` (webhook processed, subscription active).
+     */
+    status: 'pending' | 'completed' | 'settled';
+}
+
+interface AutumnStore {
+    customers: Collection<AutumnCustomer>;
+    events: Collection<AutumnTrackEvent>;
+    plans: Collection<AutumnPlan>;
+    checkouts: Collection<AutumnCheckout>;
+}
+declare function getAutumnStore(store: Store): AutumnStore;
+
+interface AutumnSeedPlan {
+    id: string;
+    name?: string;
+    add_on?: boolean;
+    auto_enable?: boolean;
+    price?: {
+        amount: number;
+        interval: string;
+    } | null;
+    free_trial?: {
+        duration_length: number;
+        duration_type: string;
+        card_required: boolean;
+    } | null;
+    items?: AutumnPlanItem[];
+}
+interface AutumnSeedConfig {
+    customers?: Array<{
+        id: string;
+        name?: string;
+        email?: string;
+        subscriptions?: AutumnSubscription[];
+    }>;
+    /**
+     * Plan catalog the emulator advertises via `plans.list` and attaches via
+     *  `billing.attach`. In production these are synced from `autumn.config.ts`;
+     *  the emulator has no such sync, so the application under test seeds them.
+     */
+    plans?: AutumnSeedPlan[];
+}
+declare function seedFromConfig(store: Store, _baseUrl: string, config: AutumnSeedConfig): void;
+declare const autumnPlugin: ServicePlugin;
+
+export { type AutumnCheckout, type AutumnCustomer, type AutumnPlan, type AutumnPlanItem, type AutumnSeedConfig, type AutumnSeedPlan, type AutumnStore, type AutumnSubscription, type AutumnTrackEvent, autumnPlugin, autumnPlugin as default, getAutumnStore, seedFromConfig };

package/dist/index.js

@@ -0,0 +1,650 @@
+// src/serialize.ts
+var DAY_MS = 864e5;
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["active", "trialing"]);
+function freeTrialMs(ft) {
+  const n = ft.duration_length;
+  switch (ft.duration_type) {
+    case "year":
+      return n * 365 * DAY_MS;
+    case "month":
+      return n * 30 * DAY_MS;
+    default:
+      return n * DAY_MS;
+  }
+}
+function ensureCustomer(as, id, data) {
+  const existing = as.customers.findOneBy("customer_id", id);
+  if (existing) {
+    return existing;
+  }
+  return as.customers.insert({
+    customer_id: id,
+    name: typeof data.name === "string" ? data.name : null,
+    email: typeof data.email === "string" ? data.email : null,
+    subscriptions: []
+  });
+}
+function activateSubscription(as, customer, plan, opts) {
+  const now = Date.now();
+  const trialing = opts.trial && plan.free_trial != null;
+  const periodEnd = trialing ? now + freeTrialMs(plan.free_trial) : now + 30 * DAY_MS;
+  const sub = {
+    id: `sub_emulate_${customer.id}_${plan.plan_id}`,
+    plan_id: plan.plan_id,
+    status: trialing ? "trialing" : "active",
+    started_at: now,
+    current_period_start: now,
+    current_period_end: periodEnd,
+    trial_ends_at: trialing ? periodEnd : null,
+    canceled_at: null,
+    quantity: 1
+  };
+  const trialsUsed = trialing ? Array.from(/* @__PURE__ */ new Set([...customer.trials_used ?? [], plan.plan_id])) : customer.trials_used ?? [];
+  as.customers.update(customer.id, { subscriptions: [sub], trials_used: trialsUsed });
+}
+function activeSubscription(customer) {
+  return (customer.subscriptions ?? []).find((s) => ACTIVE_STATUSES.has(s.status));
+}
+function usageFor(as, customerId, featureId) {
+  return as.events.all().filter((e) => e.customer_id === customerId && e.feature_id === featureId).reduce((sum, e) => sum + (e.value ?? 0), 0);
+}
+function serializeBalanceFeature(featureId) {
+  return {
+    id: featureId,
+    name: featureId,
+    type: "metered",
+    consumable: true,
+    event_names: [featureId],
+    archived: false
+  };
+}
+function serializeSubscription(sub) {
+  return {
+    id: sub.id ?? `sub_emulate_${sub.plan_id}`,
+    plan_id: sub.plan_id,
+    auto_enable: false,
+    add_on: false,
+    status: sub.status,
+    past_due: false,
+    canceled_at: sub.canceled_at ?? null,
+    expires_at: null,
+    trial_ends_at: sub.trial_ends_at ?? null,
+    started_at: sub.started_at ?? Date.now(),
+    current_period_start: sub.current_period_start ?? null,
+    current_period_end: sub.current_period_end ?? null,
+    quantity: sub.quantity ?? 1
+  };
+}
+function balancesFor(as, customer) {
+  const planId = activeSubscription(customer)?.plan_id ?? "free";
+  const plan = as.plans.findOneBy("plan_id", planId);
+  const balances = {};
+  for (const item of plan?.items ?? []) {
+    const unlimited = item.unlimited === true;
+    const granted = unlimited ? 0 : item.included ?? 0;
+    const usage = usageFor(as, customer.customer_id, item.feature_id);
+    balances[item.feature_id] = {
+      feature_id: item.feature_id,
+      feature: serializeBalanceFeature(item.feature_id),
+      granted,
+      remaining: unlimited ? 0 : Math.max(0, granted - usage),
+      usage,
+      unlimited,
+      overage_allowed: false,
+      max_purchase: null,
+      next_reset_at: null
+    };
+  }
+  return balances;
+}
+function balanceForFeature(as, customer, featureId) {
+  return balancesFor(as, customer)[featureId];
+}
+function serializeCustomer(as, customer) {
+  return {
+    id: customer.customer_id,
+    created_at: Date.parse(customer.created_at) || Date.now(),
+    name: customer.name,
+    email: customer.email,
+    fingerprint: null,
+    stripe_id: `cus_emulate_${customer.id}`,
+    env: "sandbox",
+    metadata: {},
+    send_email_receipts: true,
+    billing_controls: {},
+    subscriptions: (customer.subscriptions ?? []).map(serializeSubscription),
+    purchases: [],
+    balances: balancesFor(as, customer),
+    flags: {},
+    invoices: [],
+    products: [],
+    features: {}
+  };
+}
+function eligibilityFor(as, customer, plan) {
+  const subs = customer.subscriptions ?? [];
+  const subForPlan = subs.find((s) => s.plan_id === plan.plan_id && ACTIVE_STATUSES.has(s.status));
+  if (subForPlan) {
+    return {
+      status: "active",
+      canceling: subForPlan.canceled_at != null,
+      trialing: subForPlan.status === "trialing",
+      trial_available: false,
+      attach_action: "none"
+    };
+  }
+  const paidSub = subs.find((s) => ACTIVE_STATUSES.has(s.status) && s.plan_id !== "free");
+  if (plan.plan_id === "free") {
+    if (!paidSub) {
+      return { status: "active", canceling: false, trialing: false, attach_action: "none" };
+    }
+    return { canceling: false, trialing: false, trial_available: false, attach_action: "downgrade" };
+  }
+  const paidPlan = paidSub ? as.plans.findOneBy("plan_id", paidSub.plan_id) : void 0;
+  const trialUsed = (customer.trials_used ?? []).includes(plan.plan_id);
+  const attachAction = paidSub && paidPlan ? plan.order > paidPlan.order ? "upgrade" : "downgrade" : "upgrade";
+  return {
+    canceling: false,
+    trialing: false,
+    trial_available: plan.free_trial != null && !trialUsed,
+    attach_action: attachAction
+  };
+}
+function serializePlan(as, customer, plan) {
+  return {
+    id: plan.plan_id,
+    name: plan.name,
+    description: null,
+    group: null,
+    version: 1,
+    add_on: plan.add_on,
+    auto_enable: plan.auto_enable,
+    price: plan.price ? { amount: plan.price.amount, interval: plan.price.interval, interval_count: 1 } : null,
+    items: (plan.items ?? []).map((it) => ({
+      feature_id: it.feature_id,
+      included: it.included ?? 0,
+      unlimited: it.unlimited === true,
+      reset: null,
+      price: it.price ?? null
+    })),
+    free_trial: plan.free_trial ? {
+      duration_length: plan.free_trial.duration_length,
+      duration_type: plan.free_trial.duration_type,
+      card_required: plan.free_trial.card_required
+    } : void 0,
+    created_at: Date.parse(plan.created_at) || Date.now(),
+    env: "sandbox",
+    archived: false,
+    base_variant_id: null,
+    config: { ignore_past_due: false },
+    customer_eligibility: customer ? eligibilityFor(as, customer, plan) : void 0
+  };
+}
+
+// src/store.ts
+function getAutumnStore(store) {
+  return {
+    customers: store.collection("autumn.customers", ["customer_id"]),
+    events: store.collection("autumn.events", ["customer_id", "feature_id"]),
+    plans: store.collection("autumn.plans", ["plan_id"]),
+    checkouts: store.collection("autumn.checkouts", ["session_id", "customer_id"])
+  };
+}
+
+// src/routes/api.ts
+function autumnApiRoutes(ctx) {
+  const { app, store, baseUrl } = ctx;
+  const as = () => getAutumnStore(store);
+  app.post("/v1/customers.get_or_create", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const id = String(body.customer_id ?? body.customerId ?? body.id ?? "");
+    if (!id) {
+      return c.json({ message: "customer_id is required", code: "invalid_request" }, 400);
+    }
+    const data = body.customer_data ?? body;
+    const customer = ensureCustomer(as(), id, data);
+    return c.json(serializeCustomer(as(), customer));
+  });
+  app.post("/v1/customers.list", async (c) => {
+    const store2 = as();
+    const customers = store2.customers.all().map((customer) => serializeCustomer(store2, customer));
+    return c.json({ list: customers, total: customers.length, offset: 0, limit: 100 });
+  });
+  app.post("/v1/customers.update", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const id = String(body.customer_id ?? body.customerId ?? body.id ?? "");
+    const store2 = as();
+    const customer = store2.customers.findOneBy("customer_id", id);
+    if (!customer) {
+      return c.json({ message: "Customer not found", code: "not_found" }, 404);
+    }
+    const updated = store2.customers.update(customer.id, {
+      name: typeof body.name === "string" ? body.name : customer.name,
+      email: typeof body.email === "string" ? body.email : customer.email
+    });
+    return c.json(serializeCustomer(store2, updated));
+  });
+  app.post("/v1/balances.track", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const customerId = String(body.customer_id ?? body.customerId ?? "");
+    const featureId = String(body.feature_id ?? body.featureId ?? body.event_name ?? "");
+    if (!customerId || !featureId) {
+      return c.json({ message: "customer_id and feature_id are required", code: "invalid_request" }, 400);
+    }
+    const customer = ensureCustomer(as(), customerId, {});
+    const event = as().events.insert({
+      customer_id: customerId,
+      feature_id: featureId,
+      value: typeof body.value === "number" ? body.value : 1
+    });
+    return c.json({
+      id: `evt_emulate_${event.id}`,
+      code: "event_received",
+      customer_id: customerId,
+      feature_id: featureId,
+      value: event.value,
+      balance: balanceForFeature(as(), customer, featureId) ?? null
+    });
+  });
+  app.post("/v1/balances.check", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const customerId = String(body.customer_id ?? body.customerId ?? "");
+    const featureId = String(body.feature_id ?? body.featureId ?? "");
+    if (!customerId || !featureId) {
+      return c.json({ message: "customer_id and feature_id are required", code: "invalid_request" }, 400);
+    }
+    const requiredBalance = typeof body.required_balance === "number" ? body.required_balance : 1;
+    const entityId = typeof body.entity_id === "string" ? body.entity_id : null;
+    const store2 = as();
+    const customer = ensureCustomer(store2, customerId, body);
+    const balance = balanceForFeature(store2, customer, featureId);
+    const allowed = balance === void 0 || balance.unlimited || balance.overage_allowed || balance.remaining >= requiredBalance;
+    return c.json({
+      allowed,
+      customer_id: customerId,
+      entity_id: entityId,
+      required_balance: requiredBalance,
+      balance: balance ?? null,
+      flag: null
+    });
+  });
+  app.post("/v1/plans.list", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const customerId = String(body.customer_id ?? body.customerId ?? "");
+    const store2 = as();
+    const customer = customerId ? ensureCustomer(store2, customerId, body) : void 0;
+    const list = store2.plans.all().sort((a, b) => a.order - b.order).map((plan) => serializePlan(store2, customer, plan));
+    return c.json({ list });
+  });
+  app.post("/v1/billing.attach", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const customerId = String(body.customer_id ?? body.customerId ?? "");
+    const planId = String(body.plan_id ?? body.product_id ?? body.planId ?? body.productId ?? "");
+    const successUrl = String(body.success_url ?? body.successUrl ?? "");
+    if (!customerId || !planId) {
+      return c.json({ message: "customer_id and plan_id are required", code: "invalid_request" }, 400);
+    }
+    const store2 = as();
+    const customer = ensureCustomer(store2, customerId, body);
+    const plan = store2.plans.findOneBy("plan_id", planId);
+    const requiresPayment = plan ? plan.price != null || plan.free_trial?.card_required === true : true;
+    if (requiresPayment) {
+      const session = store2.checkouts.insert({
+        session_id: "",
+        customer_id: customerId,
+        plan_id: planId,
+        success_url: successUrl,
+        status: "pending"
+      });
+      const sessionId = `cs_emulate_${session.id}`;
+      store2.checkouts.update(session.id, { session_id: sessionId });
+      return c.json({
+        customer_id: customerId,
+        payment_url: `${baseUrl}/checkout/${sessionId}`,
+        invoice: null,
+        required_action: null
+      });
+    }
+    if (plan) {
+      activateSubscription(store2, customer, plan, { trial: plan.free_trial != null });
+    }
+    return c.json({ customer_id: customerId, payment_url: null, invoice: null, required_action: null });
+  });
+  app.post("/v1/billing.open_customer_portal", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const customerId = String(body.customer_id ?? body.customerId ?? "");
+    if (!customerId) {
+      return c.json({ message: "customer_id is required", code: "invalid_request" }, 400);
+    }
+    ensureCustomer(as(), customerId, body);
+    return c.json({ customer_id: customerId, url: `${baseUrl}/checkout/portal/${customerId}` });
+  });
+  app.post("/v1/features.list", async (c) => c.json({ list: [], total: 0, offset: 0, limit: 100 }));
+  app.post("/v1/events.list", async (c) => {
+    const events = as().events.all().map((event) => ({
+      id: `evt_emulate_${event.id}`,
+      customer_id: event.customer_id,
+      feature_id: event.feature_id,
+      value: event.value,
+      timestamp: Date.parse(event.created_at)
+    }));
+    return c.json({ list: events, total: events.length, offset: 0, limit: 100 });
+  });
+}
+
+// src/routes/checkout.ts
+import { renderCardPage, renderCheckoutPage } from "@emulators/core";
+var SERVICE_LABEL = "Autumn";
+function settle(as, session) {
+  const customer = as.customers.findOneBy("customer_id", session.customer_id);
+  const plan = as.plans.findOneBy("plan_id", session.plan_id);
+  if (customer && plan) {
+    activateSubscription(as, customer, plan, { trial: plan.free_trial != null });
+  }
+  as.checkouts.update(session.id, { status: "settled" });
+}
+function checkoutRoutes(ctx) {
+  const { app, store } = ctx;
+  const as = () => getAutumnStore(store);
+  app.post("/checkout/settle", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const customerId = String(body.customer_id ?? body.customerId ?? "");
+    if (!customerId) {
+      return c.json({ message: "customer_id is required", code: "invalid_request" }, 400);
+    }
+    const store2 = as();
+    const sessions = store2.checkouts.findBy("customer_id", customerId).filter((s) => s.status === "completed");
+    for (const session of sessions) {
+      settle(store2, session);
+    }
+    return c.json({ settled: sessions.length });
+  });
+  app.get("/checkout/:sessionId", (c) => {
+    const store2 = as();
+    const session = store2.checkouts.findOneBy("session_id", c.req.param("sessionId"));
+    if (!session) {
+      return c.html(
+        renderCardPage(
+          "Checkout not found",
+          "This checkout session does not exist.",
+          '<p class="empty">The session id is invalid or has been removed.</p>',
+          SERVICE_LABEL
+        ),
+        404
+      );
+    }
+    if (session.status === "settled") {
+      return c.html(
+        renderCardPage(
+          "Checkout complete",
+          "This subscription is already active.",
+          '<p class="empty check">Subscription active</p>',
+          SERVICE_LABEL
+        )
+      );
+    }
+    const plan = store2.plans.findOneBy("plan_id", session.plan_id);
+    const planName = plan?.name ?? session.plan_id;
+    const trialing = plan?.free_trial != null;
+    const dueCents = trialing ? 0 : Math.round((plan?.price?.amount ?? 0) * 100);
+    const lineItems = [
+      {
+        name: trialing ? `${planName} (free trial)` : planName,
+        quantity: 1,
+        unitPrice: dueCents,
+        totalPrice: dueCents,
+        currency: "usd"
+      }
+    ];
+    return c.html(
+      renderCheckoutPage(
+        {
+          merchantName: "Executor",
+          lineItems,
+          subtotal: dueCents,
+          total: dueCents,
+          currency: "usd",
+          sessionId: session.session_id,
+          cancelUrl: session.success_url || null
+        },
+        SERVICE_LABEL
+      )
+    );
+  });
+  app.post("/checkout/:sessionId/complete", async (c) => {
+    const store2 = as();
+    const session = store2.checkouts.findOneBy("session_id", c.req.param("sessionId"));
+    if (!session) {
+      return c.html(
+        renderCardPage("Checkout not found", "This checkout session does not exist.", "", SERVICE_LABEL),
+        404
+      );
+    }
+    if (session.status === "pending") {
+      store2.checkouts.update(session.id, { status: "completed" });
+    }
+    return c.redirect(session.success_url || "/");
+  });
+  app.post("/checkout/:sessionId/settle", (c) => {
+    const store2 = as();
+    const session = store2.checkouts.findOneBy("session_id", c.req.param("sessionId"));
+    if (!session) {
+      return c.json({ message: "checkout not found", code: "not_found" }, 404);
+    }
+    settle(store2, session);
+    return c.json({ settled: 1 });
+  });
+}
+
+// src/routes/openapi.ts
+function openapiRoutes({ app, baseUrl }) {
+  app.get("/openapi.json", (c) => c.json(buildSpec(baseUrl)));
+}
+function ok(description) {
+  return {
+    description,
+    content: { "application/json": { schema: { type: "object" } } }
+  };
+}
+function jsonBody(properties, required, description) {
+  return {
+    required: true,
+    description,
+    content: {
+      "application/json": {
+        schema: { type: "object", properties, required: [...required] }
+      }
+    }
+  };
+}
+function buildSpec(baseUrl) {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Autumn API (Emulated)",
+      version: "1.0.0",
+      description: "Emulated subset of the Autumn v1 API (RPC-style paths, all POST). Authenticate with a bearer secret key (mint one at POST /_emulate/credentials)."
+    },
+    servers: [{ url: baseUrl }],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: "Autumn secret key, sent as `Authorization: Bearer am_sk_\u2026`."
+        }
+      }
+    },
+    security: [{ bearerAuth: [] }],
+    paths: {
+      "/v1/customers.get_or_create": {
+        post: {
+          operationId: "customers.get_or_create",
+          tags: ["customers"],
+          summary: "Get or create a customer",
+          requestBody: jsonBody(
+            {
+              customer_id: { type: "string" },
+              customer_data: {
+                type: "object",
+                properties: { name: { type: "string" }, email: { type: "string" } }
+              },
+              name: { type: "string" },
+              email: { type: "string" }
+            },
+            ["customer_id"],
+            "The customer to fetch or create."
+          ),
+          responses: { 200: ok("The customer."), 400: ok("Validation error.") }
+        }
+      },
+      "/v1/customers.list": {
+        post: {
+          operationId: "customers.list",
+          tags: ["customers"],
+          summary: "List customers",
+          responses: { 200: ok("Customer list.") }
+        }
+      },
+      "/v1/customers.update": {
+        post: {
+          operationId: "customers.update",
+          tags: ["customers"],
+          summary: "Update a customer",
+          requestBody: jsonBody(
+            {
+              customer_id: { type: "string" },
+              name: { type: "string" },
+              email: { type: "string" }
+            },
+            ["customer_id"],
+            "The customer fields to update."
+          ),
+          responses: { 200: ok("The updated customer."), 404: ok("Not found.") }
+        }
+      },
+      "/v1/balances.track": {
+        post: {
+          operationId: "balances.track",
+          tags: ["balances"],
+          summary: "Track a usage event",
+          requestBody: jsonBody(
+            {
+              customer_id: { type: "string" },
+              feature_id: { type: "string" },
+              event_name: { type: "string" },
+              value: { type: "number" }
+            },
+            ["customer_id", "feature_id"],
+            "The usage event to record (`event_name` is accepted as an alias for `feature_id`)."
+          ),
+          responses: { 200: ok("Event confirmation."), 400: ok("Validation error.") }
+        }
+      },
+      "/v1/balances.check": {
+        post: {
+          operationId: "balances.check",
+          tags: ["balances"],
+          summary: "Check feature access for a customer",
+          requestBody: jsonBody(
+            {
+              customer_id: { type: "string" },
+              feature_id: { type: "string" },
+              required_balance: { type: "number" }
+            },
+            ["customer_id", "feature_id"],
+            "The customer and feature to check. `required_balance` defaults to 1."
+          ),
+          responses: { 200: ok("Access decision with the feature balance."), 400: ok("Validation error.") }
+        }
+      },
+      "/v1/plans.list": {
+        post: {
+          operationId: "plans.list",
+          tags: ["plans"],
+          summary: "List plans",
+          responses: { 200: ok("Plan list.") }
+        }
+      },
+      "/v1/features.list": {
+        post: {
+          operationId: "features.list",
+          tags: ["features"],
+          summary: "List features",
+          responses: { 200: ok("Feature list.") }
+        }
+      },
+      "/v1/events.list": {
+        post: {
+          operationId: "events.list",
+          tags: ["events"],
+          summary: "List tracked usage events",
+          responses: { 200: ok("Event list.") }
+        }
+      }
+    }
+  };
+}
+
+// src/index.ts
+function seedPlans(as, plans) {
+  plans.forEach((plan, index) => {
+    const fields = {
+      plan_id: plan.id,
+      name: plan.name ?? plan.id,
+      add_on: plan.add_on ?? false,
+      auto_enable: plan.auto_enable ?? false,
+      price: plan.price ?? null,
+      free_trial: plan.free_trial ?? null,
+      items: plan.items ?? [],
+      order: index
+    };
+    const existing = as.plans.findOneBy("plan_id", plan.id);
+    if (existing) {
+      as.plans.update(existing.id, fields);
+    } else {
+      as.plans.insert(fields);
+    }
+  });
+}
+function seedFromConfig(store, _baseUrl, config) {
+  const as = getAutumnStore(store);
+  if (config.plans) {
+    seedPlans(as, config.plans);
+  }
+  for (const customer of config.customers ?? []) {
+    const existing = as.customers.findOneBy("customer_id", customer.id);
+    if (existing) {
+      as.customers.update(existing.id, {
+        name: customer.name ?? existing.name,
+        email: customer.email ?? existing.email,
+        subscriptions: customer.subscriptions ?? existing.subscriptions
+      });
+      continue;
+    }
+    as.customers.insert({
+      customer_id: customer.id,
+      name: customer.name ?? null,
+      email: customer.email ?? null,
+      subscriptions: customer.subscriptions ?? []
+    });
+  }
+}
+var autumnPlugin = {
+  name: "autumn",
+  register(app, store, webhooks, baseUrl, tokenMap) {
+    const ctx = { app, store, webhooks, baseUrl, tokenMap };
+    autumnApiRoutes(ctx);
+    checkoutRoutes(ctx);
+    openapiRoutes(ctx);
+  },
+  seed(_store, _baseUrl) {
+  }
+};
+var index_default = autumnPlugin;
+export {
+  autumnPlugin,
+  index_default as default,
+  getAutumnStore,
+  seedFromConfig
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pleaseai/emulate-autumn",
+  "type": "module",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pleaseai/emulate.git",
+    "directory": "packages/autumn"
+  },
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup --clean",
+    "dev": "tsup --watch",
+    "test": "bun test",
+    "clean": "rm -rf dist .turbo",
+    "type-check": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@emulators/core": "^0.6.0"
+  },
+  "devDependencies": {
+    "autumn-js": "1.2.28",
+    "tsup": "^8",
+    "typescript": "^6"
+  }
+}