Stripe

npm install stripe @novu/api

NOVU_SECRET_KEY=novu_secret_...
STRIPE_SECRET_KEY=sk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...

STRIPE_WEBHOOK_SECRET=your_signing_secret_here

import { clerkMiddleware, createRouteMatcher } from '@clerk/nextjs/server';

const isPublicRoute = createRouteMatcher(['/api/webhooks(.*)']);

export default clerkMiddleware(async (auth, req) => {
  if (!isPublicRoute(req)) {
    await auth.protect();
  }
});

import Stripe from "stripe";
import { NextResponse, NextRequest } from "next/server";
import { triggerWorkflow } from "@/app/utils/novu";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

const supportedEvents = [
  "customer.subscription.created",
  "customer.subscription.updated",
] as const;

export async function POST(request: NextRequest) {
  const webhookPayload = await request.text();
  const signature = request.headers.get("stripe-signature");

  if (!signature) {
    return NextResponse.json({ error: "Missing stripe-signature header" }, { status: 400 });
  }

  try {
    const event = stripe.webhooks.constructEvent(
      webhookPayload,
      signature,
      process.env.STRIPE_WEBHOOK_SECRET!
    );

    if (supportedEvents.includes(event.type as (typeof supportedEvents)[number])) {
      const workflow = event.type.replaceAll(".", "-");
      const subscriber = await buildSubscriberData(event);
      const payload = payloadBuilder(event);

      await triggerWorkflow(workflow, subscriber, payload);
      return NextResponse.json({ status: "success", workflow });
    }

    return NextResponse.json({ status: "ignored", event: event.type });
  } catch (error) {
    console.error("Stripe webhook error:", error);
    return NextResponse.json(
      { error: error instanceof Error ? error.message : "Webhook handler failed" },
      { status: 400 }
    );
  }
}

async function buildSubscriberData(event: Stripe.Event) {
  const object = event.data.object as { customer?: string | Stripe.Customer | Stripe.DeletedCustomer | null };
  const customerId = typeof object.customer === "string" ? object.customer : object.customer?.id;

  if (!customerId) {
    throw new Error("Missing customer id on Stripe event");
  }

  const customer = await stripe.customers.retrieve(customerId);

  if (customer.deleted) {
    throw new Error("Customer has been deleted");
  }

  const [firstName = "", lastName = ""] = (customer.name || "").split(" ");

  return {
    subscriberId: customer.id,
    email: customer.email || undefined,
    firstName: firstName || undefined,
    lastName: lastName || undefined,
    phone: customer.phone || undefined,
    locale: customer.preferred_locales?.[0] || "en",
    data: {
      stripeCustomerId: customer.id,
    },
  };
}

function payloadBuilder(event: Stripe.Event) {
  return event.data.object;
}

import { Novu } from '@novu/api';

const novu = new Novu({
  secretKey: process.env.NOVU_SECRET_KEY!,
});

export async function triggerWorkflow(
  workflowId: string,
  subscriber: Record<string, unknown>,
  payload: Record<string, unknown>
) {
  await novu.trigger({ workflowId, to: subscriber, payload });
}