Fullstack Node.js & React
Trang chủ / Module 2
🔷 Module 2 / 19 · 5 ngày 📅 Tuần 1-2 ●●●○ Khó

TypeScript nâng cao: thiết kế kiểu cho codebase lớn

Từ strict mode tới generics, discriminated union, mapped/conditional types và validate runtime bằng Zod — để kiểu dữ liệu chạy xuyên suốt từ database tới UI.

GenericsNarrowingUtility typesZodtsconfig strict
📌 Vì sao module này quan trọng

Gần như mọi job fullstack Node/React lương cao năm 2026 ghi "strong TypeScript". Khác biệt giữa junior và senior không phải biết interface, mà là dùng hệ thống kiểu để làm cho trạng thái sai không thể biểu diễn được: một API response không thể vừa loading vừa có error, một hàm không thể nhận userId thay cho orderId. TypeScript tốt biến cả một loại bug runtime thành lỗi biên dịch, và cho phép bạn refactor codebase 100k dòng mà không sợ.

🎯 Mục tiêu học tập

  • Cấu hình tsconfig strict cho Node và React, hiểu từng cờ quan trọng
  • Dùng narrowing, type guard, discriminated union và exhaustive check
  • Viết generic có ràng buộc; đọc hiểu được type của thư viện
  • Dùng utility, mapped, conditional và template literal types đúng chỗ
  • Validate dữ liệu runtime bằng Zod và suy ra type từ schema

tsconfig strict: những cờ phải bật

{
  "compilerOptions": {
    "target": "ES2023",
    "module": "NodeNext",              // backend Node; frontend bundler dùng "ESNext" + "moduleResolution": "Bundler"
    "moduleResolution": "NodeNext",
    "strict": true,                    // bật cả nhóm strictNullChecks, noImplicitAny, ...
    "noUncheckedIndexedAccess": true,  // arr[0] có kiểu T | undefined — bắt rất nhiều bug
    "exactOptionalPropertyTypes": true,
    "noImplicitOverride": true,
    "verbatimModuleSyntax": true,      // bắt buộc viết `import type` cho import chỉ dùng kiểu
    "skipLibCheck": true,
    "outDir": "dist"
  }
}

Node 22.18+/24 chạy được file .ts trực tiếp bằng type stripping (chỉ xóa kiểu, không kiểm tra). Kiểm tra kiểu vẫn là việc của tsc --noEmit trong CI. Trong dự án thật, dùng tsx để chạy dev và tsc/tsup để build.

Narrowing và discriminated union

type RemoteData<T, E = Error> =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: T }
  | { status: 'error'; error: E };

function render(state: RemoteData<User[]>) {
  switch (state.status) {
    case 'idle':    return 'Chưa tải';
    case 'loading': return 'Đang tải…';
    case 'success': return state.data.length + ' người dùng'; // TS biết có data
    case 'error':   return state.error.message;
    default: {
      const _never: never = state;   // thêm status mới mà quên xử lý → lỗi biên dịch
      return _never;
    }
  }
}

// Type guard tự viết
function isApiError(e: unknown): e is { code: string; message: string } {
  return typeof e === 'object' && e !== null && 'code' in e && 'message' in e;
}
💡 Quy tắc

Nhiều cờ boolean (isLoading, isError, data?) = có trạng thái vô lý. Một trường status + union = chỉ trạng thái hợp lệ tồn tại.

Generics có ràng buộc

function groupBy<T, K extends PropertyKey>(items: T[], key: (t: T) => K): Record<K, T[]> {
  return items.reduce((acc, it) => {
    (acc[key(it)] ??= []).push(it);
    return acc;
  }, {} as Record<K, T[]>);
}

function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> { /* ... */ }

// Repository generic cho backend
interface Repo<T extends { id: string }> {
  findById(id: T['id']): Promise<T | null>;
  create(data: Omit<T, 'id'>): Promise<T>;
}

Mẹo đọc type thư viện: rê chuột trong IDE, dùng "Go to Type Definition", và đọc từ ràng buộc (extends) trước — nó cho biết tác giả kỳ vọng gì.

Utility, mapped, conditional, template literal types

Công cụVí dụDùng khi
UtilityPartial, Required, Pick, Omit, Record, ReturnType, Awaited, NonNullableHằng ngày: DTO cập nhật = Partial<CreateDto>
Mapped{ readonly [K in keyof T]: T[K] }Biến đổi mọi field của một type
Conditional + inferT extends Promise<infer U> ? U : TTrích kiểu bên trong
Template literal`on${Capitalize<E>}`Tên sự kiện, route, key i18n
satisfiesconst routes = {...} satisfies Record<string, Route>Kiểm tra mà vẫn giữ kiểu hẹp
Branded typetype UserId = string & { __brand: 'UserId' }Không truyền nhầm ID
⚠️ Đừng khoe type

Type-level programming 30 dòng mà không ai đọc nổi là nợ kỹ thuật. Mục tiêu là API dễ dùng, không phải type thông minh. Tránh any; khi thực sự không biết, dùng unknown rồi narrow.

Kiểu ở compile-time, Zod ở runtime

TypeScript biến mất khi chạy. Dữ liệu từ request, form, env, API bên ngoài phải được validate tại biên. Zod cho bạn schema là nguồn sự thật duy nhất, type suy ra từ đó.

import { z } from 'zod';

export const CreateOrderSchema = z.object({
  customerId: z.string().uuid(),
  items: z.array(z.object({
    productId: z.string().uuid(),
    quantity: z.number().int().positive().max(100),
  })).min(1),
  couponCode: z.string().trim().toUpperCase().optional(),
});
export type CreateOrderInput = z.infer<typeof CreateOrderSchema>;

// Validate env một lần khi khởi động — thiếu biến thì chết sớm, không chết lúc 2h sáng
export const env = z.object({
  DATABASE_URL: z.string().url(),
  PORT: z.coerce.number().default(3000),
  NODE_ENV: z.enum(['development', 'test', 'production']),
}).parse(process.env);

Cùng một schema dùng được ở form React (Module 11), ở API (Module 4) và trong monorepo chia sẻ package @app/contracts (Module 17). Đây là xương sống "type-safe end-to-end".

🏋️ Bài tập thực hành

Gõ kiểu cho một SDK API thật

Chọn một API công khai (GitHub REST hoặc một API thanh toán sandbox). (1) Viết Zod schema cho 5 endpoint, suy ra type. (2) Viết client generic request<TSchema>(path, schema) trả về type đúng, ném lỗi có cấu trúc khi response sai schema. (3) Dùng discriminated union cho kết quả Result<T, E>. (4) Thêm branded type cho các loại ID. (5) Làm 15 bài trên type-challenges mức easy + 5 bài medium. Bật toàn bộ cờ strict ở trên, không được dùng any.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Dự án bật strict + noUncheckedIndexedAccess, không có any
  • Mô hình hóa trạng thái bằng discriminated union có exhaustive check
  • Viết được generic có ràng buộc và đọc hiểu type của thư viện
  • Mọi dữ liệu vào hệ thống đều qua Zod schema