🛠️ 처음부터 만드는 Schema Validator — Zod-style 체이너블 검증기 20줄 구현

Zod가 TypeScript 생태계를 지배하는 이유? `z.string().min(1)` 같은 체이너블 API의 직관성.
핵심은 하나: 모든 스키마는 "값 → 에러 문자열 | null" 함수다. 이걸 감싸서 체이닝을 만든다.
```js
function make(fn) {
return {
parse: v => { const e = fn(v); if (e) throw new Error(e); return v },
safeParse: v => { const e = fn(v); return e ? { ok:false, error:e } : { ok:true, data:v } },
optional: () => make(v => v == null ? null : fn(v)),
refine: (test, msg='invalid') => make(v => fn(v) || (test(v) ? null : msg)),
}
}
const z = {
string: () => make(v => typeof v !== 'string' ? 'expected string' : null),
number: () => make(v => typeof v !== 'number' ? 'expected number' : null),
object: (shape) => make(v => {
if (!v || typeof v !== 'object') return 'expected object';
for (const [k, s] of Object.entries(shape)) {
const r = s.safeParse(v[k]); if (!r.ok) return `${k}: ${r.error}`;
}
}),
array: (inner) => make(v => {
if (!Array.isArray(v)) return 'expected array';
for (let i = 0; i < v.length; i++) {
const r = inner.safeParse(v[i]); if (!r.ok) return `[${i}]: ${r.error}`;
}
}),
};
```
사용 예시:
```js
const User = z.object({
name: z.string().refine(s => s.length > 0, 'name required'),
age: z.number().refine(n => n >= 0, 'must be positive'),
tags: z.array(z.string()).optional(),
});
User.parse({ name: 'Kim', age: 28 }); // ✅
User.parse({ name: '', age: 28 });
// ❌ Error: name: name required
```
핵심 구조:
`make(fn)` — 검증 함수를 감싸 스키마 객체 생성. 모든 메서드가 새 `make()`를 반환해 이뮤터블 체이닝.
`refine()` — 기존 검증 먼저 실행, 통과 시 추가 조건 검사. `||` 연산자로 에러 전파.
`object()` — shape 각 키의 `safeParse` 실행, 첫 에러를 `key: error` 형태로 반환.
> 실제 Zod는 여기에 TypeScript 타입 추론(`z.infer`)을 더합니다. 하지만 런타임 검증의 핵심은 이 20줄에 전부 있습니다.