stripe-no-webhooks 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,24 +1,124 @@
 // src/handler.ts
 import { StripeSync } from "@supabase/stripe-sync-engine";
 import Stripe from "stripe";
-function createStripeWebhookHandler(config) {
+function createStripeHandler(config = {}) {
   const {
-    databaseUrl,
-    stripeSecretKey,
-    stripeWebhookSecret,
+    stripeSecretKey = process.env.STRIPE_SECRET_KEY,
+    stripeWebhookSecret = process.env.STRIPE_WEBHOOK_SECRET,
+    databaseUrl = process.env.DATABASE_URL,
     schema = "stripe",
+    billingConfig,
+    successUrl: defaultSuccessUrl,
+    cancelUrl: defaultCancelUrl,
+    automaticTax = true,
     callbacks
   } = config;
-  const sync = new StripeSync({
+  const stripe = new Stripe(stripeSecretKey);
+  const sync = databaseUrl ? new StripeSync({
     poolConfig: {
       connectionString: databaseUrl
     },
     schema,
     stripeSecretKey,
     stripeWebhookSecret
-  });
-  const stripe = new Stripe(stripeSecretKey);
-  return async function handler(request) {
+  }) : null;
+  function resolvePriceId(body) {
+    if (body.priceId) {
+      return body.priceId;
+    }
+    if (!body.interval) {
+      throw new Error("interval is required when using planName or planId");
+    }
+    if (!billingConfig?.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;
+    if (!plan) {
+      const identifier = body.planName || body.planId;
+      throw new Error(`Plan not found: ${identifier}`);
+    }
+    const price = plan.price.find((p) => p.interval === body.interval);
+    if (!price) {
+      throw new Error(
+        `Price with interval "${body.interval}" not found for plan "${plan.name}"`
+      );
+    }
+    if (!price.id) {
+      throw new Error(
+        `Price ID not set for plan "${plan.name}" with interval "${body.interval}". Run stripe-sync to sync price IDs.`
+      );
+    }
+    return price.id;
+  }
+  async function getPriceMode(priceId) {
+    const price = await stripe.prices.retrieve(priceId);
+    return price.type === "recurring" ? "subscription" : "payment";
+  }
+  async function handleCheckout(request) {
+    try {
+      const body = await request.json();
+      if (!body.priceId && !body.planName && !body.planId) {
+        return new Response(
+          JSON.stringify({
+            error: "Provide either priceId, planName+interval, or planId+interval"
+          }),
+          { status: 400, headers: { "Content-Type": "application/json" } }
+        );
+      }
+      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 mode = await getPriceMode(priceId);
+      const sessionParams = {
+        line_items: [
+          {
+            price: priceId,
+            quantity: body.quantity ?? 1
+          }
+        ],
+        mode,
+        success_url: successUrl,
+        cancel_url: cancelUrl,
+        automatic_tax: { enabled: automaticTax }
+      };
+      if (body.customerEmail) {
+        sessionParams.customer_email = body.customerEmail;
+      }
+      if (body.customerId) {
+        sessionParams.customer = body.customerId;
+      }
+      if (body.metadata) {
+        sessionParams.metadata = body.metadata;
+      }
+      const session = await stripe.checkout.sessions.create(sessionParams);
+      if (!session.url) {
+        return new Response(
+          JSON.stringify({ error: "Failed to create checkout session" }),
+          { status: 500, headers: { "Content-Type": "application/json" } }
+        );
+      }
+      const acceptHeader = request.headers.get("accept") || "";
+      if (acceptHeader.includes("application/json")) {
+        return new Response(JSON.stringify({ url: session.url }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return Response.redirect(session.url, 303);
+    } catch (err) {
+      console.error("Checkout error:", err);
+      const message = err instanceof Error ? err.message : "Unknown error";
+      const status = err && typeof err === "object" && "statusCode" in err ? err.statusCode : 500;
+      return new Response(JSON.stringify({ error: message }), {
+        status,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  async function handleWebhook(request) {
     try {
       const body = await request.text();
       const signature = request.headers.get("stripe-signature");
@@ -39,7 +139,9 @@ function createStripeWebhookHandler(config) {
           { status: 400 }
         );
       }
-      await sync.processWebhook(body, signature);
+      if (sync) {
+        await sync.processWebhook(body, signature);
+      }
       if (callbacks) {
         await handleCallbacks(event, callbacks);
       }
@@ -52,6 +154,30 @@ function createStripeWebhookHandler(config) {
       const message = error instanceof Error ? error.message : "Internal server error";
       return new Response(message, { status: 500 });
     }
+  }
+  return async function handler(request) {
+    const url = new URL(request.url);
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const action = pathSegments[pathSegments.length - 1];
+    if (request.method !== "POST") {
+      return new Response(JSON.stringify({ error: "Method not allowed" }), {
+        status: 405,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    switch (action) {
+      case "checkout":
+        return handleCheckout(request);
+      case "webhook":
+        return handleWebhook(request);
+      default:
+        return new Response(
+          JSON.stringify({
+            error: `Unknown action: ${action}. Supported: checkout, webhook`
+          }),
+          { status: 404, headers: { "Content-Type": "application/json" } }
+        );
+    }
   };
 }
 async function handleCallbacks(event, callbacks) {
@@ -77,5 +203,5 @@ async function handleCallbacks(event, callbacks) {
   }
 }
 export {
-  createStripeWebhookHandler
+  createStripeHandler
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stripe-no-webhooks",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "Ramon Garate",
   "description": "Stripe integration without dealing with webhooks",
   "main": "./dist/index.js",
@@ -11,6 +11,11 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.mjs",
+      "require": "./dist/client.js"
     }
   },
   "bin": {
@@ -18,16 +23,18 @@
   },
   "files": [
     "dist",
-    "bin"
+    "bin",
+    "src/templates"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "build": "tsup src/index.ts src/client.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/client.ts --format cjs,esm --dts --watch",
     "prepublishOnly": "npm run build",
-    "publish": "npm version patch && npm publish"
+    "release": "npm version patch && npm publish"
   },
   "dependencies": {
-    "@supabase/stripe-sync-engine": "^0.47.0"
+    "@supabase/stripe-sync-engine": "^0.47.0",
+    "dotenv": "^17.2.3"
   },
   "peerDependencies": {
     "stripe": ">=14.0.0"

package/src/templates/app-router.ts

@@ -0,0 +1,20 @@
+// app/api/stripe/[...all]/route.ts
+import { createStripeHandler } from "stripe-no-webhooks";
+import type { Stripe } from "stripe";
+import billingConfig from "../../../../billing.config";
+
+export const POST = createStripeHandler({
+  billingConfig,
+  callbacks: {
+    onSubscriptionCreated: async (subscription: Stripe.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: Stripe.Subscription) => {
+      // Called when a subscription is cancelled
+      console.log("Subscription cancelled:", subscription.id);
+      // e.g., send cancellation email, revoke access, etc.
+    },
+  },
+});

package/src/templates/billing.config.ts

@@ -0,0 +1,26 @@
+import type { BillingConfig } from "stripe-no-webhooks";
+
+const billingConfig: BillingConfig = {
+  /*
+    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",
+          },
+        ],
+      },
+    ],
+  */
+};
+
+export default billingConfig;

package/src/templates/pages-router.ts

@@ -0,0 +1,49 @@
+// pages/api/stripe/[...all].ts
+import { createStripeHandler } from "stripe-no-webhooks";
+import type { NextApiRequest, NextApiResponse } from "next";
+import type { Stripe } from "stripe";
+import billingConfig from "../../../billing.config";
+
+const handler = createStripeHandler({
+  billingConfig,
+  callbacks: {
+    onSubscriptionCreated: async (subscription: Stripe.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: Stripe.Subscription) => {
+      // Called when a subscription is cancelled
+      console.log("Subscription cancelled:", subscription.id);
+      // e.g., send cancellation email, revoke access, etc.
+    },
+  },
+});
+
+// Disable body parsing, we need the raw body for webhook verification
+export const config = {
+  api: {
+    bodyParser: false,
+  },
+};
+
+export default async function stripeHandler(
+  req: NextApiRequest,
+  res: NextApiResponse
+) {
+  // 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: req.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());
+}