@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/payments/stripe.md

@@ -1,272 +0,0 @@
-# Stripe Payment Patterns
-
-Battle-tested patterns for Stripe integration in Next.js.
-
-## Stripe Client Setup
-
-```typescript
-// lib/stripe.ts
-import Stripe from 'stripe'
-
-export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
-  apiVersion: '2024-12-18.acacia',
-  typescript: true
-})
-```
-
-## One-Time Payment Checkout
-
-```typescript
-// app/api/checkout/route.ts
-import { stripe } from '@/lib/stripe'
-import { auth } from '@/lib/auth'
-import { NextResponse } from 'next/server'
-
-export async function POST(req: Request) {
-  const { userId } = await auth()
-  if (!userId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const { priceId, quantity = 1 } = await req.json()
-
-  const session = await stripe.checkout.sessions.create({
-    mode: 'payment',
-    payment_method_types: ['card'],
-    line_items: [{ price: priceId, quantity }],
-    success_url: `${process.env.NEXT_PUBLIC_URL}/success?session_id={CHECKOUT_SESSION_ID}`,
-    cancel_url: `${process.env.NEXT_PUBLIC_URL}/pricing`,
-    metadata: { userId }
-  })
-
-  return NextResponse.json({ url: session.url })
-}
-```
-
-## Subscription Checkout
-
-```typescript
-// app/api/subscribe/route.ts
-import { stripe } from '@/lib/stripe'
-import { auth } from '@/lib/auth'
-import { prisma } from '@/lib/db'
-
-export async function POST(req: Request) {
-  const { userId } = await auth()
-  if (!userId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const { priceId } = await req.json()
-
-  // Get or create Stripe customer
-  const user = await prisma.user.findUnique({ where: { id: userId } })
-  let customerId = user?.stripeCustomerId
-
-  if (!customerId) {
-    const customer = await stripe.customers.create({
-      email: user?.email,
-      metadata: { userId }
-    })
-    customerId = customer.id
-
-    await prisma.user.update({
-      where: { id: userId },
-      data: { stripeCustomerId: customerId }
-    })
-  }
-
-  const session = await stripe.checkout.sessions.create({
-    mode: 'subscription',
-    customer: customerId,
-    line_items: [{ price: priceId, quantity: 1 }],
-    success_url: `${process.env.NEXT_PUBLIC_URL}/dashboard?success=true`,
-    cancel_url: `${process.env.NEXT_PUBLIC_URL}/pricing`,
-    subscription_data: {
-      metadata: { userId }
-    }
-  })
-
-  return NextResponse.json({ url: session.url })
-}
-```
-
-## Webhook Handler
-
-```typescript
-// app/api/webhooks/stripe/route.ts
-import { stripe } from '@/lib/stripe'
-import { prisma } from '@/lib/db'
-import { headers } from 'next/headers'
-import Stripe from 'stripe'
-
-export async function POST(req: Request) {
-  const body = await req.text()
-  const headersList = await headers()
-  const signature = headersList.get('stripe-signature')!
-
-  let event: Stripe.Event
-
-  try {
-    event = stripe.webhooks.constructEvent(
-      body,
-      signature,
-      process.env.STRIPE_WEBHOOK_SECRET!
-    )
-  } catch (err) {
-    console.error('Webhook signature verification failed')
-    return new Response('Webhook Error', { status: 400 })
-  }
-
-  switch (event.type) {
-    case 'checkout.session.completed': {
-      const session = event.data.object as Stripe.Checkout.Session
-      const userId = session.metadata?.userId
-
-      if (session.mode === 'subscription') {
-        await prisma.user.update({
-          where: { id: userId },
-          data: {
-            subscriptionId: session.subscription as string,
-            subscriptionStatus: 'active'
-          }
-        })
-      } else if (session.mode === 'payment') {
-        // Handle one-time payment (e.g., add credits)
-        await prisma.user.update({
-          where: { id: userId },
-          data: { credits: { increment: 100 } }
-        })
-      }
-      break
-    }
-
-    case 'customer.subscription.updated':
-    case 'customer.subscription.deleted': {
-      const subscription = event.data.object as Stripe.Subscription
-      const userId = subscription.metadata.userId
-
-      await prisma.user.update({
-        where: { id: userId },
-        data: {
-          subscriptionStatus: subscription.status,
-          currentPeriodEnd: new Date(subscription.current_period_end * 1000)
-        }
-      })
-      break
-    }
-
-    case 'invoice.payment_failed': {
-      const invoice = event.data.object as Stripe.Invoice
-      // Send email notification, update status, etc.
-      break
-    }
-  }
-
-  return new Response('OK', { status: 200 })
-}
-```
-
-## Client-Side Checkout Button
-
-```typescript
-// components/checkout-button.tsx
-'use client'
-
-import { useState } from 'react'
-
-export function CheckoutButton({
-  priceId,
-  mode = 'payment'
-}: {
-  priceId: string
-  mode?: 'payment' | 'subscription'
-}) {
-  const [loading, setLoading] = useState(false)
-
-  const handleCheckout = async () => {
-    setLoading(true)
-
-    try {
-      const endpoint = mode === 'subscription' ? '/api/subscribe' : '/api/checkout'
-      const res = await fetch(endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ priceId })
-      })
-
-      const { url, error } = await res.json()
-
-      if (error) {
-        alert(error)
-        return
-      }
-
-      window.location.href = url
-    } catch (error) {
-      console.error('Checkout error:', error)
-      alert('Something went wrong')
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  return (
-    <button
-      onClick={handleCheckout}
-      disabled={loading}
-      className="px-6 py-3 bg-blue-600 text-white rounded-lg disabled:opacity-50"
-    >
-      {loading ? 'Loading...' : mode === 'subscription' ? 'Subscribe' : 'Buy Now'}
-    </button>
-  )
-}
-```
-
-## Customer Portal (Manage Subscription)
-
-```typescript
-// app/api/billing/portal/route.ts
-import { stripe } from '@/lib/stripe'
-import { auth } from '@/lib/auth'
-import { prisma } from '@/lib/db'
-
-export async function POST() {
-  const { userId } = await auth()
-  if (!userId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const user = await prisma.user.findUnique({ where: { id: userId } })
-  if (!user?.stripeCustomerId) {
-    return NextResponse.json({ error: 'No billing account' }, { status: 400 })
-  }
-
-  const session = await stripe.billingPortal.sessions.create({
-    customer: user.stripeCustomerId,
-    return_url: `${process.env.NEXT_PUBLIC_URL}/settings/billing`
-  })
-
-  return NextResponse.json({ url: session.url })
-}
-```
-
-## Environment Variables
-
-```bash
-# .env.local
-STRIPE_SECRET_KEY=sk_test_...
-STRIPE_WEBHOOK_SECRET=whsec_...
-NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_...
-```
-
-## Testing Webhooks Locally
-
-```bash
-# Install Stripe CLI
-brew install stripe/stripe-cli/stripe
-
-# Login and forward webhooks
-stripe login
-stripe listen --forward-to localhost:3000/api/webhooks/stripe
-```

package/skills/patterns/payments/subscriptions.md

@@ -1,300 +0,0 @@
-# Subscription Patterns
-
-Patterns for managing subscriptions with Stripe.
-
-## Subscription Plans
-
-```typescript
-// lib/plans.ts
-export const PLANS = {
-  free: {
-    name: 'Free',
-    priceId: null,
-    limits: {
-      projects: 1,
-      storage: 100, // MB
-      teamMembers: 1
-    }
-  },
-  pro: {
-    name: 'Pro',
-    priceId: process.env.STRIPE_PRO_PRICE_ID!,
-    limits: {
-      projects: 10,
-      storage: 5000,
-      teamMembers: 5
-    }
-  },
-  enterprise: {
-    name: 'Enterprise',
-    priceId: process.env.STRIPE_ENTERPRISE_PRICE_ID!,
-    limits: {
-      projects: -1, // unlimited
-      storage: -1,
-      teamMembers: -1
-    }
-  }
-} as const
-
-export type PlanId = keyof typeof PLANS
-```
-
-## Create Subscription
-
-```typescript
-// lib/billing.ts
-import Stripe from 'stripe'
-import { prisma } from '@/lib/db'
-import { PLANS, PlanId } from './plans'
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
-
-export async function createSubscription(userId: string, planId: PlanId) {
-  const user = await prisma.user.findUnique({
-    where: { id: userId },
-    include: { subscription: true }
-  })
-
-  if (!user) throw new Error('User not found')
-
-  const plan = PLANS[planId]
-  if (!plan.priceId) throw new Error('Cannot subscribe to free plan')
-
-  // Get or create Stripe customer
-  let customerId = user.stripeCustomerId
-
-  if (!customerId) {
-    const customer = await stripe.customers.create({
-      email: user.email,
-      metadata: { userId: user.id }
-    })
-    customerId = customer.id
-
-    await prisma.user.update({
-      where: { id: userId },
-      data: { stripeCustomerId: customerId }
-    })
-  }
-
-  // Create checkout session
-  const session = await stripe.checkout.sessions.create({
-    customer: customerId,
-    mode: 'subscription',
-    payment_method_types: ['card'],
-    line_items: [{ price: plan.priceId, quantity: 1 }],
-    success_url: `${process.env.NEXT_PUBLIC_APP_URL}/billing?success=true`,
-    cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/billing?canceled=true`,
-    metadata: { userId, planId }
-  })
-
-  return session.url
-}
-```
-
-## Handle Subscription Webhook
-
-```typescript
-// app/api/webhooks/stripe/route.ts
-import { headers } from 'next/headers'
-import Stripe from 'stripe'
-import { prisma } from '@/lib/db'
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
-
-export async function POST(request: Request) {
-  const body = await request.text()
-  const signature = headers().get('stripe-signature')!
-
-  let event: Stripe.Event
-
-  try {
-    event = stripe.webhooks.constructEvent(
-      body,
-      signature,
-      process.env.STRIPE_WEBHOOK_SECRET!
-    )
-  } catch (err) {
-    return Response.json({ error: 'Invalid signature' }, { status: 400 })
-  }
-
-  switch (event.type) {
-    case 'customer.subscription.created':
-    case 'customer.subscription.updated': {
-      const subscription = event.data.object as Stripe.Subscription
-      await handleSubscriptionChange(subscription)
-      break
-    }
-
-    case 'customer.subscription.deleted': {
-      const subscription = event.data.object as Stripe.Subscription
-      await handleSubscriptionCanceled(subscription)
-      break
-    }
-  }
-
-  return Response.json({ received: true })
-}
-
-async function handleSubscriptionChange(subscription: Stripe.Subscription) {
-  const customerId = subscription.customer as string
-
-  const user = await prisma.user.findFirst({
-    where: { stripeCustomerId: customerId }
-  })
-
-  if (!user) return
-
-  await prisma.subscription.upsert({
-    where: { userId: user.id },
-    create: {
-      userId: user.id,
-      stripeSubscriptionId: subscription.id,
-      stripePriceId: subscription.items.data[0].price.id,
-      status: subscription.status,
-      currentPeriodEnd: new Date(subscription.current_period_end * 1000)
-    },
-    update: {
-      stripeSubscriptionId: subscription.id,
-      stripePriceId: subscription.items.data[0].price.id,
-      status: subscription.status,
-      currentPeriodEnd: new Date(subscription.current_period_end * 1000)
-    }
-  })
-}
-
-async function handleSubscriptionCanceled(subscription: Stripe.Subscription) {
-  const customerId = subscription.customer as string
-
-  const user = await prisma.user.findFirst({
-    where: { stripeCustomerId: customerId }
-  })
-
-  if (!user) return
-
-  await prisma.subscription.update({
-    where: { userId: user.id },
-    data: { status: 'canceled' }
-  })
-}
-```
-
-## Get User Plan
-
-```typescript
-// lib/billing.ts
-export async function getUserPlan(userId: string): Promise<PlanId> {
-  const subscription = await prisma.subscription.findUnique({
-    where: { userId }
-  })
-
-  if (!subscription || subscription.status !== 'active') {
-    return 'free'
-  }
-
-  // Find plan by price ID
-  for (const [planId, plan] of Object.entries(PLANS)) {
-    if (plan.priceId === subscription.stripePriceId) {
-      return planId as PlanId
-    }
-  }
-
-  return 'free'
-}
-
-export async function checkLimit(
-  userId: string,
-  resource: 'projects' | 'storage' | 'teamMembers',
-  currentCount: number
-): Promise<boolean> {
-  const planId = await getUserPlan(userId)
-  const limit = PLANS[planId].limits[resource]
-
-  // -1 means unlimited
-  if (limit === -1) return true
-
-  return currentCount < limit
-}
-```
-
-## Cancel Subscription
-
-```typescript
-// lib/billing.ts
-export async function cancelSubscription(userId: string) {
-  const subscription = await prisma.subscription.findUnique({
-    where: { userId }
-  })
-
-  if (!subscription?.stripeSubscriptionId) {
-    throw new Error('No active subscription')
-  }
-
-  // Cancel at period end (user keeps access until then)
-  await stripe.subscriptions.update(subscription.stripeSubscriptionId, {
-    cancel_at_period_end: true
-  })
-
-  await prisma.subscription.update({
-    where: { userId },
-    data: { cancelAtPeriodEnd: true }
-  })
-}
-
-export async function reactivateSubscription(userId: string) {
-  const subscription = await prisma.subscription.findUnique({
-    where: { userId }
-  })
-
-  if (!subscription?.stripeSubscriptionId) {
-    throw new Error('No subscription found')
-  }
-
-  await stripe.subscriptions.update(subscription.stripeSubscriptionId, {
-    cancel_at_period_end: false
-  })
-
-  await prisma.subscription.update({
-    where: { userId },
-    data: { cancelAtPeriodEnd: false }
-  })
-}
-```
-
-## Change Plan
-
-```typescript
-// lib/billing.ts
-export async function changePlan(userId: string, newPlanId: PlanId) {
-  const subscription = await prisma.subscription.findUnique({
-    where: { userId }
-  })
-
-  if (!subscription?.stripeSubscriptionId) {
-    throw new Error('No active subscription')
-  }
-
-  const newPlan = PLANS[newPlanId]
-  if (!newPlan.priceId) {
-    throw new Error('Cannot switch to free plan, cancel instead')
-  }
-
-  const stripeSubscription = await stripe.subscriptions.retrieve(
-    subscription.stripeSubscriptionId
-  )
-
-  await stripe.subscriptions.update(subscription.stripeSubscriptionId, {
-    items: [{
-      id: stripeSubscription.items.data[0].id,
-      price: newPlan.priceId
-    }],
-    proration_behavior: 'create_prorations'
-  })
-}
-```
-
-## When to Use
-
-- SaaS billing
-- Tiered pricing
-- Usage limits
-- Plan management