Zod Validation

import { z } from "zod";

// Entity로부터 자동 생성
export const User = z.object({
id: z.number().int(),
email: z.string().max(100),
age: z.number().int(),
role: z.enum(["admin", "normal"]),
});

export type User = z.infer<typeof User>;

import { z } from "zod";

// 커스텀 스키마
export const LoginParams = z.object({
  email: z.string().email("유효한 이메일을 입력하세요"),
  password: z.string().min(8, "비밀번호는 최소 8자 이상"),
  rememberMe: z.boolean().optional(),
});

export type LoginParams = z.infer<typeof LoginParams>;

import { User } from "./user.types";

try {
const user = User.parse({
id: 1,
email: "john@test.com",
age: 30,
role: "admin",
});
// ✅ 검증 성공, user는 User 타입
console.log(user.email);
} catch (error) {
// ❌ 검증 실패 시 ZodError
console.error(error);
}

import { User } from "./user.types";

const result = User.safeParse({
  id: 1,
  email: "invalid-email",
  age: "30",
  role: "guest",
});

if (result.success) {
  // ✅ 검증 성공
  console.log(result.data.email);
} else {
  // ❌ 검증 실패
  console.error(result.error.issues);
  // [
  //   { path: ["email"], message: "Invalid email" },
  //   { path: ["age"], message: "Expected number, received string" },
  //   { path: ["role"], message: "Invalid enum value" }
  // ]
}

const email = z.string();
email.parse("john@test.com");  // ✅

const withLength = z.string().max(100);
withLength.parse("a".repeat(100)); // ✅
withLength.parse("a".repeat(101)); // ❌

const email = z.string().email();
email.parse("john@test.com");  // ✅
email.parse("invalid-email");  // ❌

const url = z.string().url();
url.parse("https://example.com"); // ✅
url.parse("not-a-url"); // ❌

const uuid = z.string().uuid();
uuid.parse("550e8400-e29b-41d4-a716-446655440000"); // ✅
uuid.parse("invalid-uuid"); // ❌

const username = z.string().regex(/^[a-zA-Z0-9_]+$/);
username.parse("john_doe"); // ✅
username.parse("john@doe"); // ❌

const age = z.number().int();
age.parse(30);  // ✅
age.parse(30.5);  // ❌ Must be integer

const age = z.number().int().min(0).max(120);
age.parse(30); // ✅
age.parse(-1); // ❌ Number must be greater than or equal to 0
age.parse(150); // ❌ Number must be less than or equal to 120

const price = z.number().positive();
price.parse(100); // ✅
price.parse(0); // ❌
price.parse(-10); // ❌

const count = z.number().nonnegative();
count.parse(0); // ✅
count.parse(10); // ✅
count.parse(-1); // ❌

const birthDate = z.date();
birthDate.parse(new Date());  // ✅
birthDate.parse("2024-01-01");  // ❌ Expected Date, received string

const birthDate = z.date().min(new Date("1900-01-01")).max(new Date());

birthDate.parse(new Date("2000-01-01")); // ✅
birthDate.parse(new Date("1800-01-01")); // ❌

// API에서 자주 사용
const dateSchema = z
  .string()
  .datetime()
  .transform((val) => new Date(val));

dateSchema.parse("2024-01-01T00:00:00.000Z"); // ✅ Date 객체 반환

const tags = z.string().array();
tags.parse(["typescript", "nodejs"]);  // ✅
tags.parse(["typescript", 123]);  // ❌

const tags = z.string().array().min(1).max(5);
tags.parse(["tag1"]); // ✅
tags.parse([]); // ❌ Array must contain at least 1 element(s)
tags.parse(["tag1", "tag2", "tag3", "tag4", "tag5", "tag6"]); // ❌

const tags = z.string().array().nonempty();
tags.parse(["tag1"]); // ✅
tags.parse([]); // ❌ Array must contain at least 1 element(s)

const user = z.object({
  name: z.string(),
  profile: z.object({
    bio: z.string(),
    website: z.string().url().optional(),
  }),
});

user.parse({
name: "John",
profile: {
bio: "Hello",
website: "https://john.com",
},
}); // ✅

const user = z.object({
  name: z.string(),
  nickname: z.string().optional(),  // undefined 허용
  bio: z.string().nullable(),       // null 허용
});

user.parse({ name: "John" });  // ✅ (nickname은 undefined)
user.parse({ name: "John", nickname: "JD" });  // ✅
user.parse({ name: "John", bio: null });  // ✅

const role = z.enum(["admin", "moderator", "normal"]);

role.parse("admin"); // ✅
role.parse("guest"); // ❌ Invalid enum value

const roles = z.enum(["admin", "moderator", "normal"]).array();

roles.parse(["admin", "normal"]);  // ✅
roles.parse(["admin", "guest"]);  // ❌

const password = z.string()
  .min(8)
  .refine(
    (val) => /[A-Z]/.test(val),
    { message: "대문자를 포함해야 합니다" }
  )
  .refine(
    (val) => /[0-9]/.test(val),
    { message: "숫자를 포함해야 합니다" }
  )
  .refine(
    (val) => /[!@#$%^&*]/.test(val),
    { message: "특수문자를 포함해야 합니다" }
  );

password.parse("Abc12345!"); // ✅
password.parse("abc12345"); // ❌ 대문자 없음

const user = z.object({
  password: z.string(),
  passwordConfirm: z.string(),
}).superRefine((data, ctx) => {
  if (data.password !== data.passwordConfirm) {
    ctx.addIssue({
      code: "custom",
      message: "비밀번호가 일치하지 않습니다",
      path: ["passwordConfirm"],
    });
  }

  if (data.password.length < 8) {
    ctx.addIssue({
      code: "custom",
      message: "비밀번호는 8자 이상이어야 합니다",
      path: ["password"],
    });
  }
});

const age = z.string().transform(val => parseInt(val, 10));

age.parse("30"); // ✅ 30 (number)

const email = z.preprocess(
  (val) => String(val).toLowerCase().trim(),
  z.string().email()
);

email.parse("  JOHN@TEST.COM  ");  // ✅ "john@test.com"

const age = z.coerce.number();

age.parse("30"); // ✅ 30 (number로 변환)
age.parse("abc"); // ❌ NaN은 number로 통과하지만 검증 실패

const settings = z.object({
  theme: z.enum(["light", "dark"]).default("light"),
  notifications: z.boolean().default(true),
});

settings.parse({}); // ✅ { theme: "light", notifications: true }
settings.parse({ theme: "dark" }); // ✅ { theme: "dark", notifications: true }

const count = z.number().catch(0);

count.parse(10);  // ✅ 10
count.parse("invalid");  // ✅ 0 (에러 대신 기본값)

export const UserListParams = z.object({
  num: z.number().int().min(1).max(100).default(24),
  page: z.number().int().min(1).default(1),
  search: z.enum(["id", "email", "username"]).optional(),
  keyword: z.string().trim().optional(),
  orderBy: z.enum(["id-desc", "id-asc", "created_at-desc"]).optional(),
}).refine(
  (data) => {
    // keyword가 있으면 search도 필수
    if (data.keyword && !data.search) {
      return false;
    }
    return true;
  },
  {
    message: "keyword와 search는 함께 사용해야 합니다",
    path: ["search"],
  }
);

export const UserSaveParams = z
  .object({
    id: z.number().int().optional(),
    email: z.string().email().max(100),
    username: z
      .string()
      .min(2)
      .max(50)
      .regex(/^[a-zA-Z0-9_]+$/),
    password: z.string().min(8).optional(),
    role: z.enum(["admin", "normal"]).default("normal"),
  })
  .refine(
    (data) => {
      // 새 사용자면 password 필수
      if (!data.id && !data.password) {
        return false;
      }
      return true;
    },
    {
      message: "새 사용자는 비밀번호가 필요합니다",
      path: ["password"],
    },
  );

const dateRange = z.object({
  startDate: z.date(),
  endDate: z.date(),
}).refine(
  (data) => data.endDate > data.startDate,
  {
    message: "종료일은 시작일보다 이후여야 합니다",
    path: ["endDate"],
  }
).refine(
  (data) => {
    const diff = data.endDate.getTime() - data.startDate.getTime();
    const days = diff / (1000 * 60 * 60 * 24);
    return days <= 365;
  },
  {
    message: "기간은 최대 1년까지만 가능합니다",
    path: ["endDate"],
  }
);

const payment = z
  .object({
    amount: z.number().positive(),
    discount: z.number().nonnegative().optional(),
  })
  .refine(
    (data) => {
      if (data.discount && data.discount > data.amount) {
        return false;
      }
      return true;
    },
    {
      message: "할인 금액은 결제 금액보다 클 수 없습니다",
      path: ["discount"],
    },
  );

const user = z.object({
  email: z.string().email("유효한 이메일 주소를 입력하세요"),
  age: z.number()
    .int("나이는 정수여야 합니다")
    .min(0, "나이는 0 이상이어야 합니다")
    .max(120, "나이는 120 이하여야 합니다"),
});

import { z } from "zod";

// 한국어 에러 메시지
const customErrorMap: z.ZodErrorMap = (issue, ctx) => {
  if (issue.code === z.ZodIssueCode.invalid_type) {
    if (issue.expected === "string") {
      return { message: "문자열을 입력해주세요" };
    }
    if (issue.expected === "number") {
      return { message: "숫자를 입력해주세요" };
    }
  }
  if (issue.code === z.ZodIssueCode.too_small) {
    return { message: `최소 ${issue.minimum}자 이상 입력해주세요` };
  }
  return { message: ctx.defaultError };
};

z.setErrorMap(customErrorMap);