第 5 章：工程化实践¶

// vitest.config.ts
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    globals: true,         // 全局 describe/it/expect（无需导入）
    environment: "node",   // 或 "jsdom"（浏览器环境）
    coverage: {
      provider: "v8",
      reporter: ["text", "html", "lcov"],
      thresholds: {
        lines: 80,
        functions: 80,
        branches: 70,
      },
    },
  },
});

// src/utils/validator.ts
export function validateEmail(email: string): boolean {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

export function validateAge(age: number): { valid: boolean; message?: string } {
  if (age < 0)   return { valid: false, message: "Age cannot be negative" };
  if (age > 150) return { valid: false, message: "Age seems unrealistic" };
  return { valid: true };
}

// src/utils/validator.test.ts
import { describe, it, expect } from "vitest";
import { validateEmail, validateAge } from "./validator";

describe("validateEmail", () => {
  it("should accept valid emails", () => {
    expect(validateEmail("user@example.com")).toBe(true);
    expect(validateEmail("user+tag@domain.co.uk")).toBe(true);
  });

  it("should reject invalid emails", () => {
    expect(validateEmail("not-an-email")).toBe(false);
    expect(validateEmail("@nodomain.com")).toBe(false);
    expect(validateEmail("spaces in@email.com")).toBe(false);
  });
});

describe("validateAge", () => {
  it("should return valid for reasonable ages", () => {
    expect(validateAge(25)).toEqual({ valid: true });
    expect(validateAge(0)).toEqual({ valid: true });
  });

  it("should return error for negative age", () => {
    expect(validateAge(-1)).toEqual({
      valid: false,
      message: "Age cannot be negative",
    });
  });

  it("should return error for unrealistic age", () => {
    const result = validateAge(200);
    expect(result.valid).toBe(false);
    expect(result.message).toContain("unrealistic");
  });
});

// src/types.test.ts
import { expectTypeOf, assertType } from "vitest";
import { type UserPublic } from "./types";

// 确保类型转换/工具类型的输出类型正确
it("UserPublic should not include password", () => {
  expectTypeOf<UserPublic>().not.toHaveProperty("password");
  expectTypeOf<UserPublic>().toHaveProperty("name");
  expectTypeOf<UserPublic["name"]>().toBeString();
});

// 确保函数返回类型正确
it("parseId should return number", () => {
  assertType<number>(parseId("42"));
});

// src/env.d.ts — 类型化环境变量（与实际配置同步！）
declare namespace NodeJS {
  interface ProcessEnv {
    readonly NODE_ENV: "development" | "production" | "test";
    readonly DATABASE_URL: string;
    readonly REDIS_URL: string;
    readonly JWT_SECRET: string;
    readonly API_KEY: string;
    // PORT 可能未设置
    readonly PORT?: string;
  }
}

// 使用时有完整类型提示
const dbUrl = process.env.DATABASE_URL; // string（不是 string | undefined！）
const port = process.env.PORT ?? "3000"; // string | undefined → string（有默认值）

// src/global.d.ts — 全局类型扩展
declare global {
  // 扩展全局对象
  interface Window {
    gtag: (...args: unknown[]) => void;
    dataLayer: Record<string, unknown>[];
  }

  // 全局工具类型（在整个项目中可用，无需导入）
  type Maybe<T> = T | null | undefined;
  type AsyncFn<T = void> = () => Promise<T>;
}

// 模块增强：给已有模块添加类型
import "express";
declare module "express" {
  interface Request {
    user?: { id: string; role: "admin" | "user" };
    requestId: string;
  }
}