stripe-no-webhooks 0.0.8 → 0.0.11

package/bin/commands/generate.js

@@ -0,0 +1,110 @@
+const fs = require("fs");
+const path = require("path");
+const { getTemplatesDir, detectRouterType } = require("./helpers/utils");
+
+const GENERATORS = {
+  "pricing-page": {
+    description: "A ready-to-use pricing page component with embedded styles",
+    template: "PricingPage.tsx",
+    defaultOutput: "components/PricingPage.tsx",
+  },
+};
+
+async function generate(component, options = {}) {
+  const {
+    cwd = process.cwd(),
+    logger = console,
+    output,
+  } = options;
+
+  if (!component) {
+    logger.log("\nUsage: npx stripe-no-webhooks generate <component>\n");
+    logger.log("Available components:");
+    for (const [name, config] of Object.entries(GENERATORS)) {
+      logger.log(`  ${name.padEnd(20)} ${config.description}`);
+    }
+    logger.log("\nExample:");
+    logger.log("  npx stripe-no-webhooks generate pricing-page");
+    logger.log("  npx stripe-no-webhooks generate pricing-page --output src/components/Pricing.tsx");
+    return { success: false };
+  }
+
+  const generator = GENERATORS[component];
+  if (!generator) {
+    logger.error(`\n❌ Unknown component: ${component}`);
+    logger.log("\nAvailable components:");
+    for (const name of Object.keys(GENERATORS)) {
+      logger.log(`  ${name}`);
+    }
+    return { success: false, error: `Unknown component: ${component}` };
+  }
+
+  const { useSrc } = detectRouterType(cwd);
+
+  // Determine output path
+  let outputPath;
+  if (output) {
+    outputPath = path.isAbsolute(output) ? output : path.join(cwd, output);
+  } else {
+    const defaultOutput = useSrc
+      ? `src/${generator.defaultOutput}`
+      : generator.defaultOutput;
+    outputPath = path.join(cwd, defaultOutput);
+  }
+
+  // Check if file already exists
+  if (fs.existsSync(outputPath)) {
+    logger.log(`\n⚠️  File already exists: ${path.relative(cwd, outputPath)}`);
+    logger.log("   Use --output to specify a different path");
+    return { success: false, error: "File already exists" };
+  }
+
+  // Read template
+  const templatesDir = getTemplatesDir();
+  const templatePath = path.join(templatesDir, generator.template);
+
+  if (!fs.existsSync(templatePath)) {
+    logger.error(`\n❌ Template not found: ${generator.template}`);
+    return { success: false, error: "Template not found" };
+  }
+
+  const template = fs.readFileSync(templatePath, "utf8");
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Write file
+  fs.writeFileSync(outputPath, template);
+
+  const relativePath = path.relative(cwd, outputPath);
+  logger.log(`\n✅ Created ${relativePath}\n`);
+
+  // Print usage instructions
+  logger.log("Usage:");
+  logger.log("─".repeat(50));
+  logger.log(`
+import { PricingPage } from "./${path.relative(path.join(cwd, useSrc ? "src" : ""), outputPath).replace(/\\/g, "/").replace(/\.tsx$/, "")}";
+import billingConfig from "@/billing.config";
+
+// Get plans for your environment
+const plans = billingConfig.test?.plans || [];
+
+// In your page:
+export default function PricingRoute() {
+  return (
+    <PricingPage
+      plans={plans}
+      currentPlanId="free"  // Pass the user's current plan
+    />
+  );
+}
+`);
+  logger.log("─".repeat(50));
+
+  return { success: true, path: outputPath };
+}
+
+module.exports = { generate };

package/bin/commands/helpers/backfill-maps.js

@@ -0,0 +1,279 @@
+export const SYNC_OBJECTS = [
+  "all",
+  "charge",
+  "checkout_session",
+  "coupon",
+  "credit_note",
+  "customer",
+  "dispute",
+  "invoice",
+  "payment_intent",
+  "payment_method",
+  "plan",
+  "price",
+  "product",
+  "refund",
+  "setup_intent",
+  "subscription",
+  "subscription_schedule",
+];
+
+export const SYNC_ORDER = [
+  {
+    key: "product",
+    table: "products",
+    label: "Products",
+    stripeMethod: "products",
+  },
+  { key: "price", table: "prices", label: "Prices", stripeMethod: "prices" },
+  {
+    key: "coupon",
+    table: "coupons",
+    label: "Coupons",
+    stripeMethod: "coupons",
+  },
+  { key: "plan", table: "plans", label: "Plans", stripeMethod: "plans" },
+  {
+    key: "customer",
+    table: "customers",
+    label: "Customers",
+    stripeMethod: "customers",
+  },
+  {
+    key: "subscription",
+    table: "subscriptions",
+    label: "Subscriptions",
+    stripeMethod: "subscriptions",
+  },
+  {
+    key: "subscription_schedule",
+    table: "subscription_schedules",
+    label: "Subscription Schedules",
+    stripeMethod: "subscriptionSchedules",
+  },
+  {
+    key: "invoice",
+    table: "invoices",
+    label: "Invoices",
+    stripeMethod: "invoices",
+  },
+  {
+    key: "charge",
+    table: "charges",
+    label: "Charges",
+    stripeMethod: "charges",
+  },
+  {
+    key: "payment_intent",
+    table: "payment_intents",
+    label: "Payment Intents",
+    stripeMethod: "paymentIntents",
+  },
+  {
+    key: "payment_method",
+    table: "payment_methods",
+    label: "Payment Methods",
+    stripeMethod: "paymentMethods",
+  },
+  {
+    key: "setup_intent",
+    table: "setup_intents",
+    label: "Setup Intents",
+    stripeMethod: "setupIntents",
+  },
+  {
+    key: "refund",
+    table: "refunds",
+    label: "Refunds",
+    stripeMethod: "refunds",
+  },
+  {
+    key: "dispute",
+    table: "disputes",
+    label: "Disputes",
+    stripeMethod: "disputes",
+  },
+  {
+    key: "credit_note",
+    table: "credit_notes",
+    label: "Credit Notes",
+    stripeMethod: "creditNotes",
+  },
+  {
+    key: "checkout_session",
+    table: "checkout_sessions",
+    label: "Checkout Sessions",
+    stripeMethod: "checkout.sessions",
+  },
+];
+
+export const REQUIRED_TABLES = [
+  "customers",
+  "products",
+  "prices",
+  "subscriptions",
+  "invoices",
+];
+
+// Field definitions: [stripeField, dbField?, isRef?, isJson?]
+// If dbField is omitted, uses stripeField. If isRef=true, extracts .id from objects
+export const FIELD_MAPS = {
+  products: [
+    ["name"],
+    ["description"],
+    ["active"],
+    ["images", null, false, true],
+    ["default_price", null, true],
+    ["updated"],
+  ],
+  prices: [
+    ["active"],
+    ["currency"],
+    ["unit_amount"],
+    ["type"],
+    ["recurring", null, false, true],
+    ["product", null, true],
+    ["nickname"],
+    ["billing_scheme"],
+    ["lookup_key"],
+  ],
+  customers: [
+    ["email"],
+    ["name"],
+    ["phone"],
+    ["description"],
+    ["address", null, false, true],
+    ["shipping", null, false, true],
+    ["balance"],
+    ["currency"],
+    ["delinquent"],
+    ["default_source"],
+    ["invoice_settings", null, false, true],
+    ["deleted"],
+  ],
+  subscriptions: [
+    ["status"],
+    ["customer", null, true],
+    ["current_period_start"],
+    ["current_period_end"],
+    ["cancel_at_period_end"],
+    ["canceled_at"],
+    ["items", null, false, true],
+    ["latest_invoice", null, true],
+    ["default_payment_method", null, true],
+    ["collection_method"],
+  ],
+  invoices: [
+    ["status"],
+    ["customer", null, true],
+    ["subscription", null, true],
+    ["total"],
+    ["amount_due"],
+    ["amount_paid"],
+    ["currency"],
+    ["paid"],
+    ["number"],
+    ["hosted_invoice_url"],
+    ["invoice_pdf"],
+    ["lines", null, false, true],
+    ["period_start"],
+    ["period_end"],
+  ],
+  charges: [
+    ["amount"],
+    ["currency"],
+    ["status"],
+    ["paid"],
+    ["refunded"],
+    ["customer", null, true],
+    ["payment_intent", null, true],
+    ["invoice", null, true],
+    ["description"],
+  ],
+  payment_intents: [
+    ["amount"],
+    ["currency"],
+    ["status"],
+    ["customer", null, true],
+    ["payment_method", null, true],
+    ["description"],
+    ["invoice", null, true],
+  ],
+  payment_methods: [
+    ["type"],
+    ["customer", null, true],
+    ["billing_details", null, false, true],
+    ["card", null, false, true],
+  ],
+  coupons: [
+    ["name"],
+    ["percent_off"],
+    ["amount_off"],
+    ["currency"],
+    ["duration"],
+    ["duration_in_months"],
+    ["valid"],
+    ["times_redeemed"],
+    ["max_redemptions"],
+  ],
+  plans: [
+    ["active"],
+    ["amount"],
+    ["currency"],
+    ["interval"],
+    ["interval_count"],
+    ["product", null, true],
+    ["nickname"],
+  ],
+  refunds: [
+    ["amount"],
+    ["currency"],
+    ["status"],
+    ["charge", null, true],
+    ["payment_intent", null, true],
+    ["reason"],
+  ],
+  disputes: [
+    ["amount"],
+    ["currency"],
+    ["status"],
+    ["charge", null, true],
+    ["payment_intent", null, true],
+    ["reason"],
+  ],
+  setup_intents: [
+    ["status"],
+    ["customer", null, true],
+    ["payment_method", null, true],
+    ["description"],
+    ["usage"],
+  ],
+  subscription_schedules: [
+    ["status"],
+    ["customer", null, true],
+    ["subscription", null, true],
+    ["phases", null, false, true],
+    ["current_phase", null, false, true],
+    ["end_behavior"],
+  ],
+  credit_notes: [
+    ["amount"],
+    ["currency"],
+    ["status"],
+    ["customer", null, true],
+    ["invoice", null, true],
+    ["reason"],
+    ["total"],
+  ],
+  checkout_sessions: [
+    ["status"],
+    ["customer", null, true],
+    ["payment_intent", null, true],
+    ["subscription", null, true],
+    ["mode"],
+    ["payment_status"],
+    ["amount_total"],
+    ["currency"],
+    ["url"],
+  ],
+};

package/bin/commands/helpers/dev-webhook-listener.js

@@ -0,0 +1,76 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+function checkStripeCLI() {
+  try {
+    execSync("stripe --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getNextDevPort(cwd = process.cwd()) {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(cwd, "package.json"), "utf8")
+    );
+    const match = (pkg.scripts?.dev || "").match(/-p\s*(\d+)|--port\s*(\d+)/);
+    return match ? match[1] || match[2] : "3000";
+  } catch {
+    return "3000";
+  }
+}
+
+async function setupDev(options = {}) {
+  const { cwd = process.cwd(), logger = console, exitOnError = true } = options;
+  const pkgPath = path.join(cwd, "package.json");
+
+  if (!fs.existsSync(pkgPath)) {
+    logger.error("❌ package.json not found in current directory.");
+    if (exitOnError) process.exit(1);
+    return { success: false, error: "package.json not found" };
+  }
+
+  const hasStripeCLI = checkStripeCLI();
+  if (!hasStripeCLI) {
+    logger.log("⚠️  Stripe CLI not found. Webhook forwarding will be skipped.");
+    logger.log("   Install it from: https://stripe.com/docs/stripe-cli\n");
+  }
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  pkg.scripts = pkg.scripts || {};
+
+  const port = getNextDevPort(cwd);
+  const webhookUrl = `localhost:${port}/api/stripe/webhook`;
+
+  if (
+    pkg.scripts["dev:webhooks"] ||
+    (pkg.scripts.dev || "").includes("stripe listen")
+  ) {
+    logger.log("✓ Webhook forwarding already configured in package.json");
+    return { success: true, alreadyConfigured: true };
+  }
+
+  const stripeListenScript = `if command -v stripe >/dev/null 2>&1; then stripe listen --forward-to ${webhookUrl}; else echo "⚠️  Stripe CLI not available, skipping webhook forwarding"; fi`;
+  pkg.scripts["dev:stripe"] = stripeListenScript;
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+
+  logger.log("✅ Added dev:stripe script to package.json\n");
+  logger.log(
+    `  npm run dev:stripe - stripe listen --forward-to ${webhookUrl}\n`
+  );
+  logger.log(`Webhook endpoint: ${webhookUrl}`);
+
+  if (!hasStripeCLI) {
+    logger.log(
+      "\n⚠️  Note: Install the Stripe CLI to enable webhook forwarding:"
+    );
+    logger.log("   https://stripe.com/docs/stripe-cli");
+  }
+
+  return { success: true, scripts: { "dev:stripe": stripeListenScript } };
+}
+
+module.exports = { setupDev, checkStripeCLI, getNextDevPort };

package/bin/commands/helpers/sync-helpers.js

@@ -0,0 +1,190 @@
+/**
+ * Helper functions for the sync command.
+ * Extracted for testability.
+ */
+
+/**
+ * Builds a lookup map of Stripe products by name (case-insensitive)
+ * @param {Array} stripeProducts - Array of Stripe product objects
+ * @returns {Object} Map of lowercase product name to product object
+ */
+function buildProductsByNameMap(stripeProducts) {
+  const map = {};
+  for (const product of stripeProducts) {
+    const key = product.name.toLowerCase().trim();
+    if (!map[key]) {
+      map[key] = product;
+    }
+  }
+  return map;
+}
+
+/**
+ * Builds a lookup map of Stripe prices by composite key
+ * Key format: productId:amount:currency:interval
+ * @param {Array} stripePrices - Array of Stripe price objects
+ * @returns {Object} Map of composite key to price object
+ */
+function buildPricesByKeyMap(stripePrices) {
+  const map = {};
+  for (const price of stripePrices) {
+    const productId =
+      typeof price.product === "string" ? price.product : price.product.id;
+    const interval = price.recurring?.interval || "one_time";
+    const key = `${productId}:${price.unit_amount}:${price.currency}:${interval}`;
+    if (!map[key]) {
+      map[key] = price;
+    }
+  }
+  return map;
+}
+
+/**
+ * Finds a matching product by name (case-insensitive)
+ * @param {Object} productsByName - Map of lowercase product names to products
+ * @param {string} planName - Name of the plan to match
+ * @returns {Object|null} Matching product or null
+ */
+function findMatchingProduct(productsByName, planName) {
+  const key = planName.toLowerCase().trim();
+  return productsByName[key] || null;
+}
+
+/**
+ * Generates a price key for matching
+ * @param {string} productId - Stripe product ID
+ * @param {number} amount - Price amount in cents
+ * @param {string} currency - Currency code
+ * @param {string} interval - Price interval (month, year, one_time, etc.)
+ * @returns {string} Composite key
+ */
+function generatePriceKey(productId, amount, currency, interval) {
+  return `${productId}:${amount}:${currency.toLowerCase()}:${interval || "one_time"}`;
+}
+
+/**
+ * Finds a matching price by product, amount, currency, and interval
+ * @param {Object} pricesByKey - Map of composite keys to prices
+ * @param {string} productId - Stripe product ID
+ * @param {Object} localPrice - Local price object with amount, currency, interval
+ * @returns {Object|null} Matching price or null
+ */
+function findMatchingPrice(pricesByKey, productId, localPrice) {
+  const key = generatePriceKey(
+    productId,
+    localPrice.amount,
+    localPrice.currency,
+    localPrice.interval
+  );
+  return pricesByKey[key] || null;
+}
+
+/**
+ * Processes sync for a single plan
+ * @param {Object} plan - Local plan object
+ * @param {Object} productsByName - Map of Stripe products by name
+ * @param {Object} pricesByKey - Map of Stripe prices by key
+ * @param {Object} stripeApi - Stripe API interface with products.create and prices.create
+ * @returns {Object} Result with updated plan, counts, and any errors
+ */
+async function syncPlan(plan, productsByName, pricesByKey, stripeApi) {
+  const result = {
+    plan: { ...plan },
+    productMatched: false,
+    productCreated: false,
+    pricesMatched: 0,
+    pricesCreated: 0,
+    errors: [],
+  };
+
+  let productId = plan.id;
+
+  // Handle product sync
+  if (!productId) {
+    const existingProduct = findMatchingProduct(productsByName, plan.name);
+
+    if (existingProduct) {
+      productId = existingProduct.id;
+      result.plan.id = productId;
+      result.productMatched = true;
+    } else {
+      try {
+        const newProduct = await stripeApi.products.create({
+          name: plan.name,
+          description: plan.description || undefined,
+        });
+        productId = newProduct.id;
+        result.plan.id = productId;
+        result.productCreated = true;
+        // Add to map for price matching
+        const nameKey = plan.name.toLowerCase().trim();
+        productsByName[nameKey] = newProduct;
+      } catch (error) {
+        result.errors.push(`Failed to create product "${plan.name}": ${error.message}`);
+        return result;
+      }
+    }
+  }
+
+  // Handle price sync
+  if (plan.price && plan.price.length > 0) {
+    result.plan.price = [];
+
+    for (const price of plan.price) {
+      const updatedPrice = { ...price };
+
+      if (!price.id) {
+        const existingPrice = findMatchingPrice(pricesByKey, productId, price);
+
+        if (existingPrice) {
+          updatedPrice.id = existingPrice.id;
+          result.pricesMatched++;
+        } else {
+          try {
+            const priceParams = {
+              product: productId,
+              unit_amount: price.amount,
+              currency: price.currency.toLowerCase(),
+            };
+
+            if (price.interval && price.interval !== "one_time") {
+              priceParams.recurring = {
+                interval: price.interval,
+              };
+            }
+
+            const newPrice = await stripeApi.prices.create(priceParams);
+            updatedPrice.id = newPrice.id;
+            result.pricesCreated++;
+
+            // Add to map
+            const priceKey = generatePriceKey(
+              productId,
+              price.amount,
+              price.currency,
+              price.interval
+            );
+            pricesByKey[priceKey] = newPrice;
+          } catch (error) {
+            result.errors.push(
+              `Failed to create price ${price.amount} ${price.currency}/${price.interval}: ${error.message}`
+            );
+          }
+        }
+      }
+
+      result.plan.price.push(updatedPrice);
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  buildProductsByNameMap,
+  buildPricesByKeyMap,
+  findMatchingProduct,
+  findMatchingPrice,
+  generatePriceKey,
+  syncPlan,
+};