@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/deployment/monitoring.md

@@ -1,387 +0,0 @@
-# Monitoring and Observability Patterns
-
-Patterns for application monitoring, logging, and observability.
-
-## OpenTelemetry Setup
-
-```typescript
-// instrumentation.ts (Next.js)
-import { NodeSDK } from '@opentelemetry/sdk-node'
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'
-import { Resource } from '@opentelemetry/resources'
-import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions'
-
-export function register() {
-  if (process.env.NEXT_RUNTIME === 'nodejs') {
-    const sdk = new NodeSDK({
-      resource: new Resource({
-        [SEMRESATTRS_SERVICE_NAME]: 'my-nextjs-app',
-        [SEMRESATTRS_SERVICE_VERSION]: process.env.npm_package_version ?? '1.0.0'
-      }),
-      traceExporter: new OTLPTraceExporter({
-        url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT
-      }),
-      instrumentations: [getNodeAutoInstrumentations()]
-    })
-
-    sdk.start()
-  }
-}
-```
-
-## Custom Metrics
-
-```typescript
-// lib/metrics.ts
-import { Counter, Histogram, Registry } from 'prom-client'
-
-const register = new Registry()
-
-// HTTP request metrics
-export const httpRequestsTotal = new Counter({
-  name: 'http_requests_total',
-  help: 'Total number of HTTP requests',
-  labelNames: ['method', 'path', 'status'],
-  registers: [register]
-})
-
-export const httpRequestDuration = new Histogram({
-  name: 'http_request_duration_seconds',
-  help: 'HTTP request duration in seconds',
-  labelNames: ['method', 'path'],
-  buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5],
-  registers: [register]
-})
-
-// Business metrics
-export const userSignups = new Counter({
-  name: 'user_signups_total',
-  help: 'Total number of user signups',
-  labelNames: ['plan'],
-  registers: [register]
-})
-
-export const apiCalls = new Counter({
-  name: 'api_calls_total',
-  help: 'Total API calls',
-  labelNames: ['endpoint', 'status'],
-  registers: [register]
-})
-
-export { register }
-
-// API endpoint for Prometheus
-// app/api/metrics/route.ts
-import { NextResponse } from 'next/server'
-import { register } from '@/lib/metrics'
-
-export async function GET() {
-  const metrics = await register.metrics()
-  return new NextResponse(metrics, {
-    headers: {
-      'Content-Type': register.contentType
-    }
-  })
-}
-```
-
-## Request Tracing Middleware
-
-```typescript
-// middleware.ts
-import { NextRequest, NextResponse } from 'next/server'
-import { httpRequestsTotal, httpRequestDuration } from '@/lib/metrics'
-import { v4 as uuidv4 } from 'uuid'
-
-export function middleware(request: NextRequest) {
-  const requestId = uuidv4()
-  const start = Date.now()
-
-  // Add request ID header
-  const response = NextResponse.next()
-  response.headers.set('X-Request-ID', requestId)
-
-  // Log request
-  console.log(JSON.stringify({
-    type: 'request',
-    requestId,
-    method: request.method,
-    path: request.nextUrl.pathname,
-    timestamp: new Date().toISOString()
-  }))
-
-  return response
-}
-
-// Middleware for API routes
-// lib/withMetrics.ts
-import { NextRequest, NextResponse } from 'next/server'
-import { httpRequestsTotal, httpRequestDuration } from '@/lib/metrics'
-
-type Handler = (req: NextRequest) => Promise<NextResponse>
-
-export function withMetrics(handler: Handler): Handler {
-  return async (req: NextRequest) => {
-    const start = Date.now()
-    const path = req.nextUrl.pathname
-
-    try {
-      const response = await handler(req)
-      const duration = (Date.now() - start) / 1000
-
-      httpRequestsTotal.inc({
-        method: req.method,
-        path,
-        status: response.status
-      })
-
-      httpRequestDuration.observe({ method: req.method, path }, duration)
-
-      return response
-    } catch (error) {
-      httpRequestsTotal.inc({
-        method: req.method,
-        path,
-        status: 500
-      })
-      throw error
-    }
-  }
-}
-```
-
-## Error Tracking with Sentry
-
-```typescript
-// sentry.client.config.ts
-import * as Sentry from '@sentry/nextjs'
-
-Sentry.init({
-  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
-  environment: process.env.NODE_ENV,
-  tracesSampleRate: 1.0,
-  replaysSessionSampleRate: 0.1,
-  replaysOnErrorSampleRate: 1.0,
-  integrations: [
-    Sentry.replayIntegration({
-      maskAllText: true,
-      blockAllMedia: true
-    })
-  ]
-})
-
-// sentry.server.config.ts
-import * as Sentry from '@sentry/nextjs'
-
-Sentry.init({
-  dsn: process.env.SENTRY_DSN,
-  environment: process.env.NODE_ENV,
-  tracesSampleRate: 1.0
-})
-
-// lib/error-tracking.ts
-import * as Sentry from '@sentry/nextjs'
-
-export function captureError(error: Error, context?: Record<string, any>) {
-  Sentry.withScope(scope => {
-    if (context) {
-      scope.setExtras(context)
-    }
-    Sentry.captureException(error)
-  })
-}
-
-export function setUserContext(user: { id: string; email: string }) {
-  Sentry.setUser({ id: user.id, email: user.email })
-}
-
-export function addBreadcrumb(message: string, data?: Record<string, any>) {
-  Sentry.addBreadcrumb({
-    message,
-    data,
-    level: 'info'
-  })
-}
-```
-
-## Health Check Endpoints
-
-```typescript
-// app/api/health/route.ts
-import { NextResponse } from 'next/server'
-import { prisma } from '@/lib/db'
-import { redis } from '@/lib/redis'
-
-interface HealthCheck {
-  status: 'healthy' | 'unhealthy'
-  checks: {
-    [key: string]: {
-      status: 'pass' | 'fail'
-      responseTime?: number
-      error?: string
-    }
-  }
-  timestamp: string
-}
-
-export async function GET() {
-  const checks: HealthCheck['checks'] = {}
-
-  // Database check
-  const dbStart = Date.now()
-  try {
-    await prisma.$queryRaw`SELECT 1`
-    checks.database = {
-      status: 'pass',
-      responseTime: Date.now() - dbStart
-    }
-  } catch (error) {
-    checks.database = {
-      status: 'fail',
-      error: error instanceof Error ? error.message : 'Unknown error'
-    }
-  }
-
-  // Redis check
-  const redisStart = Date.now()
-  try {
-    await redis.ping()
-    checks.redis = {
-      status: 'pass',
-      responseTime: Date.now() - redisStart
-    }
-  } catch (error) {
-    checks.redis = {
-      status: 'fail',
-      error: error instanceof Error ? error.message : 'Unknown error'
-    }
-  }
-
-  const allHealthy = Object.values(checks).every(c => c.status === 'pass')
-
-  const response: HealthCheck = {
-    status: allHealthy ? 'healthy' : 'unhealthy',
-    checks,
-    timestamp: new Date().toISOString()
-  }
-
-  return NextResponse.json(response, {
-    status: allHealthy ? 200 : 503
-  })
-}
-
-// app/api/health/ready/route.ts
-export async function GET() {
-  // Kubernetes readiness probe
-  return NextResponse.json({ ready: true })
-}
-
-// app/api/health/live/route.ts
-export async function GET() {
-  // Kubernetes liveness probe
-  return NextResponse.json({ alive: true })
-}
-```
-
-## Performance Monitoring
-
-```typescript
-// lib/performance.ts
-import { trace, SpanStatusCode } from '@opentelemetry/api'
-
-const tracer = trace.getTracer('my-app')
-
-export async function withSpan<T>(
-  name: string,
-  fn: () => Promise<T>,
-  attributes?: Record<string, string | number>
-): Promise<T> {
-  return tracer.startActiveSpan(name, async span => {
-    if (attributes) {
-      span.setAttributes(attributes)
-    }
-
-    try {
-      const result = await fn()
-      span.setStatus({ code: SpanStatusCode.OK })
-      return result
-    } catch (error) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : 'Unknown error'
-      })
-      span.recordException(error as Error)
-      throw error
-    } finally {
-      span.end()
-    }
-  })
-}
-
-// Usage
-const users = await withSpan(
-  'fetch-users',
-  () => prisma.user.findMany(),
-  { 'db.operation': 'findMany', 'db.table': 'users' }
-)
-```
-
-## Dashboard Configuration
-
-```yaml
-# docker-compose.monitoring.yml
-version: '3.8'
-services:
-  prometheus:
-    image: prom/prometheus:latest
-    ports:
-      - '9090:9090'
-    volumes:
-      - ./prometheus.yml:/etc/prometheus/prometheus.yml
-      - prometheus_data:/prometheus
-    command:
-      - '--config.file=/etc/prometheus/prometheus.yml'
-      - '--storage.tsdb.path=/prometheus'
-
-  grafana:
-    image: grafana/grafana:latest
-    ports:
-      - '3001:3000'
-    volumes:
-      - grafana_data:/var/lib/grafana
-      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards
-      - ./grafana/datasources:/etc/grafana/provisioning/datasources
-    environment:
-      - GF_SECURITY_ADMIN_PASSWORD=admin
-
-  jaeger:
-    image: jaegertracing/all-in-one:latest
-    ports:
-      - '16686:16686'
-      - '4317:4317'
-      - '4318:4318'
-
-volumes:
-  prometheus_data:
-  grafana_data:
-```
-
-```yaml
-# prometheus.yml
-global:
-  scrape_interval: 15s
-
-scrape_configs:
-  - job_name: 'nextjs-app'
-    static_configs:
-      - targets: ['host.docker.internal:3000']
-    metrics_path: '/api/metrics'
-```
-
-## When to Use
-
-- Production deployments
-- Performance debugging
-- Error tracking
-- SLA monitoring

package/skills/patterns/deployment/vercel.md

@@ -1,160 +0,0 @@
-# Vercel Deployment Patterns
-
-Patterns for deploying to Vercel.
-
-## Environment Variables
-
-```bash
-# .env.local (local development)
-DATABASE_URL="postgresql://..."
-NEXTAUTH_SECRET="..."
-
-# Vercel Dashboard: Settings > Environment Variables
-# Or via CLI:
-vercel env add DATABASE_URL production
-vercel env add NEXTAUTH_SECRET production
-```
-
-## vercel.json Configuration
-
-```json
-{
-  "framework": "nextjs",
-  "regions": ["iad1"],
-  "headers": [
-    {
-      "source": "/api/(.*)",
-      "headers": [
-        { "key": "Access-Control-Allow-Origin", "value": "*" }
-      ]
-    }
-  ],
-  "redirects": [
-    {
-      "source": "/old-page",
-      "destination": "/new-page",
-      "permanent": true
-    }
-  ],
-  "rewrites": [
-    {
-      "source": "/api/proxy/:path*",
-      "destination": "https://api.external.com/:path*"
-    }
-  ],
-  "crons": [
-    {
-      "path": "/api/cron/daily",
-      "schedule": "0 0 * * *"
-    }
-  ]
-}
-```
-
-## Preview Deployments
-
-```typescript
-// lib/env.ts
-export function getBaseUrl() {
-  // Vercel preview deployments
-  if (process.env.VERCEL_URL) {
-    return `https://${process.env.VERCEL_URL}`
-  }
-
-  // Production
-  if (process.env.NEXT_PUBLIC_APP_URL) {
-    return process.env.NEXT_PUBLIC_APP_URL
-  }
-
-  // Local development
-  return 'http://localhost:3000'
-}
-```
-
-## Cron Jobs
-
-```typescript
-// app/api/cron/cleanup/route.ts
-import { NextResponse } from 'next/server'
-
-export async function GET(request: Request) {
-  // Verify cron secret
-  const authHeader = request.headers.get('authorization')
-
-  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  // Run cleanup task
-  await prisma.session.deleteMany({
-    where: { expiresAt: { lt: new Date() } }
-  })
-
-  return NextResponse.json({ success: true })
-}
-
-// vercel.json
-{
-  "crons": [{
-    "path": "/api/cron/cleanup",
-    "schedule": "0 */6 * * *"
-  }]
-}
-```
-
-## Edge Functions
-
-```typescript
-// app/api/geo/route.ts
-export const runtime = 'edge'
-export const preferredRegion = ['iad1', 'sfo1', 'fra1']
-
-export async function GET(request: Request) {
-  // Access Vercel geo headers
-  const country = request.headers.get('x-vercel-ip-country')
-  const city = request.headers.get('x-vercel-ip-city')
-
-  return Response.json({ country, city })
-}
-```
-
-## Build Configuration
-
-```typescript
-// next.config.js
-module.exports = {
-  // Standalone output for containers
-  output: 'standalone',
-
-  // Image optimization
-  images: {
-    domains: ['cdn.example.com'],
-    remotePatterns: [
-      { protocol: 'https', hostname: '**.example.com' }
-    ]
-  },
-
-  // Environment at build time
-  env: {
-    BUILD_TIME: new Date().toISOString()
-  }
-}
-```
-
-## Deploy Hooks
-
-```bash
-# Trigger deploy via webhook
-curl -X POST https://api.vercel.com/v1/integrations/deploy/prj_xxx/hook_xxx
-
-# In CI/CD
-- name: Deploy to Vercel
-  run: curl -X POST ${{ secrets.VERCEL_DEPLOY_HOOK }}
-```
-
-## When to Use
-
-- Next.js production
-- Preview environments
-- Scheduled tasks
-- Edge computing

package/skills/patterns/email/resend.md

@@ -1,143 +0,0 @@
-# Resend Email Patterns
-
-Patterns for sending emails with Resend.
-
-## Client Setup
-
-```typescript
-// lib/email.ts
-import { Resend } from 'resend'
-
-export const resend = new Resend(process.env.RESEND_API_KEY)
-```
-
-## Send Basic Email
-
-```typescript
-// lib/email.ts
-export async function sendEmail({
-  to,
-  subject,
-  html
-}: {
-  to: string
-  subject: string
-  html: string
-}) {
-  const { data, error } = await resend.emails.send({
-    from: 'Your App <noreply@yourapp.com>',
-    to,
-    subject,
-    html
-  })
-
-  if (error) {
-    console.error('Email error:', error)
-    throw error
-  }
-
-  return data
-}
-```
-
-## With React Email
-
-```typescript
-// lib/email.ts
-import { render } from '@react-email/render'
-import { WelcomeEmail } from '@/emails/welcome'
-
-export async function sendWelcomeEmail(to: string, name: string) {
-  const html = await render(
-    WelcomeEmail({ name, actionUrl: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard` })
-  )
-
-  return resend.emails.send({
-    from: 'Your App <welcome@yourapp.com>',
-    to,
-    subject: 'Welcome to Our App!',
-    html
-  })
-}
-```
-
-## Email Service Pattern
-
-```typescript
-// lib/email-service.ts
-import { resend } from './email'
-import { render } from '@react-email/render'
-import { WelcomeEmail } from '@/emails/welcome'
-import { PasswordResetEmail } from '@/emails/password-reset'
-import { InviteEmail } from '@/emails/invite'
-
-export const emailService = {
-  async sendWelcome(to: string, name: string) {
-    const html = await render(
-      WelcomeEmail({
-        name,
-        actionUrl: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard`
-      })
-    )
-
-    return resend.emails.send({
-      from: 'Your App <welcome@yourapp.com>',
-      to,
-      subject: 'Welcome to Our App!',
-      html
-    })
-  },
-
-  async sendPasswordReset(to: string, resetUrl: string) {
-    const html = await render(PasswordResetEmail({ resetUrl }))
-
-    return resend.emails.send({
-      from: 'Your App <security@yourapp.com>',
-      to,
-      subject: 'Reset Your Password',
-      html
-    })
-  },
-
-  async sendInvite(
-    to: string,
-    inviterName: string,
-    teamName: string,
-    inviteUrl: string
-  ) {
-    const html = await render(
-      InviteEmail({ inviterName, teamName, inviteUrl })
-    )
-
-    return resend.emails.send({
-      from: 'Your App <invites@yourapp.com>',
-      to,
-      subject: `${inviterName} invited you to join ${teamName}`,
-      html
-    })
-  }
-}
-```
-
-## Batch Sending
-
-```typescript
-// lib/email.ts
-export async function sendBatch(
-  emails: { to: string; subject: string; html: string }[]
-) {
-  return resend.batch.send(
-    emails.map((email) => ({
-      from: 'Your App <noreply@yourapp.com>',
-      ...email
-    }))
-  )
-}
-```
-
-## When to Use
-
-- Transactional emails
-- Welcome sequences
-- Password resets
-- Notifications