@basaltkit/subscriptions 1.0.0

package/dist/index.js

@@ -0,0 +1,718 @@
+// src/plans.ts
+import { BasaltError } from "@basaltkit/core";
+var UnknownPlanError = class extends BasaltError {
+  constructor(plan) {
+    super("BILLING_UNKNOWN_PLAN", `Plan "${plan}" is not defined in definePlans().`);
+  }
+};
+function meter(limit) {
+  return { meter: true, limit };
+}
+function definePlans(plans) {
+  return plans;
+}
+function planPrice(plan, period) {
+  if (plan.price === "custom") return "custom";
+  return typeof plan.price === "number" ? plan.price : plan.price[period];
+}
+function featureLimit(value) {
+  if (value === void 0 || value === false) return 0;
+  if (value === true) return Number.POSITIVE_INFINITY;
+  return typeof value === "number" ? value : value.limit;
+}
+function isMeter(value) {
+  return typeof value === "object" && value !== null && value.meter === true;
+}
+
+// src/stores.ts
+var MemorySubscriptionStore = class {
+  records = /* @__PURE__ */ new Map();
+  async get(billableId) {
+    return this.records.get(billableId) ?? null;
+  }
+  async save(record) {
+    this.records.set(record.billableId, { ...record });
+  }
+  async all() {
+    return [...this.records.values()].map((record) => ({ ...record }));
+  }
+};
+var MemoryWebhookStore = class {
+  seen = /* @__PURE__ */ new Set();
+  async markProcessed(id) {
+    if (this.seen.has(id)) return false;
+    this.seen.add(id);
+    return true;
+  }
+  async release(id) {
+    this.seen.delete(id);
+  }
+};
+var MemoryUsageStore = class {
+  counters = /* @__PURE__ */ new Map();
+  key(billableId, feature, periodKey) {
+    return `${billableId}::${feature}::${periodKey}`;
+  }
+  async get(billableId, feature, periodKey) {
+    return this.counters.get(this.key(billableId, feature, periodKey)) ?? 0;
+  }
+  async increment(billableId, feature, periodKey, amount) {
+    const key = this.key(billableId, feature, periodKey);
+    const total = (this.counters.get(key) ?? 0) + amount;
+    this.counters.set(key, total);
+    return total;
+  }
+  async consume(billableId, feature, periodKey, amount, limit) {
+    const key = this.key(billableId, feature, periodKey);
+    const current = this.counters.get(key) ?? 0;
+    if (current + amount > limit) return { applied: false, used: current };
+    const total = current + amount;
+    this.counters.set(key, total);
+    return { applied: true, used: total };
+  }
+};
+
+// src/drivers/redis-usage.ts
+var CONSUME_SCRIPT = `
+local current = tonumber(redis.call('GET', KEYS[1]) or '0')
+local amount = tonumber(ARGV[1])
+local limit = tonumber(ARGV[2])
+local ttl = tonumber(ARGV[3])
+if current + amount > limit then
+  return {0, current}
+end
+local total = redis.call('INCRBY', KEYS[1], amount)
+if ttl > 0 then
+  redis.call('EXPIRE', KEYS[1], ttl)
+end
+return {1, total}
+`.trim();
+var RedisUsageStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "basalt:usage";
+    this.ttlSeconds = options.ttlSeconds ?? 60 * 24 * 60 * 60;
+  }
+  redis;
+  prefix;
+  ttlSeconds;
+  key(billableId, feature, periodKey) {
+    return `${this.prefix}:${billableId}:${feature}:${periodKey}`;
+  }
+  ttlFor(periodKey) {
+    return periodKey === "lifetime" ? 0 : this.ttlSeconds;
+  }
+  async get(billableId, feature, periodKey) {
+    const raw = await this.redis.get(this.key(billableId, feature, periodKey));
+    return raw === null ? 0 : Number(raw);
+  }
+  async increment(billableId, feature, periodKey, amount) {
+    const reply = await this.redis.eval(
+      CONSUME_SCRIPT,
+      1,
+      this.key(billableId, feature, periodKey),
+      amount,
+      Number.MAX_SAFE_INTEGER,
+      this.ttlFor(periodKey)
+    );
+    return Number(reply[1]);
+  }
+  async consume(billableId, feature, periodKey, amount, limit) {
+    const reply = await this.redis.eval(
+      CONSUME_SCRIPT,
+      1,
+      this.key(billableId, feature, periodKey),
+      amount,
+      limit,
+      this.ttlFor(periodKey)
+    );
+    return { applied: Number(reply[0]) === 1, used: Number(reply[1]) };
+  }
+};
+
+// src/drivers/redis-webhook.ts
+var RedisWebhookStore = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "basalt:webhook";
+    this.ttlSeconds = options.ttlSeconds ?? 7 * 24 * 60 * 60;
+  }
+  redis;
+  prefix;
+  ttlSeconds;
+  key(id) {
+    return `${this.prefix}:${id}`;
+  }
+  async markProcessed(id) {
+    const result = await this.redis.set(this.key(id), "1", "EX", this.ttlSeconds, "NX");
+    return result === "OK";
+  }
+  async release(id) {
+    await this.redis.del(this.key(id));
+  }
+};
+
+// src/gateway.ts
+import { BasaltError as BasaltError2 } from "@basaltkit/core";
+var WebhookInvalidError = class extends BasaltError2 {
+  status = 400;
+  constructor() {
+    super("BILLING_WEBHOOK_INVALID", "Webhook signature verification failed.");
+  }
+};
+var FakeBillingGateway = class {
+  name = "fake";
+  created = [];
+  canceled = [];
+  checkouts = [];
+  portals = [];
+  swaps = [];
+  counter = 0;
+  async createSubscription(input) {
+    this.created.push(input);
+    return { gatewayRef: `fake_sub_${++this.counter}` };
+  }
+  async cancelSubscription(gatewayRef, options) {
+    this.canceled.push({ gatewayRef, atPeriodEnd: options.atPeriodEnd });
+  }
+  async createCheckoutSession(input) {
+    this.checkouts.push(input);
+    const id = `fake_cs_${++this.counter}`;
+    return { url: `https://fake.test/checkout/${id}`, id };
+  }
+  async createPortalSession(input) {
+    this.portals.push(input);
+    return { url: `https://fake.test/portal/${input.billableId}` };
+  }
+  async swapSubscription(gatewayRef, input) {
+    this.swaps.push({ gatewayRef, input });
+  }
+  verifyWebhook(rawBody, signature) {
+    if (signature !== "valid") throw new WebhookInvalidError();
+    return JSON.parse(rawBody);
+  }
+};
+
+// src/drivers/stripe.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { BasaltError as BasaltError3 } from "@basaltkit/core";
+var StripeRequestError = class extends BasaltError3 {
+  constructor(httpStatus, message) {
+    super("BILLING_GATEWAY_ERROR", `Stripe request failed (${httpStatus}): ${message}`);
+    this.httpStatus = httpStatus;
+  }
+  httpStatus;
+};
+var EVENT_MAP = {
+  "customer.subscription.deleted": "subscription.canceled",
+  "invoice.payment_failed": "payment.failed",
+  "invoice.paid": "payment.succeeded",
+  "invoice.payment_succeeded": "payment.succeeded"
+};
+var StripeBillingGateway = class {
+  constructor(options) {
+    this.options = options;
+    this.fetch = options.fetch ?? globalThis.fetch;
+    this.now = options.now ?? Date.now;
+    this.tolerance = options.tolerance ?? 300;
+    this.apiBase = options.apiBase ?? "https://api.stripe.com";
+    this.resolveBillableId = options.resolveBillableId ?? ((event) => event?.data?.object?.metadata?.["billableId"]);
+  }
+  options;
+  name = "stripe";
+  fetch;
+  now;
+  tolerance;
+  apiBase;
+  resolveBillableId;
+  async createSubscription(input) {
+    const customer = await this.options.customerId(input.billableId);
+    const price = this.options.priceId(input.plan, input.period);
+    const created = await this.request("POST", "/v1/subscriptions", {
+      customer,
+      "items[0][price]": price,
+      "metadata[billableId]": input.billableId,
+      ...input.trialDays !== void 0 ? { trial_period_days: String(input.trialDays) } : {}
+    });
+    return { gatewayRef: String(created.id) };
+  }
+  async cancelSubscription(gatewayRef, options) {
+    if (options.atPeriodEnd) {
+      await this.request("POST", `/v1/subscriptions/${gatewayRef}`, {
+        cancel_at_period_end: "true"
+      });
+    } else {
+      await this.request("DELETE", `/v1/subscriptions/${gatewayRef}`);
+    }
+  }
+  async createCheckoutSession(input) {
+    const customer = await this.options.customerId(input.billableId);
+    const created = await this.request("POST", "/v1/checkout/sessions", {
+      mode: "subscription",
+      customer,
+      "line_items[0][price]": this.options.priceId(input.plan, input.period),
+      "line_items[0][quantity]": "1",
+      success_url: input.successUrl,
+      cancel_url: input.cancelUrl,
+      "subscription_data[metadata][billableId]": input.billableId,
+      ...input.trialDays !== void 0 ? { "subscription_data[trial_period_days]": String(input.trialDays) } : {}
+    });
+    return { url: String(created.url), id: String(created.id) };
+  }
+  async createPortalSession(input) {
+    const customer = await this.options.customerId(input.billableId);
+    const created = await this.request("POST", "/v1/billing_portal/sessions", {
+      customer,
+      return_url: input.returnUrl
+    });
+    return { url: String(created.url) };
+  }
+  async swapSubscription(gatewayRef, input) {
+    const sub = await this.request("GET", `/v1/subscriptions/${gatewayRef}`);
+    const itemId = sub.items?.data?.[0]?.id;
+    if (!itemId) throw new StripeRequestError(500, "subscription has no line item to update");
+    await this.request("POST", `/v1/subscriptions/${gatewayRef}`, {
+      "items[0][id]": itemId,
+      "items[0][price]": this.options.priceId(input.plan, input.period),
+      proration_behavior: input.prorationBehavior ?? "create_prorations"
+    });
+  }
+  verifyWebhook(rawBody, signature) {
+    if (!signature) throw new WebhookInvalidError();
+    const parts = Object.fromEntries(
+      signature.split(",").map((pair) => {
+        const index = pair.indexOf("=");
+        return [pair.slice(0, index), pair.slice(index + 1)];
+      })
+    );
+    const timestamp = Number(parts.t);
+    if (!Number.isFinite(timestamp) || !parts.v1) throw new WebhookInvalidError();
+    const expected = createHmac("sha256", this.options.webhookSecret).update(`${timestamp}.${rawBody}`).digest("hex");
+    const received = parts.v1;
+    const a = Buffer.from(expected);
+    const b = Buffer.from(received);
+    if (a.length !== b.length || !timingSafeEqual(a, b)) throw new WebhookInvalidError();
+    if (Math.abs(this.now() / 1e3 - timestamp) > this.tolerance) throw new WebhookInvalidError();
+    let event;
+    try {
+      event = JSON.parse(rawBody);
+    } catch {
+      throw new WebhookInvalidError();
+    }
+    const type = event.type ? EVENT_MAP[event.type] : void 0;
+    if (!type || !event.id) return null;
+    const billableId = this.resolveBillableId(event);
+    if (!billableId) return null;
+    const obj = event.data?.object;
+    const gatewayRef = obj?.subscription ?? obj?.id;
+    return { id: event.id, type, billableId, ...gatewayRef ? { gatewayRef } : {} };
+  }
+  async request(method, path, body) {
+    const response = await this.fetch(`${this.apiBase}${path}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.options.secretKey}`,
+        "content-type": "application/x-www-form-urlencoded"
+      },
+      ...body ? { body: formEncode(body) } : {}
+    });
+    const text = await response.text();
+    const json = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+      const message = json.error?.message ?? text ?? "unknown error";
+      throw new StripeRequestError(response.status, message);
+    }
+    return json;
+  }
+};
+function formEncode(data) {
+  return Object.entries(data).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+
+// src/subscriptions.ts
+import { BasaltError as BasaltError4, parseDuration } from "@basaltkit/core";
+var NotSubscribedError = class extends BasaltError4 {
+  status = 402;
+  constructor() {
+    super("BILLING_SUBSCRIPTION_REQUIRED", "An active subscription is required.");
+  }
+};
+var FeatureUnavailableError = class extends BasaltError4 {
+  status = 403;
+  constructor(feature) {
+    super("BILLING_FEATURE_UNAVAILABLE", `The feature "${feature}" is not available on this plan.`);
+  }
+};
+var QuotaExceededError = class extends BasaltError4 {
+  status = 402;
+  constructor(feature, remaining) {
+    super(
+      "BILLING_QUOTA_EXCEEDED",
+      `Quota exceeded for "${feature}" (remaining: ${remaining}).`
+    );
+  }
+};
+var GatewayUnsupportedError = class extends BasaltError4 {
+  status = 501;
+  constructor(capability) {
+    super("BILLING_GATEWAY_UNSUPPORTED", `The billing gateway does not support "${capability}".`);
+  }
+};
+var currentMeterPeriod = () => (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
+var Subscriptions = class {
+  plans;
+  store;
+  usage;
+  gateway;
+  fallbackPlan;
+  hooks;
+  webhooks;
+  constructor(options) {
+    this.plans = options.plans;
+    this.store = options.store ?? new MemorySubscriptionStore();
+    this.usage = options.usage ?? new MemoryUsageStore();
+    this.gateway = options.gateway;
+    this.webhooks = options.webhooks ?? new MemoryWebhookStore();
+    this.fallbackPlan = options.fallbackPlan;
+    this.hooks = options.hooks;
+    if (options.fallbackPlan) this.plan(options.fallbackPlan);
+  }
+  plan(name) {
+    const plan = this.plans[name];
+    if (!plan) throw new UnknownPlanError(name);
+    return plan;
+  }
+  async subscribe(billableId, planName, options = {}) {
+    const plan = this.plan(planName);
+    const period = options.period ?? "monthly";
+    const price = planPrice(plan, period);
+    const record = {
+      billableId,
+      plan: planName,
+      period,
+      status: plan.trial ? "trialing" : "active",
+      ...plan.trial ? { trialEndsAt: Date.now() + parseDuration(plan.trial) } : {}
+    };
+    if (this.gateway && typeof price === "number" && price > 0) {
+      const trialDays = plan.trial ? Math.max(1, Math.ceil(parseDuration(plan.trial) / 864e5)) : void 0;
+      const { gatewayRef } = await this.gateway.createSubscription({
+        billableId,
+        plan: planName,
+        period,
+        price,
+        ...trialDays !== void 0 ? { trialDays } : {}
+      });
+      record.gatewayRef = gatewayRef;
+    }
+    await this.store.save(record);
+    await this.hooks?.emit("billing:subscribed", { subscription: record });
+    return record;
+  }
+  /**
+   * Starts a hosted Checkout flow for a paid plan. Records the intended
+   * subscription locally as `incomplete` — it becomes `active` when the
+   * gateway confirms payment via webhook (`payment.succeeded`). Returns the
+   * URL to redirect the customer to.
+   */
+  async checkout(billableId, planName, options) {
+    const plan = this.plan(planName);
+    if (!this.gateway?.createCheckoutSession) throw new GatewayUnsupportedError("checkout");
+    const period = options.period ?? "monthly";
+    const trialDays = plan.trial ? Math.max(1, Math.ceil(parseDuration(plan.trial) / 864e5)) : void 0;
+    const session = await this.gateway.createCheckoutSession({
+      billableId,
+      plan: planName,
+      period,
+      successUrl: options.successUrl,
+      cancelUrl: options.cancelUrl,
+      ...trialDays !== void 0 ? { trialDays } : {}
+    });
+    const record = { billableId, plan: planName, period, status: "incomplete" };
+    await this.store.save(record);
+    await this.hooks?.emit("billing:checkout_started", { billableId, plan: planName, url: session.url });
+    return { url: session.url };
+  }
+  /**
+   * Opens a Customer Portal session for self-service billing (update card,
+   * change plan, cancel). Returns the URL to redirect the customer to.
+   */
+  async portal(billableId, options) {
+    if (!this.gateway?.createPortalSession) throw new GatewayUnsupportedError("portal");
+    return this.gateway.createPortalSession({ billableId, returnUrl: options.returnUrl });
+  }
+  async get(billableId) {
+    return this.store.get(billableId);
+  }
+  /** Active = status active, or trialing with the trial still running. */
+  async subscribed(billableId, plan) {
+    const record = await this.store.get(billableId);
+    if (!record) return false;
+    if (plan && record.plan !== plan) return false;
+    return this.isActive(record);
+  }
+  async onTrial(billableId) {
+    const record = await this.store.get(billableId);
+    return record?.status === "trialing" && record.trialEndsAt !== void 0 && record.trialEndsAt > Date.now();
+  }
+  /**
+   * Changes the plan on an active subscription. When the subscription is
+   * gateway-backed, the change is pushed to the gateway with proration so the
+   * customer is credited/charged the mid-cycle difference (pass
+   * `{ prorate: false }` to switch at the next renewal with no immediate
+   * settlement).
+   */
+  async swap(billableId, planName, options = {}) {
+    const record = await this.store.get(billableId);
+    if (!record || !this.isActive(record)) throw new NotSubscribedError();
+    this.plan(planName);
+    const from = record.plan;
+    if (record.gatewayRef && this.gateway?.swapSubscription) {
+      await this.gateway.swapSubscription(record.gatewayRef, {
+        plan: planName,
+        period: record.period,
+        prorationBehavior: options.prorate === false ? "none" : "create_prorations"
+      });
+    }
+    record.plan = planName;
+    await this.store.save(record);
+    await this.hooks?.emit("billing:swapped", { subscription: record, from });
+    return record;
+  }
+  async cancel(billableId, options = {}) {
+    const record = await this.store.get(billableId);
+    if (!record) throw new NotSubscribedError();
+    const atPeriodEnd = options.atPeriodEnd ?? true;
+    if (record.gatewayRef) {
+      await this.gateway?.cancelSubscription(record.gatewayRef, { atPeriodEnd });
+    }
+    if (atPeriodEnd) {
+      record.cancelAtPeriodEnd = true;
+    } else {
+      record.status = "canceled";
+      record.canceledAt = Date.now();
+    }
+    await this.store.save(record);
+    await this.hooks?.emit("billing:canceled", { subscription: record });
+    return record;
+  }
+  async resume(billableId) {
+    const record = await this.store.get(billableId);
+    if (!record || record.status === "canceled") throw new NotSubscribedError();
+    record.cancelAtPeriodEnd = false;
+    await this.store.save(record);
+    return record;
+  }
+  /** Feature checks and consumption, Soulbscription-style. */
+  features(billableId) {
+    const resolve = async () => {
+      const record = await this.store.get(billableId);
+      if (record && this.isActive(record)) return this.plan(record.plan);
+      return this.fallbackPlan ? this.plan(this.fallbackPlan) : null;
+    };
+    const periodKey = (plan, feature) => isMeter(plan.features[feature]) ? currentMeterPeriod() : "lifetime";
+    return {
+      can: async (feature) => {
+        const plan = await resolve();
+        return plan !== null && featureLimit(plan.features[feature]) > 0;
+      },
+      limit: async (feature) => {
+        const plan = await resolve();
+        return plan ? featureLimit(plan.features[feature]) : 0;
+      },
+      usage: async (feature) => {
+        const plan = await resolve();
+        if (!plan) return 0;
+        return this.usage.get(billableId, feature, periodKey(plan, feature));
+      },
+      remaining: async (feature) => {
+        const plan = await resolve();
+        if (!plan) return 0;
+        const limit = featureLimit(plan.features[feature]);
+        if (limit === Number.POSITIVE_INFINITY) return limit;
+        const used = await this.usage.get(billableId, feature, periodKey(plan, feature));
+        return Math.max(0, limit - used);
+      },
+      consume: async (feature, amount = 1) => {
+        const plan = await resolve();
+        if (!plan) throw new FeatureUnavailableError(feature);
+        const limit = featureLimit(plan.features[feature]);
+        if (limit === 0) throw new FeatureUnavailableError(feature);
+        const key = periodKey(plan, feature);
+        if (limit === Number.POSITIVE_INFINITY) {
+          return this.usage.increment(billableId, feature, key, amount);
+        }
+        const result = await this.usage.consume(billableId, feature, key, amount, limit);
+        if (!result.applied) {
+          throw new QuotaExceededError(feature, Math.max(0, limit - result.used));
+        }
+        return result.used;
+      }
+    };
+  }
+  /**
+   * Applies a gateway webhook: idempotent by event id, updates local state
+   * and emits domain hooks. Local state is the read model — feature checks
+   * never call the gateway.
+   */
+  async handleWebhook(event) {
+    const fresh = await this.webhooks.markProcessed(event.id);
+    if (!fresh) return false;
+    try {
+      const record = await this.store.get(event.billableId);
+      if (record) {
+        if (event.gatewayRef && !record.gatewayRef) record.gatewayRef = event.gatewayRef;
+        if (event.type === "subscription.canceled") {
+          record.status = "canceled";
+          record.canceledAt = Date.now();
+        } else if (event.type === "payment.failed") {
+          record.status = "past_due";
+        } else if (event.type === "payment.succeeded") {
+          record.status = "active";
+          record.cancelAtPeriodEnd = false;
+        }
+        await this.store.save(record);
+      }
+    } catch (error) {
+      await this.webhooks.release(event.id);
+      throw error;
+    }
+    await this.hooks?.emit("billing:webhook", { event });
+    return true;
+  }
+  /**
+   * Maintenance (run from the scheduler): settles expired local trials.
+   * Gateway-backed trials are settled by the gateway's webhook, not here.
+   */
+  async expireTrials() {
+    const expired = [];
+    for (const record of await this.store.all()) {
+      if (record.status === "trialing" && record.trialEndsAt !== void 0 && record.trialEndsAt <= Date.now() && record.gatewayRef === void 0) {
+        const price = planPrice(this.plan(record.plan), record.period);
+        record.status = typeof price === "number" && price === 0 ? "active" : "past_due";
+        await this.store.save(record);
+        expired.push(record);
+        await this.hooks?.emit("billing:trial_expired", { subscription: record });
+      }
+    }
+    return expired;
+  }
+  isActive(record) {
+    if (record.status === "active") return true;
+    return record.status === "trialing" && record.trialEndsAt !== void 0 && record.trialEndsAt > Date.now();
+  }
+};
+
+// src/plugin.ts
+import { createToken, ctx, definePlugin, ensureMetadata } from "@basaltkit/core";
+import { route } from "@basaltkit/fastify";
+import { z } from "zod";
+var SUBSCRIPTIONS = createToken("subscriptions");
+function subscriptionsPlugin(options) {
+  return definePlugin({
+    name: "basalt:subscriptions",
+    register({ container, hooks }) {
+      container.singleton(SUBSCRIPTIONS, () => new Subscriptions({ ...options, hooks }));
+      const guard = async ({ route: definition, context, container: c }) => {
+        const requiredSubscription = definition.meta?.["subscribed"];
+        const requiredFeature = definition.meta?.["feature"];
+        if (requiredSubscription === void 0 && requiredFeature === void 0) return;
+        const subscriptions2 = c.get(SUBSCRIPTIONS);
+        const billableId = context.tenant?.id;
+        if (requiredSubscription !== void 0) {
+          if (!billableId) throw new NotSubscribedError();
+          const plan = typeof requiredSubscription === "string" ? requiredSubscription : void 0;
+          if (!await subscriptions2.subscribed(billableId, plan)) {
+            throw new NotSubscribedError();
+          }
+        }
+        if (typeof requiredFeature === "string") {
+          if (!billableId || !await subscriptions2.features(billableId).can(requiredFeature)) {
+            throw new FeatureUnavailableError(requiredFeature);
+          }
+        }
+      };
+      ensureMetadata(container).add("http:guards", guard);
+    }
+  });
+}
+var billable = () => {
+  const id = ctx().tenant?.id;
+  if (!id) throw new NotSubscribedError();
+  return id;
+};
+var subscriptions = () => ctx().container.get(SUBSCRIPTIONS);
+function billingRoutes(options) {
+  const portalReturn = options.portalReturnUrl ?? options.successUrl;
+  return [
+    route({
+      method: "POST",
+      url: "/billing/checkout",
+      body: z.object({
+        plan: z.string(),
+        period: z.enum(["monthly", "yearly"]).optional(),
+        successUrl: z.string().url().optional(),
+        cancelUrl: z.string().url().optional()
+      }),
+      async handler({ body }) {
+        return subscriptions().checkout(billable(), body.plan, {
+          successUrl: body.successUrl ?? options.successUrl,
+          cancelUrl: body.cancelUrl ?? options.cancelUrl,
+          ...body.period !== void 0 ? { period: body.period } : {}
+        });
+      }
+    }),
+    route({
+      method: "POST",
+      url: "/billing/portal",
+      body: z.object({ returnUrl: z.string().url().optional() }).optional(),
+      async handler({ body }) {
+        return subscriptions().portal(billable(), { returnUrl: body?.returnUrl ?? portalReturn });
+      }
+    })
+  ];
+}
+function billingWebhookRoute(gateway) {
+  return route({
+    method: "POST",
+    url: "/billing/webhook",
+    body: z.unknown(),
+    async handler({ request, reply }) {
+      const rawBody = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
+      const header = request.headers["stripe-signature"] ?? request.headers["x-billing-signature"];
+      const event = gateway.verifyWebhook(
+        rawBody,
+        Array.isArray(header) ? header[0] : header
+      );
+      const subscriptions2 = ctx().container.get(SUBSCRIPTIONS);
+      if (!event) return reply.code(200).send({ received: true, ignored: true });
+      const applied = await subscriptions2.handleWebhook(event);
+      return reply.code(200).send({ received: true, duplicate: !applied });
+    }
+  });
+}
+export {
+  FakeBillingGateway,
+  FeatureUnavailableError,
+  GatewayUnsupportedError,
+  MemorySubscriptionStore,
+  MemoryUsageStore,
+  MemoryWebhookStore,
+  NotSubscribedError,
+  QuotaExceededError,
+  RedisUsageStore,
+  RedisWebhookStore,
+  SUBSCRIPTIONS,
+  StripeBillingGateway,
+  StripeRequestError,
+  Subscriptions,
+  UnknownPlanError,
+  WebhookInvalidError,
+  billingRoutes,
+  billingWebhookRoute,
+  definePlans,
+  featureLimit,
+  isMeter,
+  meter,
+  planPrice,
+  subscriptionsPlugin
+};