@kood/claude-code 0.1.6 → 0.1.9

package/templates/tanstack-start/docs/guides/services.md

@@ -0,0 +1,143 @@
+# Service Layer
+
+도메인별 SDK/서비스 레이어 구조.
+
+## 폴더 구조
+
+```
+services/
+├── user/
+│   ├── index.ts            # 진입점 (re-export)
+│   ├── schemas.ts          # Zod 스키마
+│   ├── queries.ts          # GET 요청 (읽기)
+│   └── mutations.ts        # POST 요청 (쓰기)
+├── auth/
+│   ├── index.ts
+│   ├── schemas.ts
+│   ├── queries.ts
+│   └── mutations.ts
+└── post/
+    ├── index.ts
+    ├── schemas.ts
+    ├── queries.ts
+    └── mutations.ts
+```
+
+## Schemas 파일
+
+```typescript
+// services/user/schemas.ts
+import { z } from 'zod'
+
+export const createUserSchema = z.object({
+  email: z.email(),
+  name: z.string().min(1).max(100).trim(),
+})
+
+export const updateUserSchema = z.object({
+  id: z.string(),
+  email: z.email().optional(),
+  name: z.string().min(1).max(100).trim().optional(),
+})
+
+export type CreateUserInput = z.infer<typeof createUserSchema>
+export type UpdateUserInput = z.infer<typeof updateUserSchema>
+```
+
+## Queries 파일
+
+```typescript
+// services/user/queries.ts
+import { createServerFn } from '@tanstack/react-start'
+import { prisma } from '@/database/prisma'
+
+export const getUsers = createServerFn({ method: 'GET' })
+  .handler(async () => {
+    return prisma.user.findMany({
+      orderBy: { createdAt: 'desc' },
+    })
+  })
+
+export const getUserById = createServerFn({ method: 'GET' })
+  .handler(async ({ data: id }: { data: string }) => {
+    const user = await prisma.user.findUnique({ where: { id } })
+    if (!user) throw new Error('User not found')
+    return user
+  })
+
+export const getUserByEmail = createServerFn({ method: 'GET' })
+  .handler(async ({ data: email }: { data: string }) => {
+    return prisma.user.findUnique({ where: { email } })
+  })
+```
+
+## Mutations 파일
+
+```typescript
+// services/user/mutations.ts
+import { createServerFn } from '@tanstack/react-start'
+import { prisma } from '@/database/prisma'
+import { createUserSchema, updateUserSchema } from './schemas'
+
+export const createUser = createServerFn({ method: 'POST' })
+  .inputValidator(createUserSchema)
+  .handler(async ({ data }) => {
+    return prisma.user.create({ data })
+  })
+
+export const updateUser = createServerFn({ method: 'POST' })
+  .inputValidator(updateUserSchema)
+  .handler(async ({ data }) => {
+    const { id, ...updateData } = data
+    return prisma.user.update({ where: { id }, data: updateData })
+  })
+
+export const deleteUser = createServerFn({ method: 'POST' })
+  .handler(async ({ data: id }: { data: string }) => {
+    return prisma.user.delete({ where: { id } })
+  })
+```
+
+## 진입점 파일
+
+```typescript
+// services/user/index.ts
+export * from './schemas'
+export * from './queries'
+export * from './mutations'
+```
+
+## 사용 예시
+
+```typescript
+// routes/users/-hooks/use-users.ts
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
+import { getUsers, createUser, deleteUser } from '@/services/user'
+```
+
+## Database 폴더
+
+```
+database/
+├── prisma.ts               # Prisma Client 싱글톤
+└── seed.ts                 # 시드 스크립트 (선택)
+```
+
+```typescript
+// database/prisma.ts
+import { PrismaClient } from '../../generated/prisma'
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined
+}
+
+export const prisma =
+  globalForPrisma.prisma ??
+  new PrismaClient({
+    log: process.env.NODE_ENV === 'development' ? ['query'] : [],
+  })
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma
+}
+```

package/templates/tanstack-start/docs/library/better-auth/2fa.md

@@ -1,136 +1,48 @@
 # Better Auth - 2단계 인증 (2FA)
 
-> **상위 문서**: [Better Auth](./index.md)
-
-## 서버 설정
+## 서버
 
 ```typescript
-import { betterAuth } from 'better-auth'
 import { twoFactor } from 'better-auth/plugins'
 
-export const auth = betterAuth({
-  plugins: [
-    twoFactor({
-      issuer: 'My Application',
-      otpOptions: {
-        async sendOTP({ user, otp }) {
-          await sendEmail({
-            to: user.email,
-            subject: 'Your verification code',
-            html: `Your code is: ${otp}`,
-          })
-        },
-        period: 300, // 5분
-        length: 6,
-      },
-      backupCodeLength: 10,
-      backupCodeCount: 10,
-    }),
-  ],
-})
+plugins: [
+  twoFactor({
+    issuer: 'My App',
+    otpOptions: {
+      async sendOTP({ user, otp }) { await sendEmail({ to: user.email, html: `Code: ${otp}` }) },
+      period: 300, length: 6,
+    },
+    backupCodeLength: 10,
+    backupCodeCount: 10,
+  }),
+]
 ```
 
-## 클라이언트 설정
+## 클라이언트
 
 ```typescript
 import { twoFactorClient } from 'better-auth/client/plugins'
-
-const authClient = createAuthClient({
-  plugins: [
-    twoFactorClient({
-      twoFactorPage: '/two-factor',
-    }),
-  ],
-})
+plugins: [twoFactorClient({ twoFactorPage: '/two-factor' })]
 ```
 
-## 2FA 활성화
+## 사용법
 
 ```typescript
-// 2FA 활성화
-const { data } = await authClient.twoFactor.enable({
-  password: 'userPassword123',
-})
-console.log('TOTP URI:', data.totpURI)
-console.log('Backup codes:', data.backupCodes)
-```
+// 활성화
+const { data } = await authClient.twoFactor.enable({ password })
+// data.totpURI, data.backupCodes
 
-## TOTP 코드 검증
-
-```typescript
-// TOTP 코드 검증
-await authClient.twoFactor.verifyTotp({
-  code: '123456',
-})
-```
+// TOTP 검증
+await authClient.twoFactor.verifyTotp({ code: '123456' })
 
-## OTP 전송 및 검증
-
-```typescript
-// OTP 전송
+// OTP 전송 및 검증
 await authClient.twoFactor.sendOtp()
+await authClient.twoFactor.verifyOtp({ code })
 
-// OTP 검증
-await authClient.twoFactor.verifyOtp({
-  code: '123456',
-})
-```
-
-## 백업 코드
-
-```typescript
-// 백업 코드 사용
-await authClient.twoFactor.useBackupCode({
-  code: 'ABCD-1234-EFGH',
-})
-
-// 백업 코드 재생성
-const { data: newCodes } = await authClient.twoFactor.regenerateBackupCodes({
-  password: 'userPassword123',
-})
-```
-
-## 2FA 비활성화
-
-```typescript
-await authClient.twoFactor.disable({
-  password: 'userPassword123',
-})
-```
-
-## 2FA 페이지 구현
-
-```tsx
-// pages/two-factor.tsx
-import { useState } from 'react'
-import { authClient } from '@/lib/auth-client'
-
-export default function TwoFactorPage() {
-  const [code, setCode] = useState('')
-  const [error, setError] = useState('')
-
-  const handleVerify = async () => {
-    try {
-      await authClient.twoFactor.verifyTotp({ code })
-      // 성공 시 대시보드로 이동
-      window.location.href = '/dashboard'
-    } catch (e) {
-      setError('Invalid code')
-    }
-  }
+// 백업 코드
+await authClient.twoFactor.useBackupCode({ code: 'ABCD-1234' })
+await authClient.twoFactor.regenerateBackupCodes({ password })
 
-  return (
-    <div>
-      <h1>2단계 인증</h1>
-      <input
-        type="text"
-        value={code}
-        onChange={(e) => setCode(e.target.value)}
-        placeholder="6자리 코드 입력"
-      />
-      <button onClick={handleVerify}>확인</button>
-      {error && <p style={{ color: 'red' }}>{error}</p>}
-    </div>
-  )
-}
+// 비활성화
+await authClient.twoFactor.disable({ password })
 ```

package/templates/tanstack-start/docs/library/better-auth/advanced.md

@@ -1,138 +1,55 @@
 # Better Auth - 고급 기능
 
-> **상위 문서**: [Better Auth](./index.md)
-
-## CAPTCHA 보호
+## CAPTCHA
 
 ```typescript
-import { betterAuth } from 'better-auth'
+// 서버
 import { captcha } from 'better-auth/plugins'
-
-export const auth = betterAuth({
-  plugins: [
-    captcha({
-      provider: 'recaptcha', // 'recaptcha' | 'hcaptcha'
-      siteKey: process.env.RECAPTCHA_SITE_KEY!,
-      secretKey: process.env.RECAPTCHA_SECRET_KEY!,
-      protectEndpoints: ['/sign-up/email', '/sign-in/email'],
-    }),
-  ],
-})
+plugins: [captcha({
+  provider: 'recaptcha',
+  siteKey: SITE_KEY, secretKey: SECRET_KEY,
+  protectEndpoints: ['/sign-up/email', '/sign-in/email'],
+})]
 
 // 클라이언트
 import { captchaClient } from 'better-auth/client/plugins'
-
-const authClient = createAuthClient({
-  plugins: [
-    captchaClient({
-      siteKey: process.env.NEXT_PUBLIC_RECAPTCHA_SITE_KEY!,
-    }),
-  ],
-})
-
-// CAPTCHA는 보호된 요청에 자동 포함됨
-await authClient.signUp.email({
-  email: 'user@example.com',
-  password: 'SecurePassword123!',
-})
+plugins: [captchaClient({ siteKey: SITE_KEY })]
 ```
 
-## SSO (Single Sign-On)
+## SSO
 
 ```typescript
-// Provider ID로 SSO 로그인
-const res = await authClient.signIn.sso({
-  providerId: 'example-provider-id',
-  callbackURL: '/dashboard',
-})
+await authClient.signIn.sso({ providerId: 'provider-id', callbackURL: '/dashboard' })
 ```
 
-## SIWE (Sign-In with Ethereum)
-
-### 서버 설정
+## SIWE (Ethereum)
 
 ```typescript
-import { betterAuth } from 'better-auth'
+// 서버
 import { siwe } from 'better-auth/plugins'
+plugins: [siwe({ domain: 'example.com', uri: 'https://example.com' })]
 
-export const auth = betterAuth({
-  plugins: [
-    siwe({
-      domain: 'example.com',
-      uri: 'https://example.com',
-      statement: 'Sign in with your Ethereum account',
-    }),
-  ],
-})
-```
-
-### 클라이언트 사용
-
-```typescript
-import { siweClient } from 'better-auth/client/plugins'
-import { ethers } from 'ethers'
-
-const authClient = createAuthClient({
-  plugins: [siweClient()],
-})
-
-// Nonce 가져오기
+// 클라이언트
 const { data: nonce } = await authClient.siwe.getNonce()
-
-// 메시지 생성 및 서명
-const provider = new ethers.BrowserProvider(window.ethereum)
-const signer = await provider.getSigner()
-const address = await signer.getAddress()
-
-const message = await authClient.siwe.prepareMessage({
-  address,
-  nonce: nonce.nonce,
-})
-
+const message = await authClient.siwe.prepareMessage({ address, nonce: nonce.nonce })
 const signature = await signer.signMessage(message)
-
-// 검증 및 로그인
-await authClient.siwe.signIn({
-  message,
-  signature,
-})
+await authClient.siwe.signIn({ message, signature })
 ```
 
 ## Stateless 모드
 
-데이터베이스 없이 사용:
-
 ```typescript
-import { betterAuth } from 'better-auth'
-
+// DB 없이 소셜 로그인만
 export const auth = betterAuth({
-  // 데이터베이스 설정 없음 - 자동으로 stateless 모드
-  socialProviders: {
-    google: {
-      clientId: process.env.GOOGLE_CLIENT_ID,
-      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
-    },
-  },
+  socialProviders: { google: { clientId, clientSecret } },
 })
-```
-
-### Redis와 함께 하이브리드 모드
-
-```typescript
-import { betterAuth } from 'better-auth'
-import { redis } from './redis'
 
+// Redis 하이브리드
 export const auth = betterAuth({
   secondaryStorage: {
-    get: async (key) => await redis.get(key),
-    set: async (key, value, ttl) => await redis.set(key, value, 'EX', ttl),
-    delete: async (key) => await redis.del(key),
-  },
-  session: {
-    cookieCache: {
-      maxAge: 5 * 60, // 5분
-      refreshCache: false,
-    },
+    get: (key) => redis.get(key),
+    set: (key, value, ttl) => redis.set(key, value, 'EX', ttl),
+    delete: (key) => redis.del(key),
   },
 })
 ```

package/templates/tanstack-start/docs/library/better-auth/index.md

@@ -1,83 +1,34 @@
 # Better Auth
 
-> **Version**: Latest
-> **Framework**: TypeScript Authentication Library
-> **Source**: [Better Auth Documentation](https://www.better-auth.com)
+> TypeScript Authentication Library
 
-Better Auth는 TypeScript를 위한 프레임워크 독립적인 인증 및 권한 부여 라이브러리입니다.
+@setup.md
+@session.md
+@plugins.md
+@2fa.md
+@advanced.md
 
-## 문서 구조
-
-- [설치 및 설정](./setup.md) - 서버/클라이언트 설정, 소셜 로그인
-- [세션 관리](./session.md) - 세션 설정, 쿠키 캐시
-- [플러그인](./plugins.md) - Multi-Session, Custom Session
-- [2단계 인증](./2fa.md) - TOTP, OTP, 백업 코드
-- [고급 기능](./advanced.md) - CAPTCHA, SSO, SIWE, Stateless 모드
-
-## 빠른 시작
-
-```bash
-yarn add better-auth
-```
-
-### 기본 서버 설정
+## Quick Reference
 
 ```typescript
-// lib/auth.ts
+// 서버
 import { betterAuth } from 'better-auth'
 import { prismaAdapter } from 'better-auth/adapters/prisma'
-import { prisma } from './prisma'
 
 export const auth = betterAuth({
   database: prismaAdapter(prisma),
-  emailAndPassword: {
-    enabled: true,
-    requireEmailVerification: false,
-  },
+  emailAndPassword: { enabled: true },
 })
-```
 
-### 기본 클라이언트 설정
-
-```typescript
-// lib/auth-client.ts
+// 클라이언트
 import { createAuthClient } from 'better-auth/react'
+export const authClient = createAuthClient({})
 
-export const authClient = createAuthClient({
-  // 옵션
-})
-```
-
-## 핵심 개념
+// 로그인/가입
+await authClient.signIn.email({ email, password })
+await authClient.signUp.email({ email, password, name })
 
-### 이메일/비밀번호 인증
-```typescript
-// 로그인
-await authClient.signIn.email({
-  email: 'user@example.com',
-  password: 'password123',
-})
-
-// 회원가입
-await authClient.signUp.email({
-  email: 'user@example.com',
-  password: 'password123',
-  name: 'John Doe',
-})
+// 세션
+const session = await authClient.getSession()  // 클라이언트
+const session = await auth.api.getSession({ headers })  // 서버
 ```
-
-### 세션 조회
-```typescript
-// 클라이언트
-const session = await authClient.getSession()
-
-// 서버
-const session = await auth.api.getSession({
-  headers: request.headers,
-})
-```
-
-## 참고 자료
-
-- [Better Auth 공식 문서](https://www.better-auth.com)
-- [Better Auth GitHub](https://github.com/better-auth/better-auth)

package/templates/tanstack-start/docs/library/better-auth/plugins.md

@@ -1,111 +1,34 @@
 # Better Auth - 플러그인
 
-> **상위 문서**: [Better Auth](./index.md)
-
-## Multi-Session Plugin
-
-여러 계정으로 동시 로그인을 지원합니다.
-
-### 서버 설정
+## Multi-Session
 
 ```typescript
-import { betterAuth } from 'better-auth'
+// 서버
 import { multiSession } from 'better-auth/plugins'
+plugins: [multiSession({ maximumSessions: 5 })]
 
-export const auth = betterAuth({
-  plugins: [
-    multiSession({
-      maximumSessions: 5, // 최대 동시 세션 수
-    }),
-  ],
-})
-```
-
-### 클라이언트 사용
-
-```typescript
-import { createAuthClient } from 'better-auth/client'
+// 클라이언트
 import { multiSessionClient } from 'better-auth/client/plugins'
+plugins: [multiSessionClient()]
 
-export const authClient = createAuthClient({
-  plugins: [multiSessionClient()],
-})
-
-// 활성 세션 목록 조회
-const { data: sessions } = await authClient.multiSession.listSessions()
-
-sessions?.forEach((session) => {
-  console.log(`Device: ${session.userAgent}, Last active: ${session.updatedAt}`)
-})
-
-// 특정 세션 취소
-await authClient.multiSession.revokeSession({
-  sessionId: 'session_456',
-})
-
-// 다른 모든 세션 취소
+// 사용
+await authClient.multiSession.listSessions()
+await authClient.multiSession.revokeSession({ sessionId })
 await authClient.multiSession.revokeOtherSessions()
 ```
 
-## Polar Checkout Plugin
-
-결제 통합을 위한 플러그인입니다.
-
-```typescript
-import { polar, checkout } from '@polar-sh/better-auth'
-
-const auth = betterAuth({
-  plugins: [
-    polar({
-      use: [
-        checkout({
-          products: [{ productId: '123-456-789', slug: 'pro' }],
-          successUrl: '/success?checkout_id={CHECKOUT_ID}',
-          authenticatedUsersOnly: true,
-        }),
-      ],
-    }),
-  ],
-})
-
-// 클라이언트
-import { polarClient } from '@polar-sh/better-auth'
-
-export const authClient = createAuthClient({
-  plugins: [polarClient()],
-})
-```
-
 ## 플러그인 조합
 
 ```typescript
-import { betterAuth } from 'better-auth'
-import {
-  multiSession,
-  customSession,
-  twoFactor,
-  captcha
-} from 'better-auth/plugins'
+import { multiSession, customSession, twoFactor, captcha } from 'better-auth/plugins'
 
 export const auth = betterAuth({
   database: prismaAdapter(prisma),
   plugins: [
     multiSession({ maximumSessions: 5 }),
-    customSession({
-      schema: {
-        session: {
-          fields: {
-            ipAddress: { type: 'string', required: false },
-          },
-        },
-      },
-    }),
+    customSession({ schema: { session: { fields: { ipAddress: { type: 'string' } } } } }),
     twoFactor({ issuer: 'My App' }),
-    captcha({
-      provider: 'recaptcha',
-      siteKey: process.env.RECAPTCHA_SITE_KEY!,
-      secretKey: process.env.RECAPTCHA_SECRET_KEY!,
-    }),
+    captcha({ provider: 'recaptcha', siteKey: SITE_KEY, secretKey: SECRET_KEY }),
   ],
 })
 ```