Zod는 런타임에 어떻게 타입을 검증하는가? - (2) 직접 만든 zod 구조의 한계

직접 만든 Zod 구조의 한계

// 1편의 순진한 optional — 타입에 undefined만 더했습니다
function optional<S extends Schema<unknown>>(inner: S): Schema<Infer<S> | undefined> {
  return {
    parse(value) {
      if (value === undefined) return undefined;
      return inner.parse(value);
    },
  };
}

const User = m.object({ name: m.string(), age: optional(m.number()) });
type User = Infer<typeof User>;
// { name: string; age: number | undefined }
//                  ^^^ age?: 가 아니라 age: 입니다

const u: User = { name: "kim" }; // 에러: Property 'age' is missing

import * as z from "zod";

// 문자열을 받아 검증한 뒤, 그 길이(number)로 바꿔 내보냅니다
const NameLength = z.string().transform((s) => s.trim().length);

NameLength.parse("  kim  "); // 3 (number)

type In = z.input<typeof NameLength>;   // string — parse에 들어가는 타입
type Out = z.output<typeof NameLength>; // number — parse를 통과해 나온 타입

// 1편에서 만든 Schema 타입 — Output 이라는 타입을 하나만 들고 다닙니다
interface Schema<Output> {
  parse(value: unknown): Output;
}

optional 키에 진짜 ? 붙이기 — key remapping

const User = m.object({ name: m.string(), age: optional(m.number()) });
type User = Infer<typeof User>; // { name: string; age?: number }

// optional 여부를 타입 레벨에 새기는 표식을 추가합니다
interface Schema<Output> {
  parse(value: unknown): Output;
  optional?: "optional"; // 보통 schema는 이 칸이 없을 수 있습니다
}

// optional schema는 항상 "optional"을 갖습니다
interface OptionalSchema<Output> extends Schema<Output> {
  optional: "optional";
}

key remapping이란? 매핑 타입에서 [K in keyof T as ...] 형태로 각 키를 다른 키 이름으로 바꾸거나 never로 걸러내는 기능입니다.

// 값을 never로 둬도 키는 사라지지 않습니다 — 여전히 필수로 남습니다
type T = { [K in "a" | "b"]: K extends "a" ? string : never };
// { a: string; b: never } 결과로 나온 타입을 보면 b 키가 그대로 있고, 심지어 필수입니다.

// 교집합(A & B) 객체를 펼쳐 한 덩어리로 줍니다.
type Prettify<T> = { [K in keyof T]: T[K] } & {};

type A = { name: string };
type B = { age?: number };

type Merged = A & B;
// 에디터 힌트: A & B  ← 합쳐진 모양이 아니라 식 그대로 보입니다.
// {name: string} & {age?: number}

type Pretty = Prettify<A & B>;
// 에디터 힌트: { name: string; age?: number }  ← 한 객체로 펼쳐집니다

// 표식을 가진 키와 아닌 키를 두 블록으로 갈라 합칩니다
type Shape = Record<string, Schema<unknown>>;
type OptionalMarker = { optional: "optional" };

type ObjectOutput<S extends Shape> = Prettify<
  // 1) 표식 없는 키는 그대로 필수
  { [K in keyof S as S[K] extends OptionalMarker ? never : K]: Infer<S[K]> } &
  // 2) 표식 있는 키는 ?를 붙여 optional
  { [K in keyof S as S[K] extends OptionalMarker ? K : never]?: Infer<S[K]> }
>;

// 표식을 달고, output에는 undefined를 더합니다
function optional<S extends Schema<unknown>>(
  inner: S,
): OptionalSchema<Infer<S> | undefined> {
  return {
    optional: "optional",
    parse(value) {
      if (value === undefined) return undefined;
      return inner.parse(value) as Infer<S>;
    },
  };
}

const User = m.object({ name: m.string(), age: optional(m.number()) });
type User = Infer<typeof User>; // { name: string; age?: number | undefined }

const u: User = { name: "kim" }; // 통과합니다

input 타입을 실어 나를 자리 만들기 — phantom 타입

// Input을 실어 나르는 phantom 슬롯을 추가합니다 (런타임 값은 없습니다)
interface Schema<Output, Input = Output> {
  parse(value: unknown): Output;
  readonly _input?: Input; // 타입만 운반하고, 실제 값은 들어가지 않습니다
  optional?: "optional";
}

// output은 첫 제네릭에서, input은 둘째 제네릭에서 꺼냅니다
type Infer<S> = S extends Schema<infer O, any> ? O : never;
type InferInput<S> = S extends Schema<any, infer I> ? I : never;

// output은 fn의 반환 타입, input은 원래 schema의 input을 잇습니다
function transform<S extends Schema<unknown>, NewOut>(
  inner: S,
  fn: (value: Infer<S>) => NewOut,
): Schema<NewOut, InferInput<S>> {
  return {
    parse(value) {
      return fn(inner.parse(value) as Infer<S>);
    },
  };
}

const Id = transform(m.string(), (s) => s.length);
type IdOut = Infer<typeof Id>;      // number
type IdIn = InferInput<typeof Id>;  // string

// output 객체와 input 객체를 따로 재구성합니다
type ObjectOutput<S extends Shape> = Prettify<
  { [K in keyof S as S[K] extends OptionalMarker ? never : K]: Infer<S[K]> } &
  { [K in keyof S as S[K] extends OptionalMarker ? K : never]?: Infer<S[K]> }
>;
type ObjectInput<S extends Shape> = Prettify<
  { [K in keyof S as S[K] extends OptionalMarker ? never : K]: InferInput<S[K]> } &
  { [K in keyof S as S[K] extends OptionalMarker ? K : never]?: InferInput<S[K]> }
>;

function object<S extends Shape>(shape: S): Schema<ObjectOutput<S>, ObjectInput<S>> {
  return {
    parse(value) {
      if (typeof value !== "object" || value === null) throw new Error("object가 아닙니다");
      const result: Record<string, unknown> = {};
      for (const key in shape) result[key] = shape[key].parse((value as Record<string, unknown>)[key]);
      return result as ObjectOutput<S>;
    },
  };
}

export const m = { string, number, object, optional, transform };

실제 Zod 4 소스와 대조

export type input<T> = T extends { _zod: { input: any } } ? T["_zod"]["input"] : unknown;
export type output<T> = T extends { _zod: { output: any } } ? T["_zod"]["output"] : unknown;
export type { output as infer };

export interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
  /** @internal The inferred output type */
  output: O;
  /** @internal The inferred input type */
  input: I;
}

export interface $ZodOptionalInternals<T extends SomeType = $ZodType>
  extends $ZodTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {
  optin: "optional";
  optout: "optional";
}

type OptionalOutSchema = { _zod: { optout: "optional" } };

// ...
{
  -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
} & {
  -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
} & Extra

transform(tx) {
  return pipe(this, transform(tx));
}

export interface $ZodPipeInternals<A extends SomeType, B extends SomeType>
  extends $ZodTypeInternals<core.output<B>, core.input<A>> {
  optin: A["_zod"]["optin"];
  optout: B["_zod"]["optout"];
}

그래도 남는 것

마무리

참고 자료

• TypeScript Handbook — Mapped Types (Key Remapping via as)

• TypeScript Handbook — Conditional Types

• Zod 공식 문서 — Zod Core ($ZodType, _zod internals)

• Zod 공식 문서 — Defining schemas (object, optional)

• colinhacks/zod — v4 core schemas.ts (v4.4.3, $InferObjectOutput·$ZodOptional·$ZodPipe)

• colinhacks/zod — v4 core core.ts (v4.4.3, output·input·infer)