1. Typing Request and Response
TypeScript allows typing the Request and Response objects in Express for better type safety.
Installation
npm install express
npm install --save-dev @types/express
Example
import express, { Request, Response } from "express";
const app = express();
app.get("/user/:id", (req: Request, res: Response) => {
const userId: string = req.params.id;
res.json({ id: userId, name: "Muni" });
});
app.listen(3000, () => console.log("Server running on port 3000"));
Typing requests and responses ensures safe access to params, body, query, and response methods.
2. Middleware Typing
Middleware functions can be typed with Request, Response, and NextFunction for proper type checking.
Example
import { Request, Response, NextFunction } from "express";
const loggerMiddleware = (req: Request, res: Response, next: NextFunction) => {
console.log(`${req.method} ${req.url}`);
next();
};
app.use(loggerMiddleware);
Typing middleware ensures correct handling of request, response, and next callbacks.
Example: Typed Request Body
interface UserBody {
name: string;
age: number;
}
app.post("/user", (req: Request<{}, {}, UserBody>, res: Response) => {
const { name, age } = req.body;
res.json({ message: `User ${name} added with age ${age}` });
});
Typed request bodies prevent invalid data access and provide IntelliSense support.
3. Centralized Error Handling
TypeScript helps enforce type safety in error-handling middleware.
Example
import { Request, Response, NextFunction } from "express";
interface CustomError extends Error {
status?: number;
}
const errorHandler = (err: CustomError, req: Request, res: Response, next: NextFunction) => {
const status = err.status || 500;
res.status(status).json({ message: err.message });
};
app.use(errorHandler);
Throwing Custom Errors
app.get("/error", (req, res, next) => {
const err: CustomError = new Error("Something went wrong");
err.status = 400;
next(err);
});
Centralized error handling ensures consistent responses and type-safe error management across the application.
Conclusion
Using Express.js with TypeScript provides strong type safety for requests, responses, middleware, and error handling. Typed Express applications reduce runtime errors, improve maintainability, and enhance developer productivity.
