@fonderie/billing 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BillingModule: () => BillingModule,
+  DBCounterBackend: () => DBCounterBackend,
+  MESSAGE_KEYS: () => MESSAGE_KEYS,
+  MemoryCounterBackend: () => MemoryCounterBackend,
+  StripeProvider: () => StripeProvider,
+  createPlan: () => createPlan,
+  deletePlan: () => deletePlan,
+  getDBPlans: () => getDBPlans,
+  getLimitStatus: () => getLimitStatus,
+  getPlanById: () => getPlanById,
+  getPlanByName: () => getPlanByName,
+  getPlanLimit: () => getPlanLimit,
+  getPlans: () => getPlans,
+  getSubscription: () => getSubscription,
+  getUsage: () => getUsage,
+  hasFeature: () => hasFeature,
+  recordUsage: () => recordUsage,
+  requireFeature: () => requireFeature,
+  requirePlan: () => requirePlan,
+  toPlanDTO: () => toPlanDTO,
+  toSubscriptionDTO: () => toSubscriptionDTO,
+  toUsageRecordDTO: () => toUsageRecordDTO,
+  updatePlan: () => updatePlan,
+  withBilling: () => withBilling
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/routes.ts
+var import_middlewares = require("@fonderie/core/middlewares");
+
+// src/controllers/plan.controller.ts
+var import_core = require("@fonderie/core");
+
+// src/services/plans.ts
+function getPlans(config) {
+  return config.plans;
+}
+function getPlanByName(name, config) {
+  return config.plans.find((p) => p.name.toLowerCase() === name.toLowerCase()) ?? null;
+}
+async function syncPlansToDB(config, store) {
+  const plans = config.plans;
+  if (plans.length === 0) return;
+  const values = plans.map((_, i) => {
+    const b = i * 9;
+    return `($${b + 1}, $${b + 2}, $${b + 3}, $${b + 4}, $${b + 5}, $${b + 6}, $${b + 7}, $${b + 8}, $${b + 9}::jsonb)`;
+  });
+  const params = plans.flatMap((plan) => [
+    plan.name,
+    plan.trialDays ?? 0,
+    plan.monthly?.amount ?? null,
+    plan.monthly?.priceId ?? null,
+    plan.yearly?.amount ?? null,
+    plan.yearly?.priceId ?? null,
+    plan.description ?? null,
+    plan.tier ?? 0,
+    JSON.stringify(plan.metadata ?? {})
+  ]);
+  await store.query(
+    `INSERT INTO fonderie_plans
+			(name, trial_days,
+			 monthly_amount, monthly_price_id,
+			 yearly_amount,  yearly_price_id,
+			 description, tier, metadata)
+		VALUES ${values.join(", ")}
+		ON CONFLICT (name) DO UPDATE SET
+			trial_days       = EXCLUDED.trial_days,
+			monthly_amount   = EXCLUDED.monthly_amount,
+			monthly_price_id = EXCLUDED.monthly_price_id,
+			yearly_amount    = EXCLUDED.yearly_amount,
+			yearly_price_id  = EXCLUDED.yearly_price_id,
+			description      = EXCLUDED.description,
+			tier             = EXCLUDED.tier,
+			metadata         = EXCLUDED.metadata`,
+    params
+  );
+}
+var SELECT_PLAN = `
+	SELECT
+		id,
+		name,
+		seats,
+		trial_days        AS "trialDays",
+		monthly_amount    AS "monthlyAmount",
+		monthly_price_id  AS "monthlyPriceId",
+		yearly_amount     AS "yearlyAmount",
+		yearly_price_id   AS "yearlyPriceId",
+		description,
+		tier,
+		features,
+		metadata
+	FROM fonderie_plans`;
+async function getDBPlans(store) {
+  return store.query(
+    `${SELECT_PLAN} WHERE active = true ORDER BY tier ASC, monthly_amount ASC NULLS LAST`
+  );
+}
+async function getPlanById(id, store) {
+  const [row] = await store.query(`${SELECT_PLAN} WHERE id = $1`, [id]);
+  return row ?? null;
+}
+async function createPlan(data, store) {
+  const [row] = await store.query(
+    `INSERT INTO fonderie_plans
+			(name, seats, trial_days, monthly_amount, monthly_price_id,
+			 yearly_amount, yearly_price_id, description, tier, features, metadata)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11::jsonb)
+		RETURNING
+			id, name, seats,
+			trial_days        AS "trialDays",
+			monthly_amount    AS "monthlyAmount",
+			monthly_price_id  AS "monthlyPriceId",
+			yearly_amount     AS "yearlyAmount",
+			yearly_price_id   AS "yearlyPriceId",
+			description, tier, features, metadata`,
+    [
+      data.name,
+      data.seats ?? null,
+      data.trialDays ?? 0,
+      data.monthlyAmount ?? null,
+      data.monthlyPriceId ?? null,
+      data.yearlyAmount ?? null,
+      data.yearlyPriceId ?? null,
+      data.description ?? null,
+      data.tier ?? 0,
+      JSON.stringify(data.features ?? []),
+      JSON.stringify(data.metadata ?? {})
+    ]
+  );
+  if (!row) throw new Error("Failed to create plan");
+  return row;
+}
+async function updatePlan(id, data, store) {
+  const fieldMap = {
+    name: "name",
+    seats: "seats",
+    trialDays: "trial_days",
+    monthlyAmount: "monthly_amount",
+    monthlyPriceId: "monthly_price_id",
+    yearlyAmount: "yearly_amount",
+    yearlyPriceId: "yearly_price_id",
+    description: "description",
+    tier: "tier"
+  };
+  const jsonbFields = /* @__PURE__ */ new Set(["features", "metadata"]);
+  const setClauses = [];
+  const params = [id];
+  for (const [key, col] of Object.entries(fieldMap)) {
+    if (key in data) {
+      params.push(data[key]);
+      setClauses.push(`${col} = $${params.length}`);
+    }
+  }
+  for (const key of jsonbFields) {
+    if (key in data) {
+      params.push(JSON.stringify(data[key]));
+      setClauses.push(`${key} = $${params.length}::jsonb`);
+    }
+  }
+  if (setClauses.length === 0) return getPlanById(id, store);
+  const [row] = await store.query(
+    `UPDATE fonderie_plans SET ${setClauses.join(", ")}
+		WHERE id = $1
+		RETURNING
+			id, name, seats,
+			trial_days        AS "trialDays",
+			monthly_amount    AS "monthlyAmount",
+			monthly_price_id  AS "monthlyPriceId",
+			yearly_amount     AS "yearlyAmount",
+			yearly_price_id   AS "yearlyPriceId",
+			description, tier, features, metadata`,
+    params
+  );
+  return row ?? null;
+}
+async function deletePlan(id, store) {
+  const rows = await store.query(
+    `DELETE FROM fonderie_plans WHERE id = $1 RETURNING id`,
+    [id]
+  );
+  return rows.length > 0;
+}
+
+// src/models/plan.model.ts
+var PlanModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  listFromConfig(config) {
+    return getPlans(config);
+  }
+  findByNameInConfig(name, config) {
+    return getPlanByName(name, config);
+  }
+  list() {
+    return getDBPlans(this.store);
+  }
+  findById(id) {
+    return getPlanById(id, this.store);
+  }
+  create(data) {
+    return createPlan(data, this.store);
+  }
+  update(id, data) {
+    return updatePlan(id, data, this.store);
+  }
+  delete(id) {
+    return deletePlan(id, this.store);
+  }
+};
+
+// src/dtos/billing.ts
+function toPlanDTO(plan) {
+  return {
+    id: plan.id,
+    planId: plan.name.toUpperCase(),
+    name: plan.name,
+    description: plan.description ?? "",
+    tier: plan.tier,
+    seats: plan.seats,
+    trialDays: plan.trialDays,
+    pricing: {
+      monthly: plan.monthlyAmount ?? 0,
+      yearly: plan.yearlyAmount ?? 0,
+      currency: "USD"
+    },
+    features: Array.isArray(plan.features) ? plan.features : [],
+    metadata: plan.metadata && typeof plan.metadata === "object" ? plan.metadata : {}
+  };
+}
+function toSubscriptionDTO(sub) {
+  return {
+    id: sub.id,
+    subscriberType: sub.subscriberType,
+    subscriberId: sub.subscriberId,
+    plan: sub.plan,
+    interval: sub.interval,
+    status: sub.status,
+    cancelAtPeriodEnd: sub.cancelAtPeriodEnd,
+    currentPeriodStart: sub.currentPeriodStart,
+    currentPeriodEnd: sub.currentPeriodEnd,
+    trialEndsAt: sub.trialEndsAt,
+    createdAt: sub.createdAt
+  };
+}
+function toUsageRecordDTO(record) {
+  return {
+    id: record.id,
+    subscriberType: record.subscriberType,
+    subscriberId: record.subscriberId,
+    metric: record.metric,
+    quantity: record.quantity,
+    recordedAt: record.recordedAt
+  };
+}
+
+// src/controllers/plan.controller.ts
+function planController(store) {
+  const plans = new PlanModel(store);
+  return {
+    async list(_ctx) {
+      const list = await plans.list();
+      const dtos = list.map(toPlanDTO);
+      return (0, import_core.setApiResponse)(import_core.HTTP.OK, "PLAN_LIST", `Retrieved ${list.length} workspace plans`, {
+        plans: dtos
+      });
+    },
+    async get(ctx) {
+      const params = ctx.meta["params"];
+      const id = params?.["planId"];
+      if (!id) return (0, import_core.setApiResponse)(import_core.HTTP.BAD_REQUEST, "INVALID_PARAMETER", "Plan ID required");
+      const plan = await plans.findById(id);
+      if (!plan) return (0, import_core.setApiResponse)(import_core.HTTP.NOT_FOUND, "NOT_FOUND", "Plan not found");
+      return (0, import_core.setApiResponse)(import_core.HTTP.OK, "PLAN_FETCHED", "Plan retrieved successfully.", {
+        plan: toPlanDTO(plan)
+      });
+    },
+    async create(ctx) {
+      const body = ctx.meta["body"];
+      const name = (0, import_core.stringOrEmpty)(body?.["name"]);
+      if (!name) {
+        return (0, import_core.setApiResponse)(import_core.HTTP.UNPROCESSABLE, "VALIDATION_ERROR", "name is required");
+      }
+      const plan = await plans.create({
+        name,
+        description: body?.["description"] != null ? String(body["description"]) : null,
+        tier: body?.["tier"] != null ? (0, import_core.numberOrZero)(body["tier"]) : 0,
+        seats: body?.["seats"] != null ? (0, import_core.numberOrZero)(body["seats"]) : null,
+        trialDays: body?.["trialDays"] != null ? (0, import_core.numberOrZero)(body["trialDays"]) : 0,
+        monthlyAmount: body?.["monthlyAmount"] != null ? (0, import_core.numberOrZero)(body["monthlyAmount"]) : null,
+        monthlyPriceId: body?.["monthlyPriceId"] != null ? String(body["monthlyPriceId"]) : null,
+        yearlyAmount: body?.["yearlyAmount"] != null ? (0, import_core.numberOrZero)(body["yearlyAmount"]) : null,
+        yearlyPriceId: body?.["yearlyPriceId"] != null ? String(body["yearlyPriceId"]) : null,
+        features: body?.["features"],
+        metadata: body?.["metadata"]
+      });
+      return (0, import_core.setApiResponse)(import_core.HTTP.CREATED, "PLAN_CREATED", "Plan created successfully.", {
+        plan: toPlanDTO(plan)
+      });
+    },
+    async update(ctx) {
+      const params = ctx.meta["params"];
+      const id = params?.["planId"];
+      if (!id) {
+        return (0, import_core.setApiResponse)(import_core.HTTP.BAD_REQUEST, "INVALID_PARAMETER", "Plan ID required");
+      }
+      const body = ctx.meta["body"];
+      if (!body || Object.keys(body).length === 0) {
+        return (0, import_core.setApiResponse)(import_core.HTTP.UNPROCESSABLE, "VALIDATION_ERROR", "Request body is empty");
+      }
+      const patch = {};
+      const allowed = [
+        "name",
+        "description",
+        "tier",
+        "seats",
+        "trialDays",
+        "monthlyAmount",
+        "monthlyPriceId",
+        "yearlyAmount",
+        "yearlyPriceId",
+        "features",
+        "metadata"
+      ];
+      for (const key of allowed) {
+        if (key in body) patch[key] = body[key];
+      }
+      const plan = await plans.update(id, patch);
+      if (!plan) {
+        return (0, import_core.setApiResponse)(import_core.HTTP.NOT_FOUND, "NOT_FOUND", "Plan not found");
+      }
+      return (0, import_core.setApiResponse)(import_core.HTTP.OK, "PLAN_UPDATED", "Plan updated successfully.", {
+        plan: toPlanDTO(plan)
+      });
+    },
+    async delete(ctx) {
+      const params = ctx.meta["params"];
+      const id = params?.["planId"];
+      if (!id) {
+        return (0, import_core.setApiResponse)(import_core.HTTP.BAD_REQUEST, "INVALID_PARAMETER", "Plan ID required");
+      }
+      const deleted = await plans.delete(id);
+      if (!deleted) {
+        return (0, import_core.setApiResponse)(import_core.HTTP.NOT_FOUND, "NOT_FOUND", "Plan not found");
+      }
+      return (0, import_core.setApiResponse)(import_core.HTTP.OK, "PLAN_DELETED", "Plan deleted successfully.");
+    }
+  };
+}
+
+// src/controllers/subscription.controller.ts
+var import_core2 = require("@fonderie/core");
+
+// src/services/subscriptions.ts
+var SELECT_SUBSCRIPTION = `
+	SELECT
+		id,
+		subscriber_type          AS "subscriberType",
+		subscriber_id            AS "subscriberId",
+		plan,
+		interval,
+		status,
+		provider_customer_id     AS "providerCustomerId",
+		provider_subscription_id AS "providerSubscriptionId",
+		current_period_start     AS "currentPeriodStart",
+		current_period_end       AS "currentPeriodEnd",
+		cancel_at_period_end     AS "cancelAtPeriodEnd",
+		trial_ends_at            AS "trialEndsAt",
+		created_at               AS "createdAt"
+	FROM fonderie_subscriptions`;
+async function getSubscription(subscriberType, subscriberId, store) {
+  const [row] = await store.query(
+    `${SELECT_SUBSCRIPTION} WHERE subscriber_type = $1 AND subscriber_id = $2`,
+    [subscriberType, subscriberId]
+  );
+  return row ?? null;
+}
+async function upsertSubscription(data, store) {
+  await store.query(
+    `INSERT INTO fonderie_subscriptions
+			(subscriber_type, subscriber_id, plan, interval, status,
+			 provider_customer_id, provider_subscription_id,
+			 current_period_start, current_period_end,
+			 cancel_at_period_end, trial_ends_at)
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+		 ON CONFLICT (subscriber_type, subscriber_id) DO UPDATE SET
+			 plan                     = $3,
+			 interval                 = $4,
+			 status                   = $5,
+			 provider_customer_id     = COALESCE($6, fonderie_subscriptions.provider_customer_id),
+			 provider_subscription_id = COALESCE($7, fonderie_subscriptions.provider_subscription_id),
+			 current_period_start     = $8,
+			 current_period_end       = $9,
+			 cancel_at_period_end     = $10,
+			 trial_ends_at            = $11`,
+    [
+      data.subscriberType,
+      data.subscriberId,
+      data.plan,
+      data.interval ?? "month",
+      data.status,
+      data.providerCustomerId ?? null,
+      data.providerSubscriptionId ?? null,
+      data.currentPeriodStart ?? null,
+      data.currentPeriodEnd ?? null,
+      data.cancelAtPeriodEnd ?? false,
+      data.trialEndsAt ?? null
+    ]
+  );
+}
+
+// src/models/subscription.model.ts
+var SubscriptionModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  get(subscriberType, subscriberId) {
+    return getSubscription(subscriberType, subscriberId, this.store);
+  }
+  upsert(data) {
+    return upsertSubscription(data, this.store);
+  }
+};
+
+// src/utils.ts
+function parseWindowMs(window) {
+  const n = parseInt(window, 10);
+  const unit = window.slice(String(n).length);
+  switch (unit) {
+    case "h":
+      return n * 36e5;
+    case "d":
+      return n * 864e5;
+    case "m":
+      return n * 6e4;
+    default:
+      throw new Error(`Unknown window unit: '${unit}' in '${window}'`);
+  }
+}
+function resolveSubscriber(ctx) {
+  const wsFromHeader = ctx.request.headers.get("x-workspace-id");
+  if (wsFromHeader) {
+    return {
+      type: "workspace",
+      id: wsFromHeader
+    };
+  }
+  if (ctx.workspace?.id) {
+    return {
+      type: "workspace",
+      id: ctx.workspace.id
+    };
+  }
+  if (ctx.user?.id) {
+    return {
+      type: "user",
+      id: ctx.user.id
+    };
+  }
+  return null;
+}
+
+// src/controllers/subscription.controller.ts
+function subscriptionController(store) {
+  const subscriptions = new SubscriptionModel(store);
+  return {
+    async get(ctx) {
+      const subscriber = resolveSubscriber(ctx);
+      if (!subscriber) {
+        return (0, import_core2.setApiResponse)(
+          import_core2.HTTP.BAD_REQUEST,
+          "SUBSCRIBER_REQUIRED",
+          "Subscriber context required"
+        );
+      }
+      const subscription = await subscriptions.get(subscriber.type, subscriber.id);
+      if (!subscription)
+        return (0, import_core2.setApiResponse)(import_core2.HTTP.NOT_FOUND, "NOT_FOUND", "No active subscription");
+      return (0, import_core2.setApiResponse)(
+        import_core2.HTTP.OK,
+        "SUBSCRIPTION_FETCHED",
+        "Subscription retrieved successfully.",
+        {
+          subscription: toSubscriptionDTO(subscription)
+        }
+      );
+    }
+  };
+}
+
+// src/controllers/checkout.controller.ts
+var import_core3 = require("@fonderie/core");
+function checkoutController(store, config) {
+  const plans = new PlanModel(store);
+  const subscriptions = new SubscriptionModel(store);
+  return {
+    async createSession(ctx) {
+      const body = ctx.meta["body"];
+      const planName = body?.["plan"];
+      const interval = body?.["interval"] ?? "month";
+      const subscriber = resolveSubscriber(ctx);
+      if (typeof planName !== "string") {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "plan is required");
+      }
+      if (interval !== "month" && interval !== "year") {
+        return (0, import_core3.setApiResponse)(
+          import_core3.HTTP.UNPROCESSABLE,
+          "INVALID_PARAMETER",
+          "interval must be month or year"
+        );
+      }
+      if (!subscriber) {
+        return (0, import_core3.setApiResponse)(
+          import_core3.HTTP.BAD_REQUEST,
+          "SUBSCRIBER_REQUIRED",
+          "Subscriber context required"
+        );
+      }
+      const plan = plans.findByNameInConfig(planName, config);
+      if (!plan) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", `Unknown plan: ${planName}`);
+      }
+      const pricing = interval === "year" ? plan.yearly : plan.monthly;
+      if (!pricing?.priceId) {
+        return (0, import_core3.setApiResponse)(
+          import_core3.HTTP.UNPROCESSABLE,
+          "INVALID_PARAMETER",
+          `Plan ${planName} does not support ${interval} billing`
+        );
+      }
+      const { customerId } = await config.provider.createCustomer({
+        email: ctx.user.email ?? "",
+        subscriberType: subscriber.type,
+        subscriberId: subscriber.id,
+        userId: ctx.user.id
+      });
+      const sessionOpts = {
+        customerId,
+        priceId: pricing.priceId,
+        subscriberType: subscriber.type,
+        subscriberId: subscriber.id,
+        successUrl: config.successUrl,
+        cancelUrl: config.cancelUrl
+      };
+      if (plan.trialDays !== void 0) sessionOpts.trialDays = plan.trialDays;
+      const { url } = await config.provider.createCheckoutSession(sessionOpts);
+      await subscriptions.upsert({
+        subscriberType: subscriber.type,
+        subscriberId: subscriber.id,
+        plan: planName,
+        interval,
+        status: "incomplete",
+        providerCustomerId: customerId
+      });
+      return (0, import_core3.setApiResponse)(import_core3.HTTP.OK, "CHECKOUT_URL", "Checkout session created.", { url });
+    },
+    async createPortal(ctx) {
+      const subscriber = resolveSubscriber(ctx);
+      if (!subscriber) {
+        return (0, import_core3.setApiResponse)(
+          import_core3.HTTP.BAD_REQUEST,
+          "SUBSCRIBER_REQUIRED",
+          "Subscriber context required"
+        );
+      }
+      const subscription = await subscriptions.get(subscriber.type, subscriber.id);
+      if (!subscription?.providerCustomerId) {
+        return (0, import_core3.setApiResponse)(import_core3.HTTP.NOT_FOUND, "NOT_FOUND", "No active subscription");
+      }
+      const { url } = await config.provider.createPortalSession({
+        customerId: subscription.providerCustomerId,
+        returnUrl: config.successUrl
+      });
+      return (0, import_core3.setApiResponse)(import_core3.HTTP.OK, "PORTAL_URL", "Portal session created.", { url });
+    }
+  };
+}
+
+// src/controllers/usage.controller.ts
+var import_core4 = require("@fonderie/core");
+
+// src/services/usage.ts
+async function recordUsage(opts, store) {
+  await store.query(
+    `INSERT INTO fonderie_usage_records (subscriber_type, subscriber_id, metric, quantity)
+		VALUES ($1, $2, $3, $4)`,
+    [opts.subscriberType, opts.subscriberId, opts.metric, opts.quantity]
+  );
+}
+async function getUsage(subscriberType, subscriberId, metric, since, store) {
+  const rows = await store.query(
+    `SELECT COALESCE(SUM(quantity), 0) AS total
+		FROM fonderie_usage_records
+		WHERE subscriber_type = $1
+			AND subscriber_id   = $2
+			AND metric          = $3
+			AND recorded_at    >= $4`,
+    [subscriberType, subscriberId, metric, since]
+  );
+  return parseInt(rows[0]?.total ?? "0", 10);
+}
+
+// src/models/usage.model.ts
+var UsageModel = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  record(opts) {
+    return recordUsage(opts, this.store);
+  }
+  get(subscriberType, subscriberId, metric, since) {
+    return getUsage(subscriberType, subscriberId, metric, since, this.store);
+  }
+};
+
+// src/controllers/usage.controller.ts
+function usageController(store) {
+  const usage = new UsageModel(store);
+  return {
+    async record(ctx) {
+      const body = ctx.meta["body"];
+      const metric = body?.["metric"];
+      const quantity = body?.["quantity"];
+      const subscriber = resolveSubscriber(ctx);
+      if (!subscriber) {
+        return (0, import_core4.setApiResponse)(
+          import_core4.HTTP.BAD_REQUEST,
+          "SUBSCRIBER_REQUIRED",
+          "Subscriber context required"
+        );
+      }
+      if (typeof metric !== "string") {
+        return (0, import_core4.setApiResponse)(import_core4.HTTP.UNPROCESSABLE, "INVALID_PARAMETER", "metric is required");
+      }
+      await usage.record({
+        subscriberType: subscriber.type,
+        subscriberId: subscriber.id,
+        metric,
+        quantity: typeof quantity === "number" ? quantity : 1
+      });
+      return (0, import_core4.setApiResponse)(import_core4.HTTP.OK, "USAGE_RECORDED", "Usage recorded successfully.");
+    },
+    async get(ctx) {
+      const params = ctx.meta["params"];
+      const metric = params?.["metric"];
+      const subscriber = resolveSubscriber(ctx);
+      if (!subscriber || !metric) {
+        return (0, import_core4.setApiResponse)(
+          import_core4.HTTP.UNPROCESSABLE,
+          "INVALID_PARAMETER",
+          "subscriber and metric are required"
+        );
+      }
+      const since = /* @__PURE__ */ new Date();
+      since.setDate(1);
+      since.setHours(0, 0, 0, 0);
+      const total = await usage.get(subscriber.type, subscriber.id, metric, since);
+      return (0, import_core4.setApiResponse)(import_core4.HTTP.OK, "USAGE_FETCHED", "Usage retrieved successfully.", {
+        metric,
+        total,
+        since
+      });
+    }
+  };
+}
+
+// src/controllers/webhook.controller.ts
+var import_core5 = require("@fonderie/core");
+function webhookController(store, config) {
+  const subscriptions = new SubscriptionModel(store);
+  return {
+    async handle(ctx) {
+      if (!config.webhookSecret) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.SERVER_ERROR, "SERVER_ERROR", "Webhook secret not configured");
+      }
+      const signature = ctx.request.headers.get("stripe-signature") ?? ctx.request.headers.get("paypal-auth-algo") ?? "";
+      if (!signature) {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.BAD_REQUEST, "INVALID_REQUEST", "Missing webhook signature");
+      }
+      const payload = await ctx.request.text();
+      let event;
+      try {
+        event = await config.provider.constructEvent({
+          payload,
+          signature,
+          secret: config.webhookSecret
+        });
+      } catch {
+        return (0, import_core5.setApiResponse)(import_core5.HTTP.BAD_REQUEST, "INVALID_REQUEST", "Invalid webhook signature");
+      }
+      if (event.subscription) {
+        await subscriptions.upsert({
+          subscriberType: event.subscription.subscriberType,
+          subscriberId: event.subscription.subscriberId,
+          plan: event.subscription.plan,
+          status: event.subscription.status,
+          providerCustomerId: event.subscription.providerCustomerId,
+          providerSubscriptionId: event.subscription.providerSubscriptionId,
+          currentPeriodStart: event.subscription.currentPeriodStart,
+          currentPeriodEnd: event.subscription.currentPeriodEnd,
+          cancelAtPeriodEnd: event.subscription.cancelAtPeriodEnd,
+          trialEndsAt: event.subscription.trialEndsAt
+        });
+      }
+      return Response.json({ received: true });
+    }
+  };
+}
+
+// src/routes.ts
+function buildBillingRoutes(store, config) {
+  const plan = planController(store);
+  const subscription = subscriptionController(store);
+  const checkout = checkoutController(store, config);
+  const usage = usageController(store);
+  const webhook = webhookController(store, config);
+  return [
+    // Plans — public read-only
+    ["GET", "/plans", plan.list],
+    ["GET", "/plans/:planId", plan.get],
+    // Plans — admin write (caller is responsible for authorization)
+    ["POST", "/plans", plan.create],
+    ["PUT", "/plans/:planId", plan.update],
+    ["DELETE", "/plans/:planId", plan.delete],
+    // Billing — subscriber resolved from X-Workspace-ID header (workspace) or session (user)
+    // Workspace membership is verified automatically by the withBilling global middleware
+    ["GET", "/billing/subscription", import_middlewares.requireAuth, subscription.get],
+    ["POST", "/billing/checkout", import_middlewares.requireAuth, checkout.createSession],
+    ["POST", "/billing/portal", import_middlewares.requireAuth, checkout.createPortal],
+    ["POST", "/billing/usage", import_middlewares.requireAuth, usage.record],
+    ["GET", "/billing/usage/:metric", import_middlewares.requireAuth, usage.get],
+    // Webhook — signature verified inside the handler
+    ["POST", "/billing/webhook", webhook.handle]
+  ];
+}
+
+// src/middlewares/billing.ts
+var import_core6 = require("@fonderie/core");
+
+// src/config.ts
+var MESSAGE_KEYS = {
+  limitWarning: "billing.limit-warning",
+  limitReached: "billing.limit-reached",
+  limitBlocked: "billing.limit-blocked"
+};
+
+// src/services/policy.ts
+function buildBillingContext(opts) {
+  const { subscriber, plan, active, counters } = opts;
+  const defaults = plan.defaults ?? {};
+  const statuses = {};
+  for (const [key, entry] of Object.entries(plan.policy ?? {})) {
+    if ("enabled" in entry) {
+      statuses[key] = { type: "feature", enabled: entry.enabled };
+      continue;
+    }
+    const { limit, buffer = defaults.buffer ?? 0, warnAt = defaults.warnAt ?? 0.8, window } = entry;
+    const used = counters[key] ?? 0;
+    const hardLimit = limit !== null ? limit + buffer : null;
+    let status = "ok";
+    if (hardLimit !== null && used >= hardLimit) status = "blocked";
+    else if (limit !== null && used >= limit) status = "over_limit";
+    else if (limit !== null && used >= limit * warnAt) status = "warning";
+    let resetsAt = null;
+    if (window) {
+      const windowMs = parseWindowMs(window);
+      const windowStart = Math.floor(Date.now() / windowMs) * windowMs;
+      resetsAt = new Date(windowStart + windowMs).toISOString();
+    }
+    statuses[key] = { type: "counter", limit, used, status, resetsAt };
+  }
+  return { subscriber, plan: plan.name, active, statuses };
+}
+
+// src/middlewares/billing.ts
+var notified = /* @__PURE__ */ new Set();
+function withBilling(store, config, backend) {
+  return async (ctx, next) => {
+    const subscriber = resolveSubscriber(ctx);
+    if (!subscriber) return next();
+    const subscription = await getSubscription(subscriber.type, subscriber.id, store);
+    const planName = subscription?.plan ?? config.plans[0]?.name ?? "free";
+    const active = !subscription || subscription.status === "active" || subscription.status === "trialing";
+    const plan = config.plans.find((p) => p.name === planName) ?? config.plans[0];
+    if (!plan) return next();
+    const counters = {};
+    for (const [key, entry] of Object.entries(plan.policy ?? {})) {
+      if ("enabled" in entry || !entry.window) continue;
+      const windowMs = parseWindowMs(entry.window);
+      const counterKey = `${subscriber.type}:${subscriber.id}:${key}`;
+      counters[key] = await backend.increment(counterKey, windowMs);
+    }
+    const billingCtx = buildBillingContext({ subscriber, plan, active, counters });
+    ctx.meta["billing"] = billingCtx;
+    for (const [key, status] of Object.entries(billingCtx.statuses)) {
+      if (status.type === "counter" && status.status === "blocked") {
+        return (0, import_core6.setApiResponse)(
+          import_core6.HTTP.TOO_MANY_REQUESTS,
+          "RATE_LIMIT_EXCEEDED",
+          `Limit exceeded for: ${key}`,
+          { key, limit: status.limit, used: status.used, resetsAt: status.resetsAt }
+        );
+      }
+    }
+    if (config.notifications) {
+      const toNotify = [];
+      const recipient = {
+        email: ctx.user?.email ?? null,
+        phone: null,
+        deviceToken: null
+      };
+      for (const [key, status] of Object.entries(billingCtx.statuses)) {
+        if (status.type !== "counter" || status.limit === null) continue;
+        const base = `${subscriber.type}:${subscriber.id}:${key}`;
+        if (config.notifications.softHit && status.status === "over_limit") {
+          const nk = `${base}:reached`;
+          if (!notified.has(nk)) {
+            notified.add(nk);
+            toNotify.push({
+              type: MESSAGE_KEYS.limitReached,
+              recipient,
+              data: {
+                key,
+                plan: plan.name,
+                limit: status.limit,
+                used: status.used
+              }
+            });
+          }
+        } else if (config.notifications.warnAt && status.status === "warning") {
+          const nk = `${base}:warning`;
+          if (!notified.has(nk)) {
+            notified.add(nk);
+            toNotify.push({
+              type: MESSAGE_KEYS.limitWarning,
+              recipient,
+              data: {
+                key,
+                plan: plan.name,
+                limit: status.limit,
+                used: status.used
+              }
+            });
+          }
+        }
+      }
+      if (toNotify.length > 0) {
+        const existing = ctx.meta["messages"];
+        ctx.meta["messages"] = [...existing ?? [], ...toNotify];
+      }
+    }
+    return next();
+  };
+}
+
+// src/backends/memory.ts
+var MemoryCounterBackend = class {
+  counters = /* @__PURE__ */ new Map();
+  async increment(key, windowMs, quantity = 1) {
+    const now = Date.now();
+    const existing = this.counters.get(key);
+    if (!existing || windowMs !== null && now - existing.windowStart >= windowMs) {
+      this.counters.set(key, { count: quantity, windowStart: now });
+      return quantity;
+    }
+    existing.count += quantity;
+    return existing.count;
+  }
+  async get(key, windowMs) {
+    const now = Date.now();
+    const existing = this.counters.get(key);
+    if (!existing) return 0;
+    if (windowMs !== null && now - existing.windowStart >= windowMs) return 0;
+    return existing.count;
+  }
+};
+
+// src/backends/db.ts
+var DBCounterBackend = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async increment(key, windowMs, quantity = 1) {
+    const [subscriberType, subscriberId, ...rest] = key.split(":");
+    const metric = rest.join(":");
+    await this.store.query(
+      `INSERT INTO fonderie_usage_records (subscriber_type, subscriber_id, metric, quantity)
+			 VALUES ($1, $2, $3, $4)`,
+      [subscriberType, subscriberId, metric, quantity]
+    );
+    return this.get(key, windowMs);
+  }
+  async get(key, windowMs) {
+    const [subscriberType, subscriberId, ...rest] = key.split(":");
+    const metric = rest.join(":");
+    const since = windowMs !== null ? new Date(Date.now() - windowMs) : /* @__PURE__ */ new Date(0);
+    const rows = await this.store.query(
+      `SELECT COALESCE(SUM(quantity), 0) AS total
+			 FROM fonderie_usage_records
+			 WHERE subscriber_type = $1
+			   AND subscriber_id   = $2
+			   AND metric          = $3
+			   AND recorded_at    >= $4`,
+      [subscriberType, subscriberId, metric, since]
+    );
+    return parseInt(rows[0]?.total ?? "0", 10);
+  }
+};
+
+// src/backends/index.ts
+function createBackend(config, store) {
+  if (!config || config === "memory") return new MemoryCounterBackend();
+  if (config === "db") return new DBCounterBackend(store);
+  return config;
+}
+
+// src/module.ts
+var BillingModule = class {
+  constructor(store, config) {
+    this.store = store;
+    this.config = config;
+  }
+  store;
+  config;
+  name = "@fonderie/billing";
+  deps = ["@fonderie/auth"];
+  async install(app) {
+    await syncPlansToDB(this.config, this.store);
+    const backend = createBackend(this.config.rateLimit?.backend, this.store);
+    app.use(withBilling(this.store, this.config, backend));
+    const routes = buildBillingRoutes(this.store, this.config);
+    for (const [method, path, ...handlers] of routes) {
+      app.addRoute(method, path, ...handlers);
+    }
+  }
+};
+
+// src/providers/stripe.ts
+var _client = null;
+async function getClient(secretKey) {
+  if (_client) return _client;
+  const pkg = "stripe";
+  const mod = await import(pkg).catch(() => {
+    throw new Error("[billing:stripe] stripe is required: npm install stripe");
+  });
+  const Stripe = mod.default ?? mod;
+  _client = new Stripe(secretKey, { apiVersion: "2024-11-20.acacia" });
+  return _client;
+}
+function normalizeSubscription(sub) {
+  return {
+    subscriberType: sub.metadata?.["subscriberType"] ?? "workspace",
+    subscriberId: sub.metadata?.["subscriberId"] ?? "",
+    plan: sub.items.data[0]?.price.nickname ?? "unknown",
+    status: sub.status,
+    providerCustomerId: sub.customer,
+    providerSubscriptionId: sub.id,
+    currentPeriodStart: new Date(sub.current_period_start * 1e3),
+    currentPeriodEnd: new Date(sub.current_period_end * 1e3),
+    cancelAtPeriodEnd: sub.cancel_at_period_end,
+    trialEndsAt: sub.trial_end ? new Date(sub.trial_end * 1e3) : null
+  };
+}
+var StripeProvider = class {
+  constructor(secretKey, webhookSecret) {
+    this.secretKey = secretKey;
+    this.webhookSecret = webhookSecret;
+  }
+  secretKey;
+  webhookSecret;
+  name = "stripe";
+  async client() {
+    return getClient(this.secretKey);
+  }
+  async createCustomer(opts) {
+    const stripe = await this.client();
+    const customer = await stripe.customers.create({
+      email: opts.email,
+      metadata: {
+        subscriberType: opts.subscriberType,
+        subscriberId: opts.subscriberId,
+        userId: opts.userId
+      }
+    });
+    return { customerId: customer.id };
+  }
+  async createCheckoutSession(opts) {
+    const stripe = await this.client();
+    const session = await stripe.checkout.sessions.create({
+      customer: opts.customerId,
+      mode: "subscription",
+      line_items: [{ price: opts.priceId, quantity: 1 }],
+      success_url: opts.successUrl,
+      cancel_url: opts.cancelUrl,
+      subscription_data: {
+        metadata: {
+          subscriberType: opts.subscriberType,
+          subscriberId: opts.subscriberId
+        },
+        ...opts.trialDays && opts.trialDays > 0 ? { trial_period_days: opts.trialDays } : {}
+      }
+    });
+    return { url: session.url ?? "" };
+  }
+  async createPortalSession(opts) {
+    const stripe = await this.client();
+    const session = await stripe.billingPortal.sessions.create({
+      customer: opts.customerId,
+      return_url: opts.returnUrl
+    });
+    return { url: session.url };
+  }
+  async constructEvent(opts) {
+    const stripe = await this.client();
+    let raw;
+    try {
+      raw = stripe.webhooks.constructEvent(opts.payload, opts.signature, opts.secret);
+    } catch {
+      throw new Error("[billing:stripe] Invalid webhook signature");
+    }
+    const isSubscriptionEvent = [
+      "customer.subscription.created",
+      "customer.subscription.updated",
+      "customer.subscription.deleted"
+    ].includes(raw.type);
+    if (!isSubscriptionEvent) {
+      return { type: raw.type, subscription: null };
+    }
+    const sub = raw.data.object;
+    if (raw.type === "customer.subscription.deleted") {
+      return {
+        type: raw.type,
+        subscription: { ...normalizeSubscription(sub), plan: "free", status: "canceled" }
+      };
+    }
+    return { type: raw.type, subscription: normalizeSubscription(sub) };
+  }
+};
+
+// src/middlewares/require-plan.ts
+var import_core7 = require("@fonderie/core");
+function makeHandler(plans, store) {
+  const allowed = Array.isArray(plans) ? plans : [plans];
+  return async (ctx, next) => {
+    if (!ctx.user) {
+      return (0, import_core7.setApiResponse)(import_core7.HTTP.UNAUTHORIZED, "UNAUTHORIZED", "Unauthorized");
+    }
+    const subscriber = resolveSubscriber(ctx);
+    if (!subscriber) {
+      return (0, import_core7.setApiResponse)(import_core7.HTTP.BAD_REQUEST, "SUBSCRIBER_REQUIRED", "Subscriber context required");
+    }
+    const subscription = await getSubscription(subscriber.type, subscriber.id, store);
+    if (!subscription || !allowed.includes(subscription.plan)) {
+      return (0, import_core7.setApiResponse)(
+        import_core7.HTTP.PAYMENT_REQUIRED,
+        "PLAN_UPGRADE_REQUIRED",
+        "Plan upgrade required",
+        { required: allowed, current: subscription?.plan ?? "none" }
+      );
+    }
+    if (subscription.status !== "active" && subscription.status !== "trialing") {
+      return (0, import_core7.setApiResponse)(
+        import_core7.HTTP.PAYMENT_REQUIRED,
+        "SUBSCRIPTION_INACTIVE",
+        "Subscription is not active",
+        { status: subscription.status }
+      );
+    }
+    return next();
+  };
+}
+function requirePlan(plans, store, ctx, next) {
+  const handler = makeHandler(plans, store);
+  if (ctx !== void 0 && next !== void 0) return handler(ctx, next);
+  return handler;
+}
+
+// src/helpers.ts
+var import_core8 = require("@fonderie/core");
+function getBillingContext(ctx) {
+  return ctx.meta["billing"] ?? null;
+}
+function hasFeature(ctx, key) {
+  const billing = getBillingContext(ctx);
+  if (!billing) return true;
+  const status = billing.statuses[key];
+  if (!status) return true;
+  if (status.type === "feature") return status.enabled;
+  return true;
+}
+function getPlanLimit(ctx, key) {
+  const billing = getBillingContext(ctx);
+  if (!billing) return null;
+  const status = billing.statuses[key];
+  if (!status || status.type === "feature") return null;
+  return status.limit;
+}
+function getLimitStatus(ctx, key) {
+  const billing = getBillingContext(ctx);
+  if (!billing) return null;
+  return billing.statuses[key] ?? null;
+}
+function requireFeature(key) {
+  return (ctx, next) => {
+    if (!hasFeature(ctx, key)) {
+      return Promise.resolve(
+        (0, import_core8.setApiResponse)(
+          import_core8.HTTP.PAYMENT_REQUIRED,
+          "FEATURE_UNAVAILABLE",
+          `Feature '${key}' is not available on your current plan`
+        )
+      );
+    }
+    return next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BillingModule,
+  DBCounterBackend,
+  MESSAGE_KEYS,
+  MemoryCounterBackend,
+  StripeProvider,
+  createPlan,
+  deletePlan,
+  getDBPlans,
+  getLimitStatus,
+  getPlanById,
+  getPlanByName,
+  getPlanLimit,
+  getPlans,
+  getSubscription,
+  getUsage,
+  hasFeature,
+  recordUsage,
+  requireFeature,
+  requirePlan,
+  toPlanDTO,
+  toSubscriptionDTO,
+  toUsageRecordDTO,
+  updatePlan,
+  withBilling
+});
+//# sourceMappingURL=index.cjs.map