《TypeScript高级编程》10.3 边界数据与不可信输入

// 校验：返回 boolean，调用方拿到的东西类型没变
declare function validateUser(input: unknown): boolean;

// 解析：返回类型化结果，调用方拿到的东西类型变了
declare function parseUser(input: unknown): User;

const data: unknown = await req.json();
if (validateUser(data)) {
  // data 的类型仍然是 unknown
  // data.name; ❌ Object is of type 'unknown'.
}

const user = parseUser(await req.json());
user.name.toUpperCase(); // ✅ 类型确定

declare const brand: unique symbol;

type Brand<T, B extends string> = T & { readonly [brand]: B };

type UserId = Brand<number, "UserId">;
type Email = Brand<string, "Email">;

// 唯一能构造出 Email 的地方
function parseEmail(input: unknown): Email {
  if (typeof input !== "string" || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(input)) {
    throw new ValidationError([`非法邮箱: ${String(input)}`]);
  }
  return input as Email; // 这里是唯一允许的断言，且被局部验证覆盖
}

const raw = "a@b.com";
sendEmail(raw);        // ❌ Argument of type 'string' is not assignable to parameter of type 'Email'.
sendEmail(parseEmail(raw)); // ✅

import { z } from "zod"; // 或 10.1 里手写的 Validator

const CreateOrder = z.object({
  sku: z.string().min(1),
  qty: z.number().int().positive(),
});

app.post("/orders", async (req, res) => {
  const parsed = CreateOrder.safeParse(req.body); // body 是 any，但立刻被收口
  if (!parsed.success) {
    return res.status(400).json({ issues: parsed.error.issues });
  }
  const order = parsed.data; // 类型确定
  res.json(await createOrder(order));
});

const { id } = req.params; // 类型是 string，但可能是 "abc"
const num = Number(id);    // NaN
await db.findUser(num);    // 静默查不到，或查到意外结果

function requireEnv(name: string): string {
  const v = process.env[name];
  if (v === undefined || v.trim() === "") {
    throw new Error(`缺少必需的环境变量 ${name}`);
  }
  return v;
}

const PORT = (() => {
  const n = Number(requireEnv("PORT"));
  if (!Number.isInteger(n) || n <= 0 || n > 65535) throw new Error(`PORT 非法: ${n}`);
  return n;
})();

const DEBUG = requireEnv("DEBUG") === "true"; // 注意：不是 Boolean("false") === true 的坑

console.log(Boolean("false")); // true  ← 经典陷阱
console.log(Boolean("0"));     // true
console.log(Boolean(""));      // false

const res = await fetch("https://api.partner.com/v1/user/42");
if (!res.ok) throw new Error(`上游失败: ${res.status}`);

const payload = PartnerUserSchema.safeParse(await res.json());
if (!payload.success) {
  // 关键：上游格式变了要能快速发现，而不是静默降级
  throw new UpstreamContractError(payload.error.issues);
}
const partner = payload.data;

// ❌ 把 any 直接当业务类型
const { rows } = await pool.query("SELECT id, name, deleted_at FROM users WHERE id = $1", [id]);
const user: User = rows[0];

// ✅ 显式声明行类型并解析
interface UserRow { id: number; name: string; deleted_at: Date | null }
const { rows } = await pool.query<UserRow>("SELECT ...", [id]);
const user = parseUserRow(rows[0]); // 处理 null、软删除、历史脏数据

function parseUserRow(row: UserRow | undefined): User {
  if (!row) throw new NotFoundError("user");
  if (row.deleted_at !== null) throw new GoneError("user 已删除");
  return { id: row.id, name: row.name.trim() || "匿名" };
}

const payload = JSON.parse('{"__proto__":{"isAdmin":true}}');
console.log(Object.keys(payload)); // [ '__proto__' ] —— 是自有属性，不触发 setter

function merge(target: any, source: any): any {
  for (const key in source) {
    const val = source[key];
    if (typeof val === "object" && val !== null) {
      target[key] = merge(target[key] ?? {}, val);
    } else {
      target[key] = val;
    }
  }
  return target;
}

const user = merge({}, JSON.parse('{"__proto__":{"isAdmin":true}}'));
console.log(user.isAdmin); // true  ← 通过原型链读到
console.log({}.isAdmin);   // undefined ← 尚未污染全局

merge({}, JSON.parse('{"constructor":{"prototype":{"isAdmin":true}}}'));
console.log({}.isAdmin); // true  ← 全进程所有对象都被污染

const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);

function safeMerge<T extends Record<string, unknown>>(target: T, source: unknown): T {
  if (typeof source !== "object" || source === null) return target;
  for (const key of Object.keys(source)) {      // ① 只取自有可枚举键
    if (UNSAFE_KEYS.has(key)) continue;          // ② 拒绝危险键
    const val = (source as Record<string, unknown>)[key];
    if (typeof val === "object" && val !== null) {
      const base = Object.hasOwn(target, key) ? (target as any)[key] : undefined;
      const baseObj = typeof base === "object" && base !== null ? base : Object.create(null); // ③ 无原型容器
      (target as any)[key] = safeMerge(baseObj, val);
    } else {
      (target as any)[key] = val;
    }
  }
  return target;
}

{
  "rules": {
    "@typescript-eslint/no-unsafe-assignment": "error",
    "@typescript-eslint/no-unsafe-member-access": "error",
    "@typescript-eslint/no-unsafe-return": "error"
  }
}