1
2
3
4
5
6
7

import * as v from "valibot";

const UserSchema = v.object({
  id: v.number(),
  name: v.pipe(v.string(), v.minLength(1)),
  email: v.pipe(v.string(), v.email()),
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import * as v from "valibot";

// transform 会改变输出类型
const Schema = v.pipe(
  v.string(),
  v.transform((s) => s.length),
);

type In = v.InferInput<typeof Schema>;    // string  ← 接口收到的
type Out = v.InferOutput<typeof Schema>;  // number  ← 转换后的

1
2
3
4
5
6
7

const result = v.safeParse(UserSchema, raw);
if (result.success) {
  const user: v.InferOutput<typeof UserSchema> = result.output;
  console.log(user.name);
} else {
  console.log(result.issues);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import { type } from "arktype";

const User = type({
  id: "number",
  name: "string",
  "role?": "'admin' | 'user'",
});

type U = typeof User.infer;    // 直接得到类型
const out = User(raw);          // 校验（返回错误或数据）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import type { Static, TSchema } from "@sinclair/typebox";
import { Type } from "@sinclair/typebox";
import Ajv from "ajv";

const UserSchema = Type.Object({
  id: Type.Number(),
  name: Type.String(),
});
type User = Static<typeof UserSchema>;   // ✅ 类型从 schema 来

const ajv = new Ajv();
const validate = ajv.compile(UserSchema);
if (validate(raw)) { /* raw 现在是 User */ }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import { z } from "zod";

const EnvSchema = z.object({
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
  PORT: z.coerce.number().int().min(1).max(65535).default(3000),
  DATABASE_URL: z.url(),
  API_KEY: z.string().min(1),
  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
  FEATURE_X: z.coerce.boolean().default(false),
});

// ✅ 在进程启动时校验一次，失败立刻退出
function loadEnv() {
  const parsed = EnvSchema.safeParse(process.env);
  if (!parsed.success) {
    console.error("环境变量配置错误：");
    for (const issue of parsed.error.issues) {
      console.error(`  ${issue.path.join(".")}: ${issue.message}`);
    }
    process.exit(1);      // 🔥 启动即失败，好过运行时才炸
  }
  return parsed.data;
}

export const env = loadEnv();
// env.PORT 是 number ✅，env.NODE_ENV 是联合类型 ✅

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import { z } from "zod";

const SettingsSchema = z.object({
  theme: z.enum(["light", "dark"]).default("light"),
  fontSize: z.number().min(8).max(72).default(14),
});
type Settings = z.infer<typeof SettingsSchema>;

const KEY = "app-settings";

function loadSettings(): Settings {
  const raw = localStorage.getItem(KEY);
  if (raw === null) return SettingsSchema.parse({});   // 用默认值

  try {
    const parsed = SettingsSchema.safeParse(JSON.parse(raw));
    if (parsed.success) return parsed.data;

    // ⚠️ 数据不符合当前 schema（很可能是旧版本写的）
    console.warn("设置格式已变化，使用默认值", parsed.error.issues);
    return SettingsSchema.parse({});
  } catch {
    // JSON 本身就坏了
    console.warn("设置数据损坏，使用默认值");
    return SettingsSchema.parse({});
  }
}

function saveSettings(s: Settings): void {
  localStorage.setItem(KEY, JSON.stringify(s));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

const V2Schema = z.object({
  version: z.literal(2),
  settings: SettingsSchema,
});

type Stored = z.infer<typeof V2Schema>;

function load(): Settings {
  const raw = localStorage.getItem(KEY);
  if (!raw) return SettingsSchema.parse({});

  let data: unknown;
  try { data = JSON.parse(raw); } catch { return SettingsSchema.parse({}); }

  // 按 version 分派
  const v2 = V2Schema.safeParse(data);
  if (v2.success) return v2.data.settings;

  // 旧版本迁移
  const legacy = LegacySchema.safeParse(data);
  if (legacy.success) return migrateV1toV2(legacy.data);

  return SettingsSchema.parse({});
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import { z } from "zod";

const SignupSchema = z.object({
  email: z.email("请输入有效邮箱"),
  password: z.string().min(8, "密码至少 8 位"),
  confirm: z.string(),
  age: z.coerce.number().int().min(18, "需年满 18 岁"),
}).refine((d) => d.password === d.confirm, {
  message: "两次密码不一致",
  path: ["confirm"],            // ✅ 把错误挂到具体字段
});

type Signup = z.infer<typeof SignupSchema>;

function handleSubmit(formData: FormData) {
  // FormData 的值都是 string | File | null，先转成普通对象
  const raw = Object.fromEntries(formData.entries());
  const parsed = SignupSchema.safeParse(raw);

  if (!parsed.success) {
    // 按字段聚合错误，方便渲染到表单项上
    const fieldErrors = z.flattenError(parsed.error);
    return { ok: false as const, errors: fieldErrors.fieldErrors };
  }
  return { ok: true as const, data: parsed.data };
}