@kood/claude-code 0.1.5 → 0.1.7

package/templates/tanstack-start/docs/library/zod/basic-types.md

@@ -1,186 +1,74 @@
 # Zod - 기본 타입
 
-> **상위 문서**: [Zod](./index.md)
-
 ## 문자열
 
 ```typescript
 z.string()
-z.string().min(1)          // 최소 길이
-z.string().max(100)        // 최대 길이
-z.string().length(5)       // 정확한 길이
-z.string().regex(/^\d+$/)  // 정규식
-z.string().trim()          // 공백 제거
-z.string().toLowerCase()   // 소문자 변환
-z.string().toUpperCase()   // 대문자 변환
+z.string().min(1).max(100).length(5)
+z.string().regex(/^\d+$/)
+z.string().trim().toLowerCase().toUpperCase()
 ```
 
-### v4 새로운 최상위 문자열 포맷 API
+### v4 최상위 포맷 API
 
 ```typescript
-// 더 나은 tree-shaking을 위해 최상위 API 사용 권장
-z.email()           // 이메일 형식
-z.url()             // URL 형식
-z.uuid()            // UUID 형식
-z.base64()          // Base64 형식
-z.base64url()       // Base64 URL 형식
-z.nanoid()          // NanoID 형식
-z.cuid()            // CUID 형식
-z.cuid2()           // CUID2 형식
-z.ulid()            // ULID 형식
-z.emoji()           // 이모지 (단일 문자)
-z.ipv4()            // IPv4 주소
-z.ipv6()            // IPv6 주소
-z.cidrv4()          // IPv4 범위
-z.cidrv6()          // IPv6 범위
-
-// ISO 날짜/시간 형식
-z.iso.date()        // ISO 날짜 (2024-01-15)
-z.iso.time()        // ISO 시간 (14:30:00)
-z.iso.datetime()    // ISO 날짜시간
-z.iso.duration()    // ISO 기간 (P1D, PT1H)
+z.email()    z.url()      z.uuid()     z.base64()
+z.nanoid()   z.cuid()     z.cuid2()    z.ulid()
+z.ipv4()     z.ipv6()     z.cidrv4()   z.cidrv6()
+
+z.iso.date()      // 2024-01-15
+z.iso.time()      // 14:30:00
+z.iso.datetime()  // ISO 날짜시간
+z.iso.duration()  // P1D, PT1H
 ```
 
-### 템플릿 리터럴 타입 (v4 신규)
+### 템플릿 리터럴 (v4)
 
 ```typescript
-const hello = z.templateLiteral(["hello, ", z.string()])
-// `hello, ${string}`
-
-const cssUnits = z.enum(["px", "em", "rem", "%"])
-const css = z.templateLiteral([z.number(), cssUnits])
-// `${number}px` | `${number}em` | `${number}rem` | `${number}%`
-
-const email = z.templateLiteral([
-  z.string().min(1),
-  "@",
-  z.string().max(64),
-])
-// `${string}@${string}` (min/max refinements도 적용됨!)
+const css = z.templateLiteral([z.number(), z.enum(["px", "em", "rem"])])
+// `${number}px` | `${number}em` | `${number}rem`
 ```
 
 ## 숫자
 
 ```typescript
 z.number()
-z.number().min(0)          // 최솟값
-z.number().max(100)        // 최댓값
-z.number().int()           // 정수만
-z.number().positive()      // 양수만
-z.number().negative()      // 음수만
-z.number().nonnegative()   // 0 이상
-z.number().nonpositive()   // 0 이하
-z.number().finite()        // 유한 숫자
-z.number().safe()          // 안전한 정수 범위
+z.number().min(0).max(100).int()
+z.number().positive().negative().nonnegative().nonpositive()
+z.number().finite().safe()
 ```
 
 ## 불리언
 
 ```typescript
 z.boolean()
-```
-
-### 문자열 불리언 (v4 신규)
-
-환경변수 스타일 불리언 변환:
-
-```typescript
-const strbool = z.stringbool()
-
-strbool.parse("true")     // => true
-strbool.parse("1")        // => true
-strbool.parse("yes")      // => true
-strbool.parse("on")       // => true
-strbool.parse("enabled")  // => true
-
-strbool.parse("false")    // => false
-strbool.parse("0")        // => false
-strbool.parse("no")       // => false
-strbool.parse("off")      // => false
-strbool.parse("disabled") // => false
-
-// 커스텀 truthy/falsy 값
-z.stringbool({
-  truthy: ["yes", "true"],
-  falsy: ["no", "false"]
-})
-```
-
-## 날짜
-
-```typescript
-z.date()
-z.date().min(new Date('2020-01-01'))
-z.date().max(new Date('2030-12-31'))
-```
-
-## BigInt
-
-```typescript
-z.bigint()
-z.bigint().positive()
-z.bigint().negative()
-```
-
-## 리터럴
-
-```typescript
-z.literal('hello')       // 정확히 'hello'만
-z.literal(42)            // 정확히 42만
-z.literal(true)          // 정확히 true만
-```
-
-## Null, Undefined, Void
-
-```typescript
-z.null()       // null만 허용
-z.undefined()  // undefined만 허용
-z.void()       // undefined 허용 (반환 타입용)
-```
 
-## Any, Unknown, Never
-
-```typescript
-z.any()      // 모든 타입 허용
-z.unknown()  // unknown 타입
-z.never()    // 값 없음 (유니온에서 사용)
+// v4 문자열 불리언 (환경변수용)
+z.stringbool()  // "true"/"yes"/"1" → true, "false"/"no"/"0" → false
 ```
 
-> **v4 변경**: `z.any()`와 `z.unknown()`은 더 이상 객체에서 선택적 키로 추론되지 않습니다.
-> ```typescript
-> const mySchema = z.object({ a: z.any(), b: z.unknown() })
-> // v3: { a?: any; b?: unknown }
-> // v4: { a: any; b: unknown }
-> ```
-
-## Optional & Nullable
+## 날짜/BigInt/리터럴
 
 ```typescript
-z.string().optional()  // string | undefined
-z.string().nullable()  // string | null
-z.string().nullish()   // string | null | undefined
+z.date().min(new Date('2020-01-01')).max(new Date('2030-12-31'))
+z.bigint().positive().negative()
+z.literal('hello')  z.literal(42)  z.literal(true)
 ```
 
-## Default 값
+## 특수 타입
 
 ```typescript
-const Schema = z.object({
-  name: z.string().default('Anonymous'),
-  role: z.enum(['admin', 'user']).default('user'),
-})
-
-Schema.parse({}) // { name: 'Anonymous', role: 'user' }
+z.null()       z.undefined()    z.void()
+z.any()        z.unknown()      z.never()
 ```
 
-## 타입 추론
+## 수정자
 
 ```typescript
-const stringSchema = z.string()
-type StringType = z.infer<typeof stringSchema> // string
-
-const numberSchema = z.number().optional()
-type NumberType = z.infer<typeof numberSchema> // number | undefined
+z.string().optional()   // string | undefined
+z.string().nullable()   // string | null
+z.string().nullish()    // string | null | undefined
+z.string().default('Anonymous')
 
-const dateSchema = z.date().nullable()
-type DateType = z.infer<typeof dateSchema> // Date | null
+type T = z.infer<typeof schema>
 ```

package/templates/tanstack-start/docs/library/zod/complex-types.md

@@ -1,204 +1,80 @@
 # Zod - 복합 타입
 
-> **상위 문서**: [Zod](./index.md)
-
 ## 객체
 
 ```typescript
 const UserSchema = z.object({
   name: z.string(),
-  email: z.email(),  // v4 새 API
-  age: z.number().optional(),  // 선택적 필드
-})
-
-// 검증
-const result = UserSchema.parse({
-  name: 'john',
-  email: 'john@example.com',
-  age: 25,
-})
-
-// 안전한 검증
-const safeResult = UserSchema.safeParse(data)
-if (safeResult.success) {
-  console.log(safeResult.data)
-} else {
-  console.log(safeResult.error)
-}
-```
-
-### 객체 메서드
-
-```typescript
-// 부분 객체 (모든 필드가 optional)
-const PartialUser = UserSchema.partial()
-
-// 필수 객체 (모든 필드가 required)
-const RequiredUser = UserSchema.required()
-
-// 필드 선택
-const UserName = UserSchema.pick({ name: true })
-
-// 필드 제외
-const UserWithoutEmail = UserSchema.omit({ email: true })
-
-// 확장
-const ExtendedUser = UserSchema.extend({
-  role: z.enum(['admin', 'user']),
+  email: z.email(),
+  age: z.number().optional(),
 })
 
-// 병합
-const MergedSchema = UserSchema.merge(AnotherSchema)
-```
-
-### Strict/Loose 객체 (v4)
+// 메서드
+UserSchema.partial()              // 모든 필드 optional
+UserSchema.required()             // 모든 필드 required
+UserSchema.pick({ name: true })   // 특정 필드만
+UserSchema.omit({ email: true })  // 특정 필드 제외
+UserSchema.extend({ role: z.enum(['admin', 'user']) })
+UserSchema.merge(AnotherSchema)
 
-```typescript
-// v3
-z.object({ name: z.string() }).strict()     // 추가 키 에러
-z.object({ name: z.string() }).passthrough() // 추가 키 통과
-
-// v4 - 새로운 API
+// v4 Strict/Loose
 z.strictObject({ name: z.string() })  // 추가 키 에러
 z.looseObject({ name: z.string() })   // 추가 키 통과
 ```
 
-## 배열
+## 배열/튜플
 
 ```typescript
 z.array(z.string())
-z.array(z.number()).min(1)     // 최소 1개
-z.array(z.number()).max(10)    // 최대 10개
-z.array(z.number()).length(5)  // 정확히 5개
-z.array(z.number()).nonempty() // 비어있지 않음
-```
+z.array(z.number()).min(1).max(10).length(5).nonempty()
 
-## 튜플
-
-```typescript
-const tuple = z.tuple([
-  z.string(),  // 첫 번째 요소
-  z.number(),  // 두 번째 요소
-])
-
-type Tuple = z.infer<typeof tuple>
-// [string, number]
+z.tuple([z.string(), z.number()])  // [string, number]
 ```
 
 ## 유니온
 
 ```typescript
-const StringOrNumber = z.union([z.string(), z.number()])
-// 또는
-const StringOrNumber = z.string().or(z.number())
-
-type StringOrNumber = z.infer<typeof StringOrNumber>
-// string | number
-```
+z.union([z.string(), z.number()])
+z.string().or(z.number())
 
-## Discriminated Union
-
-```typescript
-const Shape = z.discriminatedUnion('type', [
+// Discriminated Union
+z.discriminatedUnion('type', [
   z.object({ type: z.literal('circle'), radius: z.number() }),
   z.object({ type: z.literal('rectangle'), width: z.number(), height: z.number() }),
 ])
-
-type Shape = z.infer<typeof Shape>
-// { type: 'circle'; radius: number } | { type: 'rectangle'; width: number; height: number }
-```
-
-### v4 향상된 Discriminated Union
-
-```typescript
-// 유니온 및 파이프 discriminator 지원
-const MyResult = z.discriminatedUnion("status", [
-  // 단순 리터럴
-  z.object({ status: z.literal("aaa"), data: z.string() }),
-  // 유니온 discriminator
-  z.object({ status: z.union([z.literal("bbb"), z.literal("ccc")]) }),
-  // 파이프 discriminator
-  z.object({ status: z.literal("fail").transform(val => val.toUpperCase()) }),
-])
-
-// 중첩 discriminated union
-const BaseError = z.object({ status: z.literal("failed"), message: z.string() })
-
-const MyResult2 = z.discriminatedUnion("status", [
-  z.object({ status: z.literal("success"), data: z.string() }),
-  z.discriminatedUnion("code", [
-    BaseError.extend({ code: z.literal(400) }),
-    BaseError.extend({ code: z.literal(401) }),
-    BaseError.extend({ code: z.literal(500) })
-  ])
-])
 ```
 
 ## Enum
 
 ```typescript
-// 문자열 enum
-const FishEnum = z.enum(['Salmon', 'Tuna', 'Trout'])
-
-FishEnum.parse('Salmon') // => "Salmon"
-FishEnum.parse('Swordfish') // => ❌ throws
-
-type Fish = z.infer<typeof FishEnum>
-// 'Salmon' | 'Tuna' | 'Trout'
+const Status = z.enum(['pending', 'done', 'cancelled'])
+type Status = z.infer<typeof Status>  // 'pending' | 'done' | 'cancelled'
 
 // Native enum
-enum Fruits {
-  Apple,
-  Banana,
-}
-const FruitSchema = z.nativeEnum(Fruits)
+enum Fruits { Apple, Banana }
+z.nativeEnum(Fruits)
 ```
 
-## Record
+## Record/Map/Set
 
 ```typescript
-const UserStore = z.record(z.string(), z.object({
-  name: z.string(),
-}))
-
-type UserStore = z.infer<typeof UserStore>
+z.record(z.string(), z.object({ name: z.string() }))
 // { [key: string]: { name: string } }
 
-// 사용
-const userStore: UserStore = {}
-userStore['77d2586b-9e8e-4ecf-8b21-ea7e0530eadd'] = {
-  name: 'Carlotta',
-} // passes
-
-userStore['77d2586b-9e8e-4ecf-8b21-ea7e0530eadd'] = {
-  whatever: 'Ice cream sundae',
-} // TypeError
+z.map(z.string(), z.number())  // Map<string, number>
+z.set(z.number())              // Set<number>
 ```
 
-## Map & Set
+## 재귀 스키마
 
 ```typescript
-// Map
-const stringNumberMap = z.map(z.string(), z.number())
-type StringNumberMap = z.infer<typeof stringNumberMap>
-// Map<string, number>
-
-// Set
-const numberSet = z.set(z.number())
-type NumberSet = z.infer<typeof numberSet>
-// Set<number>
-```
-
-## 재귀 스키마 (JSON)
-
-```typescript
-const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()])
-type Literal = z.infer<typeof literalSchema>
-type Json = Literal | { [key: string]: Json } | Json[]
+type Json = string | number | boolean | null | { [key: string]: Json } | Json[]
 
 const jsonSchema: z.ZodType<Json> = z.lazy(() =>
-  z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)])
+  z.union([
+    z.string(), z.number(), z.boolean(), z.null(),
+    z.array(jsonSchema),
+    z.record(jsonSchema)
+  ])
 )
-
-jsonSchema.parse({ foo: [1, 2, { bar: 'baz' }] })
 ```

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

@@ -1,21 +1,25 @@
 # Zod
 
-> **Version**: 4.x | TypeScript Schema Validation
+> **v4** | TypeScript Schema Validation
+
+@basic-types.md
+@complex-types.md
+@transforms.md
+@validation.md
 
 ---
 
-## 🚀 Quick Reference (복사용)
+## Quick Reference
 
 ```typescript
 // 기본 스키마
 const schema = z.object({
-  email: z.email(),              // v4 (string().email() 아님!)
+  email: z.email(),              // v4! (string().email() 아님)
   name: z.string().min(1).trim(),
-  website: z.url().optional(),   // v4 (string().url() 아님!)
+  website: z.url().optional(),   // v4! (string().url() 아님)
   age: z.number().int().positive(),
 })
 
-// 타입 추출
 type Input = z.infer<typeof schema>
 
 // 파싱
@@ -28,159 +32,27 @@ export const createUser = createServerFn({ method: 'POST' })
   .handler(async ({ data }) => prisma.user.create({ data }))
 ```
 
-### v4 새 API (⚠️ 중요)
+### ⚠️ v4 새 API
 
 ```typescript
-// ✅ v4 사용
-z.email()
-z.url()
-z.uuid()
-z.iso.date()
-z.iso.datetime()
+// ✅ v4
+z.email()          z.url()          z.uuid()
+z.iso.date()       z.iso.datetime()
 
-// ❌ v3 (deprecated)
-z.string().email()
-z.string().url()
+// ❌ v3 deprecated
+z.string().email()  z.string().url()
 ```
 
----
-
-## 문서 구조
-
-- [기본 타입](./basic-types.md) - 문자열, 숫자, 불리언, 날짜
-- [복합 타입](./complex-types.md) - 객체, 배열, 튜플, 유니온, Enum
-- [변환](./transforms.md) - Transform, Coerce, Preprocess
-- [검증](./validation.md) - Refinement, Superrefine, 커스텀 검증
-
-## 빠른 시작
-
-```bash
-yarn add zod
-```
-
-### 기본 사용법
+### v4 주요 변경
 
 ```typescript
-import { z } from 'zod'
-
-// 스키마 생성
-const mySchema = z.string()
-
-// parsing (실패 시 에러 throw)
-mySchema.parse('tuna') // => "tuna"
-mySchema.parse(12) // => throws ZodError
-
-// safe parsing (에러를 던지지 않음)
-mySchema.safeParse('tuna') // => { success: true; data: "tuna" }
-mySchema.safeParse(12) // => { success: false; error: ZodError }
-```
-
-### 타입 추론
-
-```typescript
-import { z } from 'zod'
-
-const Player = z.object({
-  username: z.string(),
-  xp: z.number(),
-})
-
-// 스키마에서 타입 추출
-type Player = z.infer<typeof Player>
-
-// 타입 안전하게 사용
-const player: Player = { username: 'billie', xp: 100 }
-```
-
-## v4 주요 변경사항
-
-### 에러 커스터마이징 통합
-
-```typescript
-// v3 (deprecated)
-z.string().min(5, { message: "Too short." })
-z.string({ invalid_type_error: "Not a string", required_error: "Required" })
-
-// v4 - error 파라미터로 통합
+// 에러 커스텀: message → error
 z.string().min(5, { error: "Too short." })
-z.string({
-  error: (issue) => issue.input === undefined
-    ? "This field is required"
-    : "Not a string"
-})
-```
-
-### 새로운 최상위 문자열 포맷 API
-
-```typescript
-// v3 (deprecated)
-z.string().email()
-z.string().uuid()
-
-// v4 - 최상위 API (더 나은 tree-shaking)
-z.email()
-z.uuid()
-z.url()
-z.base64()
-z.nanoid()
-z.cuid()
-z.cuid2()
-z.ulid()
-z.ipv4()
-z.ipv6()
-z.iso.date()
-z.iso.time()
-z.iso.datetime()
-```
-
-### Strict/Loose 객체
-
-```typescript
-// v3
-z.object({ name: z.string() }).strict()
-z.object({ name: z.string() }).passthrough()
-
-// v4
-z.strictObject({ name: z.string() })
-z.looseObject({ name: z.string() })
-```
 
-### Refinements가 스키마 내부에 저장
+// Strict/Loose 객체
+z.strictObject({ name: z.string() })  // 추가 키 에러
+z.looseObject({ name: z.string() })   // 추가 키 통과
 
-```typescript
-// v3 - ZodEffects로 래핑되어 .min() 호출 불가
-z.string()
-  .refine(val => val.includes("@"))
-  .min(5) // ❌ Property 'min' does not exist on type ZodEffects
-
-// v4 - 스키마 내부에 저장되어 체이닝 가능
-z.string()
-  .refine(val => val.includes("@"))
-  .min(5) // ✅
-```
-
-## TanStack Start와 함께 사용
-
-```typescript
-import { createServerFn } from '@tanstack/react-start'
-import { zodValidator } from '@tanstack/react-start/validators'
-import { z } from 'zod'
-
-const createUserSchema = z.object({
-  email: z.email(),  // v4 새 API
-  name: z.string().min(1).max(100).trim(),
-  bio: z.string().max(500).optional(),
-})
-
-export const createUser = createServerFn({ method: 'POST' })
-  .inputValidator(zodValidator(createUserSchema))
-  .handler(async ({ data }) => {
-    // data는 타입 안전함
-    return prisma.user.create({ data })
-  })
+// Refinement 체이닝 가능
+z.string().refine(val => val.includes("@")).min(5)  // ✅ v4
 ```
-
-## 참고 자료
-
-- [Zod 공식 문서](https://zod.dev)
-- [Zod GitHub](https://github.com/colinhacks/zod)