@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/payments/usage.md

@@ -1,279 +0,0 @@
-# Usage-Based Billing Patterns
-
-Patterns for metered billing with Stripe.
-
-## Track Usage
-
-```typescript
-// lib/usage.ts
-import Stripe from 'stripe'
-import { prisma } from '@/lib/db'
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
-
-export async function recordUsage(
-  userId: string,
-  metric: string,
-  quantity: number
-) {
-  // Get subscription with usage meter
-  const subscription = await prisma.subscription.findUnique({
-    where: { userId },
-    include: { user: true }
-  })
-
-  if (!subscription?.stripeSubscriptionId) {
-    throw new Error('No active subscription')
-  }
-
-  // Find the metered subscription item
-  const stripeSubscription = await stripe.subscriptions.retrieve(
-    subscription.stripeSubscriptionId
-  )
-
-  const meteredItem = stripeSubscription.items.data.find(
-    item => item.price.recurring?.usage_type === 'metered'
-  )
-
-  if (!meteredItem) {
-    throw new Error('No metered subscription item found')
-  }
-
-  // Record usage
-  await stripe.subscriptionItems.createUsageRecord(meteredItem.id, {
-    quantity,
-    timestamp: Math.floor(Date.now() / 1000),
-    action: 'increment'
-  })
-
-  // Also store locally for quick access
-  await prisma.usageRecord.create({
-    data: {
-      userId,
-      metric,
-      quantity,
-      timestamp: new Date()
-    }
-  })
-}
-```
-
-## Usage Middleware
-
-```typescript
-// lib/usage-middleware.ts
-export async function trackApiUsage(userId: string, endpoint: string) {
-  const metric = `api_calls`
-
-  // Batch usage records
-  await prisma.usageBuffer.create({
-    data: {
-      userId,
-      metric,
-      endpoint,
-      timestamp: new Date()
-    }
-  })
-}
-
-// Background job to flush usage to Stripe
-export async function flushUsageToStripe() {
-  const bufferRecords = await prisma.usageBuffer.groupBy({
-    by: ['userId', 'metric'],
-    _count: { id: true },
-    where: { flushedAt: null }
-  })
-
-  for (const record of bufferRecords) {
-    try {
-      await recordUsage(record.userId, record.metric, record._count.id)
-
-      await prisma.usageBuffer.updateMany({
-        where: {
-          userId: record.userId,
-          metric: record.metric,
-          flushedAt: null
-        },
-        data: { flushedAt: new Date() }
-      })
-    } catch (error) {
-      console.error(`Failed to flush usage for ${record.userId}:`, error)
-    }
-  }
-}
-```
-
-## Get Usage Summary
-
-```typescript
-// lib/usage.ts
-export async function getUsageSummary(userId: string, period?: { start: Date; end: Date }) {
-  const startDate = period?.start ?? startOfMonth(new Date())
-  const endDate = period?.end ?? new Date()
-
-  const usage = await prisma.usageRecord.groupBy({
-    by: ['metric'],
-    where: {
-      userId,
-      timestamp: {
-        gte: startDate,
-        lte: endDate
-      }
-    },
-    _sum: { quantity: true }
-  })
-
-  return usage.reduce((acc, record) => {
-    acc[record.metric] = record._sum.quantity ?? 0
-    return acc
-  }, {} as Record<string, number>)
-}
-
-export async function getUsageHistory(
-  userId: string,
-  metric: string,
-  days: number = 30
-) {
-  const startDate = subDays(new Date(), days)
-
-  const records = await prisma.usageRecord.findMany({
-    where: {
-      userId,
-      metric,
-      timestamp: { gte: startDate }
-    },
-    orderBy: { timestamp: 'asc' }
-  })
-
-  // Group by day
-  const byDay = records.reduce((acc, record) => {
-    const day = format(record.timestamp, 'yyyy-MM-dd')
-    acc[day] = (acc[day] ?? 0) + record.quantity
-    return acc
-  }, {} as Record<string, number>)
-
-  return byDay
-}
-```
-
-## Usage Limits
-
-```typescript
-// lib/usage-limits.ts
-import { PLANS, PlanId } from './plans'
-
-export const USAGE_LIMITS: Record<PlanId, Record<string, number>> = {
-  free: {
-    api_calls: 1000,
-    ai_tokens: 10000,
-    storage_mb: 100
-  },
-  pro: {
-    api_calls: 50000,
-    ai_tokens: 500000,
-    storage_mb: 5000
-  },
-  enterprise: {
-    api_calls: -1, // unlimited
-    ai_tokens: -1,
-    storage_mb: -1
-  }
-}
-
-export async function checkUsageLimit(
-  userId: string,
-  metric: string
-): Promise<{ allowed: boolean; current: number; limit: number }> {
-  const planId = await getUserPlan(userId)
-  const limit = USAGE_LIMITS[planId][metric]
-
-  // Unlimited
-  if (limit === -1) {
-    return { allowed: true, current: 0, limit: -1 }
-  }
-
-  const usage = await getUsageSummary(userId)
-  const current = usage[metric] ?? 0
-
-  return {
-    allowed: current < limit,
-    current,
-    limit
-  }
-}
-
-export async function enforceUsageLimit(userId: string, metric: string) {
-  const { allowed, current, limit } = await checkUsageLimit(userId, metric)
-
-  if (!allowed) {
-    throw new UsageLimitExceededError(metric, current, limit)
-  }
-}
-```
-
-## Usage Dashboard Component
-
-```tsx
-// components/usage/UsageDashboard.tsx
-import { getUsageSummary, getUsageHistory } from '@/lib/usage'
-import { USAGE_LIMITS } from '@/lib/usage-limits'
-import { getUserPlan } from '@/lib/billing'
-
-interface Props {
-  userId: string
-}
-
-export async function UsageDashboard({ userId }: Props) {
-  const planId = await getUserPlan(userId)
-  const usage = await getUsageSummary(userId)
-  const limits = USAGE_LIMITS[planId]
-
-  const metrics = [
-    { key: 'api_calls', label: 'API Calls' },
-    { key: 'ai_tokens', label: 'AI Tokens' },
-    { key: 'storage_mb', label: 'Storage (MB)' }
-  ]
-
-  return (
-    <div className="grid gap-4 md:grid-cols-3">
-      {metrics.map(metric => {
-        const current = usage[metric.key] ?? 0
-        const limit = limits[metric.key]
-        const percentage = limit === -1 ? 0 : (current / limit) * 100
-
-        return (
-          <div key={metric.key} className="rounded-lg border p-4">
-            <h3 className="text-sm font-medium text-gray-600">{metric.label}</h3>
-            <p className="text-2xl font-bold">
-              {current.toLocaleString()}
-              {limit !== -1 && (
-                <span className="text-sm font-normal text-gray-500">
-                  {' / '}{limit.toLocaleString()}
-                </span>
-              )}
-            </p>
-            {limit !== -1 && (
-              <div className="mt-2 h-2 rounded-full bg-gray-200">
-                <div
-                  className={`h-2 rounded-full ${
-                    percentage > 90 ? 'bg-red-500' :
-                    percentage > 75 ? 'bg-amber-500' : 'bg-green-500'
-                  }`}
-                  style={{ width: `${Math.min(100, percentage)}%` }}
-                />
-              </div>
-            )}
-          </div>
-        )
-      })}
-    </div>
-  )
-}
-```
-
-## When to Use
-
-- API rate limits
-- AI token usage
-- Storage quotas
-- Pay-as-you-go billing

package/skills/patterns/performance/caching.md

@@ -1,276 +0,0 @@
-# Caching Patterns
-
-Patterns for application caching.
-
-## React Cache
-
-```typescript
-// lib/cache.ts
-import { cache } from 'react'
-import { prisma } from '@/lib/db'
-
-// React cache - deduplicates within a single request
-export const getUser = cache(async (userId: string) => {
-  return prisma.user.findUnique({ where: { id: userId } })
-})
-
-// Multiple calls within same request = 1 database query
-export async function UserProfile({ userId }: { userId: string }) {
-  const user = await getUser(userId) // First call - hits DB
-  return <Profile user={user} />
-}
-
-export async function UserSidebar({ userId }: { userId: string }) {
-  const user = await getUser(userId) // Same request - cached
-  return <Sidebar user={user} />
-}
-```
-
-## Next.js Data Cache
-
-```typescript
-// Fetch with caching
-async function getData() {
-  const res = await fetch('https://api.example.com/data', {
-    next: {
-      revalidate: 3600, // Cache for 1 hour
-      tags: ['data'] // For on-demand revalidation
-    }
-  })
-  return res.json()
-}
-
-// Force fresh data
-async function getFreshData() {
-  const res = await fetch('https://api.example.com/data', {
-    cache: 'no-store'
-  })
-  return res.json()
-}
-
-// On-demand revalidation
-import { revalidateTag, revalidatePath } from 'next/cache'
-
-export async function updateData() {
-  await saveToDatabase()
-
-  // Revalidate by tag
-  revalidateTag('data')
-
-  // Or by path
-  revalidatePath('/dashboard')
-}
-```
-
-## unstable_cache for Database
-
-```typescript
-// lib/cache.ts
-import { unstable_cache } from 'next/cache'
-import { prisma } from '@/lib/db'
-
-export const getCachedPosts = unstable_cache(
-  async (userId: string) => {
-    return prisma.post.findMany({
-      where: { authorId: userId },
-      orderBy: { createdAt: 'desc' },
-      take: 10
-    })
-  },
-  ['user-posts'], // Cache key prefix
-  {
-    revalidate: 60, // 1 minute
-    tags: ['posts'] // For manual revalidation
-  }
-)
-
-// With dynamic cache key
-export const getCachedPost = unstable_cache(
-  async (postId: string) => {
-    return prisma.post.findUnique({
-      where: { id: postId },
-      include: { author: true }
-    })
-  },
-  ['post'], // Prefix - actual key will be ['post', postId]
-  { revalidate: 300, tags: ['posts'] }
-)
-```
-
-## Redis Caching
-
-```typescript
-// lib/redis.ts
-import { Redis } from '@upstash/redis'
-
-const redis = new Redis({
-  url: process.env.UPSTASH_REDIS_URL!,
-  token: process.env.UPSTASH_REDIS_TOKEN!
-})
-
-export async function getCached<T>(
-  key: string,
-  fetcher: () => Promise<T>,
-  ttl: number = 3600
-): Promise<T> {
-  // Try cache first
-  const cached = await redis.get<T>(key)
-
-  if (cached !== null) {
-    return cached
-  }
-
-  // Fetch fresh data
-  const data = await fetcher()
-
-  // Cache it
-  await redis.setex(key, ttl, data)
-
-  return data
-}
-
-// Usage
-const user = await getCached(
-  `user:${userId}`,
-  () => prisma.user.findUnique({ where: { id: userId } }),
-  300 // 5 minutes
-)
-
-// Invalidation
-export async function invalidateCache(pattern: string) {
-  const keys = await redis.keys(pattern)
-  if (keys.length > 0) {
-    await redis.del(...keys)
-  }
-}
-```
-
-## Stale-While-Revalidate
-
-```typescript
-// lib/swr-cache.ts
-import { Redis } from '@upstash/redis'
-
-const redis = new Redis({
-  url: process.env.UPSTASH_REDIS_URL!,
-  token: process.env.UPSTASH_REDIS_TOKEN!
-})
-
-interface CacheEntry<T> {
-  data: T
-  staleAt: number
-  expiresAt: number
-}
-
-export async function swrCache<T>(
-  key: string,
-  fetcher: () => Promise<T>,
-  { staleTime = 60, maxAge = 300 }: { staleTime?: number; maxAge?: number } = {}
-): Promise<T> {
-  const now = Date.now()
-
-  const cached = await redis.get<CacheEntry<T>>(key)
-
-  // Fresh cache hit
-  if (cached && now < cached.staleAt) {
-    return cached.data
-  }
-
-  // Stale cache - return stale data but revalidate in background
-  if (cached && now < cached.expiresAt) {
-    // Revalidate in background
-    revalidateInBackground(key, fetcher, staleTime, maxAge)
-    return cached.data
-  }
-
-  // Cache miss - fetch fresh
-  return fetchAndCache(key, fetcher, staleTime, maxAge)
-}
-
-async function fetchAndCache<T>(
-  key: string,
-  fetcher: () => Promise<T>,
-  staleTime: number,
-  maxAge: number
-): Promise<T> {
-  const data = await fetcher()
-  const now = Date.now()
-
-  const entry: CacheEntry<T> = {
-    data,
-    staleAt: now + staleTime * 1000,
-    expiresAt: now + maxAge * 1000
-  }
-
-  await redis.setex(key, maxAge, entry)
-  return data
-}
-
-function revalidateInBackground<T>(
-  key: string,
-  fetcher: () => Promise<T>,
-  staleTime: number,
-  maxAge: number
-) {
-  // Don't await - fire and forget
-  fetchAndCache(key, fetcher, staleTime, maxAge).catch(console.error)
-}
-```
-
-## Memoization
-
-```typescript
-// lib/memoize.ts
-
-// Simple memoization
-export function memoize<T extends (...args: any[]) => any>(fn: T): T {
-  const cache = new Map()
-
-  return ((...args: Parameters<T>) => {
-    const key = JSON.stringify(args)
-
-    if (cache.has(key)) {
-      return cache.get(key)
-    }
-
-    const result = fn(...args)
-    cache.set(key, result)
-    return result
-  }) as T
-}
-
-// Async memoization with TTL
-export function memoizeAsync<T extends (...args: any[]) => Promise<any>>(
-  fn: T,
-  ttl: number = 60000
-): T {
-  const cache = new Map<string, { value: Awaited<ReturnType<T>>; expires: number }>()
-
-  return (async (...args: Parameters<T>) => {
-    const key = JSON.stringify(args)
-    const now = Date.now()
-
-    const cached = cache.get(key)
-    if (cached && cached.expires > now) {
-      return cached.value
-    }
-
-    const value = await fn(...args)
-    cache.set(key, { value, expires: now + ttl })
-    return value
-  }) as T
-}
-
-// Usage
-const expensiveCalculation = memoize((x: number, y: number) => {
-  // Complex computation
-  return x * y
-})
-```
-
-## When to Use
-
-- Database queries
-- API responses
-- Expensive computations
-- Session data