TypeScript กับ Express
npm install express
npm install --save-dev @types/express @types/noderoute 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.bodytyped แล้วคิดว่า validated — ไม่; zodsafeParseทุก 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.bodytyped ≠ validated — zodsafeParseทุก 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