stripe-no-webhooks 0.0.1

package/README.md

@@ -0,0 +1,152 @@
+# stripe-no-webhooks
+
+Stripe integration without dealing with webhooks. Automatically syncs Stripe data to your PostgreSQL database and provides simple callbacks for subscription events.
+
+## Installation
+
+```bash
+npm install stripe-no-webhooks stripe
+```
+
+## Setup
+
+### 1. Create Stripe schema and tables
+
+**Option 1:** Run the migration command
+
+```bash
+npx stripe-no-webhooks migrate postgresql://postgres.[USER]:[PASSWORD]@[DB_URL]/postgres
+```
+
+**Option 2:** Copy `stripe_schema.sql` and run the query manually
+
+### 2. Set up the webhook handler
+
+Create a webhook endpoint in your Next.js app:
+
+#### App Router (recommended)
+
+```ts
+// app/api/stripe/webhook/route.ts
+import { createStripeWebhookHandler } from "stripe-no-webhooks";
+
+const handler = createStripeWebhookHandler({
+  databaseUrl: process.env.DATABASE_URL!,
+  stripeSecretKey: process.env.STRIPE_SECRET_KEY!,
+  stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
+  callbacks: {
+    onSubscriptionCreated: async (subscription) => {
+      // Called when a new subscription is created
+      console.log("New subscription:", subscription.id);
+      // e.g., send welcome email, provision resources, etc.
+    },
+    onSubscriptionCancelled: async (subscription) => {
+      // Called when a subscription is cancelled
+      console.log("Subscription cancelled:", subscription.id);
+      // e.g., send cancellation email, revoke access, etc.
+    },
+  },
+});
+
+export const POST = handler;
+```
+
+#### Pages Router
+
+```ts
+// pages/api/stripe/webhook.ts
+import { createStripeWebhookHandler } from "stripe-no-webhooks";
+import type { NextApiRequest, NextApiResponse } from "next";
+
+const handler = createStripeWebhookHandler({
+  databaseUrl: process.env.DATABASE_URL!,
+  stripeSecretKey: process.env.STRIPE_SECRET_KEY!,
+  stripeWebhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
+  callbacks: {
+    onSubscriptionCreated: async (subscription) => {
+      console.log("New subscription:", subscription.id);
+    },
+    onSubscriptionCancelled: async (subscription) => {
+      console.log("Subscription cancelled:", subscription.id);
+    },
+  },
+});
+
+// Disable body parsing, we need the raw body for webhook verification
+export const config = {
+  api: {
+    bodyParser: false,
+  },
+};
+
+export default async function webhookHandler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  if (req.method !== "POST") {
+    return res.status(405).json({ error: "Method not allowed" });
+  }
+
+  // Convert NextApiRequest to Request for the handler
+  const body = await new Promise<string>((resolve) => {
+    let data = "";
+    req.on("data", (chunk) => (data += chunk));
+    req.on("end", () => resolve(data));
+  });
+
+  const request = new Request(`https://${req.headers.host}${req.url}`, {
+    method: "POST",
+    headers: new Headers(req.headers as Record<string, string>),
+    body,
+  });
+
+  const response = await handler(request);
+  res.status(response.status).send(await response.text());
+}
+```
+
+### 3. Configure Stripe webhook
+
+Run the config command to automatically create a webhook in your Stripe account:
+
+```bash
+npx stripe-no-webhooks config
+```
+
+This will:
+
+1. Ask for your Stripe Secret Key
+2. Ask for your site URL (defaults to `NEXT_PUBLIC_SITE_URL` if set)
+3. Create a webhook endpoint at `https://yoursite.com/api/stripe/webhook` listening to all events
+4. Automatically add `STRIPE_WEBHOOK_SECRET` to your `.env` files (if they exist)
+
+## Environment Variables
+
+```env
+DATABASE_URL=postgresql://user:pass@host:port/db
+STRIPE_SECRET_KEY=sk_test_...
+STRIPE_WEBHOOK_SECRET=whsec_...  # Output from `npx stripe-no-webhooks config`
+```
+
+## What gets synced?
+
+All Stripe webhook events are automatically synced to your PostgreSQL database in the `stripe` schema. This includes:
+
+- Customers
+- Subscriptions
+- Products
+- Prices
+- Invoices
+- Payment methods
+- And more...
+
+You can query this data directly from your database without making API calls to Stripe.
+
+## Callbacks
+
+| Callback                  | Event                                                           | Description                               |
+| ------------------------- | --------------------------------------------------------------- | ----------------------------------------- |
+| `onSubscriptionCreated`   | `customer.subscription.created`                                 | Called when a new subscription is created |
+| `onSubscriptionCancelled` | `customer.subscription.deleted` or status changes to `canceled` | Called when a subscription is cancelled   |
+
+Both callbacks receive the full Stripe `Subscription` object.

package/bin/cli.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+const { runMigrations } = require("@supabase/stripe-sync-engine");
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+
+const args = process.argv.slice(2);
+const command = args[0];
+const databaseUrl = args[1];
+
+function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+function question(rl, query, defaultValue = "") {
+  return new Promise((resolve) => {
+    const prompt = defaultValue ? `${query} (${defaultValue}): ` : `${query}: `;
+    rl.question(prompt, (answer) => {
+      resolve(answer || defaultValue);
+    });
+  });
+}
+
+function questionHidden(rl, query) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    stdout.write(`${query}: `);
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    let input = "";
+    const onData = (char) => {
+      if (char === "\n" || char === "\r" || char === "\u0004") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        stdout.write("\n");
+        resolve(input);
+      } else if (char === "\u0003") {
+        // Ctrl+C
+        process.exit();
+      } else if (char === "\u007F" || char === "\b") {
+        // Backspace
+        if (input.length > 0) {
+          input = input.slice(0, -1);
+          stdout.write("\b \b"); // Erase character from display
+        }
+      } else {
+        input += char;
+        stdout.write("**************"); // Show asterisk for each character
+      }
+    };
+
+    stdin.on("data", onData);
+  });
+}
+
+async function migrate(databaseUrl) {
+  if (!databaseUrl) {
+    console.error("❌ Missing database URL.\n");
+    console.log(
+      "Usage:\n  npx stripe-no-webhooks migrate <postgres_connection_string>"
+    );
+    process.exit(1);
+  }
+
+  console.log("🚀 Running Stripe migrations...");
+  try {
+    await runMigrations({
+      databaseUrl,
+      schema: "stripe",
+      logger: console,
+    });
+    console.log("✅ Migrations completed successfully!");
+  } catch (error) {
+    console.error("❌ Migration failed:");
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+async function config() {
+  let Stripe;
+  try {
+    Stripe = require("stripe").default || require("stripe");
+  } catch (e) {
+    console.error("❌ Stripe package not found.");
+    console.log("Please install it first: npm install stripe");
+    process.exit(1);
+  }
+
+  const rl = createPrompt();
+
+  console.log("\n🔧 Stripe Webhook Configuration\n");
+
+  // Get Stripe API key (hidden input)
+  rl.close(); // Close readline for hidden input
+  const stripeSecretKey = await questionHidden(
+    null,
+    "Enter your Stripe Secret Key (sk_...)"
+  );
+
+  if (!stripeSecretKey || !stripeSecretKey.startsWith("sk_")) {
+    console.error("❌ Invalid Stripe Secret Key. It should start with 'sk_'");
+    process.exit(1);
+  }
+
+  // Reopen readline for remaining questions
+  const rl2 = createPrompt();
+
+  // Get site URL with default from env
+  const defaultSiteUrl = process.env.NEXT_PUBLIC_SITE_URL || "";
+  const siteUrl = await question(rl2, "Enter your site URL", defaultSiteUrl);
+
+  if (!siteUrl) {
+    console.error("❌ Site URL is required");
+    rl2.close();
+    process.exit(1);
+  }
+
+  // Validate URL
+  let webhookUrl;
+  try {
+    const url = new URL(siteUrl);
+    webhookUrl = `${url.origin}/api/stripe/webhook`;
+  } catch (e) {
+    console.error("❌ Invalid URL format");
+    rl2.close();
+    process.exit(1);
+  }
+
+  rl2.close();
+
+  console.log(`\n📡 Creating webhook endpoint: ${webhookUrl}\n`);
+
+  const stripe = new Stripe(stripeSecretKey);
+
+  try {
+    // Get all available event types
+    const webhook = await stripe.webhookEndpoints.create({
+      url: webhookUrl,
+      enabled_events: ["*"], // Listen to all events
+      description: "Created by stripe-no-webhooks CLI",
+    });
+
+    console.log("✅ Webhook created successfully!\n");
+
+    // Try to add webhook secret to env files
+    const envFiles = [
+      ".env",
+      ".env.local",
+      ".env.development",
+      ".env.production",
+    ];
+    const cwd = process.cwd();
+    const updatedFiles = [];
+
+    for (const envFile of envFiles) {
+      const envPath = path.join(cwd, envFile);
+      if (fs.existsSync(envPath)) {
+        let content = fs.readFileSync(envPath, "utf8");
+        const secretLine = `STRIPE_WEBHOOK_SECRET=${webhook.secret}`;
+
+        if (content.includes("STRIPE_WEBHOOK_SECRET=")) {
+          // Replace existing value
+          content = content.replace(/STRIPE_WEBHOOK_SECRET=.*/, secretLine);
+        } else {
+          // Append to file
+          const newline = content.endsWith("\n") ? "" : "\n";
+          content = content + newline + secretLine + "\n";
+        }
+
+        fs.writeFileSync(envPath, content);
+        updatedFiles.push(envFile);
+      }
+    }
+
+    if (updatedFiles.length > 0) {
+      console.log(
+        `📝 Updated ${updatedFiles.join(
+          ", "
+        )} with STRIPE_WEBHOOK_SECRET\nREMEMBER: Update the enviroment variable in Vercel too\nSTRIPE_WEBHOOK_SECRET=${
+          webhook.secret
+        }`
+      );
+    } else {
+      console.log("Add this to your environment variables:\n");
+      console.log(`STRIPE_WEBHOOK_SECRET=${webhook.secret}\n`);
+    }
+
+    console.log("─".repeat(50));
+    console.log("Webhook ID:", webhook.id);
+    console.log("Webhook URL:", webhook.url);
+    console.log("Events: All events (*)");
+    if (updatedFiles.length === 0) {
+      console.log("Secret:", webhook.secret);
+    }
+    console.log("─".repeat(50));
+  } catch (error) {
+    if (error.type === "StripeAuthenticationError") {
+      console.error("❌ Authentication failed. Check your Stripe Secret Key.");
+    } else if (error.type === "StripeInvalidRequestError") {
+      console.error("❌ Invalid request:", error.message);
+    } else {
+      console.error("❌ Failed to create webhook:");
+      console.error(error.message);
+    }
+    process.exit(1);
+  }
+}
+
+async function main() {
+  switch (command) {
+    case "migrate":
+      await migrate(databaseUrl);
+      break;
+
+    case "config":
+      await config();
+      break;
+
+    default:
+      console.log("Usage:");
+      console.log("  npx stripe-no-webhooks migrate <connection_string>");
+      console.log("  npx stripe-no-webhooks config");
+      process.exit(1);
+  }
+}
+
+main();

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import Stripe from 'stripe';
+
+interface StripeWebhookCallbacks {
+    /**
+     * Called when a new subscription is created
+     */
+    onSubscriptionCreated?: (subscription: Stripe.Subscription) => void | Promise<void>;
+    /**
+     * Called when a subscription is cancelled
+     */
+    onSubscriptionCancelled?: (subscription: Stripe.Subscription) => void | Promise<void>;
+}
+interface StripeWebhookConfig {
+    /**
+     * PostgreSQL connection string for the Stripe sync database
+     */
+    databaseUrl: string;
+    /**
+     * Stripe secret key (sk_test_... or sk_live_...)
+     */
+    stripeSecretKey: string;
+    /**
+     * Stripe webhook signing secret (whsec_...)
+     */
+    stripeWebhookSecret: string;
+    /**
+     * Database schema name (defaults to 'stripe')
+     */
+    schema?: string;
+    /**
+     * Callbacks for subscription events
+     */
+    callbacks?: StripeWebhookCallbacks;
+}
+declare function createStripeWebhookHandler(config: StripeWebhookConfig): (request: Request) => Promise<Response>;
+
+export { type StripeWebhookCallbacks, type StripeWebhookConfig, createStripeWebhookHandler };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import Stripe from 'stripe';
+
+interface StripeWebhookCallbacks {
+    /**
+     * Called when a new subscription is created
+     */
+    onSubscriptionCreated?: (subscription: Stripe.Subscription) => void | Promise<void>;
+    /**
+     * Called when a subscription is cancelled
+     */
+    onSubscriptionCancelled?: (subscription: Stripe.Subscription) => void | Promise<void>;
+}
+interface StripeWebhookConfig {
+    /**
+     * PostgreSQL connection string for the Stripe sync database
+     */
+    databaseUrl: string;
+    /**
+     * Stripe secret key (sk_test_... or sk_live_...)
+     */
+    stripeSecretKey: string;
+    /**
+     * Stripe webhook signing secret (whsec_...)
+     */
+    stripeWebhookSecret: string;
+    /**
+     * Database schema name (defaults to 'stripe')
+     */
+    schema?: string;
+    /**
+     * Callbacks for subscription events
+     */
+    callbacks?: StripeWebhookCallbacks;
+}
+declare function createStripeWebhookHandler(config: StripeWebhookConfig): (request: Request) => Promise<Response>;
+
+export { type StripeWebhookCallbacks, type StripeWebhookConfig, createStripeWebhookHandler };

package/dist/index.js

@@ -0,0 +1,118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createStripeWebhookHandler: () => createStripeWebhookHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/handler.ts
+var import_stripe_sync_engine = require("@supabase/stripe-sync-engine");
+var import_stripe = __toESM(require("stripe"));
+function createStripeWebhookHandler(config) {
+  const {
+    databaseUrl,
+    stripeSecretKey,
+    stripeWebhookSecret,
+    schema = "stripe",
+    callbacks
+  } = config;
+  const sync = new import_stripe_sync_engine.StripeSync({
+    poolConfig: {
+      connectionString: databaseUrl
+    },
+    schema,
+    stripeSecretKey,
+    stripeWebhookSecret
+  });
+  const stripe = new import_stripe.default(stripeSecretKey);
+  return async function handler(request) {
+    try {
+      const body = await request.text();
+      const signature = request.headers.get("stripe-signature");
+      if (!signature) {
+        return new Response("Missing stripe-signature header", { status: 400 });
+      }
+      let event;
+      try {
+        event = stripe.webhooks.constructEvent(
+          body,
+          signature,
+          stripeWebhookSecret
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return new Response(
+          `Webhook signature verification failed: ${message}`,
+          { status: 400 }
+        );
+      }
+      await sync.processWebhook(body, signature);
+      if (callbacks) {
+        await handleCallbacks(event, callbacks);
+      }
+      return new Response(JSON.stringify({ received: true }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (error) {
+      console.error("Stripe webhook error:", error);
+      const message = error instanceof Error ? error.message : "Internal server error";
+      return new Response(message, { status: 500 });
+    }
+  };
+}
+async function handleCallbacks(event, callbacks) {
+  const { onSubscriptionCreated, onSubscriptionCancelled } = callbacks;
+  switch (event.type) {
+    case "customer.subscription.created":
+      if (onSubscriptionCreated) {
+        await onSubscriptionCreated(event.data.object);
+      }
+      break;
+    case "customer.subscription.deleted":
+      if (onSubscriptionCancelled) {
+        await onSubscriptionCancelled(event.data.object);
+      }
+      break;
+    case "customer.subscription.updated":
+      const subscription = event.data.object;
+      const previousAttributes = event.data.previous_attributes;
+      if (onSubscriptionCancelled && subscription.status === "canceled" && previousAttributes?.status && previousAttributes.status !== "canceled") {
+        await onSubscriptionCancelled(subscription);
+      }
+      break;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStripeWebhookHandler
+});

package/dist/index.mjs

@@ -0,0 +1,81 @@
+// src/handler.ts
+import { StripeSync } from "@supabase/stripe-sync-engine";
+import Stripe from "stripe";
+function createStripeWebhookHandler(config) {
+  const {
+    databaseUrl,
+    stripeSecretKey,
+    stripeWebhookSecret,
+    schema = "stripe",
+    callbacks
+  } = config;
+  const sync = new StripeSync({
+    poolConfig: {
+      connectionString: databaseUrl
+    },
+    schema,
+    stripeSecretKey,
+    stripeWebhookSecret
+  });
+  const stripe = new Stripe(stripeSecretKey);
+  return async function handler(request) {
+    try {
+      const body = await request.text();
+      const signature = request.headers.get("stripe-signature");
+      if (!signature) {
+        return new Response("Missing stripe-signature header", { status: 400 });
+      }
+      let event;
+      try {
+        event = stripe.webhooks.constructEvent(
+          body,
+          signature,
+          stripeWebhookSecret
+        );
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return new Response(
+          `Webhook signature verification failed: ${message}`,
+          { status: 400 }
+        );
+      }
+      await sync.processWebhook(body, signature);
+      if (callbacks) {
+        await handleCallbacks(event, callbacks);
+      }
+      return new Response(JSON.stringify({ received: true }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (error) {
+      console.error("Stripe webhook error:", error);
+      const message = error instanceof Error ? error.message : "Internal server error";
+      return new Response(message, { status: 500 });
+    }
+  };
+}
+async function handleCallbacks(event, callbacks) {
+  const { onSubscriptionCreated, onSubscriptionCancelled } = callbacks;
+  switch (event.type) {
+    case "customer.subscription.created":
+      if (onSubscriptionCreated) {
+        await onSubscriptionCreated(event.data.object);
+      }
+      break;
+    case "customer.subscription.deleted":
+      if (onSubscriptionCancelled) {
+        await onSubscriptionCancelled(event.data.object);
+      }
+      break;
+    case "customer.subscription.updated":
+      const subscription = event.data.object;
+      const previousAttributes = event.data.previous_attributes;
+      if (onSubscriptionCancelled && subscription.status === "canceled" && previousAttributes?.status && previousAttributes.status !== "canceled") {
+        await onSubscriptionCancelled(subscription);
+      }
+      break;
+  }
+}
+export {
+  createStripeWebhookHandler
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "stripe-no-webhooks",
+  "version": "0.0.1",
+  "author": "Ramon Garate",
+  "description": "Stripe integration without dealing with webhooks",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "stripe-no-webhooks": "./bin/cli.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build",
+    "publish": "npm version patch && npm publish"
+  },
+  "dependencies": {
+    "@supabase/stripe-sync-engine": "^0.47.0"
+  },
+  "peerDependencies": {
+    "stripe": ">=14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "stripe": "^17.4.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "stripe",
+    "webhooks",
+    "nextjs",
+    "supabase",
+    "sync"
+  ],
+  "license": "MIT"
+}