stripe-no-webhooks 0.0.4 → 0.0.6

package/bin/cli.js

@@ -413,134 +413,154 @@ function findMatchingBrace(content, startIndex) {
   return -1;
 }
 
-function parseBillingConfig(content) {
-  // Extract the plans array from the file content
-  const plansStartMatch = content.match(/plans\s*:\s*\[/);
-  if (!plansStartMatch) {
-    return [];
+function getMode(stripeKey) {
+  if (stripeKey.includes("_test_")) {
+    return "test";
+  } else if (stripeKey.includes("_live_")) {
+    return "production";
+  } else {
+    throw new Error("Invalid Stripe key");
   }
+}
 
-  const plansStart = plansStartMatch.index + plansStartMatch[0].length - 1;
-  const plansEnd = findMatchingBrace(content, plansStart);
-  if (plansEnd === -1) return [];
-
-  const plansContent = content.substring(plansStart + 1, plansEnd);
-  const plans = [];
+function tsObjectToJson(tsContent) {
+  // Remove single-line comments
+  let json = tsContent.replace(/\/\/.*$/gm, "");
+  // Remove multi-line comments
+  json = json.replace(/\/\*[\s\S]*?\*\//g, "");
+  // Quote unquoted keys (word characters followed by colon)
+  json = json.replace(/(\s*)(\w+)(\s*:)/g, '$1"$2"$3');
+  // Remove trailing commas before ] or }
+  json = json.replace(/,(\s*[}\]])/g, "$1");
+  return json;
+}
 
-  // Find each plan object by looking for opening braces at the top level
-  let depth = 0;
-  let planStart = -1;
-
-  for (let i = 0; i < plansContent.length; i++) {
-    const char = plansContent[i];
-    if (char === "{") {
-      if (depth === 0) planStart = i;
-      depth++;
-    } else if (char === "}") {
-      depth--;
-      if (depth === 0 && planStart !== -1) {
-        const planRaw = plansContent.substring(planStart, i + 1);
-        const plan = parsePlanObject(planRaw);
-        if (plan.name) {
-          plans.push({
-            plan,
-            raw: planRaw,
-            startIndex:
-              plansStartMatch.index + plansStartMatch[0].length + planStart,
-          });
-        }
-        planStart = -1;
-      }
-    }
+function extractBillingConfigObject(content) {
+  // Find the start of the config object
+  const configStartMatch = content.match(
+    /const\s+billingConfig\s*:\s*BillingConfig\s*=\s*\{/
+  );
+  if (!configStartMatch) {
+    return null;
   }
 
-  return plans;
+  const objectStart = configStartMatch.index + configStartMatch[0].length - 1;
+  const objectEnd = findMatchingBrace(content, objectStart);
+  if (objectEnd === -1) return null;
+
+  const rawObject = content.substring(objectStart, objectEnd + 1);
+  return {
+    raw: rawObject,
+    start: objectStart,
+    end: objectEnd + 1,
+  };
 }
 
-function parsePlanObject(planContent) {
-  const plan = {};
-
-  // Extract id if present (product id)
-  const idMatch = planContent.match(/^\s*\{\s*id\s*:\s*["']([^"']+)["']/);
-  if (idMatch) plan.id = idMatch[1];
-
-  // Also try to find id not at start
-  if (!plan.id) {
-    const idMatch2 = planContent.match(/[,{]\s*id\s*:\s*["']([^"']+)["']/);
-    if (idMatch2) plan.id = idMatch2[1];
-  }
-
-  // Extract name
-  const nameMatch = planContent.match(/name\s*:\s*["']([^"']+)["']/);
-  if (nameMatch) plan.name = nameMatch[1];
-
-  // Extract description
-  const descMatch = planContent.match(/description\s*:\s*["']([^"']+)["']/);
-  if (descMatch) plan.description = descMatch[1];
-
-  // Extract price array
-  const priceStartMatch = planContent.match(/price\s*:\s*\[/);
-  if (priceStartMatch) {
-    const priceStart = priceStartMatch.index + priceStartMatch[0].length - 1;
-    const priceEnd = findMatchingBrace(planContent, priceStart);
-    if (priceEnd !== -1) {
-      const priceArrayContent = planContent.substring(priceStart + 1, priceEnd);
-      plan.prices = parsePriceArray(priceArrayContent);
-      plan.priceArrayStart = priceStart;
-      plan.priceArrayEnd = priceEnd;
-    }
+function parseBillingConfig(content, mode) {
+  const extracted = extractBillingConfigObject(content);
+  if (!extracted) {
+    return { config: null, plans: [] };
   }
 
-  return plan;
+  // Convert to JSON and parse
+  const jsonString = tsObjectToJson(extracted.raw);
+  let config;
+  try {
+    config = JSON.parse(jsonString);
+  } catch (e) {
+    console.error("Failed to parse billing config as JSON:", e.message);
+    return { config: null, plans: [] };
+  }
+
+  // Get plans for the specified mode
+  const modeConfig = config[mode];
+  if (!modeConfig || !modeConfig.plans || modeConfig.plans.length === 0) {
+    return { config, plans: [], extracted };
+  }
+
+  // Return parsed plans with their indices for updating
+  const plans = modeConfig.plans.map((plan, index) => ({
+    plan,
+    index,
+  }));
+
+  return { config, plans, extracted };
 }
 
-function parsePriceArray(priceArrayContent) {
-  const prices = [];
-  let depth = 0;
-  let priceStart = -1;
-
-  for (let i = 0; i < priceArrayContent.length; i++) {
-    const char = priceArrayContent[i];
-    if (char === "{") {
-      if (depth === 0) priceStart = i;
-      depth++;
-    } else if (char === "}") {
-      depth--;
-      if (depth === 0 && priceStart !== -1) {
-        const priceRaw = priceArrayContent.substring(priceStart, i + 1);
-        const price = parsePriceObject(priceRaw);
-        prices.push({ price, raw: priceRaw, localStart: priceStart });
-        priceStart = -1;
-      }
-    }
+function reorderWithIdFirst(obj) {
+  // Reorder object so 'id' is the first property if it exists
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return obj;
   }
 
-  return prices;
+  const { id, ...rest } = obj;
+  if (id !== undefined) {
+    return { id, ...rest };
+  }
+  return obj;
 }
 
-function parsePriceObject(priceContent) {
-  const price = {};
+function toTsObjectLiteral(value, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  const childSpaces = "  ".repeat(indent + 1);
 
-  // Extract id if present (price id)
-  const idMatch = priceContent.match(/id\s*:\s*["']([^"']+)["']/);
-  if (idMatch) price.id = idMatch[1];
+  if (value === null || value === undefined) {
+    return String(value);
+  }
+
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
 
-  // Extract amount
-  const amountMatch = priceContent.match(/amount\s*:\s*(\d+)/);
-  if (amountMatch) price.amount = parseInt(amountMatch[1], 10);
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
 
-  // Extract currency
-  const currencyMatch = priceContent.match(/currency\s*:\s*["']([^"']+)["']/);
-  if (currencyMatch) price.currency = currencyMatch[1];
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((item) => toTsObjectLiteral(item, indent + 1));
+    return `[\n${childSpaces}${items.join(`,\n${childSpaces}`)},\n${spaces}]`;
+  }
 
-  // Extract interval
-  const intervalMatch = priceContent.match(/interval\s*:\s*["']([^"']+)["']/);
-  if (intervalMatch) price.interval = intervalMatch[1];
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return "{}";
+    }
+    const props = entries.map(
+      ([key, val]) => `${key}: ${toTsObjectLiteral(val, indent + 1)}`
+    );
+    return `{\n${childSpaces}${props.join(`,\n${childSpaces}`)},\n${spaces}}`;
+  }
 
-  return price;
+  return String(value);
 }
 
-async function push() {
+function formatConfigToTs(config) {
+  // Reorder plans and prices so 'id' is always first
+  const reorderedConfig = {};
+
+  for (const mode of ["test", "production"]) {
+    if (config[mode]) {
+      reorderedConfig[mode] = {
+        plans: (config[mode].plans || []).map((plan) => {
+          const reorderedPlan = reorderWithIdFirst(plan);
+          if (reorderedPlan.price) {
+            reorderedPlan.price = reorderedPlan.price.map(reorderWithIdFirst);
+          }
+          return reorderedPlan;
+        }),
+      };
+    }
+  }
+
+  // Convert to TypeScript object literal format (unquoted keys)
+  return toTsObjectLiteral(reorderedConfig, 0);
+}
+
+async function sync() {
   const billingConfigPath = path.join(process.cwd(), "billing.config.ts");
 
   if (!fs.existsSync(billingConfigPath)) {
@@ -572,28 +592,176 @@ async function push() {
     process.exit(1);
   }
 
+  // Determine mode based on Stripe key
+  let mode;
+  try {
+    mode = getMode(stripeSecretKey);
+  } catch (e) {
+    console.error("❌", e.message);
+    process.exit(1);
+  }
+
   const stripe = new Stripe(stripeSecretKey);
 
-  console.log("\n📤 Pushing billing plans to Stripe...\n");
+  console.log(`\n🔄 Syncing billing plans with Stripe (${mode} mode)...\n`);
 
   let content = fs.readFileSync(billingConfigPath, "utf8");
-  const parsedPlans = parseBillingConfig(content);
+  const { config, plans, extracted } = parseBillingConfig(content, mode);
 
-  if (parsedPlans.length === 0) {
-    console.log("No plans found in billing.config.ts");
-    console.log("Add plans to the config file and run this command again.");
-    process.exit(0);
+  if (!config) {
+    console.error("❌ Failed to parse billing.config.ts");
+    process.exit(1);
+  }
+
+  // Ensure the mode config exists with plans array
+  if (!config[mode]) {
+    config[mode] = { plans: [] };
+  }
+  if (!config[mode].plans) {
+    config[mode].plans = [];
   }
 
-  let updatedContent = content;
+  let configModified = false;
+  let productsPulled = 0;
+  let pricesPulled = 0;
   let productsCreated = 0;
   let pricesCreated = 0;
   let skippedProducts = 0;
   let skippedPrices = 0;
 
-  for (const { plan, raw } of parsedPlans) {
+  // === PULL: Fetch products and prices from Stripe and add missing ones ===
+  console.log("📥 Pulling products from Stripe...\n");
+
+  try {
+    // Fetch all active products from Stripe
+    const stripeProducts = await stripe.products.list({
+      active: true,
+      limit: 100,
+    });
+
+    // Fetch all active prices from Stripe
+    const stripePrices = await stripe.prices.list({ active: true, limit: 100 });
+
+    // Build a map of price by product
+    const pricesByProduct = {};
+    for (const price of stripePrices.data) {
+      const productId =
+        typeof price.product === "string" ? price.product : price.product.id;
+      if (!pricesByProduct[productId]) {
+        pricesByProduct[productId] = [];
+      }
+      pricesByProduct[productId].push(price);
+    }
+
+    // Get existing product IDs in config
+    const existingProductIds = new Set(
+      config[mode].plans.filter((p) => p.id).map((p) => p.id)
+    );
+
+    // Get existing price IDs in config
+    const existingPriceIds = new Set();
+    for (const plan of config[mode].plans) {
+      if (plan.price) {
+        for (const price of plan.price) {
+          if (price.id) {
+            existingPriceIds.add(price.id);
+          }
+        }
+      }
+    }
+
+    // Add missing products and their prices
+    for (const product of stripeProducts.data) {
+      if (existingProductIds.has(product.id)) {
+        // Product exists, but check if any prices are missing
+        const planIndex = config[mode].plans.findIndex(
+          (p) => p.id === product.id
+        );
+        const plan = config[mode].plans[planIndex];
+        const productPrices = pricesByProduct[product.id] || [];
+
+        for (const stripePrice of productPrices) {
+          if (!existingPriceIds.has(stripePrice.id)) {
+            // Add missing price to existing plan
+            const newPrice = {
+              id: stripePrice.id,
+              amount: stripePrice.unit_amount,
+              currency: stripePrice.currency,
+              interval: stripePrice.recurring?.interval || "one_time",
+            };
+            if (!plan.price) {
+              plan.price = [];
+            }
+            plan.price.push(newPrice);
+            existingPriceIds.add(stripePrice.id);
+            pricesPulled++;
+            configModified = true;
+            console.log(
+              `   📥 Added price ${stripePrice.unit_amount / 100} ${
+                stripePrice.currency
+              }/${newPrice.interval} to "${product.name}"`
+            );
+          }
+        }
+        continue;
+      }
+
+      // Product doesn't exist in config, add it
+      const productPrices = pricesByProduct[product.id] || [];
+      const newPlan = {
+        id: product.id,
+        name: product.name,
+        description: product.description || undefined,
+        price: productPrices.map((p) => ({
+          id: p.id,
+          amount: p.unit_amount,
+          currency: p.currency,
+          interval: p.recurring?.interval || "one_time",
+        })),
+      };
+
+      // Remove undefined description
+      if (!newPlan.description) {
+        delete newPlan.description;
+      }
+
+      config[mode].plans.push(newPlan);
+      productsPulled++;
+      pricesPulled += productPrices.length;
+      configModified = true;
+
+      console.log(`📥 Added product "${product.name}" (${product.id})`);
+      for (const price of newPlan.price) {
+        console.log(
+          `   📥 Added price ${price.amount / 100} ${price.currency}/${
+            price.interval
+          }`
+        );
+      }
+    }
+
+    if (productsPulled === 0 && pricesPulled === 0) {
+      console.log("   No new products or prices to pull from Stripe.\n");
+    } else {
+      console.log("");
+    }
+  } catch (error) {
+    console.error("❌ Failed to fetch products from Stripe:", error.message);
+  }
+
+  // === PUSH: Create products and prices in Stripe from config ===
+  console.log("📤 Pushing new plans to Stripe...\n");
+
+  // Re-get plans after potential modifications
+  const currentPlans = config[mode].plans || [];
+
+  if (currentPlans.length === 0) {
+    console.log(`   No plans in billing.config.ts for ${mode} mode.\n`);
+  }
+
+  for (let index = 0; index < currentPlans.length; index++) {
+    const plan = currentPlans[index];
     let productId = plan.id;
-    let updatedPlanRaw = raw;
 
     // Create product if needed
     if (!productId) {
@@ -608,12 +776,10 @@ async function push() {
         productId = product.id;
         console.log(`✅ Created product "${plan.name}" (${productId})`);
 
-        // Add product id to plan
-        updatedPlanRaw = updatedPlanRaw.replace(
-          /\{/,
-          `{\n      id: "${productId}",`
-        );
+        // Update the config object with the new product id
+        config[mode].plans[index].id = productId;
         productsCreated++;
+        configModified = true;
       } catch (error) {
         console.error(
           `❌ Failed to create product "${plan.name}":`,
@@ -622,17 +788,15 @@ async function push() {
         continue;
       }
     } else {
-      console.log(`⏭️  Product "${plan.name}" already exists (${productId})`);
       skippedProducts++;
     }
 
     // Create prices if needed
-    if (plan.prices && plan.prices.length > 0) {
-      for (const { price, raw: priceRaw } of plan.prices) {
+    if (plan.price && plan.price.length > 0) {
+      for (let priceIndex = 0; priceIndex < plan.price.length; priceIndex++) {
+        const price = plan.price[priceIndex];
+
         if (price.id) {
-          console.log(
-            `   ⏭️  Price ${price.interval}/${price.currency} already exists (${price.id})`
-          );
           skippedPrices++;
           continue;
         }
@@ -644,24 +808,27 @@ async function push() {
             }...`
           );
 
-          const stripePrice = await stripe.prices.create({
+          const priceParams = {
             product: productId,
             unit_amount: price.amount,
             currency: price.currency.toLowerCase(),
-            recurring: {
+          };
+
+          // Only add recurring for non-one_time intervals
+          if (price.interval && price.interval !== "one_time") {
+            priceParams.recurring = {
               interval: price.interval,
-            },
-          });
+            };
+          }
+
+          const stripePrice = await stripe.prices.create(priceParams);
 
           console.log(`   ✅ Created price (${stripePrice.id})`);
 
-          // Add price id to price object
-          const updatedPriceRaw = priceRaw.replace(
-            /\{/,
-            `{\n          id: "${stripePrice.id}",`
-          );
-          updatedPlanRaw = updatedPlanRaw.replace(priceRaw, updatedPriceRaw);
+          // Update the config object with the new price id
+          config[mode].plans[index].price[priceIndex].id = stripePrice.id;
           pricesCreated++;
+          configModified = true;
         } catch (error) {
           console.error(
             `   ❌ Failed to create price ${price.interval}/${price.currency}:`,
@@ -670,26 +837,30 @@ async function push() {
         }
       }
     }
+  }
 
-    // Update content with modified plan
-    if (updatedPlanRaw !== raw) {
-      updatedContent = updatedContent.replace(raw, updatedPlanRaw);
-    }
+  if (productsCreated === 0 && pricesCreated === 0) {
+    console.log("   No new products or prices to push to Stripe.\n");
   }
 
-  // Write updated content back to file
-  if (productsCreated > 0 || pricesCreated > 0) {
-    fs.writeFileSync(billingConfigPath, updatedContent);
-    console.log(
-      `\n📝 Updated billing.config.ts with ${productsCreated} product(s) and ${pricesCreated} price(s)`
-    );
+  // Write updated config back to file
+  if (configModified) {
+    const newConfigJson = formatConfigToTs(config);
+    const newContent =
+      content.substring(0, extracted.start) +
+      newConfigJson +
+      content.substring(extracted.end);
+    fs.writeFileSync(billingConfigPath, newContent);
+    console.log(`\n📝 Updated billing.config.ts`);
   }
 
   console.log(`\n✅ Done!`);
   console.log(
-    `   Products: ${productsCreated} created, ${skippedProducts} skipped`
+    `   Pulled from Stripe: ${productsPulled} product(s), ${pricesPulled} price(s)`
+  );
+  console.log(
+    `   Pushed to Stripe: ${productsCreated} product(s), ${pricesCreated} price(s)`
   );
-  console.log(`   Prices: ${pricesCreated} created, ${skippedPrices} skipped`);
 }
 
 async function main() {
@@ -702,8 +873,8 @@ async function main() {
       await config();
       break;
 
-    case "push":
-      await push();
+    case "sync":
+      await sync();
       break;
 
     default:

package/dist/BillingConfig-n6VbfqGY.d.mts

@@ -0,0 +1,23 @@
+type PriceInterval = "month" | "year" | "week" | "one_time";
+type Price = {
+    id?: string;
+    amount: number;
+    currency: string;
+    interval: PriceInterval;
+};
+type Plan = {
+    id?: string;
+    name: string;
+    description?: string;
+    price: Price[];
+};
+type BillingConfig = {
+    test?: {
+        plans?: Plan[];
+    };
+    production?: {
+        plans?: Plan[];
+    };
+};
+
+export type { BillingConfig as B, PriceInterval as P, Price as a, Plan as b };

package/dist/BillingConfig-n6VbfqGY.d.ts

@@ -0,0 +1,23 @@
+type PriceInterval = "month" | "year" | "week" | "one_time";
+type Price = {
+    id?: string;
+    amount: number;
+    currency: string;
+    interval: PriceInterval;
+};
+type Plan = {
+    id?: string;
+    name: string;
+    description?: string;
+    price: Price[];
+};
+type BillingConfig = {
+    test?: {
+        plans?: Plan[];
+    };
+    production?: {
+        plans?: Plan[];
+    };
+};
+
+export type { BillingConfig as B, PriceInterval as P, Price as a, Plan as b };

package/dist/client.d.mts

@@ -1,4 +1,4 @@
-import { P as PriceInterval } from './BillingConfig-BYrAQ7Wx.mjs';
+import { P as PriceInterval } from './BillingConfig-n6VbfqGY.mjs';
 
 interface CheckoutOptions {
     /**

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { P as PriceInterval } from './BillingConfig-BYrAQ7Wx.js';
+import { P as PriceInterval } from './BillingConfig-n6VbfqGY.js';
 
 interface CheckoutOptions {
     /**

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import Stripe from 'stripe';
-import { B as BillingConfig, P as PriceInterval } from './BillingConfig-BYrAQ7Wx.mjs';
-export { b as Plan, a as Price } from './BillingConfig-BYrAQ7Wx.mjs';
+import { B as BillingConfig, P as PriceInterval } from './BillingConfig-n6VbfqGY.mjs';
+export { b as Plan, a as Price } from './BillingConfig-n6VbfqGY.mjs';
 
 interface StripeWebhookCallbacks {
     /**

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import Stripe from 'stripe';
-import { B as BillingConfig, P as PriceInterval } from './BillingConfig-BYrAQ7Wx.js';
-export { b as Plan, a as Price } from './BillingConfig-BYrAQ7Wx.js';
+import { B as BillingConfig, P as PriceInterval } from './BillingConfig-n6VbfqGY.js';
+export { b as Plan, a as Price } from './BillingConfig-n6VbfqGY.js';
 
 interface StripeWebhookCallbacks {
     /**

package/dist/index.js

@@ -37,6 +37,19 @@ module.exports = __toCommonJS(index_exports);
 // src/handler.ts
 var import_stripe_sync_engine = require("@supabase/stripe-sync-engine");
 var import_stripe = __toESM(require("stripe"));
+
+// src/utils.ts
+var getMode = (stripeKey) => {
+  if (stripeKey.includes("_test_")) {
+    return "test";
+  } else if (stripeKey.includes("_live_")) {
+    return "production";
+  } else {
+    throw new Error("Invalid Stripe key");
+  }
+};
+
+// src/handler.ts
 function createStripeHandler(config = {}) {
   const {
     stripeSecretKey = process.env.STRIPE_SECRET_KEY,
@@ -58,19 +71,19 @@ function createStripeHandler(config = {}) {
     stripeSecretKey,
     stripeWebhookSecret
   }) : null;
-  function resolvePriceId(body) {
+  function resolvePriceId(body, mode) {
     if (body.priceId) {
       return body.priceId;
     }
     if (!body.interval) {
       throw new Error("interval is required when using planName or planId");
     }
-    if (!billingConfig?.plans) {
+    if (!billingConfig?.[mode]?.plans) {
       throw new Error(
         "billingConfig with plans is required when using planName or planId"
       );
     }
-    const plan = body.planName ? billingConfig.plans.find((p) => p.name === body.planName) : body.planId ? billingConfig.plans.find((p) => p.id === body.planId) : null;
+    const plan = body.planName ? billingConfig[mode]?.plans?.find((p) => p.name === body.planName) : body.planId ? billingConfig[mode]?.plans?.find((p) => p.id === body.planId) : null;
     if (!plan) {
       const identifier = body.planName || body.planId;
       throw new Error(`Plan not found: ${identifier}`);
@@ -106,7 +119,7 @@ function createStripeHandler(config = {}) {
       const origin = request.headers.get("origin") || "";
       const successUrl = body.successUrl || defaultSuccessUrl || `${origin}/success?session_id={CHECKOUT_SESSION_ID}`;
       const cancelUrl = body.cancelUrl || defaultCancelUrl || `${origin}/`;
-      const priceId = resolvePriceId(body);
+      const priceId = resolvePriceId(body, getMode(stripeSecretKey));
       const mode = await getPriceMode(priceId);
       const sessionParams = {
         line_items: [

package/dist/index.mjs

@@ -1,6 +1,19 @@
 // src/handler.ts
 import { StripeSync } from "@supabase/stripe-sync-engine";
 import Stripe from "stripe";
+
+// src/utils.ts
+var getMode = (stripeKey) => {
+  if (stripeKey.includes("_test_")) {
+    return "test";
+  } else if (stripeKey.includes("_live_")) {
+    return "production";
+  } else {
+    throw new Error("Invalid Stripe key");
+  }
+};
+
+// src/handler.ts
 function createStripeHandler(config = {}) {
   const {
     stripeSecretKey = process.env.STRIPE_SECRET_KEY,
@@ -22,19 +35,19 @@ function createStripeHandler(config = {}) {
     stripeSecretKey,
     stripeWebhookSecret
   }) : null;
-  function resolvePriceId(body) {
+  function resolvePriceId(body, mode) {
     if (body.priceId) {
       return body.priceId;
     }
     if (!body.interval) {
       throw new Error("interval is required when using planName or planId");
     }
-    if (!billingConfig?.plans) {
+    if (!billingConfig?.[mode]?.plans) {
       throw new Error(
         "billingConfig with plans is required when using planName or planId"
       );
     }
-    const plan = body.planName ? billingConfig.plans.find((p) => p.name === body.planName) : body.planId ? billingConfig.plans.find((p) => p.id === body.planId) : null;
+    const plan = body.planName ? billingConfig[mode]?.plans?.find((p) => p.name === body.planName) : body.planId ? billingConfig[mode]?.plans?.find((p) => p.id === body.planId) : null;
     if (!plan) {
       const identifier = body.planName || body.planId;
       throw new Error(`Plan not found: ${identifier}`);
@@ -70,7 +83,7 @@ function createStripeHandler(config = {}) {
       const origin = request.headers.get("origin") || "";
       const successUrl = body.successUrl || defaultSuccessUrl || `${origin}/success?session_id={CHECKOUT_SESSION_ID}`;
       const cancelUrl = body.cancelUrl || defaultCancelUrl || `${origin}/`;
-      const priceId = resolvePriceId(body);
+      const priceId = resolvePriceId(body, getMode(stripeSecretKey));
       const mode = await getPriceMode(priceId);
       const sessionParams = {
         line_items: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stripe-no-webhooks",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "author": "Ramon Garate",
   "description": "Stripe integration without dealing with webhooks",
   "main": "./dist/index.js",

package/src/templates/billing.config.ts

@@ -1,26 +1,29 @@
 import type { BillingConfig } from "stripe-no-webhooks";
 
 const billingConfig: BillingConfig = {
-  /*
+  test: {
     plans: [
-      {
-        name: "Premium",
-        description: "Access to all features",
-        price: [
-          {
-            amount: 1000, // in cents, 1000 = $10.00
-            currency: "usd",
-            interval: "month",
-          },
-          {
-            amount: 10000, // in cents, 10000 = $100.00
-            currency: "usd",
-            interval: "year",
-          },
-        ],
-      },
+      //   {
+      //     name: "Premium",
+      //     description: "Access to all features",
+      //     price: [
+      //       {
+      //         amount: 1000, // in cents, 1000 = $10.00
+      //         currency: "usd",
+      //         interval: "month",
+      //       },
+      //       {
+      //         amount: 10000, // in cents, 10000 = $100.00
+      //         currency: "usd",
+      //         interval: "year",
+      //       },
+      //     ],
+      //   },
     ],
-  */
+  },
+  production: {
+    plans: [],
+  },
 };
 
 export default billingConfig;