@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/database/migrations.md

@@ -1,177 +0,0 @@
-# Database Migration Patterns
-
-Patterns for managing database migrations with Prisma.
-
-## Development Migration
-
-```bash
-# Create and apply migration
-npx prisma migrate dev --name add_user_role
-
-# Reset database (drops all data!)
-npx prisma migrate reset
-
-# Generate Prisma client only
-npx prisma generate
-```
-
-## Production Migration
-
-```bash
-# Apply pending migrations
-npx prisma migrate deploy
-
-# Check migration status
-npx prisma migrate status
-```
-
-## Data Migration Script
-
-```typescript
-// scripts/migrate-add-slugs.ts
-import { prisma } from '@/lib/db'
-import { slugify } from '@/lib/utils'
-
-async function migrate() {
-  const posts = await prisma.post.findMany({
-    where: { slug: null }
-  })
-
-  console.log(`Migrating ${posts.length} posts...`)
-
-  for (const post of posts) {
-    const slug = slugify(post.title)
-
-    await prisma.post.update({
-      where: { id: post.id },
-      data: { slug }
-    })
-  }
-
-  console.log('Migration complete')
-}
-
-migrate()
-  .catch(console.error)
-  .finally(() => prisma.$disconnect())
-```
-
-## Batch Data Migration
-
-```typescript
-// scripts/migrate-batch.ts
-import { prisma } from '@/lib/db'
-
-const BATCH_SIZE = 100
-
-async function migrate() {
-  let processed = 0
-  let hasMore = true
-
-  while (hasMore) {
-    const users = await prisma.user.findMany({
-      where: { migratedAt: null },
-      take: BATCH_SIZE
-    })
-
-    if (users.length === 0) {
-      hasMore = false
-      continue
-    }
-
-    await prisma.$transaction(
-      users.map((user) =>
-        prisma.user.update({
-          where: { id: user.id },
-          data: {
-            // Migration logic
-            displayName: user.name || user.email.split('@')[0],
-            migratedAt: new Date()
-          }
-        })
-      )
-    )
-
-    processed += users.length
-    console.log(`Processed ${processed} users...`)
-  }
-
-  console.log(`Migration complete: ${processed} users`)
-}
-
-migrate()
-  .catch(console.error)
-  .finally(() => prisma.$disconnect())
-```
-
-## Reversible Migration
-
-```typescript
-// scripts/migrate-reversible.ts
-import { prisma } from '@/lib/db'
-
-async function up() {
-  // Add new column with default
-  await prisma.$executeRaw`
-    ALTER TABLE "User" ADD COLUMN "status" TEXT DEFAULT 'ACTIVE'
-  `
-
-  // Populate based on existing data
-  await prisma.$executeRaw`
-    UPDATE "User" SET "status" = 'INACTIVE'
-    WHERE "lastLoginAt" < NOW() - INTERVAL '90 days'
-  `
-}
-
-async function down() {
-  await prisma.$executeRaw`
-    ALTER TABLE "User" DROP COLUMN "status"
-  `
-}
-
-// Run with: npx ts-node scripts/migrate-reversible.ts up
-const direction = process.argv[2]
-
-if (direction === 'up') {
-  up().then(() => console.log('Migration up complete'))
-} else if (direction === 'down') {
-  down().then(() => console.log('Migration down complete'))
-} else {
-  console.log('Usage: npx ts-node script.ts [up|down]')
-}
-```
-
-## Safe Schema Changes
-
-```typescript
-// Approach for zero-downtime migrations
-
-// 1. Add new column (nullable)
-// schema.prisma: newField String?
-
-// 2. Deploy code that writes to both columns
-await prisma.user.update({
-  where: { id },
-  data: {
-    oldField: value,
-    newField: value // Write to both
-  }
-})
-
-// 3. Backfill existing data
-// scripts/backfill.ts
-
-// 4. Deploy code that reads from new column
-
-// 5. Remove old column in schema
-// schema.prisma: remove oldField
-
-// 6. Clean up code
-```
-
-## When to Use
-
-- Schema evolution
-- Data backfills
-- Column renames
-- Zero-downtime deploys

package/skills/patterns/database/pagination.md

@@ -1,230 +0,0 @@
-# Pagination Patterns
-
-Patterns for database pagination.
-
-## Offset Pagination
-
-```typescript
-// lib/pagination.ts
-interface PaginationParams {
-  page?: number
-  limit?: number
-}
-
-interface PaginatedResult<T> {
-  data: T[]
-  pagination: {
-    page: number
-    limit: number
-    total: number
-    totalPages: number
-    hasNext: boolean
-    hasPrev: boolean
-  }
-}
-
-export async function paginate<T>(
-  model: any,
-  params: PaginationParams,
-  options?: {
-    where?: object
-    orderBy?: object
-    include?: object
-  }
-): Promise<PaginatedResult<T>> {
-  const page = Math.max(1, params.page ?? 1)
-  const limit = Math.min(100, Math.max(1, params.limit ?? 10))
-  const skip = (page - 1) * limit
-
-  const [data, total] = await Promise.all([
-    model.findMany({
-      ...options,
-      skip,
-      take: limit
-    }),
-    model.count({ where: options?.where })
-  ])
-
-  const totalPages = Math.ceil(total / limit)
-
-  return {
-    data,
-    pagination: {
-      page,
-      limit,
-      total,
-      totalPages,
-      hasNext: page < totalPages,
-      hasPrev: page > 1
-    }
-  }
-}
-
-// Usage
-const result = await paginate(prisma.post, { page: 2, limit: 10 }, {
-  where: { published: true },
-  orderBy: { createdAt: 'desc' }
-})
-```
-
-## Cursor Pagination
-
-```typescript
-// lib/cursor-pagination.ts
-interface CursorPaginationParams {
-  cursor?: string
-  limit?: number
-}
-
-interface CursorPaginatedResult<T> {
-  data: T[]
-  nextCursor: string | null
-  hasMore: boolean
-}
-
-export async function cursorPaginate<T extends { id: string }>(
-  model: any,
-  params: CursorPaginationParams,
-  options?: {
-    where?: object
-    orderBy?: object
-    include?: object
-  }
-): Promise<CursorPaginatedResult<T>> {
-  const limit = Math.min(100, Math.max(1, params.limit ?? 10))
-
-  const data = await model.findMany({
-    ...options,
-    take: limit + 1,
-    ...(params.cursor && {
-      cursor: { id: params.cursor },
-      skip: 1
-    })
-  })
-
-  const hasMore = data.length > limit
-  const items = hasMore ? data.slice(0, -1) : data
-
-  return {
-    data: items,
-    nextCursor: hasMore ? items[items.length - 1].id : null,
-    hasMore
-  }
-}
-
-// Usage
-const result = await cursorPaginate(prisma.post, {
-  cursor: lastPostId,
-  limit: 20
-}, {
-  orderBy: { createdAt: 'desc' }
-})
-```
-
-## API Route with Pagination
-
-```typescript
-// app/api/posts/route.ts
-import { paginate } from '@/lib/pagination'
-
-export async function GET(request: Request) {
-  const { searchParams } = new URL(request.url)
-
-  const page = parseInt(searchParams.get('page') ?? '1')
-  const limit = parseInt(searchParams.get('limit') ?? '10')
-
-  const result = await paginate(prisma.post, { page, limit }, {
-    where: { published: true },
-    orderBy: { createdAt: 'desc' },
-    include: { author: true }
-  })
-
-  return Response.json(result)
-}
-```
-
-## Pagination Component
-
-```tsx
-// components/Pagination.tsx
-'use client'
-
-import Link from 'next/link'
-import { useSearchParams } from 'next/navigation'
-import { ChevronLeft, ChevronRight } from 'lucide-react'
-
-interface Props {
-  totalPages: number
-  basePath: string
-}
-
-export function Pagination({ totalPages, basePath }: Props) {
-  const searchParams = useSearchParams()
-  const currentPage = parseInt(searchParams.get('page') ?? '1')
-
-  const createPageUrl = (page: number) => {
-    const params = new URLSearchParams(searchParams)
-    params.set('page', page.toString())
-    return `${basePath}?${params.toString()}`
-  }
-
-  const pages = getPageNumbers(currentPage, totalPages)
-
-  return (
-    <nav className="flex items-center gap-2">
-      <Link
-        href={createPageUrl(currentPage - 1)}
-        className={`p-2 ${currentPage <= 1 ? 'pointer-events-none opacity-50' : ''}`}
-      >
-        <ChevronLeft className="h-5 w-5" />
-      </Link>
-
-      {pages.map((page, i) => (
-        page === '...' ? (
-          <span key={i} className="px-2">...</span>
-        ) : (
-          <Link
-            key={i}
-            href={createPageUrl(page as number)}
-            className={`rounded px-3 py-1 ${
-              currentPage === page ? 'bg-blue-600 text-white' : 'hover:bg-gray-100'
-            }`}
-          >
-            {page}
-          </Link>
-        )
-      ))}
-
-      <Link
-        href={createPageUrl(currentPage + 1)}
-        className={`p-2 ${currentPage >= totalPages ? 'pointer-events-none opacity-50' : ''}`}
-      >
-        <ChevronRight className="h-5 w-5" />
-      </Link>
-    </nav>
-  )
-}
-
-function getPageNumbers(current: number, total: number): (number | '...')[] {
-  if (total <= 7) {
-    return Array.from({ length: total }, (_, i) => i + 1)
-  }
-
-  if (current <= 3) {
-    return [1, 2, 3, 4, 5, '...', total]
-  }
-
-  if (current >= total - 2) {
-    return [1, '...', total - 4, total - 3, total - 2, total - 1, total]
-  }
-
-  return [1, '...', current - 1, current, current + 1, '...', total]
-}
-```
-
-## When to Use
-
-- List views
-- Search results
-- Data tables
-- Infinite scroll