@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/state/zustand.md

@@ -1,262 +0,0 @@
-# Zustand State Management Patterns
-
-Patterns for state management with Zustand.
-
-## Basic Store
-
-```typescript
-// stores/useStore.ts
-import { create } from 'zustand'
-
-interface CounterStore {
-  count: number
-  increment: () => void
-  decrement: () => void
-  reset: () => void
-}
-
-export const useCounterStore = create<CounterStore>((set) => ({
-  count: 0,
-  increment: () => set((state) => ({ count: state.count + 1 })),
-  decrement: () => set((state) => ({ count: state.count - 1 })),
-  reset: () => set({ count: 0 })
-}))
-
-// Usage
-function Counter() {
-  const { count, increment, decrement } = useCounterStore()
-
-  return (
-    <div>
-      <span>{count}</span>
-      <button onClick={increment}>+</button>
-      <button onClick={decrement}>-</button>
-    </div>
-  )
-}
-```
-
-## Typed Store with Slices
-
-```typescript
-// stores/useAppStore.ts
-import { create } from 'zustand'
-
-interface User {
-  id: string
-  name: string
-  email: string
-}
-
-interface UserSlice {
-  user: User | null
-  setUser: (user: User | null) => void
-  logout: () => void
-}
-
-interface UISlice {
-  sidebarOpen: boolean
-  theme: 'light' | 'dark'
-  toggleSidebar: () => void
-  setTheme: (theme: 'light' | 'dark') => void
-}
-
-interface AppStore extends UserSlice, UISlice {}
-
-export const useAppStore = create<AppStore>((set) => ({
-  // User slice
-  user: null,
-  setUser: (user) => set({ user }),
-  logout: () => set({ user: null }),
-
-  // UI slice
-  sidebarOpen: true,
-  theme: 'light',
-  toggleSidebar: () => set((state) => ({ sidebarOpen: !state.sidebarOpen })),
-  setTheme: (theme) => set({ theme })
-}))
-
-// Select specific values to avoid re-renders
-function Sidebar() {
-  const sidebarOpen = useAppStore((state) => state.sidebarOpen)
-  const toggleSidebar = useAppStore((state) => state.toggleSidebar)
-
-  return sidebarOpen ? <nav>...</nav> : null
-}
-```
-
-## Persist Middleware
-
-```typescript
-// stores/useSettingsStore.ts
-import { create } from 'zustand'
-import { persist, createJSONStorage } from 'zustand/middleware'
-
-interface SettingsStore {
-  notifications: boolean
-  language: string
-  setNotifications: (enabled: boolean) => void
-  setLanguage: (lang: string) => void
-}
-
-export const useSettingsStore = create<SettingsStore>()(
-  persist(
-    (set) => ({
-      notifications: true,
-      language: 'en',
-      setNotifications: (enabled) => set({ notifications: enabled }),
-      setLanguage: (language) => set({ language })
-    }),
-    {
-      name: 'settings',
-      storage: createJSONStorage(() => localStorage),
-      partialize: (state) => ({
-        notifications: state.notifications,
-        language: state.language
-      })
-    }
-  )
-)
-```
-
-## Async Actions
-
-```typescript
-// stores/useProductStore.ts
-import { create } from 'zustand'
-
-interface Product {
-  id: string
-  name: string
-  price: number
-}
-
-interface ProductStore {
-  products: Product[]
-  loading: boolean
-  error: string | null
-  fetchProducts: () => Promise<void>
-  addProduct: (product: Omit<Product, 'id'>) => Promise<void>
-}
-
-export const useProductStore = create<ProductStore>((set, get) => ({
-  products: [],
-  loading: false,
-  error: null,
-
-  fetchProducts: async () => {
-    set({ loading: true, error: null })
-
-    try {
-      const response = await fetch('/api/products')
-      const products = await response.json()
-      set({ products, loading: false })
-    } catch (error) {
-      set({ error: 'Failed to fetch products', loading: false })
-    }
-  },
-
-  addProduct: async (productData) => {
-    try {
-      const response = await fetch('/api/products', {
-        method: 'POST',
-        body: JSON.stringify(productData)
-      })
-      const product = await response.json()
-      set({ products: [...get().products, product] })
-    } catch (error) {
-      set({ error: 'Failed to add product' })
-    }
-  }
-}))
-```
-
-## Computed Values
-
-```typescript
-// stores/useCartStore.ts
-import { create } from 'zustand'
-
-interface CartItem {
-  id: string
-  name: string
-  price: number
-  quantity: number
-}
-
-interface CartStore {
-  items: CartItem[]
-  addItem: (item: Omit<CartItem, 'quantity'>) => void
-  removeItem: (id: string) => void
-  updateQuantity: (id: string, quantity: number) => void
-  clearCart: () => void
-}
-
-export const useCartStore = create<CartStore>((set) => ({
-  items: [],
-
-  addItem: (item) => set((state) => {
-    const existing = state.items.find(i => i.id === item.id)
-
-    if (existing) {
-      return {
-        items: state.items.map(i =>
-          i.id === item.id ? { ...i, quantity: i.quantity + 1 } : i
-        )
-      }
-    }
-
-    return { items: [...state.items, { ...item, quantity: 1 }] }
-  }),
-
-  removeItem: (id) => set((state) => ({
-    items: state.items.filter(i => i.id !== id)
-  })),
-
-  updateQuantity: (id, quantity) => set((state) => ({
-    items: state.items.map(i =>
-      i.id === id ? { ...i, quantity } : i
-    ).filter(i => i.quantity > 0)
-  })),
-
-  clearCart: () => set({ items: [] })
-}))
-
-// Computed selectors
-export const useCartTotal = () =>
-  useCartStore((state) =>
-    state.items.reduce((sum, item) => sum + item.price * item.quantity, 0)
-  )
-
-export const useCartCount = () =>
-  useCartStore((state) =>
-    state.items.reduce((sum, item) => sum + item.quantity, 0)
-  )
-```
-
-## DevTools
-
-```typescript
-// stores/useStore.ts
-import { create } from 'zustand'
-import { devtools } from 'zustand/middleware'
-
-export const useStore = create<Store>()(
-  devtools(
-    (set) => ({
-      // ... store implementation
-    }),
-    {
-      name: 'MyApp',
-      enabled: process.env.NODE_ENV === 'development'
-    }
-  )
-)
-```
-
-## When to Use
-
-- Client-side state
-- UI state
-- Cart/wishlist
-- User preferences

package/skills/patterns/testing/api.md

@@ -1,259 +0,0 @@
-# API Testing Patterns
-
-Patterns for testing API routes.
-
-## Basic API Route Test
-
-```typescript
-// __tests__/api/users.test.ts
-import { GET, POST } from '@/app/api/users/route'
-import { prisma } from '@/lib/db'
-
-// Mock Prisma
-vi.mock('@/lib/db', () => ({
-  prisma: {
-    user: {
-      findMany: vi.fn(),
-      create: vi.fn()
-    }
-  }
-}))
-
-describe('GET /api/users', () => {
-  it('returns list of users', async () => {
-    const mockUsers = [
-      { id: '1', name: 'Alice', email: 'alice@example.com' },
-      { id: '2', name: 'Bob', email: 'bob@example.com' }
-    ]
-
-    vi.mocked(prisma.user.findMany).mockResolvedValue(mockUsers)
-
-    const request = new Request('http://localhost/api/users')
-    const response = await GET(request)
-    const data = await response.json()
-
-    expect(response.status).toBe(200)
-    expect(data).toEqual(mockUsers)
-  })
-})
-
-describe('POST /api/users', () => {
-  it('creates a new user', async () => {
-    const newUser = { id: '1', name: 'Alice', email: 'alice@example.com' }
-
-    vi.mocked(prisma.user.create).mockResolvedValue(newUser)
-
-    const request = new Request('http://localhost/api/users', {
-      method: 'POST',
-      body: JSON.stringify({ name: 'Alice', email: 'alice@example.com' })
-    })
-
-    const response = await POST(request)
-    const data = await response.json()
-
-    expect(response.status).toBe(201)
-    expect(data).toEqual(newUser)
-  })
-
-  it('returns 400 for invalid data', async () => {
-    const request = new Request('http://localhost/api/users', {
-      method: 'POST',
-      body: JSON.stringify({ name: '' }) // Missing email
-    })
-
-    const response = await POST(request)
-
-    expect(response.status).toBe(400)
-  })
-})
-```
-
-## Testing with Authentication
-
-```typescript
-// __tests__/api/protected.test.ts
-import { GET } from '@/app/api/protected/route'
-import { auth } from '@/auth'
-
-vi.mock('@/auth', () => ({
-  auth: vi.fn()
-}))
-
-describe('GET /api/protected', () => {
-  it('returns 401 for unauthenticated requests', async () => {
-    vi.mocked(auth).mockResolvedValue(null)
-
-    const request = new Request('http://localhost/api/protected')
-    const response = await GET(request)
-
-    expect(response.status).toBe(401)
-  })
-
-  it('returns data for authenticated users', async () => {
-    vi.mocked(auth).mockResolvedValue({
-      user: { id: '1', name: 'Test User' }
-    })
-
-    const request = new Request('http://localhost/api/protected')
-    const response = await GET(request)
-
-    expect(response.status).toBe(200)
-  })
-})
-```
-
-## Testing with MSW
-
-```typescript
-// __tests__/api/external.test.ts
-import { server } from '@/mocks/server'
-import { http, HttpResponse } from 'msw'
-import { fetchExternalData } from '@/lib/external'
-
-describe('External API calls', () => {
-  it('handles successful response', async () => {
-    server.use(
-      http.get('https://api.external.com/data', () => {
-        return HttpResponse.json({ result: 'success' })
-      })
-    )
-
-    const data = await fetchExternalData()
-    expect(data.result).toBe('success')
-  })
-
-  it('handles error response', async () => {
-    server.use(
-      http.get('https://api.external.com/data', () => {
-        return HttpResponse.json({ error: 'Not found' }, { status: 404 })
-      })
-    )
-
-    await expect(fetchExternalData()).rejects.toThrow('Not found')
-  })
-
-  it('handles network error', async () => {
-    server.use(
-      http.get('https://api.external.com/data', () => {
-        return HttpResponse.error()
-      })
-    )
-
-    await expect(fetchExternalData()).rejects.toThrow()
-  })
-})
-```
-
-## Testing Webhooks
-
-```typescript
-// __tests__/api/webhooks/stripe.test.ts
-import { POST } from '@/app/api/webhooks/stripe/route'
-import Stripe from 'stripe'
-
-vi.mock('stripe', () => ({
-  default: vi.fn(() => ({
-    webhooks: {
-      constructEvent: vi.fn()
-    }
-  }))
-}))
-
-describe('POST /api/webhooks/stripe', () => {
-  it('handles checkout.session.completed', async () => {
-    const mockEvent = {
-      type: 'checkout.session.completed',
-      data: {
-        object: {
-          id: 'cs_123',
-          customer: 'cus_123',
-          metadata: { userId: 'user_123' }
-        }
-      }
-    }
-
-    vi.mocked(Stripe).mockImplementation(() => ({
-      webhooks: {
-        constructEvent: vi.fn().mockReturnValue(mockEvent)
-      }
-    } as any))
-
-    const request = new Request('http://localhost/api/webhooks/stripe', {
-      method: 'POST',
-      body: JSON.stringify(mockEvent),
-      headers: { 'stripe-signature': 'test_signature' }
-    })
-
-    const response = await POST(request)
-
-    expect(response.status).toBe(200)
-  })
-
-  it('returns 400 for invalid signature', async () => {
-    vi.mocked(Stripe).mockImplementation(() => ({
-      webhooks: {
-        constructEvent: vi.fn().mockImplementation(() => {
-          throw new Error('Invalid signature')
-        })
-      }
-    } as any))
-
-    const request = new Request('http://localhost/api/webhooks/stripe', {
-      method: 'POST',
-      body: '{}',
-      headers: { 'stripe-signature': 'invalid' }
-    })
-
-    const response = await POST(request)
-
-    expect(response.status).toBe(400)
-  })
-})
-```
-
-## Integration Tests
-
-```typescript
-// __tests__/integration/user-flow.test.ts
-import { prisma } from '@/lib/db'
-import { POST as createUser } from '@/app/api/users/route'
-import { GET as getUser } from '@/app/api/users/[id]/route'
-
-describe('User flow integration', () => {
-  beforeEach(async () => {
-    await prisma.user.deleteMany()
-  })
-
-  it('creates and retrieves a user', async () => {
-    // Create user
-    const createRequest = new Request('http://localhost/api/users', {
-      method: 'POST',
-      body: JSON.stringify({
-        name: 'Test User',
-        email: 'test@example.com'
-      })
-    })
-
-    const createResponse = await createUser(createRequest)
-    const createdUser = await createResponse.json()
-
-    expect(createResponse.status).toBe(201)
-    expect(createdUser.id).toBeDefined()
-
-    // Get user
-    const getRequest = new Request(`http://localhost/api/users/${createdUser.id}`)
-    const getResponse = await getUser(getRequest, { params: { id: createdUser.id } })
-    const fetchedUser = await getResponse.json()
-
-    expect(getResponse.status).toBe(200)
-    expect(fetchedUser.name).toBe('Test User')
-  })
-})
-```
-
-## When to Use
-
-- Route handlers
-- Webhook endpoints
-- External API calls
-- Integration tests