@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/logging/structured.md

@@ -1,292 +0,0 @@
-# Structured Logging Patterns
-
-Patterns for application logging.
-
-## Logger Setup
-
-```typescript
-// lib/logger.ts
-type LogLevel = 'debug' | 'info' | 'warn' | 'error'
-
-interface LogContext {
-  [key: string]: any
-}
-
-interface LogEntry {
-  level: LogLevel
-  message: string
-  timestamp: string
-  context?: LogContext
-  error?: {
-    name: string
-    message: string
-    stack?: string
-  }
-}
-
-class Logger {
-  private context: LogContext = {}
-
-  constructor(defaultContext: LogContext = {}) {
-    this.context = defaultContext
-  }
-
-  private log(level: LogLevel, message: string, context?: LogContext, error?: Error) {
-    const entry: LogEntry = {
-      level,
-      message,
-      timestamp: new Date().toISOString(),
-      context: { ...this.context, ...context }
-    }
-
-    if (error) {
-      entry.error = {
-        name: error.name,
-        message: error.message,
-        stack: error.stack
-      }
-    }
-
-    // In production, send to logging service
-    if (process.env.NODE_ENV === 'production') {
-      this.sendToService(entry)
-    } else {
-      console[level](JSON.stringify(entry, null, 2))
-    }
-  }
-
-  private async sendToService(entry: LogEntry) {
-    // Send to Datadog, LogTail, etc.
-    await fetch(process.env.LOG_ENDPOINT!, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(entry)
-    }).catch(() => {})
-  }
-
-  child(context: LogContext) {
-    return new Logger({ ...this.context, ...context })
-  }
-
-  debug(message: string, context?: LogContext) {
-    this.log('debug', message, context)
-  }
-
-  info(message: string, context?: LogContext) {
-    this.log('info', message, context)
-  }
-
-  warn(message: string, context?: LogContext) {
-    this.log('warn', message, context)
-  }
-
-  error(message: string, error?: Error, context?: LogContext) {
-    this.log('error', message, context, error)
-  }
-}
-
-export const logger = new Logger({
-  service: 'myapp',
-  environment: process.env.NODE_ENV
-})
-```
-
-## Request Logging Middleware
-
-```typescript
-// middleware.ts
-import { NextResponse } from 'next/server'
-import type { NextRequest } from 'next/server'
-import { logger } from '@/lib/logger'
-
-export function middleware(request: NextRequest) {
-  const requestId = crypto.randomUUID()
-  const start = Date.now()
-
-  const response = NextResponse.next()
-
-  // Add request ID header
-  response.headers.set('x-request-id', requestId)
-
-  // Log request
-  const duration = Date.now() - start
-
-  logger.info('HTTP Request', {
-    requestId,
-    method: request.method,
-    path: request.nextUrl.pathname,
-    duration,
-    status: response.status,
-    userAgent: request.headers.get('user-agent')
-  })
-
-  return response
-}
-```
-
-## API Route Logging
-
-```typescript
-// lib/api-logger.ts
-import { logger } from './logger'
-import { NextRequest, NextResponse } from 'next/server'
-
-type Handler = (request: NextRequest) => Promise<NextResponse>
-
-export function withLogging(handler: Handler): Handler {
-  return async (request: NextRequest) => {
-    const requestId = crypto.randomUUID()
-    const start = Date.now()
-
-    const requestLogger = logger.child({
-      requestId,
-      method: request.method,
-      path: request.nextUrl.pathname
-    })
-
-    requestLogger.info('Request started')
-
-    try {
-      const response = await handler(request)
-      const duration = Date.now() - start
-
-      requestLogger.info('Request completed', {
-        status: response.status,
-        duration
-      })
-
-      response.headers.set('x-request-id', requestId)
-      return response
-    } catch (error) {
-      const duration = Date.now() - start
-
-      requestLogger.error('Request failed', error as Error, { duration })
-
-      return NextResponse.json(
-        { error: 'Internal Server Error', requestId },
-        { status: 500 }
-      )
-    }
-  }
-}
-
-// Usage
-export const GET = withLogging(async (request) => {
-  const data = await fetchData()
-  return NextResponse.json(data)
-})
-```
-
-## Error Logging
-
-```typescript
-// lib/error-handler.ts
-import { logger } from './logger'
-
-export function logError(error: Error, context?: Record<string, any>) {
-  logger.error(error.message, error, {
-    ...context,
-    errorType: error.constructor.name
-  })
-
-  // Send to error tracking service
-  if (process.env.SENTRY_DSN) {
-    Sentry.captureException(error, { extra: context })
-  }
-}
-
-// Usage in try/catch
-try {
-  await riskyOperation()
-} catch (error) {
-  logError(error as Error, {
-    operation: 'riskyOperation',
-    userId: session.user.id
-  })
-}
-```
-
-## Audit Logging
-
-```typescript
-// lib/audit.ts
-import { prisma } from '@/lib/db'
-import { logger } from './logger'
-
-interface AuditEvent {
-  action: string
-  userId: string
-  resourceType: string
-  resourceId: string
-  metadata?: Record<string, any>
-}
-
-export async function logAuditEvent(event: AuditEvent) {
-  // Log to console/service
-  logger.info('Audit event', event)
-
-  // Persist to database
-  await prisma.auditLog.create({
-    data: {
-      action: event.action,
-      userId: event.userId,
-      resourceType: event.resourceType,
-      resourceId: event.resourceId,
-      metadata: event.metadata ?? {},
-      timestamp: new Date()
-    }
-  })
-}
-
-// Usage
-await logAuditEvent({
-  action: 'user.deleted',
-  userId: adminId,
-  resourceType: 'user',
-  resourceId: deletedUserId,
-  metadata: { reason: 'Requested by user' }
-})
-```
-
-## Performance Logging
-
-```typescript
-// lib/performance.ts
-import { logger } from './logger'
-
-export function measurePerformance<T>(
-  name: string,
-  fn: () => Promise<T>
-): Promise<T> {
-  const start = performance.now()
-
-  return fn().finally(() => {
-    const duration = performance.now() - start
-
-    logger.info('Performance measurement', {
-      operation: name,
-      durationMs: Math.round(duration)
-    })
-
-    // Alert on slow operations
-    if (duration > 5000) {
-      logger.warn('Slow operation detected', {
-        operation: name,
-        durationMs: Math.round(duration)
-      })
-    }
-  })
-}
-
-// Usage
-const users = await measurePerformance('fetchUsers', () =>
-  prisma.user.findMany()
-)
-```
-
-## When to Use
-
-- API requests
-- Error tracking
-- Audit trails
-- Performance monitoring

package/skills/patterns/notifications/email-queue.md

@@ -1,248 +0,0 @@
-# Email Queue Patterns
-
-Patterns for queued email delivery.
-
-## Database-Backed Queue
-
-```typescript
-// lib/email-queue.ts
-import { prisma } from '@/lib/db'
-import { resend } from '@/lib/email'
-import { render } from '@react-email/render'
-
-interface QueuedEmail {
-  to: string
-  subject: string
-  template: string
-  data: Record<string, any>
-  scheduledAt?: Date
-  priority?: number
-}
-
-export async function queueEmail(email: QueuedEmail) {
-  return prisma.emailQueue.create({
-    data: {
-      to: email.to,
-      subject: email.subject,
-      template: email.template,
-      data: JSON.stringify(email.data),
-      scheduledAt: email.scheduledAt ?? new Date(),
-      priority: email.priority ?? 0,
-      status: 'PENDING'
-    }
-  })
-}
-
-export async function processEmailQueue() {
-  const emails = await prisma.emailQueue.findMany({
-    where: {
-      status: 'PENDING',
-      scheduledAt: { lte: new Date() }
-    },
-    orderBy: [
-      { priority: 'desc' },
-      { scheduledAt: 'asc' }
-    ],
-    take: 10
-  })
-
-  for (const email of emails) {
-    try {
-      // Mark as processing
-      await prisma.emailQueue.update({
-        where: { id: email.id },
-        data: { status: 'PROCESSING' }
-      })
-
-      // Render and send
-      const html = await renderTemplate(email.template, JSON.parse(email.data))
-
-      await resend.emails.send({
-        from: 'noreply@myapp.com',
-        to: email.to,
-        subject: email.subject,
-        html
-      })
-
-      // Mark as sent
-      await prisma.emailQueue.update({
-        where: { id: email.id },
-        data: { status: 'SENT', sentAt: new Date() }
-      })
-    } catch (error) {
-      // Mark as failed
-      await prisma.emailQueue.update({
-        where: { id: email.id },
-        data: {
-          status: 'FAILED',
-          error: error instanceof Error ? error.message : 'Unknown error',
-          retryCount: { increment: 1 }
-        }
-      })
-    }
-  }
-}
-```
-
-## Cron Job for Processing
-
-```typescript
-// app/api/cron/process-emails/route.ts
-import { processEmailQueue } from '@/lib/email-queue'
-
-export async function GET(request: Request) {
-  // Verify cron secret
-  const auth = request.headers.get('authorization')
-  if (auth !== `Bearer ${process.env.CRON_SECRET}`) {
-    return Response.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  await processEmailQueue()
-
-  return Response.json({ success: true })
-}
-
-// vercel.json
-{
-  "crons": [{
-    "path": "/api/cron/process-emails",
-    "schedule": "* * * * *"
-  }]
-}
-```
-
-## Retry Logic
-
-```typescript
-// lib/email-queue.ts
-const MAX_RETRIES = 3
-const RETRY_DELAYS = [60, 300, 900] // 1min, 5min, 15min
-
-export async function retryFailedEmails() {
-  const failedEmails = await prisma.emailQueue.findMany({
-    where: {
-      status: 'FAILED',
-      retryCount: { lt: MAX_RETRIES }
-    }
-  })
-
-  for (const email of failedEmails) {
-    const retryDelay = RETRY_DELAYS[email.retryCount] ?? RETRY_DELAYS[RETRY_DELAYS.length - 1]
-    const nextRetry = new Date(Date.now() + retryDelay * 1000)
-
-    await prisma.emailQueue.update({
-      where: { id: email.id },
-      data: {
-        status: 'PENDING',
-        scheduledAt: nextRetry
-      }
-    })
-  }
-}
-```
-
-## Batch Emails
-
-```typescript
-// lib/email-queue.ts
-export async function queueBatchEmails(
-  recipients: string[],
-  template: string,
-  subject: string,
-  getData: (email: string) => Record<string, any>
-) {
-  const emails = recipients.map(to => ({
-    to,
-    subject,
-    template,
-    data: JSON.stringify(getData(to)),
-    scheduledAt: new Date(),
-    status: 'PENDING' as const
-  }))
-
-  await prisma.emailQueue.createMany({ data: emails })
-}
-
-// Usage - Newsletter
-await queueBatchEmails(
-  subscriberEmails,
-  'newsletter',
-  'Weekly Newsletter',
-  (email) => ({ email, unsubscribeUrl: generateUnsubscribeUrl(email) })
-)
-```
-
-## Priority Queue
-
-```typescript
-// Email priorities
-const PRIORITY = {
-  CRITICAL: 100,  // Password resets, 2FA
-  HIGH: 75,       // Order confirmations
-  NORMAL: 50,     // Notifications
-  LOW: 25,        // Marketing
-  BULK: 0         // Newsletters
-}
-
-// Queue with priority
-await queueEmail({
-  to: user.email,
-  subject: 'Reset your password',
-  template: 'password-reset',
-  data: { resetUrl },
-  priority: PRIORITY.CRITICAL
-})
-
-await queueEmail({
-  to: user.email,
-  subject: 'Weekly digest',
-  template: 'digest',
-  data: { posts },
-  priority: PRIORITY.LOW,
-  scheduledAt: nextSunday()
-})
-```
-
-## Email Analytics
-
-```typescript
-// lib/email-tracking.ts
-export async function trackEmailOpen(emailId: string) {
-  await prisma.emailQueue.update({
-    where: { id: emailId },
-    data: { openedAt: new Date() }
-  })
-}
-
-export async function trackEmailClick(emailId: string, link: string) {
-  await prisma.emailClick.create({
-    data: { emailId, link, clickedAt: new Date() }
-  })
-}
-
-// Tracking pixel endpoint
-// app/api/email/track/[id]/route.ts
-export async function GET(
-  request: Request,
-  { params }: { params: { id: string } }
-) {
-  await trackEmailOpen(params.id)
-
-  // Return 1x1 transparent pixel
-  const pixel = Buffer.from(
-    'R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7',
-    'base64'
-  )
-
-  return new Response(pixel, {
-    headers: { 'Content-Type': 'image/gif' }
-  })
-}
-```
-
-## When to Use
-
-- Transactional emails
-- Newsletters
-- Scheduled notifications
-- Batch processing