TypeScript กับ Express



npm install express
npm install --save-dev @types/express @types/node

route handler พื้นฐาน

import express, { type Request, type Response } from "express";

const app = express();
app.use(express.json());

app.get("/health", (req: Request, res: Response) => {
  res.json({ status: "ok" });
});

app.listen(3000);

Request generic — params, body, query

Request<Params, ResBody, ReqBody, Query>:

interface UserParams {
  id: string;   // route params เป็น string เสมอ
}

interface CreateUserBody {
  name: string;
  email: string;
}

interface UserQuery {
  include?: string;
}

app.get("/users/:id", (req: Request<UserParams>, res: Response) => {
  const id = req.params.id;   // string (typed)
});

app.post(
  "/users",
  (req: Request<{}, {}, CreateUserBody>, res: Response) => {
    const { name, email } = req.body;   // typed — แต่ไม่ validate runtime!
  },
);

app.get(
  "/users",
  (req: Request<{}, {}, {}, UserQuery>, res: Response) => {
    const include = req.query.include;   // string | undefined
  },
);

req.body typed ≠ validated — client ส่งอะไรมาก็ได้ ต้อง validate ด้วย zod (บทที่ 30):

const CreateUserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});

app.post("/users", (req, res) => {
  const result = CreateUserSchema.safeParse(req.body);
  if (!result.success) {
    return res.status(422).json({ errors: result.error.issues });
  }
  const { name, email } = result.data;   // validated + typed
});

typed response body

interface UserResponse {
  id: string;
  name: string;
}

interface ErrorResponse {
  error: string;
}

app.get(
  "/users/:id",
  (req: Request<UserParams>, res: Response<UserResponse | ErrorResponse>) => {
    const user = findUser(req.params.id);
    if (!user) {
      return res.status(404).json({ error: "not found" });   // ต้องตรง ErrorResponse
    }
    res.json({ id: user.id, name: user.name });   // ต้องตรง UserResponse
  },
);

middleware typing

import { type Request, type Response, type NextFunction } from "express";

function logger(req: Request, res: Response, next: NextFunction): void {
  const start = Date.now();
  res.on("finish", () => {
    console.log(`${req.method} ${req.path} ${res.statusCode} ${Date.now() - start}ms`);
  });
  next();
}

app.use(logger);

// error middleware — 4 arguments (Express รู้จากจำนวน args)
function errorHandler(err: unknown, req: Request, res: Response, next: NextFunction): void {
  if (err instanceof z.ZodError) {
    res.status(422).json({ errors: err.issues });
    return;
  }
  if (err instanceof NotFoundError) {
    res.status(404).json({ error: err.message });
    return;
  }
  console.error(err);
  res.status(500).json({ error: "internal server error" });
}

app.use(errorHandler);   // ต้องอยู่หลัง route ทั้งหมด

async handler — จับ error

Express 4 ไม่จับ error จาก async handler อัตโนมัติ:

// ❌ error หายไป (unhandled rejection)
app.get("/users/:id", async (req, res) => {
  const user = await db.findUser(req.params.id);   // ถ้า throw → ไม่ถึง errorHandler
  res.json(user);
});

// ✅ wrapper
function asyncHandler<P = {}, ResBody = {}, ReqBody = {}, Query = {}>(
  fn: (
    req: Request<P, ResBody, ReqBody, Query>,
    res: Response<ResBody>,
    next: NextFunction,
  ) => Promise<unknown>,
) {
  return (req: Request<P, ResBody, ReqBody, Query>, res: Response<ResBody>, next: NextFunction) => {
    fn(req, res, next).catch(next);   // ส่ง error ไป errorHandler
  };
}

app.get(
  "/users/:id",
  asyncHandler(async (req, res) => {
    const user = await db.findUser(req.params.id);
    if (!user) throw new NotFoundError("user");
    res.json(user);
  }),
);

Express 5 (beta) จับ async error เอง — ไม่ต้อง wrapper

เพิ่ม property ให้ Request — module augmentation

// types/express.d.ts
import "express";

declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        role: "admin" | "user";
      };
    }
  }
}
// auth middleware
function authenticate(req: Request, res: Response, next: NextFunction): void {
  const token = req.headers.authorization?.replace("Bearer ", "");
  if (!token) {
    res.status(401).json({ error: "unauthorized" });
    return;
  }
  const payload = verifyToken(token);
  req.user = { id: payload.sub, role: payload.role };   // typed!
  next();
}

// route ที่ต้อง auth
app.get(
  "/me",
  authenticate,
  (req, res) => {
    res.json({ userId: req.user?.id });   // req.user: {...} | undefined
  },
);

typed router

import { Router } from "express";

const userRouter = Router();

userRouter.get("/", listUsers);
userRouter.get("/:id", getUser);
userRouter.post("/", asyncHandler(createUser));

app.use("/api/users", userRouter);

ทางเลือกที่ type-safe กว่า Express

  • Hono — TS-first, c.req.param("id") typed, RPC mode (end-to-end type)
  • Fastify — schema-based, integrate zod ได้, มี type provider
  • tRPC — ไม่มี REST layer เลย, type ไหลจาก server ไป client โดยตรง (บทที่ 40)
  • Elysia (Bun) — type inference จาก schema

Express type support ไม่ค่อยดี (generic ยุ่ง, req.body ไม่ validate) — framework ใหม่ ๆ ออกแบบมาเพื่อ TS

เรื่องที่คนมักพลาด

  • req.body typed แล้วคิดว่า validated — ไม่; zod safeParse ทุก body
  • async handler ไม่ wrap — error หาย (Express 4); ใช้ asyncHandler หรือ Express 5
  • error middleware ไม่มี 4 args — Express ดูจาก err.length === 4; ต้องมี next แม้ไม่ใช้
  • augment Express.Request ในไฟล์ที่ไม่ใช่ module — ต้องมี import "express" / export {}
  • req.params.id เป็น number — เป็น string เสมอ; Number(req.params.id) + validate
  • error middleware อยู่ก่อน route — ต้องอยู่ หลัง route ทั้งหมด (app.use(errorHandler) สุดท้าย)
  • res.json() แล้วยังเขียนต่อ — return res.json(...) เพื่อหยุด

สรุป

  • @types/express; handler (req: Request, res: Response) — Request<Params, ResBody, ReqBody, Query>
  • req.params.id = string เสมอ; req.body typed ≠ validated — zod safeParse ทุก body
  • middleware: (req, res, next); error middleware: (err, req, res, next) (4 args, หลัง route ทั้งหมด)
  • async handler ต้อง wrap (.catch(next)) ใน Express 4 (Express 5 จับเอง)
  • เพิ่ม req.user ด้วย module augmentation (declare global { namespace Express { interface Request } })
  • framework ที่ TS-first: Hono, Fastify, tRPC, Elysia — Express type support จำกัด

บทถัดไปว่าด้วยการแชร์ type ระหว่าง client กับ server — monorepo, tRPC concept และ end-to-end type safety