@fonderie/billing 5.0.2 → 5.3.0

package/dist/index.js

@@ -42,6 +42,54 @@ var recordUsageSchema = z.object({
   quantity: z.number().min(0).optional()
 });
 
+// src/services/price-cache.ts
+var PriceCache = class {
+  ttl;
+  grace;
+  maxStale;
+  byId = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.ttl = opts.ttlMs ?? 3e5;
+    this.grace = opts.graceMs ?? 36e5;
+    this.maxStale = opts.maxStaleMs ?? 864e5;
+  }
+  async byPriceId(priceId, provider) {
+    const now = Date.now();
+    const hit = this.byId.get(priceId);
+    if (hit && now - hit.at < this.ttl) return { price: hit.price, stale: false };
+    let fresh;
+    try {
+      fresh = await this.single(priceId, () => provider.resolvePriceById(priceId));
+    } catch {
+      if (hit && now - hit.at < this.maxStale) return { price: hit.price, stale: true };
+      return { price: null, stale: true };
+    }
+    if (fresh) {
+      this.byId.set(priceId, { price: fresh, at: now });
+      return { price: fresh, stale: false };
+    }
+    if (hit && now - hit.at < this.grace) return { price: hit.price, stale: true };
+    return { price: null, stale: true };
+  }
+  invalidate(priceId) {
+    if (priceId) this.byId.delete(priceId);
+    else this.byId.clear();
+  }
+  /** Warm the cache with prices already resolved elsewhere (e.g. boot guard). */
+  prime(prices) {
+    const now = Date.now();
+    for (const p of prices) this.byId.set(p.priceId, { price: p, at: now });
+  }
+  single(key, run) {
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+    const p = run().finally(() => this.inflight.delete(key));
+    this.inflight.set(key, p);
+    return p;
+  }
+};
+
 // src/controllers/plan.controller.ts
 import { setApiResponse, HTTP, stringOrEmpty, numberOrZero } from "@fonderie/core";
 
@@ -52,6 +100,18 @@ function getPlans(config) {
 function getPlanByName(name, config) {
   return config.plans.find((p) => p.name.toLowerCase() === name.toLowerCase()) ?? null;
 }
+function resolvePlanNameByPrice(price, plans) {
+  const find = (pred) => plans.find((pl) => pred(pl.monthly) || pred(pl.yearly))?.name ?? null;
+  if (price.lookupKey) {
+    const m = find((p) => p?.lookupKey === price.lookupKey);
+    if (m) return m;
+  }
+  if (price.priceId) {
+    const m = find((p) => p?.priceId === price.priceId);
+    if (m) return m;
+  }
+  return null;
+}
 async function syncPlansToDB(config, store) {
   const plans = config.plans;
   if (plans.length === 0) return;
@@ -270,12 +330,41 @@ function toUsageRecordDTO(record) {
 }
 
 // src/controllers/plan.controller.ts
-function planController(store) {
+async function hydratePricing(dto, plan, config, cache) {
+  try {
+    let stale = false;
+    const resolve = async (priceId) => {
+      if (!priceId) return null;
+      const r = await cache.byPriceId(priceId, config.provider);
+      if (r.stale) stale = true;
+      return r.price;
+    };
+    const [m, y] = await Promise.all([resolve(plan.monthlyPriceId), resolve(plan.yearlyPriceId)]);
+    if (m && y && m.currency !== y.currency) {
+      throw new Error(
+        `[billing] plan "${plan.name}": monthly/yearly currency mismatch (${m.currency} vs ${y.currency})`
+      );
+    }
+    if (m) dto.pricing.monthly = m.unitAmount;
+    if (y) dto.pricing.yearly = y.unitAmount;
+    const currency = m?.currency ?? y?.currency;
+    if (currency) dto.pricing.currency = currency.toUpperCase();
+    if (stale) dto.pricingStale = true;
+  } catch (err) {
+    console.error(`[billing] pricing hydration failed for "${plan.name}":`, err.message);
+    dto.pricingStale = true;
+  }
+}
+function planController(store, config, cache) {
   const plans = new PlanModel(store);
+  const hydrate = config.pricing?.hydration === true;
   return {
     async list(_ctx) {
       const list = await plans.list();
       const dtos = list.map(toPlanDTO);
+      if (hydrate) {
+        await Promise.all(dtos.map((dto, i) => hydratePricing(dto, list[i], config, cache)));
+      }
       return setApiResponse(HTTP.OK, "PLAN_LIST", `Retrieved ${list.length} workspace plans`, {
         plans: dtos
       });
@@ -286,8 +375,10 @@ function planController(store) {
       if (!id) return setApiResponse(HTTP.BAD_REQUEST, "INVALID_PARAMETER", "Plan ID required");
       const plan = await plans.findById(id);
       if (!plan) return setApiResponse(HTTP.NOT_FOUND, "NOT_FOUND", "Plan not found");
+      const dto = toPlanDTO(plan);
+      if (hydrate) await hydratePricing(dto, plan, config, cache);
       return setApiResponse(HTTP.OK, "PLAN_FETCHED", "Plan retrieved successfully.", {
-        plan: toPlanDTO(plan)
+        plan: dto
       });
     },
     async create(ctx) {
@@ -544,6 +635,43 @@ function checkoutController(store, config) {
           `Plan ${planName} does not support ${interval} billing`
         );
       }
+      const current = await subscriptions.get(subscriber.type, subscriber.id);
+      const ACTIVE = ["active", "trialing", "past_due"];
+      if (current && ACTIVE.includes(current.status)) {
+        const currentTier = plans.findByNameInConfig(current.plan, config)?.tier ?? -1;
+        const targetTier = plan.tier ?? -1;
+        if (targetTier <= currentTier) {
+          return setApiResponse3(
+            HTTP3.UNPROCESSABLE,
+            "DOWNGRADE_NOT_ALLOWED",
+            `Cannot switch from ${current.plan} to a same-or-lower tier (${planName}) mid-cycle. Upgrades only.`
+          );
+        }
+        if (current.providerSubscriptionId) {
+          const res = await config.provider.updateSubscription({
+            subscriptionId: current.providerSubscriptionId,
+            priceId: pricing.priceId
+          });
+          const upsert = {
+            subscriberType: subscriber.type,
+            subscriberId: subscriber.id,
+            plan: planName,
+            interval,
+            status: res.status,
+            providerSubscriptionId: current.providerSubscriptionId
+          };
+          if (current.providerCustomerId) upsert.providerCustomerId = current.providerCustomerId;
+          if (res.currentPeriodStart) upsert.currentPeriodStart = res.currentPeriodStart;
+          if (res.currentPeriodEnd) upsert.currentPeriodEnd = res.currentPeriodEnd;
+          await subscriptions.upsert(upsert);
+          return setApiResponse3(
+            HTTP3.OK,
+            "SUBSCRIPTION_UPGRADED",
+            "Subscription upgraded; the prorated difference was charged.",
+            { upgraded: true, plan: planName }
+          );
+        }
+      }
       const { customerId } = await config.provider.createCustomer({
         email: ctx.user.email ?? "",
         subscriberType: subscriber.type,
@@ -683,7 +811,7 @@ function usageController(store) {
 
 // src/controllers/webhook.controller.ts
 import { setApiResponse as setApiResponse5, HTTP as HTTP5 } from "@fonderie/core";
-function webhookController(store, config) {
+function webhookController(store, config, priceCache) {
   const subscriptions = new SubscriptionModel(store);
   return {
     async handle(ctx) {
@@ -705,11 +833,15 @@ function webhookController(store, config) {
       } catch {
         return setApiResponse5(HTTP5.BAD_REQUEST, "INVALID_REQUEST", "Invalid webhook signature");
       }
+      if (priceCache && (event.type.startsWith("price.") || event.type.startsWith("product."))) {
+        priceCache.invalidate();
+      }
       if (event.subscription) {
+        const plan = event.type === "customer.subscription.deleted" ? event.subscription.plan : resolvePlanNameByPrice(event.subscription, config.plans) ?? event.subscription.plan;
         await subscriptions.upsert({
           subscriberType: event.subscription.subscriberType,
           subscriberId: event.subscription.subscriberId,
-          plan: event.subscription.plan,
+          plan,
           interval: event.subscription.interval,
           status: event.subscription.status,
           providerCustomerId: event.subscription.providerCustomerId,
@@ -727,11 +859,16 @@ function webhookController(store, config) {
 
 // src/routes.ts
 function buildBillingRoutes(store, config) {
-  const plan = planController(store);
+  const priceCache = new PriceCache({
+    ttlMs: config.pricing?.cacheTtlMs,
+    graceMs: config.pricing?.transferGraceMs,
+    maxStaleMs: config.pricing?.maxStaleMs
+  });
+  const plan = planController(store, config, priceCache);
   const subscription = subscriptionController(store);
   const checkout = checkoutController(store, config);
   const usage = usageController(store);
-  const webhook = webhookController(store, config);
+  const webhook = webhookController(store, config, priceCache);
   return [
     // Plans — public read-only
     ["GET", "/plans", plan.list],
@@ -954,6 +1091,9 @@ var BillingModule = class {
   }
 };
 
+// src/types.ts
+var BILLING_INTERVAL = { MONTH: "month", YEAR: "year" };
+
 // src/providers/stripe.ts
 var _client = null;
 async function getClient(secretKey) {
@@ -974,6 +1114,8 @@ function normalizeSubscription(sub) {
     subscriberType: sub.metadata?.["subscriberType"] ?? "workspace",
     subscriberId: sub.metadata?.["subscriberId"] ?? "",
     plan: item?.price.nickname ?? "unknown",
+    priceLookupKey: item?.price.lookup_key ?? null,
+    priceId: item?.price.id ?? null,
     status: sub.status,
     providerCustomerId: sub.customer,
     providerSubscriptionId: sub.id,
@@ -981,7 +1123,19 @@ function normalizeSubscription(sub) {
     currentPeriodEnd: periodEnd ? new Date(periodEnd * 1e3) : /* @__PURE__ */ new Date(),
     cancelAtPeriodEnd: sub.cancel_at_period_end,
     trialEndsAt: sub.trial_end ? new Date(sub.trial_end * 1e3) : null,
-    interval: item?.price.recurring?.interval === "year" ? "year" : "month"
+    interval: item?.price.recurring?.interval === BILLING_INTERVAL.YEAR ? BILLING_INTERVAL.YEAR : BILLING_INTERVAL.MONTH
+  };
+}
+function toResolvedPrice(p) {
+  return {
+    priceId: p.id,
+    lookupKey: p.lookup_key ?? null,
+    unitAmount: p.unit_amount ?? 0,
+    currency: p.currency,
+    interval: p.recurring?.interval === BILLING_INTERVAL.YEAR ? BILLING_INTERVAL.YEAR : BILLING_INTERVAL.MONTH,
+    nickname: p.nickname ?? null,
+    productId: typeof p.product === "string" ? p.product : p.product?.id ?? "",
+    active: p.active ?? true
   };
 }
 var StripeProvider = class {
@@ -1025,6 +1179,48 @@ var StripeProvider = class {
     });
     return { url: session.url ?? "" };
   }
+  async resolvePriceById(priceId) {
+    const stripe = await this.client();
+    try {
+      const p = await stripe.prices.retrieve(priceId, { expand: ["product"] });
+      return toResolvedPrice(p);
+    } catch {
+      return null;
+    }
+  }
+  async resolvePricesByLookupKey(lookupKeys) {
+    const out = /* @__PURE__ */ new Map();
+    if (lookupKeys.length === 0) return out;
+    const stripe = await this.client();
+    const res = await stripe.prices.list({
+      lookup_keys: lookupKeys,
+      active: true,
+      expand: ["data.product"],
+      limit: 100
+    });
+    for (const p of res.data) {
+      if (p.lookup_key) out.set(p.lookup_key, toResolvedPrice(p));
+    }
+    return out;
+  }
+  async updateSubscription(opts) {
+    const stripe = await this.client();
+    const sub = await stripe.subscriptions.retrieve(opts.subscriptionId);
+    const itemId = sub.items.data[0]?.id;
+    const updated = await stripe.subscriptions.update(opts.subscriptionId, {
+      items: [{ id: itemId, price: opts.priceId }],
+      proration_behavior: "always_invoice",
+      payment_behavior: "error_if_incomplete"
+    });
+    const item = updated.items?.data?.[0];
+    const cps = item?.current_period_start ?? updated.current_period_start;
+    const cpe = item?.current_period_end ?? updated.current_period_end;
+    return {
+      status: updated.status,
+      currentPeriodStart: cps ? new Date(cps * 1e3) : null,
+      currentPeriodEnd: cpe ? new Date(cpe * 1e3) : null
+    };
+  }
   async createPortalSession(opts) {
     const stripe = await this.client();
     const session = await stripe.billingPortal.sessions.create({
@@ -1138,6 +1334,7 @@ function requireFeature(key) {
   };
 }
 export {
+  BILLING_INTERVAL,
   BillingModule,
   DBCounterBackend,
   MESSAGE_KEYS,