結合 Zod 與 TypeScript，為 AI 應用建立可靠的資料驗證機制

import { z } from "zod";

// 建立字串模式
const stringSchema = z.string();

// 驗證成功
stringSchema.parse("hello"); // => "hello"

// 驗證失敗（將拋出 ZodError）
try {
  stringSchema.parse(12);
} catch (error) {
  console.log((error as z.ZodError).errors);
  // [
  //   {
  //     code: 'invalid_type',
  //     expected: 'string',
  //     received: 'number',
  //     path: [],
  //     message: 'Expected string, received number'
  //   }
  // ]
}

// 安全驗證（不拋出錯誤）
const result = stringSchema.safeParse("hello");
if (result.success) {
  console.log(result.data); // "hello"
} else {
  console.log((result.error as z.ZodError).errors); // ZodError details
}

// 定義物件模式
const UserSchema = z.object({
  username: z.string(),
  email: z.string().email(),
  age: z.number().min(18),
});

// 型別自動推斷
type User = z.infer<typeof UserSchema>;
// 等同於：{ username: string; email: string; age: number }

import { z } from "zod";

const UserSchema = z.object({
    id: z.string().uuid(),
    name: z.string().min(2),
    email: z.string().email(),
    role: z.enum(["admin", "user", "guest"]),
    metadata: z.record(z.string()),
    lastLogin: z.date().optional(),
  });
  
  // 自動推斷類型
type User = z.infer<typeof UserSchema>;

const user: User = {
    id: "8dd7d69c-ab17-468c-80b5-c71658aa6b07",
    name: "John Doe",
    email: "john.doe@example.com",    
    role: "admin",
    metadata: {
        age: "30"
    },
    lastLogin: new Date("2023-03-15T12:34:56.789Z")
}

const result = UserSchema.parse(user);
console.log(result);

/*
{
  id: '8dd7d69c-ab17-468c-80b5-c71658aa6b07',
  name: 'John Doe',
  email: 'john.doe@example.com',
  role: 'admin',
  metadata: { age: '30' },
  lastLogin: 2023-03-15T12:34:56.789Z
}
*/

// 表單提交處理器：結合 TypeScript 類型與 Zod 執行時驗證
function handleSubmit(formData: unknown) {
  try {
    // 驗證資料結構與型別
    const validatedData = UserSchema.parse(formData);
    // 通過驗證後的資料具備完整型別安全
    saveToDatabase(validatedData);
    console.log("資料已成功儲存");
  } catch (error) {
    if (error instanceof z.ZodError) {
      // 輸出詳細驗證錯誤訊息
      console.error("表單驗證失敗：", error.errors);
    } else {
      console.error("未知錯誤：", error);
    }
  }
}

import { z } from "zod";

// 字串驗證
const username = z.string()
  .min(3, "用戶名至少需要 3 個字符")
  .max(20, "用戶名不能超過 20 個字符");

// 數字驗證
const price = z.number()
  .positive("價格必須為正數")
  .min(0.01, "價格最少為 0.01");

// 複雜對象驗證
const Product = z.object({
  id: z.string().uuid(),
  name: z.string().min(3),
  price: z.number().positive(),
  tags: z.array(z.string()),
  stock: z.number().int().nonnegative(),
});

const user = username.parse("calpa");
console.log(user);

const priceValue = price.parse(10.99);
console.log(priceValue);

const product = Product.parse({
  id: "8dd7d69c-ab17-468c-80b5-c71658aa6b07",
  name: "Product A",
  price: 10.99,
  tags: ["tag1", "tag2"],
  stock: 10,
});

console.log(product);

const registerUser = z
  .function()
  .args(
    z.object({
      username: z.string().min(3),
      password: z.string().min(8),
    })
  )
  .returns(z.object({ id: z.string().uuid() }))
  .implement(async ({ username, password }) => {
    // 處理註冊邏輯...
    return { id: crypto.randomUUID() };
  });

// 呼叫時自動檢查型別
registerUser({ username: "calpa", password: "supersecret123" }).then(console.log);
// registerUser({ username: "ab", password: "123" }); // ❌ 參數驗證失敗

import React, { useState } from "react";
import { z } from "zod";

const schema = z.object({
  email: z.string().email({ message: "請輸入有效的電子郵件" }),
  age: z
    .number({ invalid_type_error: "年齡必須為數字" })
    .min(18, { message: "必須年滿 18 歲" }),
});

export default function SignupForm() {
  const [form, setForm] = useState({ email: "", age: "" });
  const [error, setError] = useState<string | null>(null);
  const [success, setSuccess] = useState(false);

  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setForm({ ...form, [e.target.name]: e.target.value });
    setError(null);
    setSuccess(false);
  };

  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    const parseResult = schema.safeParse({
      email: form.email,
      age: Number(form.age),
    });
    if (!parseResult.success) {
      setError(parseResult.error.errors.map(e => e.message).join("，"));
      setSuccess(false);
      return;
    }
    setError(null);
    setSuccess(true);
    // 實際應用場景可在此處發送 API 請求
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        name="email"
        value={form.email}
        onChange={handleChange}
        placeholder="Email"
        type="email"
        required
      />
      <input
        name="age"
        value={form.age}
        onChange={handleChange}
        placeholder="年齡"
        type="number"
        required
      />
      <button type="submit">提交</button>
      {error && <div style={{ color: "red" }}>{error}</div>}
      {success && <div style={{ color: "green" }}>提交成功！</div>}
    </form>
  );
}

import { z } from "zod";

// 定義 AI 回傳資料的 schema
const AIResponseSchema = z.object({
  text: z.string(),
  confidence: z.number().min(0).max(1),
  entities: z.array(
    z.object({
      type: z.enum(["person", "organization", "location"]),
      text: z.string(),
      score: z.number().min(0).max(1),
    })
  ),
});

// 處理 AI 回應
async function handleAIResponse(rawResponse: unknown) {
  const result = AIResponseSchema.safeParse(rawResponse);
  if (!result.success) {
    console.error("AI 回應格式無效", result.error.issues);
    return;
  }
  // result.data 已自動型別推導且安全
  processEntities(result.data.entities);
}

// 假設的實體處理函數
function processEntities(entities: Array<{ type: string; text: string; score: number }>) {
  entities.forEach((entity) => {
    console.log(`[${entity.type}] ${entity.text} (score: ${entity.score})`);
  });
}