@auth-gate/billing 0.8.0

package/dist/chunk-AHCLNQ6P.mjs

@@ -0,0 +1,482 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-I4E63NIC.mjs";
+
+// src/validation.ts
+function validateTiers(price, prefix) {
+  if (!Array.isArray(price.tiers) || price.tiers.length === 0) {
+    throw new Error(`${prefix}: tiered/metered price must have a non-empty "tiers" array.`);
+  }
+  if (!["graduated", "volume"].includes(price.tierMode)) {
+    throw new Error(`${prefix}.tierMode must be "graduated" or "volume".`);
+  }
+  for (let j = 0; j < price.tiers.length; j++) {
+    const tier = price.tiers[j];
+    if (typeof tier.unitAmount !== "number" || tier.unitAmount < 0) {
+      throw new Error(`${prefix}.tiers[${j}].unitAmount must be a non-negative number.`);
+    }
+  }
+}
+function validateConfig(config) {
+  var _a;
+  if (!config || typeof config !== "object") {
+    throw new Error("Billing config must be an object. Did you forget `export default defineBilling({ ... })`?");
+  }
+  const unwrapped = "_config" in config ? config._config : config;
+  const c = unwrapped;
+  if (!c.plans || typeof c.plans !== "object") {
+    throw new Error("Billing config must have a `plans` object.");
+  }
+  const plans = c.plans;
+  const planKeys = Object.keys(plans);
+  if (planKeys.length === 0) {
+    throw new Error("Billing config must define at least one plan.");
+  }
+  for (const key of planKeys) {
+    if (!/^[a-z][a-z0-9_]*$/.test(key)) {
+      throw new Error(
+        `Plan key "${key}" is invalid. Use lowercase alphanumeric with underscores (e.g., "pro", "team_plan").`
+      );
+    }
+    const plan = plans[key];
+    if (!plan || typeof plan !== "object") {
+      throw new Error(`Plan "${key}" must be an object.`);
+    }
+    if (!plan.name || typeof plan.name !== "string") {
+      throw new Error(`Plan "${key}" must have a "name" string.`);
+    }
+    if (plan.description !== void 0 && typeof plan.description !== "string") {
+      throw new Error(`Plan "${key}".description must be a string.`);
+    }
+    if (plan.features !== void 0) {
+      if (!Array.isArray(plan.features) || !plan.features.every((f) => typeof f === "string")) {
+        throw new Error(`Plan "${key}".features must be an array of strings.`);
+      }
+    }
+    if (plan.grandfathering !== void 0) {
+      const validStrategies = ["keep_price", "migrate_at_renewal", "migrate_immediately"];
+      if (!validStrategies.includes(plan.grandfathering)) {
+        throw new Error(
+          `Plan "${key}".grandfathering must be one of: ${validStrategies.join(", ")}.`
+        );
+      }
+    }
+    if (!Array.isArray(plan.prices) || plan.prices.length === 0) {
+      throw new Error(`Plan "${key}" must have at least one price.`);
+    }
+    for (let i = 0; i < plan.prices.length; i++) {
+      const price = plan.prices[i];
+      const prefix = `Plan "${key}".prices[${i}]`;
+      const priceType = (_a = price.type) != null ? _a : "recurring";
+      if (typeof price.currency !== "string" || price.currency.length !== 3) {
+        throw new Error(`${prefix}.currency must be a 3-letter ISO 4217 code (e.g., "usd").`);
+      }
+      if (!["monthly", "yearly"].includes(price.interval)) {
+        throw new Error(`${prefix}.interval must be "monthly" or "yearly".`);
+      }
+      if (price.intervalCount !== void 0) {
+        if (typeof price.intervalCount !== "number" || !Number.isInteger(price.intervalCount) || price.intervalCount < 1) {
+          throw new Error(`${prefix}.intervalCount must be a positive integer.`);
+        }
+      }
+      if (priceType === "recurring" || priceType === "per_seat") {
+        if (typeof price.amount !== "number" || !Number.isInteger(price.amount) || price.amount < 0) {
+          throw new Error(`${prefix}.amount must be a non-negative integer (cents).`);
+        }
+        if (priceType === "per_seat") {
+          if (typeof price.metric !== "string" || !price.metric) {
+            throw new Error(`${prefix}: per_seat price must have a "metric" string.`);
+          }
+        }
+      } else if (priceType === "metered") {
+        if (typeof price.metric !== "string" || !price.metric) {
+          throw new Error(`${prefix}: metered price must have a "metric" string.`);
+        }
+        validateTiers(price, prefix);
+      } else if (priceType === "tiered") {
+        validateTiers(price, prefix);
+      } else {
+        throw new Error(`${prefix}.type must be one of: "recurring", "per_seat", "metered", "tiered".`);
+      }
+    }
+  }
+  const featuresRegistry = c.features;
+  if (featuresRegistry !== void 0) {
+    if (typeof featuresRegistry !== "object" || Array.isArray(featuresRegistry)) {
+      throw new Error("Billing config `features` must be an object (features registry).");
+    }
+    for (const [fKey, fDef] of Object.entries(featuresRegistry)) {
+      if (!fDef || typeof fDef !== "object") {
+        throw new Error(`Feature "${fKey}" must be an object with a "type" field.`);
+      }
+      if (!["boolean", "metered"].includes(fDef.type)) {
+        throw new Error(`Feature "${fKey}".type must be "boolean" or "metered".`);
+      }
+    }
+  }
+  for (const key of planKeys) {
+    const plan = plans[key];
+    if (plan.entitlements !== void 0) {
+      if (typeof plan.entitlements !== "object" || plan.entitlements === null || Array.isArray(plan.entitlements)) {
+        throw new Error(`Plan "${key}".entitlements must be an object.`);
+      }
+      const entitlements = plan.entitlements;
+      for (const [eKey, eVal] of Object.entries(entitlements)) {
+        if (featuresRegistry && !featuresRegistry[eKey]) {
+          throw new Error(`Plan "${key}".entitlements.${eKey} is not defined in features registry.`);
+        }
+        const featureDef = featuresRegistry == null ? void 0 : featuresRegistry[eKey];
+        if (featureDef) {
+          if (featureDef.type === "metered") {
+            if (eVal === true || typeof eVal !== "object" || !eVal || !("limit" in eVal)) {
+              throw new Error(`Plan "${key}".entitlements.${eKey}: metered feature must have { limit: number }.`);
+            }
+          } else if (featureDef.type === "boolean") {
+            if (eVal !== true) {
+              throw new Error(`Plan "${key}".entitlements.${eKey}: boolean feature must be true.`);
+            }
+          }
+        }
+      }
+    }
+  }
+  const renameTargets = /* @__PURE__ */ new Map();
+  for (const key of planKeys) {
+    const plan = plans[key];
+    if (plan.renamedFrom !== void 0) {
+      if (typeof plan.renamedFrom !== "string") {
+        throw new Error(`Plan "${key}".renamedFrom must be a string.`);
+      }
+      if (plan.renamedFrom === key) {
+        throw new Error(`Plan "${key}".renamedFrom cannot equal its own key.`);
+      }
+      if (planKeys.includes(plan.renamedFrom)) {
+        throw new Error(
+          `Plan "${key}".renamedFrom "${plan.renamedFrom}" cannot reference an existing plan key.`
+        );
+      }
+      if (renameTargets.has(plan.renamedFrom)) {
+        throw new Error(
+          `renamedFrom "${plan.renamedFrom}" is claimed by multiple plans: "${renameTargets.get(plan.renamedFrom)}" and "${key}".`
+        );
+      }
+      renameTargets.set(plan.renamedFrom, key);
+    }
+  }
+  if (c.migrations !== void 0) {
+    if (!Array.isArray(c.migrations)) {
+      throw new Error("Billing config `migrations` must be an array.");
+    }
+    const migrationFroms = /* @__PURE__ */ new Set();
+    for (let i = 0; i < c.migrations.length; i++) {
+      const m = c.migrations[i];
+      const prefix = `migrations[${i}]`;
+      if (typeof m.from !== "string" || !m.from) {
+        throw new Error(`${prefix}.from must be a non-empty string.`);
+      }
+      if (typeof m.to !== "string" || !m.to) {
+        throw new Error(`${prefix}.to must be a non-empty string.`);
+      }
+      if (m.from === m.to) {
+        throw new Error(`${prefix}: migration "from" cannot equal "to".`);
+      }
+      if (!planKeys.includes(m.to)) {
+        throw new Error(`${prefix}: migration target "${m.to}" must reference an existing plan in config.`);
+      }
+      if (migrationFroms.has(m.from)) {
+        throw new Error(`${prefix}: duplicate migration from "${m.from}".`);
+      }
+      migrationFroms.add(m.from);
+      if (renameTargets.has(m.from)) {
+        throw new Error(
+          `Cannot rename and migrate the same key "${m.from}" in one sync. Rename first, then migrate in a subsequent sync.`
+        );
+      }
+      if (m.priceMapping !== void 0) {
+        if (typeof m.priceMapping !== "object" || m.priceMapping === null || Array.isArray(m.priceMapping)) {
+          throw new Error(`${prefix}.priceMapping must be an object { oldKey: newKey }.`);
+        }
+      }
+    }
+  }
+  return unwrapped;
+}
+function normalizeConfig(config) {
+  const plans = {};
+  for (const [key, plan] of Object.entries(config.plans)) {
+    if (plan.entitlements) {
+      plans[key] = plan;
+    } else if (plan.features && plan.features.length > 0) {
+      const entitlements = {};
+      for (const f of plan.features) {
+        entitlements[f] = true;
+      }
+      plans[key] = __spreadProps(__spreadValues({}, plan), { entitlements });
+    } else {
+      plans[key] = plan;
+    }
+  }
+  return __spreadProps(__spreadValues({}, config), { plans });
+}
+
+// src/diff.ts
+function priceConfigKey(planKey, price) {
+  var _a, _b;
+  const interval = price.interval;
+  const count = (_a = price.intervalCount) != null ? _a : 1;
+  const suffix = count > 1 ? `_x${count}` : "";
+  const priceType = (_b = price.type) != null ? _b : "recurring";
+  if (priceType === "per_seat") {
+    const p2 = price;
+    return `${planKey}_seat_${p2.metric}_${interval}${suffix}_${p2.amount}_${p2.currency}`;
+  }
+  if (priceType === "metered") {
+    const p2 = price;
+    return `${planKey}_${p2.metric}_${interval}${suffix}_${p2.tierMode}_${p2.currency}`;
+  }
+  if (priceType === "tiered") {
+    const p2 = price;
+    return `${planKey}_${interval}${suffix}_${p2.tierMode}_${p2.currency}`;
+  }
+  const p = price;
+  return `${planKey}_${interval}${suffix}_${p.amount}_${p.currency}`;
+}
+function computeDiff(config, server, subscriberCounts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const planOps = [];
+  const priceOps = [];
+  let hasDestructive = false;
+  const serverByKey = /* @__PURE__ */ new Map();
+  const serverByPreviousKey = /* @__PURE__ */ new Map();
+  for (const product of server.products) {
+    if (product.configKey && product.managedBy === "config") {
+      serverByKey.set(product.configKey, product);
+    }
+    for (const prevKey of (_a = product.previousConfigKeys) != null ? _a : []) {
+      serverByPreviousKey.set(prevKey, product);
+    }
+  }
+  const renameMap = /* @__PURE__ */ new Map();
+  for (const [key, plan] of Object.entries(config.plans)) {
+    if (plan.renamedFrom) {
+      renameMap.set(plan.renamedFrom, key);
+    }
+  }
+  for (const [key, plan] of Object.entries(config.plans)) {
+    let existing = serverByKey.get(key);
+    if (!existing && plan.renamedFrom) {
+      existing = (_b = serverByKey.get(plan.renamedFrom)) != null ? _b : serverByPreviousKey.get(plan.renamedFrom);
+      if (existing) {
+        const subs = (_c = subscriberCounts[existing.id]) != null ? _c : 0;
+        planOps.push({ type: "rename", key, oldKey: plan.renamedFrom, plan, existing, activeSubscribers: subs });
+        const serverPricesByKey = /* @__PURE__ */ new Map();
+        for (const sp of existing.prices) {
+          if (sp.configKey && sp.isActive) {
+            serverPricesByKey.set(sp.configKey, sp);
+          }
+        }
+        const configPriceKeys = /* @__PURE__ */ new Set();
+        for (const price of plan.prices) {
+          const pk = priceConfigKey(key, price);
+          configPriceKeys.add(pk);
+          if (!serverPricesByKey.has(pk)) {
+            priceOps.push({ type: "create", planKey: key, price, configKey: pk });
+          }
+        }
+        for (const [pk, sp] of serverPricesByKey) {
+          if (!configPriceKeys.has(pk)) {
+            priceOps.push({ type: "archive", planKey: key, existing: sp, configKey: pk });
+          }
+        }
+        serverByKey.delete(existing.configKey);
+        serverByKey.delete(key);
+        continue;
+      }
+    }
+    if (!existing) {
+      planOps.push({ type: "create", key, plan });
+      for (const price of plan.prices) {
+        priceOps.push({
+          type: "create",
+          planKey: key,
+          price,
+          configKey: priceConfigKey(key, price)
+        });
+      }
+    } else {
+      const changes = [];
+      if (existing.name !== plan.name) changes.push(`name: "${existing.name}" \u2192 "${plan.name}"`);
+      if (((_d = existing.description) != null ? _d : void 0) !== ((_e = plan.description) != null ? _e : void 0)) {
+        changes.push(`description changed`);
+      }
+      const existingFeatures = ((_f = existing.features) != null ? _f : []).sort().join(",");
+      const configFeatures = ((_g = plan.features) != null ? _g : []).sort().join(",");
+      if (existingFeatures !== configFeatures) changes.push(`features changed`);
+      const existingEntitlements = JSON.stringify((_h = existing.entitlements) != null ? _h : null);
+      const configEntitlements = JSON.stringify((_i = plan.entitlements) != null ? _i : null);
+      if (existingEntitlements !== configEntitlements) changes.push(`entitlements changed`);
+      const serverPricesByKey = /* @__PURE__ */ new Map();
+      for (const sp of existing.prices) {
+        if (sp.configKey && sp.isActive) {
+          serverPricesByKey.set(sp.configKey, sp);
+        }
+      }
+      const configPriceKeys = /* @__PURE__ */ new Set();
+      for (const price of plan.prices) {
+        const pk = priceConfigKey(key, price);
+        configPriceKeys.add(pk);
+        if (!serverPricesByKey.has(pk)) {
+          priceOps.push({ type: "create", planKey: key, price, configKey: pk });
+        }
+      }
+      let hasPriceArchives = false;
+      for (const [pk, sp] of serverPricesByKey) {
+        if (!configPriceKeys.has(pk)) {
+          priceOps.push({ type: "archive", planKey: key, existing: sp, configKey: pk });
+          hasPriceArchives = true;
+        }
+      }
+      if (changes.length > 0 || hasPriceArchives) {
+        const versionBump = hasPriceArchives;
+        if (versionBump) changes.push("prices changed");
+        planOps.push(__spreadValues({
+          type: "update",
+          key,
+          plan,
+          existing,
+          changes
+        }, versionBump ? { versionBump: true, grandfathering: plan.grandfathering } : {}));
+      }
+    }
+    serverByKey.delete(key);
+  }
+  for (const [key, product] of serverByKey) {
+    if (renameMap.has(key)) continue;
+    if (product.isActive) {
+      const subs = (_j = subscriberCounts[product.id]) != null ? _j : 0;
+      if (subs > 0) hasDestructive = true;
+      planOps.push({ type: "archive", key, existing: product, activeSubscribers: subs });
+      for (const sp of product.prices) {
+        if (sp.isActive && sp.configKey) {
+          priceOps.push({ type: "archive", planKey: key, existing: sp, configKey: sp.configKey });
+        }
+      }
+    }
+  }
+  return { planOps, priceOps, hasDestructive };
+}
+
+// src/pull.ts
+function slugify(name) {
+  let slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  if (/^[0-9]/.test(slug)) slug = `plan_${slug}`;
+  return slug || "plan";
+}
+function deduplicateKeys(keys) {
+  const seen = /* @__PURE__ */ new Map();
+  return keys.map((k) => {
+    var _a;
+    const count = ((_a = seen.get(k)) != null ? _a : 0) + 1;
+    seen.set(k, count);
+    return count > 1 ? `${k}_${count}` : k;
+  });
+}
+function serverStateToBillingConfig(state, options) {
+  const dashboardPlans = [];
+  const activeProducts = state.products.filter((p) => p.isActive);
+  const configProducts = [];
+  for (const product of activeProducts) {
+    if (product.managedBy === "dashboard" && !(options == null ? void 0 : options.includeDashboard)) {
+      dashboardPlans.push({
+        name: product.name,
+        suggestedKey: slugify(product.name)
+      });
+    } else {
+      configProducts.push(product);
+    }
+  }
+  const rawKeys = configProducts.map((p) => {
+    var _a;
+    return (_a = p.configKey) != null ? _a : slugify(p.name);
+  });
+  const keys = deduplicateKeys(rawKeys);
+  const plans = {};
+  for (let i = 0; i < configProducts.length; i++) {
+    const product = configProducts[i];
+    const key = keys[i];
+    const prices = product.prices.filter((p) => p.isActive).map((p) => {
+      var _a;
+      const price = {
+        amount: (_a = p.amount) != null ? _a : 0,
+        currency: p.currency,
+        interval: p.interval
+      };
+      if (p.intervalCount > 1) price.intervalCount = p.intervalCount;
+      return price;
+    });
+    const plan = { name: product.name, prices };
+    if (product.description) plan.description = product.description;
+    if (product.features.length > 0) plan.features = product.features;
+    if (product.entitlements && Object.keys(product.entitlements).length > 0) {
+      plan.entitlements = product.entitlements;
+    }
+    plans[key] = plan;
+  }
+  return { config: { plans }, dashboardPlans };
+}
+function renderConfigAsTypeScript(result) {
+  var _a;
+  const lines = [
+    'import { defineBilling } from "@auth-gate/billing";',
+    "",
+    "export default defineBilling({",
+    "  plans: {"
+  ];
+  const planEntries = Object.entries(result.config.plans);
+  for (const [key, plan] of planEntries) {
+    lines.push(`    ${key}: {`);
+    lines.push(`      name: ${JSON.stringify(plan.name)},`);
+    if (plan.description)
+      lines.push(`      description: ${JSON.stringify(plan.description)},`);
+    if ((_a = plan.features) == null ? void 0 : _a.length)
+      lines.push(`      features: ${JSON.stringify(plan.features)},`);
+    lines.push("      prices: [");
+    for (const price of plan.prices) {
+      const parts = [];
+      if ("amount" in price)
+        parts.push(`amount: ${price.amount}`);
+      parts.push(
+        `currency: ${JSON.stringify(price.currency)}`,
+        `interval: ${JSON.stringify(price.interval)}`
+      );
+      if (price.intervalCount && price.intervalCount > 1)
+        parts.push(`intervalCount: ${price.intervalCount}`);
+      lines.push(`        { ${parts.join(", ")} },`);
+    }
+    lines.push("      ],");
+    lines.push("    },");
+  }
+  lines.push("  },");
+  lines.push("});");
+  if (result.dashboardPlans.length > 0) {
+    lines.push("");
+    lines.push("// Dashboard-managed plans (not synced by config):");
+    for (const dp of result.dashboardPlans) {
+      lines.push(
+        `// ${dp.suggestedKey}: { name: ${JSON.stringify(dp.name)} }`
+      );
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+export {
+  validateConfig,
+  normalizeConfig,
+  priceConfigKey,
+  computeDiff,
+  slugify,
+  serverStateToBillingConfig,
+  renderConfigAsTypeScript
+};

package/dist/chunk-I4E63NIC.mjs

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+export {
+  __spreadValues,
+  __spreadProps
+};