@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/files/download.md

@@ -1,243 +0,0 @@
-# File Download Patterns
-
-Patterns for serving file downloads.
-
-## Basic File Download
-
-```typescript
-// app/api/download/[filename]/route.ts
-import { readFile, stat } from 'fs/promises'
-import { join } from 'path'
-import { NextRequest, NextResponse } from 'next/server'
-
-const UPLOAD_DIR = join(process.cwd(), 'uploads')
-
-export async function GET(
-  request: NextRequest,
-  { params }: { params: { filename: string } }
-) {
-  const filePath = join(UPLOAD_DIR, params.filename)
-
-  try {
-    const fileBuffer = await readFile(filePath)
-    const stats = await stat(filePath)
-
-    return new NextResponse(fileBuffer, {
-      headers: {
-        'Content-Type': 'application/octet-stream',
-        'Content-Disposition': `attachment; filename="${params.filename}"`,
-        'Content-Length': stats.size.toString()
-      }
-    })
-  } catch {
-    return NextResponse.json({ error: 'File not found' }, { status: 404 })
-  }
-}
-```
-
-## Protected Download
-
-```typescript
-// app/api/files/[id]/download/route.ts
-import { auth } from '@/auth'
-import { getPresignedDownloadUrl } from '@/lib/s3'
-
-export async function GET(
-  request: Request,
-  { params }: { params: { id: string } }
-) {
-  const session = await auth()
-  if (!session) {
-    return Response.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  // Check file access
-  const file = await prisma.file.findUnique({
-    where: { id: params.id }
-  })
-
-  if (!file) {
-    return Response.json({ error: 'File not found' }, { status: 404 })
-  }
-
-  if (file.userId !== session.user.id) {
-    return Response.json({ error: 'Forbidden' }, { status: 403 })
-  }
-
-  // Generate temporary download URL
-  const downloadUrl = await getPresignedDownloadUrl(file.s3Key)
-
-  return Response.redirect(downloadUrl)
-}
-```
-
-## Streaming Large Files
-
-```typescript
-// app/api/download/large/route.ts
-import { createReadStream, statSync } from 'fs'
-import { join } from 'path'
-
-export async function GET(request: Request) {
-  const filePath = join(process.cwd(), 'large-file.zip')
-  const stats = statSync(filePath)
-
-  // Create readable stream
-  const stream = createReadStream(filePath)
-
-  // Convert to web stream
-  const webStream = new ReadableStream({
-    start(controller) {
-      stream.on('data', (chunk) => controller.enqueue(chunk))
-      stream.on('end', () => controller.close())
-      stream.on('error', (err) => controller.error(err))
-    }
-  })
-
-  return new Response(webStream, {
-    headers: {
-      'Content-Type': 'application/zip',
-      'Content-Disposition': 'attachment; filename="large-file.zip"',
-      'Content-Length': stats.size.toString()
-    }
-  })
-}
-```
-
-## Range Requests (Resume Support)
-
-```typescript
-// app/api/download/resumable/route.ts
-import { createReadStream, statSync } from 'fs'
-
-export async function GET(request: Request) {
-  const filePath = '/path/to/large-file.mp4'
-  const stats = statSync(filePath)
-  const fileSize = stats.size
-
-  const range = request.headers.get('range')
-
-  if (range) {
-    const parts = range.replace(/bytes=/, '').split('-')
-    const start = parseInt(parts[0], 10)
-    const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1
-    const chunkSize = end - start + 1
-
-    const stream = createReadStream(filePath, { start, end })
-
-    return new Response(stream as any, {
-      status: 206,
-      headers: {
-        'Content-Range': `bytes ${start}-${end}/${fileSize}`,
-        'Accept-Ranges': 'bytes',
-        'Content-Length': chunkSize.toString(),
-        'Content-Type': 'video/mp4'
-      }
-    })
-  }
-
-  const stream = createReadStream(filePath)
-
-  return new Response(stream as any, {
-    headers: {
-      'Content-Length': fileSize.toString(),
-      'Content-Type': 'video/mp4',
-      'Accept-Ranges': 'bytes'
-    }
-  })
-}
-```
-
-## Generate and Download
-
-```typescript
-// app/api/export/csv/route.ts
-import { auth } from '@/auth'
-
-export async function GET(request: Request) {
-  const session = await auth()
-  if (!session) {
-    return Response.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  // Fetch data
-  const users = await prisma.user.findMany({
-    select: { name: true, email: true, createdAt: true }
-  })
-
-  // Generate CSV
-  const headers = ['Name', 'Email', 'Created At']
-  const rows = users.map(u => [
-    u.name ?? '',
-    u.email,
-    u.createdAt.toISOString()
-  ])
-
-  const csv = [
-    headers.join(','),
-    ...rows.map(r => r.map(c => `"${c}"`).join(','))
-  ].join('\n')
-
-  return new Response(csv, {
-    headers: {
-      'Content-Type': 'text/csv',
-      'Content-Disposition': `attachment; filename="users-${Date.now()}.csv"`
-    }
-  })
-}
-```
-
-## PDF Generation
-
-```typescript
-// app/api/invoice/[id]/pdf/route.ts
-import { jsPDF } from 'jspdf'
-
-export async function GET(
-  request: Request,
-  { params }: { params: { id: string } }
-) {
-  const invoice = await prisma.invoice.findUnique({
-    where: { id: params.id },
-    include: { items: true, customer: true }
-  })
-
-  if (!invoice) {
-    return Response.json({ error: 'Not found' }, { status: 404 })
-  }
-
-  // Generate PDF
-  const doc = new jsPDF()
-
-  doc.setFontSize(20)
-  doc.text(`Invoice #${invoice.number}`, 20, 20)
-
-  doc.setFontSize(12)
-  doc.text(`Customer: ${invoice.customer.name}`, 20, 40)
-  doc.text(`Date: ${invoice.date.toLocaleDateString()}`, 20, 50)
-
-  let y = 70
-  invoice.items.forEach(item => {
-    doc.text(`${item.name} - $${item.price}`, 20, y)
-    y += 10
-  })
-
-  doc.text(`Total: $${invoice.total}`, 20, y + 10)
-
-  const pdfBuffer = Buffer.from(doc.output('arraybuffer'))
-
-  return new Response(pdfBuffer, {
-    headers: {
-      'Content-Type': 'application/pdf',
-      'Content-Disposition': `attachment; filename="invoice-${invoice.number}.pdf"`
-    }
-  })
-}
-```
-
-## When to Use
-
-- File downloads
-- Report exports
-- Invoice generation
-- Large file streaming

package/skills/patterns/files/upload.md

@@ -1,239 +0,0 @@
-# File Upload Patterns
-
-Patterns for handling file uploads.
-
-## Basic Upload API
-
-```typescript
-// app/api/upload/route.ts
-import { writeFile, mkdir } from 'fs/promises'
-import { join } from 'path'
-import { NextRequest, NextResponse } from 'next/server'
-
-const UPLOAD_DIR = join(process.cwd(), 'uploads')
-
-export async function POST(request: NextRequest) {
-  const formData = await request.formData()
-  const file = formData.get('file') as File | null
-
-  if (!file) {
-    return NextResponse.json({ error: 'No file provided' }, { status: 400 })
-  }
-
-  // Validate file type
-  const allowedTypes = ['image/jpeg', 'image/png', 'image/webp']
-  if (!allowedTypes.includes(file.type)) {
-    return NextResponse.json({ error: 'Invalid file type' }, { status: 400 })
-  }
-
-  // Validate file size (5MB)
-  if (file.size > 5 * 1024 * 1024) {
-    return NextResponse.json({ error: 'File too large' }, { status: 400 })
-  }
-
-  // Generate unique filename
-  const ext = file.name.split('.').pop()
-  const filename = `${Date.now()}-${Math.random().toString(36).slice(2)}.${ext}`
-
-  // Ensure upload directory exists
-  await mkdir(UPLOAD_DIR, { recursive: true })
-
-  // Write file
-  const bytes = await file.arrayBuffer()
-  const buffer = Buffer.from(bytes)
-  await writeFile(join(UPLOAD_DIR, filename), buffer)
-
-  return NextResponse.json({
-    filename,
-    url: `/uploads/${filename}`
-  })
-}
-```
-
-## S3 Upload
-
-```typescript
-// lib/s3.ts
-import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3'
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
-
-const s3 = new S3Client({
-  region: process.env.AWS_REGION!,
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!
-  }
-})
-
-const BUCKET = process.env.AWS_S3_BUCKET!
-
-export async function uploadToS3(file: File, key: string) {
-  const buffer = Buffer.from(await file.arrayBuffer())
-
-  await s3.send(new PutObjectCommand({
-    Bucket: BUCKET,
-    Key: key,
-    Body: buffer,
-    ContentType: file.type
-  }))
-
-  return `https://${BUCKET}.s3.amazonaws.com/${key}`
-}
-
-export async function getPresignedUploadUrl(key: string, contentType: string) {
-  const command = new PutObjectCommand({
-    Bucket: BUCKET,
-    Key: key,
-    ContentType: contentType
-  })
-
-  return getSignedUrl(s3, command, { expiresIn: 3600 })
-}
-
-export async function getPresignedDownloadUrl(key: string) {
-  const command = new GetObjectCommand({
-    Bucket: BUCKET,
-    Key: key
-  })
-
-  return getSignedUrl(s3, command, { expiresIn: 3600 })
-}
-```
-
-## Presigned Upload Flow
-
-```typescript
-// app/api/upload/presign/route.ts
-import { getPresignedUploadUrl } from '@/lib/s3'
-import { auth } from '@/auth'
-
-export async function POST(request: Request) {
-  const session = await auth()
-  if (!session) {
-    return Response.json({ error: 'Unauthorized' }, { status: 401 })
-  }
-
-  const { filename, contentType } = await request.json()
-
-  const key = `uploads/${session.user.id}/${Date.now()}-${filename}`
-  const uploadUrl = await getPresignedUploadUrl(key, contentType)
-
-  return Response.json({ uploadUrl, key })
-}
-
-// Client-side upload
-async function uploadFile(file: File) {
-  // Get presigned URL
-  const { uploadUrl, key } = await fetch('/api/upload/presign', {
-    method: 'POST',
-    body: JSON.stringify({
-      filename: file.name,
-      contentType: file.type
-    })
-  }).then(r => r.json())
-
-  // Upload directly to S3
-  await fetch(uploadUrl, {
-    method: 'PUT',
-    body: file,
-    headers: { 'Content-Type': file.type }
-  })
-
-  return key
-}
-```
-
-## UploadThing Integration
-
-```typescript
-// lib/uploadthing.ts
-import { createUploadthing, type FileRouter } from 'uploadthing/next'
-import { auth } from '@/auth'
-
-const f = createUploadthing()
-
-export const uploadRouter = {
-  imageUploader: f({ image: { maxFileSize: '4MB', maxFileCount: 4 } })
-    .middleware(async () => {
-      const session = await auth()
-      if (!session) throw new Error('Unauthorized')
-      return { userId: session.user.id }
-    })
-    .onUploadComplete(async ({ metadata, file }) => {
-      await prisma.upload.create({
-        data: {
-          userId: metadata.userId,
-          url: file.url,
-          name: file.name,
-          size: file.size
-        }
-      })
-      return { url: file.url }
-    }),
-
-  documentUploader: f({ pdf: { maxFileSize: '16MB' } })
-    .middleware(async () => {
-      const session = await auth()
-      if (!session) throw new Error('Unauthorized')
-      return { userId: session.user.id }
-    })
-    .onUploadComplete(async ({ file }) => {
-      return { url: file.url }
-    })
-} satisfies FileRouter
-
-export type OurFileRouter = typeof uploadRouter
-
-// app/api/uploadthing/route.ts
-import { createRouteHandler } from 'uploadthing/next'
-import { uploadRouter } from '@/lib/uploadthing'
-
-export const { GET, POST } = createRouteHandler({ router: uploadRouter })
-```
-
-## Image Processing
-
-```typescript
-// lib/image.ts
-import sharp from 'sharp'
-
-export async function processImage(buffer: Buffer) {
-  // Resize and optimize
-  const processed = await sharp(buffer)
-    .resize(1200, 1200, { fit: 'inside', withoutEnlargement: true })
-    .webp({ quality: 80 })
-    .toBuffer()
-
-  // Generate thumbnail
-  const thumbnail = await sharp(buffer)
-    .resize(200, 200, { fit: 'cover' })
-    .webp({ quality: 70 })
-    .toBuffer()
-
-  return { processed, thumbnail }
-}
-
-// Usage in upload handler
-export async function POST(request: NextRequest) {
-  const formData = await request.formData()
-  const file = formData.get('file') as File
-
-  const buffer = Buffer.from(await file.arrayBuffer())
-  const { processed, thumbnail } = await processImage(buffer)
-
-  // Upload both versions
-  const [imageUrl, thumbUrl] = await Promise.all([
-    uploadToS3(processed, `images/${filename}.webp`),
-    uploadToS3(thumbnail, `thumbnails/${filename}.webp`)
-  ])
-
-  return Response.json({ imageUrl, thumbUrl })
-}
-```
-
-## When to Use
-
-- User uploads
-- Profile pictures
-- Document storage
-- Media galleries

package/skills/patterns/i18n/nextintl.md

@@ -1,188 +0,0 @@
-# Next-Intl Patterns
-
-Patterns for internationalization with next-intl.
-
-## Setup
-
-```typescript
-// i18n.ts
-import { notFound } from 'next/navigation'
-import { getRequestConfig } from 'next-intl/server'
-
-export const locales = ['en', 'es', 'fr', 'de'] as const
-export type Locale = (typeof locales)[number]
-export const defaultLocale: Locale = 'en'
-
-export default getRequestConfig(async ({ locale }) => {
-  if (!locales.includes(locale as Locale)) notFound()
-
-  return {
-    messages: (await import(`./messages/${locale}.json`)).default
-  }
-})
-
-// middleware.ts
-import createMiddleware from 'next-intl/middleware'
-import { locales, defaultLocale } from './i18n'
-
-export default createMiddleware({
-  locales,
-  defaultLocale,
-  localePrefix: 'as-needed'
-})
-
-export const config = {
-  matcher: ['/((?!api|_next|.*\\..*).*)']
-}
-```
-
-## Message Files
-
-```json
-// messages/en.json
-{
-  "common": {
-    "welcome": "Welcome",
-    "login": "Log in",
-    "logout": "Log out"
-  },
-  "home": {
-    "title": "Welcome to {name}",
-    "description": "The best platform for {purpose}"
-  },
-  "products": {
-    "count": "{count, plural, =0 {No products} =1 {1 product} other {# products}}"
-  }
-}
-
-// messages/es.json
-{
-  "common": {
-    "welcome": "Bienvenido",
-    "login": "Iniciar sesión",
-    "logout": "Cerrar sesión"
-  }
-}
-```
-
-## Using Translations
-
-```tsx
-// app/[locale]/page.tsx
-import { useTranslations } from 'next-intl'
-
-export default function HomePage() {
-  const t = useTranslations('home')
-
-  return (
-    <div>
-      <h1>{t('title', { name: 'MyApp' })}</h1>
-      <p>{t('description', { purpose: 'collaboration' })}</p>
-    </div>
-  )
-}
-
-// With pluralization
-function ProductCount({ count }: { count: number }) {
-  const t = useTranslations('products')
-  return <span>{t('count', { count })}</span>
-}
-```
-
-## Server Components
-
-```tsx
-// app/[locale]/products/page.tsx
-import { getTranslations } from 'next-intl/server'
-
-export async function generateMetadata({ params: { locale } }: Props) {
-  const t = await getTranslations({ locale, namespace: 'products' })
-
-  return {
-    title: t('pageTitle')
-  }
-}
-
-export default async function ProductsPage() {
-  const t = await getTranslations('products')
-  const products = await getProducts()
-
-  return (
-    <div>
-      <h1>{t('title')}</h1>
-      <p>{t('count', { count: products.length })}</p>
-    </div>
-  )
-}
-```
-
-## Language Switcher
-
-```tsx
-// components/LanguageSwitcher.tsx
-'use client'
-
-import { useLocale } from 'next-intl'
-import { usePathname, useRouter } from 'next-intl/client'
-import { locales } from '@/i18n'
-
-const localeNames: Record<string, string> = {
-  en: 'English',
-  es: 'Español',
-  fr: 'Français',
-  de: 'Deutsch'
-}
-
-export function LanguageSwitcher() {
-  const locale = useLocale()
-  const router = useRouter()
-  const pathname = usePathname()
-
-  const handleChange = (newLocale: string) => {
-    router.replace(pathname, { locale: newLocale })
-  }
-
-  return (
-    <select
-      value={locale}
-      onChange={(e) => handleChange(e.target.value)}
-      className="rounded border px-2 py-1"
-    >
-      {locales.map(loc => (
-        <option key={loc} value={loc}>
-          {localeNames[loc]}
-        </option>
-      ))}
-    </select>
-  )
-}
-```
-
-## Date and Number Formatting
-
-```tsx
-// components/FormattedContent.tsx
-import { useFormatter } from 'next-intl'
-
-export function FormattedContent() {
-  const format = useFormatter()
-
-  const price = 1234.56
-  const date = new Date()
-
-  return (
-    <div>
-      <p>Price: {format.number(price, { style: 'currency', currency: 'USD' })}</p>
-      <p>Date: {format.dateTime(date, { dateStyle: 'long' })}</p>
-      <p>Relative: {format.relativeTime(date)}</p>
-    </div>
-  )
-}
-```
-
-## When to Use
-
-- Multi-language apps
-- Regional content
-- Date/number formatting
-- RTL support