@fonderie/billing 5.1.0 → 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) {
@@ -720,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) {
@@ -742,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,
@@ -764,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],
@@ -991,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) {
@@ -1011,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,
@@ -1018,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 {
@@ -1062,6 +1179,30 @@ 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);
@@ -1193,6 +1334,7 @@ function requireFeature(key) {
   };
 }
 export {
+  BILLING_INTERVAL,
   BillingModule,
   DBCounterBackend,
   MESSAGE_KEYS,