@kood/claude-code 0.1.6 → 0.1.9

package/templates/tanstack-start/docs/library/prisma/setup.md

@@ -1,149 +1,49 @@
 # Prisma - 설치 및 설정
 
-> **상위 문서**: [Prisma](./index.md)
-
 ## 설치
 
 ```bash
-# npm
-npm install @prisma/client@7
-npm install -D prisma@7
-
-# yarn
 yarn add @prisma/client@7
 yarn add -D prisma@7
-
-# bun
-bun add @prisma/client@7
-bun add prisma@7 --dev
-
-# 초기화
 npx prisma init
 ```
 
-## v6에서 v7 업그레이드
-
-```bash
-# npm
-npm install @prisma/client@7
-npm install -D prisma@7
-
-# yarn
-yarn up prisma@7 @prisma/client@7
-```
-
-### Generator 변경 (필수)
+## v6 → v7 업그레이드
 
 ```prisma
-// schema.prisma - 이전 (v6)
+// v6 (이전)
 generator client {
   provider = "prisma-client-js"
 }
 
-// schema.prisma - v7
+// v7 (필수)
 generator client {
-  provider = "prisma-client"        // 새로운 provider
-  output   = "../generated/prisma"  // output 필수
+  provider = "prisma-client"
+  output   = "../generated/prisma"
 }
 ```
 
-## Prisma Client 설정
-
-### 기본 설정
+## Prisma Client
 
 ```typescript
 // lib/prisma.ts
-import { PrismaClient } from './generated/prisma'  // output 경로에서 import
-
-const globalForPrisma = globalThis as unknown as {
-  prisma: PrismaClient | undefined
-}
-
-export const prisma =
-  globalForPrisma.prisma ??
-  new PrismaClient({
-    log: ['query'],
-  })
-
-if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
-```
-
-### 로깅 설정
-
-```typescript
 import { PrismaClient } from './generated/prisma'
 
-const prisma = new PrismaClient({
-  log: [{ level: 'query', emit: 'event' }],
-})
-
-prisma.$on('query', (e) => {
-  console.log('Query:', e.query)
-  console.log('Params:', e.params)
-  console.log('Duration:', e.duration, 'ms')
-})
-```
-
-### QueryEvent 타입
-
-```typescript
-type QueryEvent = {
-  timestamp: Date
-  query: string
-  params: string
-  duration: number
-  target: string
-}
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient | undefined }
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({ log: ['query'] })
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
 ```
 
-## TanStack Start 통합
+## TanStack Start 연동
 
 ```typescript
-// lib/prisma.ts
-import { PrismaClient } from './generated/prisma'
-
-const globalForPrisma = globalThis as unknown as {
-  prisma: PrismaClient | undefined
-}
-
-export const prisma =
-  globalForPrisma.prisma ?? new PrismaClient()
-
-if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma
-
-// Server Function에서 사용
 import { createServerFn } from '@tanstack/react-start'
 import { prisma } from '@/lib/prisma'
 
 export const getUsers = createServerFn({ method: 'GET' })
-  .handler(async () => {
-    return prisma.user.findMany({
-      include: { posts: true },
-    })
-  })
+  .handler(async () => prisma.user.findMany({ include: { posts: true } }))
 
 export const createUser = createServerFn({ method: 'POST' })
   .inputValidator((data: { email: string; name: string }) => data)
-  .handler(async ({ data }) => {
-    return prisma.user.create({ data })
-  })
-```
-
-## 마이그레이션
-
-```bash
-# 개발 환경 마이그레이션
-npx prisma migrate dev --name init
-
-# 프로덕션 마이그레이션
-npx prisma migrate deploy
-
-# 스키마 동기화 (개발용)
-npx prisma db push
-
-# Prisma Client 생성
-npx prisma generate
-
-# Prisma Studio (GUI)
-npx prisma studio
+  .handler(async ({ data }) => prisma.user.create({ data }))
 ```

package/templates/tanstack-start/docs/library/prisma/transactions.md

@@ -1,140 +1,50 @@
 # Prisma - 트랜잭션
 
-> **상위 문서**: [Prisma](./index.md)
-
 ## 배열 기반 트랜잭션
 
-여러 쿼리를 순차적으로 실행하고, 하나라도 실패하면 모두 롤백됩니다.
-
-```typescript
-// 관계 데이터 삭제
-const deletePosts = prisma.post.deleteMany({
-  where: { authorId: 7 },
-})
-
-const deleteUser = prisma.user.delete({
-  where: { id: 7 },
-})
-
-const transaction = await prisma.$transaction([deletePosts, deleteUser])
-```
-
-## GDPR 데이터 삭제 예시
-
-```typescript
-const id = 9 // 삭제할 사용자
-
-const deletePosts = prisma.post.deleteMany({
-  where: { userId: id },
-})
-
-const deleteMessages = prisma.privateMessage.deleteMany({
-  where: { userId: id },
-})
-
-const deleteUser = prisma.user.delete({
-  where: { id: id },
-})
-
-// 모든 작업이 성공하거나 모두 실패
-await prisma.$transaction([deletePosts, deleteMessages, deleteUser])
-```
-
-## 모든 데이터 삭제
+하나라도 실패하면 모두 롤백.
 
 ```typescript
-const deletePosts = prisma.post.deleteMany()
-const deleteProfile = prisma.profile.deleteMany()
-const deleteUsers = prisma.user.deleteMany()
-
-// 순서대로 실행 (deleteUsers가 마지막)
-await prisma.$transaction([deleteProfile, deletePosts, deleteUsers])
+const deletePosts = prisma.post.deleteMany({ where: { authorId: 7 } })
+const deleteUser = prisma.user.delete({ where: { id: 7 } })
+await prisma.$transaction([deletePosts, deleteUser])
 ```
 
 ## 인터랙티브 트랜잭션
 
-더 복잡한 트랜잭션 로직이 필요할 때 사용합니다.
+복잡한 로직, 조건부 처리.
 
 ```typescript
 const result = await prisma.$transaction(async (tx) => {
-  // 1. 잔액 확인
-  const sender = await tx.account.findUnique({
-    where: { id: senderId },
-  })
-
-  if (!sender || sender.balance < amount) {
-    throw new Error('Insufficient balance')
-  }
-
-  // 2. 보내는 계좌에서 차감
-  const updatedSender = await tx.account.update({
-    where: { id: senderId },
-    data: { balance: { decrement: amount } },
-  })
+  const sender = await tx.account.findUnique({ where: { id: senderId } })
+  if (!sender || sender.balance < amount) throw new Error('Insufficient balance')
 
-  // 3. 받는 계좌에 입금
-  const updatedRecipient = await tx.account.update({
-    where: { id: recipientId },
-    data: { balance: { increment: amount } },
-  })
+  await tx.account.update({ where: { id: senderId }, data: { balance: { decrement: amount } } })
+  await tx.account.update({ where: { id: recipientId }, data: { balance: { increment: amount } } })
 
-  return { sender: updatedSender, recipient: updatedRecipient }
+  return { success: true }
 })
 ```
 
-## 트랜잭션 옵션
+## 옵션
 
 ```typescript
-await prisma.$transaction(
-  async (tx) => {
-    // 트랜잭션 로직
-  },
-  {
-    maxWait: 5000, // 최대 대기 시간 (ms)
-    timeout: 10000, // 트랜잭션 타임아웃 (ms)
-    isolationLevel: 'Serializable', // 격리 수준
-  }
-)
-```
-
-## 격리 수준
-
-```typescript
-// 가능한 격리 수준
-type IsolationLevel =
-  | 'ReadUncommitted'
-  | 'ReadCommitted'
-  | 'RepeatableRead'
-  | 'Serializable'
-```
-
-## 타입 안전 Raw Query
-
-```typescript
-import { selectUserTitles, updateUserName } from '@prisma/client/sql'
-
-const [userList, updateUser] = await prisma.$transaction([
-  prisma.$queryRawTyped(selectUserTitles()),
-  prisma.$queryRawTyped(updateUserName(2)),
-])
+await prisma.$transaction(async (tx) => { ... }, {
+  maxWait: 5000,              // 최대 대기 (ms)
+  timeout: 10000,             // 타임아웃 (ms)
+  isolationLevel: 'Serializable',  // ReadUncommitted | ReadCommitted | RepeatableRead | Serializable
+})
 ```
 
-## 트랜잭션 내 에러 처리
+## 에러 처리
 
 ```typescript
 try {
   await prisma.$transaction(async (tx) => {
-    await tx.user.create({ data: { email: 'alice@prisma.io' } })
-
-    // 의도적 에러 발생 시 전체 롤백
-    if (someCondition) {
-      throw new Error('Rollback transaction')
-    }
-
-    await tx.post.create({ data: { title: 'Hello', authorId: 1 } })
+    await tx.user.create({ data: { email } })
+    if (someCondition) throw new Error('Rollback')
   })
 } catch (error) {
-  console.error('Transaction failed:', error)
-  // 트랜잭션 내 모든 변경사항이 롤백됨
+  // 전체 롤백됨
 }
 ```

package/templates/tanstack-start/docs/library/tanstack-query/index.md

@@ -1,28 +1,29 @@
 # TanStack Query
 
-> **Version**: 5.x | React Data Fetching Library
+> 5.x | React Data Fetching Library
+
+@use-query.md
+@use-mutation.md
+@invalidation.md
+@optimistic-updates.md
 
 ---
 
-## 🚀 Quick Reference (복사용)
+## Quick Reference
 
 ```typescript
-// useQuery - 데이터 조회
+// useQuery
 const { data, isLoading, error } = useQuery({
   queryKey: ['users'],
   queryFn: () => getUsers(),
 })
 
-// useMutation - 데이터 변경
+// useMutation + invalidation
 const queryClient = useQueryClient()
 const mutation = useMutation({
   mutationFn: createUser,
-  onSuccess: () => {
-    queryClient.invalidateQueries({ queryKey: ['users'] })
-  },
+  onSuccess: () => queryClient.invalidateQueries({ queryKey: ['users'] }),
 })
-
-// mutation 실행
 mutation.mutate({ email, name })
 
 // Optimistic Update
@@ -40,47 +41,20 @@ const mutation = useMutation({
 })
 ```
 
-### QueryClient 설정
+### 설정
 
 ```tsx
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 
-const queryClient = new QueryClient()
-
-function App() {
-  return (
-    <QueryClientProvider client={queryClient}>
-      <YourApp />
-    </QueryClientProvider>
-  )
-}
-```
-
----
-
-## 문서 구조
-
-- [설치 및 설정](./setup.md) - QueryClient 설정
-- [useQuery](./use-query.md) - 데이터 조회 훅
-- [useMutation](./use-mutation.md) - 데이터 변경 훅
-- [무효화](./invalidation.md) - Query 무효화 및 리페치
-- [Optimistic Updates](./optimistic-updates.md) - 낙관적 업데이트
-
-## 빠른 시작
-
-```bash
-yarn add @tanstack/react-query
-```
-
-### QueryClient 설정
-
-```tsx
-import {
-  QueryClient,
-  QueryClientProvider,
-} from '@tanstack/react-query'
-
-const queryClient = new QueryClient()
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 1000 * 60 * 5,   // 5분
+      gcTime: 1000 * 60 * 30,     // 30분 (이전 cacheTime)
+      retry: 3,
+    },
+  },
+})
 
 function App() {
   return (
@@ -91,56 +65,11 @@ function App() {
 }
 ```
 
-## 핵심 개념
-
-### useQuery - 데이터 조회
-
-```tsx
-import { useQuery } from '@tanstack/react-query'
-
-function Todos() {
-  const { data, isLoading, error } = useQuery({
-    queryKey: ['todos'],
-    queryFn: getTodos,
-  })
-
-  if (isLoading) return <div>Loading...</div>
-  if (error) return <div>Error: {error.message}</div>
-
-  return (
-    <ul>
-      {data?.map((todo) => (
-        <li key={todo.id}>{todo.title}</li>
-      ))}
-    </ul>
-  )
-}
-```
-
-### useMutation - 데이터 변경
-
-```tsx
-import { useMutation, useQueryClient } from '@tanstack/react-query'
-
-function AddTodo() {
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: postTodo,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['todos'] })
-    },
-  })
+### Query Keys 패턴
 
-  return (
-    <button onClick={() => mutation.mutate({ title: 'New Todo' })}>
-      Add Todo
-    </button>
-  )
-}
+```typescript
+['todos']                       // 단순
+['todo', { id: 5 }]             // 파라미터
+['todos', 'list', { filters }]  // 계층적
+['todos', 'detail', todoId]
 ```
-
-## 참고 자료
-
-- [TanStack Query 공식 문서](https://tanstack.com/query/latest)
-- [TanStack Query GitHub](https://github.com/tanstack/query)

package/templates/tanstack-start/docs/library/tanstack-query/invalidation.md

@@ -1,146 +1,67 @@
 # TanStack Query - Query 무효화
 
-> **상위 문서**: [TanStack Query](./index.md)
-
 ## 기본 무효화
 
 ```typescript
 const queryClient = useQueryClient()
 
-// 단일 쿼리 무효화
-await queryClient.invalidateQueries({ queryKey: ['todos'] })
+// 단일
+queryClient.invalidateQueries({ queryKey: ['todos'] })
 
-// 다중 쿼리 무효화
+// 다중
 await Promise.all([
   queryClient.invalidateQueries({ queryKey: ['todos'] }),
   queryClient.invalidateQueries({ queryKey: ['reminders'] }),
 ])
 
-// 모든 쿼리 무효화
+// 전체
 queryClient.invalidateQueries()
 ```
 
-## 무효화 옵션
+## 옵션
 
 ```typescript
-await queryClient.invalidateQueries(
-  {
-    queryKey: ['posts'],
-    exact: true, // 정확한 키 매칭만
-    refetchType: 'active', // 'active' | 'inactive' | 'all' | 'none'
-  },
-  {
-    throwOnError: false,
-    cancelRefetch: true,
-  }
-)
+queryClient.invalidateQueries({
+  queryKey: ['posts'],
+  exact: true,  // 정확한 키 매칭만
+  refetchType: 'active',  // 'active'(기본) | 'inactive' | 'all' | 'none'
+})
 ```
 
-## refetchType 옵션
+| refetchType | 설명 |
+|-------------|------|
+| active | 렌더링 중인 쿼리만 재조회 (기본) |
+| inactive | 비활성 쿼리만 |
+| all | 모든 매칭 쿼리 |
+| none | 무효화만, 재조회 안함 |
 
-- `active`: 현재 렌더링 중인 쿼리만 재조회 (기본값)
-- `inactive`: 비활성 쿼리만 재조회
-- `all`: 모든 매칭 쿼리 재조회
-- `none`: 무효화만 하고 재조회 안 함
-
-## Query Key로 무효화
+## Query Key 매칭
 
 ```typescript
-// 'todos'로 시작하는 모든 쿼리 무효화
+// prefix 매칭 (todos로 시작하는 모든 쿼리)
 queryClient.invalidateQueries({ queryKey: ['todos'] })
 
-// 정확히 ['todos', 'list']인 쿼리만 무효화
-queryClient.invalidateQueries({
-  queryKey: ['todos', 'list'],
-  exact: true,
-})
-
-// ['todos', { type: 'done' }] 무효화
-queryClient.invalidateQueries({
-  queryKey: ['todos', { type: 'done' }],
-})
+// 정확한 매칭
+queryClient.invalidateQueries({ queryKey: ['todos', 'list'], exact: true })
 ```
 
-## Mutation과 함께 사용
-
-### onSuccess에서 무효화
+## Mutation과 함께
 
 ```tsx
-import { useMutation, useQueryClient } from '@tanstack/react-query'
-
-function TodosComponent() {
-  const queryClient = useQueryClient()
-
-  const mutation = useMutation({
-    mutationFn: addTodo,
-    onSuccess: async () => {
-      // 단일 쿼리 무효화
-      await queryClient.invalidateQueries({ queryKey: ['todos'] })
-
-      // 여러 쿼리 무효화
-      await Promise.all([
-        queryClient.invalidateQueries({ queryKey: ['todos'] }),
-        queryClient.invalidateQueries({ queryKey: ['reminders'] }),
-      ])
-    },
-  })
-
-  return (
-    <button onClick={() => mutation.mutate(newTodo)}>
-      Add Todo
-    </button>
-  )
-}
-```
-
-### onSettled에서 무효화
-
-```tsx
-const mutation = useMutation({
-  mutationFn: updateTodo,
-  onSettled: () => {
-    // 성공/실패 관계없이 무효화
-    queryClient.invalidateQueries({ queryKey: ['todos'] })
-  },
+useMutation({
+  mutationFn: addTodo,
+  onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
+  // 또는 onSettled (성공/실패 무관)
+  onSettled: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
 })
 ```
 
 ## 캐시 직접 업데이트 vs 무효화
 
 ```tsx
-// 방법 1: 캐시 직접 업데이트 (더 빠름)
+// 직접 업데이트 (더 빠름)
 queryClient.setQueryData(['todos'], (old) => [...old, newTodo])
 
-// 방법 2: 무효화 후 재조회 (서버 데이터 보장)
-queryClient.invalidateQueries({ queryKey: ['todos'] })
-```
-
-## 조건부 무효화
-
-```tsx
-const mutation = useMutation({
-  mutationFn: updateTodo,
-  onSuccess: (data, variables) => {
-    // 특정 조건에서만 무효화
-    if (variables.category === 'important') {
-      queryClient.invalidateQueries({ queryKey: ['todos', 'important'] })
-    }
-
-    // 항상 개별 항목은 무효화
-    queryClient.invalidateQueries({ queryKey: ['todo', variables.id] })
-  },
-})
-```
-
-## prefetch와 조합
-
-```tsx
-// 무효화 전에 새 데이터 프리페치
-await queryClient.prefetchQuery({
-  queryKey: ['todos'],
-  queryFn: fetchTodos,
-})
-
-// 이후 무효화 시 이미 새 데이터가 있음
+// 무효화 (서버 데이터 보장)
 queryClient.invalidateQueries({ queryKey: ['todos'] })
 ```