@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/auth/session-management.md

@@ -1,367 +0,0 @@
-# Session Management Patterns
-
-Patterns for managing user sessions.
-
-## JWT Session Configuration
-
-```typescript
-// auth.config.ts
-import { NextAuthConfig } from 'next-auth'
-
-export const authConfig: NextAuthConfig = {
-  session: {
-    strategy: 'jwt',
-    maxAge: 30 * 24 * 60 * 60, // 30 days
-    updateAge: 24 * 60 * 60 // 24 hours
-  },
-  callbacks: {
-    jwt({ token, user, trigger, session }) {
-      // Initial sign in
-      if (user) {
-        token.id = user.id
-        token.role = user.role
-        token.organizationId = user.organizationId
-      }
-
-      // Update session when trigger is 'update'
-      if (trigger === 'update' && session) {
-        token.name = session.name
-        token.organizationId = session.organizationId
-      }
-
-      return token
-    },
-    session({ session, token }) {
-      session.user.id = token.id as string
-      session.user.role = token.role as string
-      session.user.organizationId = token.organizationId as string
-
-      return session
-    }
-  }
-}
-```
-
-## Database Sessions
-
-```typescript
-// auth.ts
-import NextAuth from 'next-auth'
-import { PrismaAdapter } from '@auth/prisma-adapter'
-import { prisma } from '@/lib/db'
-
-export const { handlers, auth, signIn, signOut } = NextAuth({
-  adapter: PrismaAdapter(prisma),
-  session: {
-    strategy: 'database',
-    maxAge: 30 * 24 * 60 * 60, // 30 days
-    updateAge: 24 * 60 * 60 // Update session every 24 hours
-  },
-  callbacks: {
-    session({ session, user }) {
-      session.user.id = user.id
-      session.user.role = user.role
-      return session
-    }
-  },
-  providers: [
-    // ... providers
-  ]
-})
-```
-
-## Session Refresh
-
-```typescript
-// lib/auth/session.ts
-import { auth, signIn } from '@/auth'
-import { redirect } from 'next/navigation'
-
-export async function getSession() {
-  const session = await auth()
-
-  if (!session) {
-    return null
-  }
-
-  // Check if session is about to expire
-  const expiresAt = new Date(session.expires)
-  const now = new Date()
-  const daysUntilExpiry = (expiresAt.getTime() - now.getTime()) / (1000 * 60 * 60 * 24)
-
-  if (daysUntilExpiry < 7) {
-    // Session will expire soon, refresh it
-    // This triggers the updateAge callback
-  }
-
-  return session
-}
-
-export async function requireAuth() {
-  const session = await getSession()
-
-  if (!session) {
-    redirect('/login')
-  }
-
-  return session
-}
-
-export async function requireRole(requiredRoles: string[]) {
-  const session = await requireAuth()
-
-  if (!requiredRoles.includes(session.user.role)) {
-    redirect('/unauthorized')
-  }
-
-  return session
-}
-```
-
-## Session Update
-
-```tsx
-// components/UpdateSessionForm.tsx
-'use client'
-
-import { useSession } from 'next-auth/react'
-import { useState } from 'react'
-
-export function UpdateSessionForm() {
-  const { data: session, update } = useSession()
-  const [name, setName] = useState(session?.user?.name ?? '')
-
-  const handleSubmit = async (e: React.FormEvent) => {
-    e.preventDefault()
-
-    // Update user in database
-    await fetch('/api/user/profile', {
-      method: 'PATCH',
-      body: JSON.stringify({ name })
-    })
-
-    // Update session
-    await update({ name })
-  }
-
-  return (
-    <form onSubmit={handleSubmit}>
-      <input
-        type="text"
-        value={name}
-        onChange={e => setName(e.target.value)}
-      />
-      <button type="submit">Update</button>
-    </form>
-  )
-}
-```
-
-## Active Sessions Management
-
-```typescript
-// prisma/schema.prisma
-model Session {
-  id           String   @id @default(cuid())
-  sessionToken String   @unique
-  userId       String
-  expires      DateTime
-  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
-
-  // Additional fields for session management
-  userAgent    String?
-  ipAddress    String?
-  lastActive   DateTime @default(now())
-  createdAt    DateTime @default(now())
-
-  @@index([userId])
-}
-```
-
-```typescript
-// lib/auth/sessions.ts
-import { prisma } from '@/lib/db'
-import { headers } from 'next/headers'
-
-export async function getUserSessions(userId: string) {
-  return prisma.session.findMany({
-    where: { userId },
-    orderBy: { lastActive: 'desc' },
-    select: {
-      id: true,
-      userAgent: true,
-      ipAddress: true,
-      lastActive: true,
-      createdAt: true,
-      expires: true
-    }
-  })
-}
-
-export async function revokeSession(sessionId: string, userId: string) {
-  return prisma.session.deleteMany({
-    where: {
-      id: sessionId,
-      userId // Ensure user owns the session
-    }
-  })
-}
-
-export async function revokeAllOtherSessions(
-  currentSessionToken: string,
-  userId: string
-) {
-  return prisma.session.deleteMany({
-    where: {
-      userId,
-      NOT: { sessionToken: currentSessionToken }
-    }
-  })
-}
-
-export async function updateSessionActivity(sessionToken: string) {
-  const headersList = headers()
-
-  await prisma.session.update({
-    where: { sessionToken },
-    data: {
-      lastActive: new Date(),
-      userAgent: headersList.get('user-agent'),
-      ipAddress:
-        headersList.get('x-forwarded-for') ??
-        headersList.get('x-real-ip')
-    }
-  })
-}
-```
-
-## Session List UI
-
-```tsx
-// app/settings/sessions/page.tsx
-import { auth } from '@/auth'
-import { getUserSessions, revokeSession } from '@/lib/auth/sessions'
-import { formatDistanceToNow } from 'date-fns'
-import { UAParser } from 'ua-parser-js'
-
-export default async function SessionsPage() {
-  const session = await auth()
-  if (!session) return null
-
-  const sessions = await getUserSessions(session.user.id)
-
-  return (
-    <div className="space-y-6">
-      <h2 className="text-xl font-semibold">Active Sessions</h2>
-
-      <div className="space-y-4">
-        {sessions.map(s => {
-          const ua = new UAParser(s.userAgent ?? '').getResult()
-          const isCurrent = s.id === session.sessionId
-
-          return (
-            <div
-              key={s.id}
-              className="flex items-center justify-between rounded-lg border p-4"
-            >
-              <div>
-                <div className="flex items-center gap-2">
-                  <span className="font-medium">
-                    {ua.browser.name} on {ua.os.name}
-                  </span>
-                  {isCurrent && (
-                    <span className="rounded bg-green-100 px-2 py-0.5 text-xs text-green-800">
-                      Current
-                    </span>
-                  )}
-                </div>
-                <div className="text-sm text-gray-500">
-                  <span>{s.ipAddress}</span>
-                  <span className="mx-2">•</span>
-                  <span>
-                    Last active {formatDistanceToNow(s.lastActive, { addSuffix: true })}
-                  </span>
-                </div>
-              </div>
-
-              {!isCurrent && (
-                <form action={async () => {
-                  'use server'
-                  await revokeSession(s.id, session.user.id)
-                }}>
-                  <button
-                    type="submit"
-                    className="text-sm text-red-600 hover:underline"
-                  >
-                    Revoke
-                  </button>
-                </form>
-              )}
-            </div>
-          )
-        })}
-      </div>
-
-      <form action={async () => {
-        'use server'
-        await revokeAllOtherSessions(session.sessionToken!, session.user.id)
-      }}>
-        <button
-          type="submit"
-          className="text-sm text-red-600 hover:underline"
-        >
-          Sign out all other sessions
-        </button>
-      </form>
-    </div>
-  )
-}
-```
-
-## Session Middleware
-
-```typescript
-// middleware.ts
-import { NextRequest, NextResponse } from 'next/server'
-import { auth } from '@/auth'
-
-export async function middleware(request: NextRequest) {
-  const session = await auth()
-
-  // Check if session exists for protected routes
-  if (request.nextUrl.pathname.startsWith('/dashboard')) {
-    if (!session) {
-      return NextResponse.redirect(new URL('/login', request.url))
-    }
-
-    // Check session expiry
-    if (new Date(session.expires) < new Date()) {
-      const response = NextResponse.redirect(new URL('/login', request.url))
-      // Clear invalid session cookie
-      response.cookies.delete('next-auth.session-token')
-      return response
-    }
-  }
-
-  // Add session info to headers for logging
-  const requestHeaders = new Headers(request.headers)
-  if (session?.user) {
-    requestHeaders.set('x-user-id', session.user.id)
-  }
-
-  return NextResponse.next({
-    request: { headers: requestHeaders }
-  })
-}
-
-export const config = {
-  matcher: ['/dashboard/:path*', '/api/:path*']
-}
-```
-
-## When to Use
-
-- User authentication
-- Multi-device management
-- Security auditing
-- Session invalidation

package/skills/patterns/auth/session.md

@@ -1,120 +0,0 @@
-# Session Management Patterns
-
-Patterns for managing user sessions with JWT and cookies.
-
-## JWT Session Creation
-
-```typescript
-// lib/session.ts
-import { SignJWT, jwtVerify } from 'jose'
-import { cookies } from 'next/headers'
-
-const secret = new TextEncoder().encode(process.env.JWT_SECRET)
-const COOKIE_NAME = 'session'
-
-export async function createSession(userId: string) {
-  const token = await new SignJWT({ userId })
-    .setProtectedHeader({ alg: 'HS256' })
-    .setIssuedAt()
-    .setExpirationTime('7d')
-    .sign(secret)
-
-  cookies().set(COOKIE_NAME, token, {
-    httpOnly: true,
-    secure: process.env.NODE_ENV === 'production',
-    sameSite: 'lax',
-    maxAge: 60 * 60 * 24 * 7, // 7 days
-    path: '/'
-  })
-
-  return token
-}
-```
-
-## Session Verification
-
-```typescript
-// lib/session.ts
-export async function getSession() {
-  const token = cookies().get(COOKIE_NAME)?.value
-
-  if (!token) return null
-
-  try {
-    const { payload } = await jwtVerify(token, secret)
-    return payload as { userId: string }
-  } catch {
-    return null
-  }
-}
-
-export async function requireSession() {
-  const session = await getSession()
-
-  if (!session) {
-    throw new Error('Unauthorized')
-  }
-
-  return session
-}
-```
-
-## Session Refresh
-
-```typescript
-// lib/session.ts
-export async function refreshSession() {
-  const session = await getSession()
-
-  if (!session) return null
-
-  // Create new token with extended expiry
-  return createSession(session.userId)
-}
-```
-
-## Session Destruction
-
-```typescript
-// lib/session.ts
-export async function destroySession() {
-  cookies().delete(COOKIE_NAME)
-}
-```
-
-## Session Middleware
-
-```typescript
-// middleware.ts
-import { NextResponse } from 'next/server'
-import type { NextRequest } from 'next/server'
-import { jwtVerify } from 'jose'
-
-const secret = new TextEncoder().encode(process.env.JWT_SECRET)
-
-export async function middleware(request: NextRequest) {
-  const token = request.cookies.get('session')?.value
-
-  if (!token) {
-    return NextResponse.redirect(new URL('/login', request.url))
-  }
-
-  try {
-    await jwtVerify(token, secret)
-    return NextResponse.next()
-  } catch {
-    return NextResponse.redirect(new URL('/login', request.url))
-  }
-}
-
-export const config = {
-  matcher: ['/dashboard/:path*', '/settings/:path*']
-}
-```
-
-## When to Use
-
-- Custom authentication systems
-- Stateless session management
-- Edge-compatible auth
-- API authentication

package/skills/patterns/database/audit.md

@@ -1,177 +0,0 @@
-# Audit Log Patterns
-
-Patterns for tracking data changes with audit logs.
-
-## Audit Log Schema
-
-```prisma
-// schema.prisma
-model AuditLog {
-  id         String   @id @default(cuid())
-  entityType String   // "User", "Post", etc.
-  entityId   String
-  action     String   // "CREATE", "UPDATE", "DELETE"
-  changes    Json?    // What changed
-  userId     String?  // Who made the change
-  user       User?    @relation(fields: [userId], references: [id])
-  ipAddress  String?
-  userAgent  String?
-  createdAt  DateTime @default(now())
-
-  @@index([entityType, entityId])
-  @@index([userId])
-  @@index([createdAt])
-}
-```
-
-## Audit Logger
-
-```typescript
-// lib/audit.ts
-import { prisma } from '@/lib/db'
-
-interface AuditContext {
-  userId?: string
-  ipAddress?: string
-  userAgent?: string
-}
-
-export async function createAuditLog(
-  entityType: string,
-  entityId: string,
-  action: 'CREATE' | 'UPDATE' | 'DELETE',
-  changes?: object,
-  context?: AuditContext
-) {
-  return prisma.auditLog.create({
-    data: {
-      entityType,
-      entityId,
-      action,
-      changes: changes ? JSON.parse(JSON.stringify(changes)) : null,
-      userId: context?.userId,
-      ipAddress: context?.ipAddress,
-      userAgent: context?.userAgent
-    }
-  })
-}
-```
-
-## Change Detection
-
-```typescript
-// lib/audit.ts
-export function detectChanges(
-  before: Record<string, any>,
-  after: Record<string, any>
-) {
-  const changes: Record<string, { from: any; to: any }> = {}
-
-  for (const key of Object.keys(after)) {
-    if (JSON.stringify(before[key]) !== JSON.stringify(after[key])) {
-      changes[key] = {
-        from: before[key],
-        to: after[key]
-      }
-    }
-  }
-
-  return Object.keys(changes).length > 0 ? changes : null
-}
-```
-
-## Audited Update
-
-```typescript
-// lib/users.ts
-import { prisma } from '@/lib/db'
-import { createAuditLog, detectChanges } from '@/lib/audit'
-
-export async function updateUser(
-  id: string,
-  data: Partial<User>,
-  context: AuditContext
-) {
-  // Get current state
-  const before = await prisma.user.findUnique({ where: { id } })
-  if (!before) throw new Error('User not found')
-
-  // Update
-  const after = await prisma.user.update({
-    where: { id },
-    data
-  })
-
-  // Log changes
-  const changes = detectChanges(before, after)
-  if (changes) {
-    await createAuditLog('User', id, 'UPDATE', changes, context)
-  }
-
-  return after
-}
-```
-
-## Prisma Middleware Approach
-
-```typescript
-// lib/db.ts
-import { PrismaClient } from '@prisma/client'
-
-const prisma = new PrismaClient()
-
-// Global audit middleware
-prisma.$use(async (params, next) => {
-  const result = await next(params)
-
-  // Skip audit log model itself
-  if (params.model === 'AuditLog') return result
-
-  // Log mutations
-  if (['create', 'update', 'delete'].includes(params.action)) {
-    await prisma.auditLog.create({
-      data: {
-        entityType: params.model!,
-        entityId: result?.id || params.args.where?.id,
-        action: params.action.toUpperCase(),
-        changes: params.args.data
-      }
-    })
-  }
-
-  return result
-})
-
-export { prisma }
-```
-
-## Query Audit History
-
-```typescript
-// lib/audit.ts
-export async function getEntityHistory(
-  entityType: string,
-  entityId: string
-) {
-  return prisma.auditLog.findMany({
-    where: { entityType, entityId },
-    orderBy: { createdAt: 'desc' },
-    include: { user: { select: { name: true, email: true } } }
-  })
-}
-
-export async function getUserActivity(userId: string, limit = 50) {
-  return prisma.auditLog.findMany({
-    where: { userId },
-    orderBy: { createdAt: 'desc' },
-    take: limit
-  })
-}
-```
-
-## When to Use
-
-- Compliance requirements (HIPAA, SOX)
-- Debug and troubleshooting
-- User activity tracking
-- Undo functionality