Stripe Integration

 1import { PricingSection } from "~/components/PricingSection";
 2
 3// In your page component
 4export default async function HomePage() {
 5  const session = await auth();
 6  
 7  // Get user's current subscription
 8  let subscription = null;
 9  if (session?.user?.id) {
10    subscription = await db.subscription.findUnique({
11      where: { userId: session.user.id },
12    });
13  }
14
15  return (
16    <div>
17      {/* Other content */}
18      
19      <PricingSection 
20        session={session}
21        subscription={subscription}
22        showHeader={true}
23      />
24    </div>
25  );
26}

 1// Checkout API route
 2import { auth } from "~/auth";
 3import { stripe } from "~/server/lib/stripe";
 4
 5export async function POST(request: Request) {
 6  const session = await auth();
 7  if (!session?.user?.email) {
 8    return new Response("Unauthorized", { status: 401 });
 9  }
10
11  const { priceId } = await request.json();
12
13  try {
14    const checkoutSession = await stripe.checkout.sessions.create({
15      customer_email: session.user.email,
16      line_items: [
17        {
18          price: priceId,
19          quantity: 1,
20        },
21      ],
22      mode: "subscription",
23      success_url: `${process.env.NEXTAUTH_URL}/account?success=true`,
24      cancel_url: `${process.env.NEXTAUTH_URL}/#pricing`,
25      metadata: {
26        userId: session.user.id,
27      },
28    });
29
30    return Response.json({ url: checkoutSession.url });
31  } catch (error) {
32    return new Response("Internal Server Error", { status: 500 });
33  }
34}

 1import { stripe } from "~/server/lib/stripe";
 2import { db } from "~/server/db";
 3
 4export async function POST(request: Request) {
 5  const body = await request.text();
 6  const signature = request.headers.get("stripe-signature")!;
 7
 8  let event;
 9  try {
10    event = stripe.webhooks.constructEvent(
11      body,
12      signature,
13      process.env.STRIPE_WEBHOOK_SECRET!
14    );
15  } catch (error) {
16    return new Response("Webhook signature verification failed", { 
17      status: 400 
18    });
19  }
20
21  switch (event.type) {
22    case "customer.subscription.created":
23    case "customer.subscription.updated":
24      await handleSubscriptionUpdate(event.data.object);
25      break;
26    
27    case "customer.subscription.deleted":
28      await handleSubscriptionCancellation(event.data.object);
29      break;
30    
31    case "invoice.payment_succeeded":
32      await handlePaymentSuccess(event.data.object);
33      break;
34    
35    case "invoice.payment_failed":
36      await handlePaymentFailure(event.data.object);
37      break;
38  }
39
40  return new Response("Webhook processed", { status: 200 });
41}

 1// Customer portal server action
 2import { stripe } from "~/server/lib/stripe";
 3import { auth } from "~/auth";
 4
 5export async function createPortalSession() {
 6  const session = await auth();
 7  if (!session?.user?.id) {
 8    throw new Error("Unauthorized");
 9  }
10
11  // Get user's Stripe customer ID
12  const subscription = await db.subscription.findUnique({
13    where: { userId: session.user.id },
14  });
15
16  if (!subscription?.stripeCustomerId) {
17    throw new Error("No subscription found");
18  }
19
20  const portalSession = await stripe.billingPortal.sessions.create({
21    customer: subscription.stripeCustomerId,
22    return_url: `${process.env.NEXTAUTH_URL}/account`,
23  });
24
25  return portalSession.url;
26}

 1export async function changePlan(newPriceId: string) {
 2  const session = await auth();
 3  if (!session?.user?.id) {
 4    throw new Error("Unauthorized");
 5  }
 6
 7  const subscription = await db.subscription.findUnique({
 8    where: { userId: session.user.id },
 9  });
10
11  if (!subscription?.stripeSubscriptionId) {
12    throw new Error("No active subscription");
13  }
14
15  // Update subscription in Stripe
16  const updatedSubscription = await stripe.subscriptions.update(
17    subscription.stripeSubscriptionId,
18    {
19      items: [{
20        id: subscription.stripeSubscriptionItemId,
21        price: newPriceId,
22      }],
23      proration_behavior: 'always_invoice', // Immediate proration
24    }
25  );
26
27  // Update database
28  await db.subscription.update({
29    where: { id: subscription.id },
30    data: {
31      stripePriceId: newPriceId,
32      // Webhook will update other fields
33    },
34  });
35
36  return updatedSubscription;
37}

 1model Subscription {
 2  id        String   @id @default(cuid())
 3  userId    String   @unique
 4  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
 5  
 6  // Stripe IDs
 7  stripeCustomerId         String?
 8  stripeSubscriptionId     String? @unique
 9  stripeSubscriptionItemId String?
10  stripePriceId           String?
11  stripeCurrentPeriodEnd  DateTime?
12  
13  // Subscription details
14  status                  String?  // active, canceled, incomplete, etc.
15  cancelAtPeriodEnd      Boolean  @default(false)
16  cancelAt               DateTime?
17  canceledAt             DateTime?
18  trialStart             DateTime?
19  trialEnd               DateTime?
20  
21  // Metadata
22  createdAt DateTime @default(now())
23  updatedAt DateTime @updatedAt
24  
25  @@map("subscriptions")
26}
27
28model SubscriptionEvent {
29  id               String   @id @default(cuid())
30  subscriptionId   String
31  subscription     Subscription @relation(fields: [subscriptionId], references: [id])
32  
33  // Event details
34  eventType        String   // created, updated, canceled, payment_succeeded, etc.
35  stripeEventId    String?  @unique
36  eventData        Json?    // Store full Stripe event data
37  
38  createdAt        DateTime @default(now())
39  
40  @@map("subscription_events")
41}