TypeScript の型推論つきバリデーションライブラリ Zod を使ってみた

// スキーマを 1 つ定義する
const userSchema = z.object({
  name: z.string().min(1), // 1文字以上の文字列
  age: z.int().gte(0), // 0以上の整数
});

// ① このスキーマから TypeScript の型を生成（コンパイル時）
type User = z.infer<typeof userSchema>;
// type User = { name: string; age: number }

// ② 同じスキーマで実行時のバリデーション（ランタイム）
userSchema.safeParse(input);

// 型定義
interface User {
  id: string;
  name: string;
  age: number;
}

// 実行時チェックは別途関数で
function isValidUser(input: unknown): input is User {
  if (typeof input !== "object" || input === null) return false;
  const u = input as Record<string, unknown>;
  if (typeof u.id !== "string") return false;
  if (typeof u.name !== "string" || u.name.length === 0) return false;
  if (typeof u.age !== "number" || u.age < 0 || u.age > 150) return false;
  return true;
}
// フィールドを追加するたびに interface と isValidUser を両方直す必要がある

const userSchema = z.object({
  id: z.uuidv4(),
  name: z.string().min(1),
  age: z.int().gte(0).lte(150),
});

type User = z.infer<typeof userSchema>; // 型はここから取り出すだけ
// スキーマを直せば、型もチェックも同時に変わる

mkdir zod && cd zod
pnpm init
pnpm add zod
pnpm add -D tsx typescript

import { z } from "zod";

// 個々の値に対するスキーマ
const nameSchema = z.string().min(1).max(20);
const ageSchema = z.int().gte(0).lte(150);

// 通る値はそのまま返ってくる
console.log(nameSchema.parse("田中太郎")); // → "田中太郎"
console.log(ageSchema.parse(30)); // → 30

// 通らない値は ZodError を投げる
try {
  ageSchema.parse(200); // lte(150) に違反
} catch (e) {
  console.error("失敗:", (e as Error).message);
}

const emailSchema = z.email();
const idSchema = z.uuidv4(); // UUID v4 専用

pnpm tsx src/index.ts

const badInput = {
  id: "not-a-uuid", // UUID 形式ではない
  name: "", // min(1) を満たさない
  age: 200, // lte(150) を超えている
  deleteFlag: false,
};

const result = userSchema.safeParse(badInput);

if (!result.success) {
  // 失敗時: result.error が ZodError、issues に詳細が入る
  console.error("バリデーション失敗");
  result.error.issues.forEach((issue) => {
    console.error(`  [${issue.path.join(".")}] ${issue.message}`);
  });
} else {
  // 成功時: result.data が User 型に絞り込まれている
  console.log("OK:", result.data);
}

import { z } from "zod";

const schema = z.object({
  user: z.object({
    name: z.string().min(1), // 1文字以上
    age: z.int().gte(0), // 0以上の整数
  }),
});

// わざと両方とも違反する値を渡す（name は空文字、age はマイナス）
const result = schema.safeParse({ user: { name: "", age: -1 } });

// 同じ error を 3 つの整形関数に通して出力を見比べる
if (!result.success) {
  // ① treeifyError: スキーマの構造に沿ったネスト構造で返る
  console.log("--- treeifyError ---");
  console.log(JSON.stringify(z.treeifyError(result.error), null, 2));

  // ② flattenError: { formErrors, fieldErrors } のフラットな形で返る
  console.log("--- flattenError ---");
  console.log(z.flattenError(result.error));

  // ③ prettifyError: 人が読める整形済みの文字列で返る
  console.log("--- prettifyError ---");
  console.log(z.prettifyError(result.error));
}

const periodSchema = z
  .object({
    // どちらもオフセット付き ISO 8601 形式（例: 2025-12-31T10:00:00+09:00）
    startDateTime: z.iso.datetime({ offset: true }),
    endDateTime: z.iso.datetime({ offset: true }),
  })
  // .refine で複数フィールドにまたがるチェック（開始 <= 終了）を追加
  .refine(
    (data) => new Date(data.startDateTime) <= new Date(data.endDateTime),
    // path でどのフィールドのエラーとして扱うか、error でメッセージを指定
    { path: ["startDateTime"], error: "開始日時は終了日時以前にしてください" }
  );

// 開始が終了より後 → .refine のチェックに引っかかる入力
const ng = periodSchema.safeParse({
  startDateTime: "2025-12-31T10:00:00+09:00",
  endDateTime: "2025-12-01T10:00:00+09:00",
});

if (!ng.success) {
  // path で指定した startDateTime にカスタムメッセージが出る
  console.log(z.prettifyError(ng.error));
}

const articleSchema = z.object({
  published: z.int().gte(0).lte(1),
  featuredFlag: z
    .literal("featured") // "featured" のみ受け付ける
    .transform(() => 1) // 値を 1 に置き換える
    .optional(), // 省略可
});

const parsed = articleSchema.parse({ published: 1, featuredFlag: "featured" });
console.log(parsed); // → { published: 1, featuredFlag: 1 }

const schema = z.strictObject({ id: z.string() });

// id は OK だが、定義していない extra が混ざっている
const result = schema.safeParse({ id: "abc", extra: "hoge" });

if (!result.success) {
  console.log(z.prettifyError(result.error));
}

const baseUserSchema = z.object({
  id: z.uuidv4(),
  name: z.string().min(1).max(256),
});

// 別スキーマで .shape から個別フィールドを参照する
const requestSchema = z.object({
  userId: baseUserSchema.shape.id, // baseUserSchema の id と同じ制約
  userName: baseUserSchema.shape.name, // baseUserSchema の name と同じ制約
});

const userWithRoleSchema = z.object({
  ...baseUserSchema.shape, // 既存の id / name をそのまま展開
  role: z.enum(["admin", "user"]), // role を追加
});

// DB テーブルに対応するスキーマ
const fishSchema = z.strictObject({
  fishId: z.uuidv4(),
  fishName: z.string().min(1).max(256),
  species: z.enum(["tuna", "salmon", "mackerel"]),
  createDateTime: z.iso.datetime(),
});

// API スキーマは fishSchema からフィールドを再利用する
const apiRequestSchema = z.object({
  fish: fishSchema.shape.fish, // DB 側と同じバリデーションを使い回す
});