@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/payments/invoices.md

@@ -1,287 +0,0 @@
-# Invoice Patterns
-
-Patterns for invoice management with Stripe.
-
-## Get Invoices
-
-```typescript
-// lib/billing.ts
-import Stripe from 'stripe'
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
-
-export async function getInvoices(userId: string, limit = 10) {
-  const user = await prisma.user.findUnique({
-    where: { id: userId }
-  })
-
-  if (!user?.stripeCustomerId) {
-    return []
-  }
-
-  const invoices = await stripe.invoices.list({
-    customer: user.stripeCustomerId,
-    limit,
-    expand: ['data.subscription']
-  })
-
-  return invoices.data.map(invoice => ({
-    id: invoice.id,
-    number: invoice.number,
-    status: invoice.status,
-    amount: invoice.amount_due,
-    currency: invoice.currency,
-    created: new Date(invoice.created * 1000),
-    dueDate: invoice.due_date ? new Date(invoice.due_date * 1000) : null,
-    paidAt: invoice.status_transitions.paid_at
-      ? new Date(invoice.status_transitions.paid_at * 1000)
-      : null,
-    pdfUrl: invoice.invoice_pdf,
-    hostedUrl: invoice.hosted_invoice_url
-  }))
-}
-```
-
-## Invoice API Route
-
-```typescript
-// app/api/billing/invoices/route.ts
-import { auth } from '@/auth'
-import { getInvoices } from '@/lib/billing'
-
-export async function GET(request: Request) {
-  const session = await auth()
-
-  if (!session?.user) {
-    return Response.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const { searchParams } = new URL(request.url)
-  const limit = parseInt(searchParams.get('limit') ?? '10')
-
-  const invoices = await getInvoices(session.user.id, limit)
-
-  return Response.json({ data: invoices })
-}
-```
-
-## Invoice List Component
-
-```tsx
-// components/billing/InvoiceList.tsx
-'use client'
-
-import { useState, useEffect } from 'react'
-import { formatCurrency, formatDate } from '@/lib/utils'
-
-interface Invoice {
-  id: string
-  number: string | null
-  status: string | null
-  amount: number
-  currency: string
-  created: string
-  pdfUrl: string | null
-  hostedUrl: string | null
-}
-
-export function InvoiceList() {
-  const [invoices, setInvoices] = useState<Invoice[]>([])
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    fetch('/api/billing/invoices')
-      .then(res => res.json())
-      .then(data => setInvoices(data.data))
-      .finally(() => setLoading(false))
-  }, [])
-
-  if (loading) {
-    return <div>Loading invoices...</div>
-  }
-
-  if (invoices.length === 0) {
-    return <p className="text-gray-500">No invoices yet</p>
-  }
-
-  return (
-    <div className="divide-y rounded-lg border">
-      {invoices.map(invoice => (
-        <div key={invoice.id} className="flex items-center justify-between p-4">
-          <div>
-            <p className="font-medium">
-              Invoice {invoice.number ?? invoice.id}
-            </p>
-            <p className="text-sm text-gray-500">
-              {formatDate(new Date(invoice.created))}
-            </p>
-          </div>
-
-          <div className="flex items-center gap-4">
-            <span className={`rounded-full px-2 py-1 text-xs ${
-              invoice.status === 'paid' ? 'bg-green-100 text-green-800' :
-              invoice.status === 'open' ? 'bg-amber-100 text-amber-800' :
-              'bg-gray-100 text-gray-800'
-            }`}>
-              {invoice.status}
-            </span>
-
-            <span className="font-medium">
-              {formatCurrency(invoice.amount / 100, invoice.currency)}
-            </span>
-
-            {invoice.pdfUrl && (
-              <a
-                href={invoice.pdfUrl}
-                target="_blank"
-                rel="noopener noreferrer"
-                className="text-blue-600 hover:underline"
-              >
-                PDF
-              </a>
-            )}
-          </div>
-        </div>
-      ))}
-    </div>
-  )
-}
-```
-
-## Handle Invoice Webhooks
-
-```typescript
-// app/api/webhooks/stripe/route.ts
-async function handleInvoiceEvents(event: Stripe.Event) {
-  switch (event.type) {
-    case 'invoice.paid': {
-      const invoice = event.data.object as Stripe.Invoice
-      await handleInvoicePaid(invoice)
-      break
-    }
-
-    case 'invoice.payment_failed': {
-      const invoice = event.data.object as Stripe.Invoice
-      await handleInvoicePaymentFailed(invoice)
-      break
-    }
-
-    case 'invoice.upcoming': {
-      const invoice = event.data.object as Stripe.Invoice
-      await handleUpcomingInvoice(invoice)
-      break
-    }
-  }
-}
-
-async function handleInvoicePaid(invoice: Stripe.Invoice) {
-  const customerId = invoice.customer as string
-
-  const user = await prisma.user.findFirst({
-    where: { stripeCustomerId: customerId }
-  })
-
-  if (!user) return
-
-  // Store invoice record
-  await prisma.invoice.create({
-    data: {
-      userId: user.id,
-      stripeInvoiceId: invoice.id,
-      amount: invoice.amount_paid,
-      currency: invoice.currency,
-      status: 'paid',
-      paidAt: new Date()
-    }
-  })
-
-  // Send receipt email
-  await emailService.sendInvoiceReceipt(user.email, {
-    invoiceNumber: invoice.number!,
-    amount: invoice.amount_paid,
-    currency: invoice.currency,
-    pdfUrl: invoice.invoice_pdf!
-  })
-}
-
-async function handleInvoicePaymentFailed(invoice: Stripe.Invoice) {
-  const customerId = invoice.customer as string
-
-  const user = await prisma.user.findFirst({
-    where: { stripeCustomerId: customerId }
-  })
-
-  if (!user) return
-
-  // Notify user
-  await emailService.sendPaymentFailed(user.email, {
-    amount: invoice.amount_due,
-    currency: invoice.currency,
-    updateUrl: `${process.env.NEXT_PUBLIC_APP_URL}/settings/billing`
-  })
-}
-
-async function handleUpcomingInvoice(invoice: Stripe.Invoice) {
-  // Send reminder for upcoming charge
-  const customerId = invoice.customer as string
-
-  const user = await prisma.user.findFirst({
-    where: { stripeCustomerId: customerId }
-  })
-
-  if (!user) return
-
-  await emailService.sendUpcomingInvoice(user.email, {
-    amount: invoice.amount_due,
-    currency: invoice.currency,
-    date: new Date(invoice.created * 1000)
-  })
-}
-```
-
-## Create Custom Invoice
-
-```typescript
-// lib/billing.ts
-export async function createInvoice(
-  userId: string,
-  items: { description: string; amount: number }[]
-) {
-  const user = await prisma.user.findUnique({
-    where: { id: userId }
-  })
-
-  if (!user?.stripeCustomerId) {
-    throw new Error('No billing account')
-  }
-
-  // Create invoice items
-  for (const item of items) {
-    await stripe.invoiceItems.create({
-      customer: user.stripeCustomerId,
-      amount: item.amount,
-      currency: 'usd',
-      description: item.description
-    })
-  }
-
-  // Create and send invoice
-  const invoice = await stripe.invoices.create({
-    customer: user.stripeCustomerId,
-    auto_advance: true, // Auto-finalize
-    collection_method: 'send_invoice',
-    days_until_due: 30
-  })
-
-  await stripe.invoices.sendInvoice(invoice.id)
-
-  return invoice
-}
-```
-
-## When to Use
-
-- Billing history
-- Payment receipts
-- Failed payment recovery
-- Custom invoicing

package/skills/patterns/payments/portal.md

@@ -1,245 +0,0 @@
-# Stripe Customer Portal Patterns
-
-Patterns for self-service billing with Stripe Customer Portal.
-
-## Create Portal Session
-
-```typescript
-// lib/billing.ts
-import Stripe from 'stripe'
-import { prisma } from '@/lib/db'
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
-
-export async function createPortalSession(userId: string) {
-  const user = await prisma.user.findUnique({
-    where: { id: userId }
-  })
-
-  if (!user?.stripeCustomerId) {
-    throw new Error('No billing account found')
-  }
-
-  const session = await stripe.billingPortal.sessions.create({
-    customer: user.stripeCustomerId,
-    return_url: `${process.env.NEXT_PUBLIC_APP_URL}/settings/billing`
-  })
-
-  return session.url
-}
-```
-
-## API Route
-
-```typescript
-// app/api/billing/portal/route.ts
-import { auth } from '@/auth'
-import { createPortalSession } from '@/lib/billing'
-import { redirect } from 'next/navigation'
-
-export async function POST() {
-  const session = await auth()
-
-  if (!session?.user) {
-    return Response.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  try {
-    const url = await createPortalSession(session.user.id)
-    return Response.json({ url })
-  } catch (error) {
-    return Response.json(
-      { error: 'Failed to create portal session' },
-      { status: 500 }
-    )
-  }
-}
-```
-
-## Portal Button Component
-
-```tsx
-// components/billing/PortalButton.tsx
-'use client'
-
-import { useState } from 'react'
-import { Button } from '@/components/ui/Button'
-
-export function PortalButton() {
-  const [loading, setLoading] = useState(false)
-
-  async function handleClick() {
-    setLoading(true)
-
-    try {
-      const response = await fetch('/api/billing/portal', {
-        method: 'POST'
-      })
-
-      const { url } = await response.json()
-
-      if (url) {
-        window.location.href = url
-      }
-    } catch (error) {
-      console.error('Failed to open billing portal:', error)
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  return (
-    <Button onClick={handleClick} disabled={loading}>
-      {loading ? 'Loading...' : 'Manage Billing'}
-    </Button>
-  )
-}
-```
-
-## Portal Configuration
-
-```typescript
-// Configure portal in Stripe Dashboard or via API
-const configuration = await stripe.billingPortal.configurations.create({
-  business_profile: {
-    headline: 'Manage your subscription'
-  },
-  features: {
-    subscription_cancel: {
-      enabled: true,
-      mode: 'at_period_end',
-      proration_behavior: 'none',
-      cancellation_reason: {
-        enabled: true,
-        options: [
-          'too_expensive',
-          'missing_features',
-          'switched_service',
-          'unused',
-          'other'
-        ]
-      }
-    },
-    subscription_update: {
-      enabled: true,
-      default_allowed_updates: ['price'],
-      proration_behavior: 'create_prorations',
-      products: [
-        {
-          product: process.env.STRIPE_PRODUCT_ID!,
-          prices: [
-            process.env.STRIPE_PRO_PRICE_ID!,
-            process.env.STRIPE_ENTERPRISE_PRICE_ID!
-          ]
-        }
-      ]
-    },
-    payment_method_update: {
-      enabled: true
-    },
-    invoice_history: {
-      enabled: true
-    }
-  }
-})
-```
-
-## Portal with Flow
-
-```typescript
-// lib/billing.ts
-export async function createPortalSessionWithFlow(
-  userId: string,
-  flow: 'subscription_cancel' | 'payment_method_update' | 'subscription_update'
-) {
-  const user = await prisma.user.findUnique({
-    where: { id: userId }
-  })
-
-  if (!user?.stripeCustomerId) {
-    throw new Error('No billing account found')
-  }
-
-  const subscription = await prisma.subscription.findUnique({
-    where: { userId }
-  })
-
-  const flowData: Stripe.BillingPortal.SessionCreateParams.FlowData = {
-    type: flow
-  }
-
-  // Add subscription ID for cancel/update flows
-  if (flow === 'subscription_cancel' || flow === 'subscription_update') {
-    flowData.subscription_cancel = {
-      subscription: subscription?.stripeSubscriptionId!
-    }
-  }
-
-  const session = await stripe.billingPortal.sessions.create({
-    customer: user.stripeCustomerId,
-    return_url: `${process.env.NEXT_PUBLIC_APP_URL}/settings/billing`,
-    flow_data: flowData
-  })
-
-  return session.url
-}
-```
-
-## Billing Page
-
-```tsx
-// app/settings/billing/page.tsx
-import { auth } from '@/auth'
-import { getUserPlan, getSubscription } from '@/lib/billing'
-import { PortalButton } from '@/components/billing/PortalButton'
-import { PlanCard } from '@/components/billing/PlanCard'
-import { PLANS } from '@/lib/plans'
-
-export default async function BillingPage() {
-  const session = await auth()
-  const planId = await getUserPlan(session!.user.id)
-  const subscription = await getSubscription(session!.user.id)
-  const plan = PLANS[planId]
-
-  return (
-    <div className="space-y-8">
-      <div>
-        <h1 className="text-2xl font-bold">Billing</h1>
-        <p className="text-gray-600">Manage your subscription and billing</p>
-      </div>
-
-      <div className="rounded-lg border p-6">
-        <div className="flex items-center justify-between">
-          <div>
-            <h2 className="font-semibold">Current Plan</h2>
-            <p className="text-2xl font-bold">{plan.name}</p>
-            {subscription?.cancelAtPeriodEnd && (
-              <p className="text-sm text-amber-600">
-                Cancels on {subscription.currentPeriodEnd.toLocaleDateString()}
-              </p>
-            )}
-          </div>
-          <PortalButton />
-        </div>
-      </div>
-
-      <div className="grid gap-4 md:grid-cols-3">
-        {Object.entries(PLANS).map(([id, plan]) => (
-          <PlanCard
-            key={id}
-            plan={plan}
-            isCurrent={id === planId}
-          />
-        ))}
-      </div>
-    </div>
-  )
-}
-```
-
-## When to Use
-
-- Subscription management
-- Payment method updates
-- Invoice history
-- Plan changes