Create an Express + TypeScript + MongoDB API boilerplate with repository pattern and…
- User
Create an Express + TypeScript + MongoDB API boilerplate with repository pattern and dependency injection using InversifyJS. Include a rigid error handling hierarchy with AppError vs DomainError and a global handler that sanitizes stack traces.
- Assistant
Providing Express + TypeScript + MongoDB boilerplate with DI and error hierarchy
Here's a concise multi-file Express API boilerplate illustrating the repository pattern, InversifyJS DI, and a rigid error handling hierarchy with sanitized global error handling.
/package.json /tsconfig.json /src/index.ts /src/app.ts /src/inversify.config.ts /src/types.ts /src/errors/BaseError.ts /src/errors/AppError.ts /src/errors/DomainError.ts /src/middlewares/errorHandler.ts /src/entities/User.ts /src/interfaces/IUserRepository.ts /src/repositories/UserRepository.ts /src/services/UserService.ts /src/controllers/UserController.ts// package.json { "name": "express-ts-mongo-boilerplate", "version": "1.0.0", "main": "dist/index.js", "scripts": { "start": "ts-node src/index.ts", "build": "tsc" }, "dependencies": { "express": "^4.18.2", "inversify": "^6.0.1", "reflect-metadata": "^0.1.13", "mongodb": "^5.6.0" }, "devDependencies": { "@types/express": "^4.17.17", "@types/node": "^20.3.3", "ts-node": "^10.9.1", "typescript": "^5.1.3" } }// tsconfig.json { "compilerOptions": { "target": "ES2020", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "emitDecoratorMetadata": true, "experimentalDecorators": true, "skipLibCheck": true } }// src/index.ts import "reflect-metadata"; import { Container } from "inversify"; import app from "./app"; import container from "./inversify.config"; const PORT = process.env.PORT || 3000; const server = app(container); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); });// src/app.ts import express, { Request, Response } from "express"; import { Container } from "inversify"; import { errorHandler } from "./middlewares/errorHandler"; import { UserController } from "./controllers/UserController"; import { TYPES } from "./types"; export default function app(container: Container) { const app = express(); app.use(express.json()); const userController = container.get<UserController>(TYPES.UserController); app.use("/users", userController.router); app.use((req: Request, res: Response) => { res.status(404).json({ message: "Not Found" }); }); app.use(errorHandler); return app; }// src/inversify.config.ts import { Container } from "inversify"; import { TYPES } from "./types"; import { IUserRepository } from "./interfaces/IUserRepository"; import { UserRepository } from "./repositories/UserRepository"; import { UserService } from "./services/UserService"; import { UserController } from "./controllers/UserController"; const container = new Container(); container.bind<IUserRepository>(TYPES.IUserRepository).to(UserRepository).inSingletonScope(); container.bind<UserService>(TYPES.UserService).to(UserService); container.bind<UserController>(TYPES.UserController).to(UserController); export default container;// src/types.ts export const TYPES = { IUserRepository: Symbol.for("IUserRepository"), UserService: Symbol.for("UserService"), UserController: Symbol.for("UserController"), };// src/errors/BaseError.ts export class BaseError extends Error { public readonly statusCode: number; public readonly isOperational: boolean; constructor(message: string, statusCode = 500, isOperational = true) { super(message); Object.setPrototypeOf(this, new.target.prototype); this.statusCode = statusCode; this.isOperational = isOperational; Error.captureStackTrace(this); } }// src/errors/AppError.ts import { BaseError } from "./BaseError"; export class AppError extends BaseError { constructor(message: string, statusCode = 500) { super(message, statusCode, true); } }// src/errors/DomainError.ts import { AppError } from "./AppError"; export class DomainError extends AppError { constructor(message: string) { super(message, 400); } }// src/middlewares/errorHandler.ts import { Request, Response, NextFunction } from "express"; import { BaseError } from "../errors/BaseError"; import { DomainError } from "../errors/DomainError"; const isDebug = process.env.NODE_ENV === "development"; export function errorHandler( err: Error, req: Request, res: Response, next: NextFunction ) { let statusCode = 500; let message = "Internal Server Error"; let sanitizedStack: string | undefined; if (err instanceof DomainError) { statusCode = err.statusCode; message = err.message; } else if (err instanceof BaseError) { statusCode = err.statusCode; message = err.message; } if (isDebug) { sanitizedStack = err.stack; } res.status(statusCode).json({ error: { message, code: statusCode, ...(sanitizedStack ? { stack: sanitizedStack } : {}), }, }); }// src/entities/User.ts export interface User { id: string; name: string; email: string; }// src/interfaces/IUserRepository.ts import { User } from "../entities/User"; export interface IUserRepository { findById(id: string): Promise<User | null>; findAll(): Promise<User[]>; create(user: User): Promise<User>; }// src/repositories/UserRepository.ts import { injectable } from "inversify"; import { IUserRepository } from "../interfaces/IUserRepository"; import { User } from "../entities/User"; @injectable() export class UserRepository implements IUserRepository { private users: User[] = []; async findById(id: string): Promise<User | null> { return this.users.find((u) => u.id === id) || null; } async findAll(): Promise<User[]> { return this.users; } async create(user: User): Promise<User> { this.users.push(user); return user; } }// src/services/UserService.ts import { injectable, inject } from "inversify"; import { IUserRepository } from "../interfaces/IUserRepository"; import { TYPES } from "../types"; import { User } from "../entities/User"; import { DomainError } from "../errors/DomainError"; @injectable() export class UserService { constructor(@inject(TYPES.IUserRepository) private userRepository: IUserRepository) {} async getUserById(id: string): Promise<User> { const user = await this.userRepository.findById(id); if (!user) { throw new DomainError("User not found"); } return user; } async createUser(user: User): Promise<User> { if (!user.email.includes("@")) { throw new DomainError("Invalid email"); } return this.userRepository.create(user); } }// src/controllers/UserController.ts import { Router, Request, Response, NextFunction } from "express"; import { injectable, inject } from "inversify"; import { UserService } from "../services/UserService"; import { TYPES } from "../types"; @injectable() export class UserController { public router = Router(); constructor(@inject(TYPES.UserService) private userService: UserService) { this.router.get("/:id", this.getUserById.bind(this)); this.router.post("/", this.createUser.bind(this)); } async getUserById(req: Request, res: Response, next: NextFunction) { try { const user = await this.userService.getUserById(req.params.id); res.json(user); } catch (err) { next(err); } } async createUser(req: Request, res: Response, next: NextFunction) { try { const user = await this.userService.createUser(req.body); res.status(201).json(user); } catch (err) { next(err); } } }
Environment & run instructions:
SetNODE_ENV=developmentto get stack traces in error responses. Run withnpm install, thennpm startto launch the server on port 3000 by default.This boilerplate demonstrates a modular architecture with dependency injection via InversifyJS, clean repository and service layers, and a global error handler that distinguishes domain errors from others while sanitizing stack traces based on environment. Below is a minimal boilerplate you can scaffold for an Express + TypeScript + MongoDB API with the repository pattern, dependency injection (InversifyJS), and a clean error hierarchy (
AppError/DomainError) plus a global error handler that sanitizes stack traces.Folder structure (suggested)
. ├─ package.json ├─ tsconfig.json ├─ .env └─ src ├─ app.ts ├─ index.ts ├─ inversify.config.ts ├─ types.ts ├─ errors │ ├─ AppError.ts │ ├─ DomainError.ts │ └─ errorHandler.ts ├─ entities │ └─ User.ts ├─ interfaces │ ├─ IUserRepository.ts │ └─ IUserService.ts ├─ repositories │ └─ UserRepository.ts ├─ services │ └─ UserService.ts └─ controllers └─ UserController.tspackage.json
{ "name": "express-ts-mongo-inversify-boilerplate", "version": "1.0.0", "main": "dist/index.js", "scripts": { "dev": "ts-node-dev --respawn --transpile-only src/index.ts", "build": "tsc", "start": "node dist/index.js" }, "dependencies": { "body-parser": "^1.20.2", "dotenv": "^16.3.1", "express": "^4.18.2", "inversify": "^6.0.1", "mongoose": "^7.5.0", "reflect-metadata": "^0.1.13" }, "devDependencies": { "@types/express": "^4.17.17", "@types/node": "^20.4.9", "ts-node-dev": "^2.0.0", "typescript": "^5.1.6" } }tsconfig.json
{ "compilerOptions": { "target": "ES2019", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "experimentalDecorators": true, "emitDecoratorMetadata": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true } }.env (example)
PORT=3000 MONGO_URI=mongodb://localhost:27017/boilerplate_db NODE_ENV=developmentsrc/types.ts
const TYPES = { UserRepository: Symbol.for("UserRepository"), UserService: Symbol.for("UserService"), UserController: Symbol.for("UserController") }; export default TYPES;src/errors/AppError.ts
export class AppError extends Error { public readonly statusCode: number; public readonly isOperational: boolean; constructor(message: string, statusCode = 500, isOperational = true) { super(message); Object.setPrototypeOf(this, new.target.prototype); this.name = "AppError"; this.statusCode = statusCode; this.isOperational = isOperational; Error.captureStackTrace(this); } }src/errors/DomainError.ts
import { AppError } from "./AppError"; export class DomainError extends AppError { constructor(message: string, statusCode = 400) { super(message, statusCode, true); this.name = "DomainError"; } }src/errors/errorHandler.ts
import { NextFunction, Request, Response } from "express"; import { AppError } from "./AppError"; const sanitizeStack = (stack?: string) => { if (!stack) return undefined; // Remove absolute paths and internal frames (rudimentary example) return stack .split("\n") .filter((line) => !line.includes("node_modules")) .map((line) => line.replace(process.cwd(), "<cwd>")) .join("\n"); }; // Global error handler middleware export const errorHandler = ( err: unknown, req: Request, res: Response, _next: NextFunction ) => { // Normalize error let error: AppError; if (err instanceof AppError) { error = err; } else { // Wrap unknown errors error = new AppError("Internal server error", 500, false); } const status = error.statusCode || 500; const response: any = { name: error.name, message: error.message, statusCode: status }; // Expose sanitized stack only in non-production (optional) if (process.env.NODE_ENV !== "production") { response.stack = sanitizeStack(error.stack); } res.status(status).json(response); };src/entities/User.ts
import { Schema, model, Document } from "mongoose"; export interface IUser extends Document { email: string; name: string; } const UserSchema = new Schema<IUser>( { email: { type: String, required: true, unique: true }, name: { type: String, required: true } }, { timestamps: true } ); export const UserModel = model<IUser>("User", UserSchema);src/interfaces/IUserRepository.ts
import { IUser } from "../entities/User"; export interface IUserRepository { findAll(): Promise<IUser[]>; findById(id: string): Promise<IUser | null>; create(data: Pick<IUser, "email" | "name">): Promise<IUser>; }src/interfaces/IUserService.ts
import { IUser } from "../entities/User"; export interface IUserService { getUsers(): Promise<IUser[]>; getUser(id: string): Promise<IUser>; createUser(data: { email: string; name: string }): Promise<IUser>; }src/repositories/UserRepository.ts
import { injectable } from "inversify"; import { IUserRepository } from "../interfaces/IUserRepository"; import { IUser, UserModel } from "../entities/User"; @injectable() export class UserRepository implements IUserRepository { async findAll(): Promise<IUser[]> { return UserModel.find().exec(); } async findById(id: string): Promise<IUser | null> { return UserModel.findById(id).exec(); } async create(data: Pick<IUser, "email" | "name">): Promise<IUser> { return UserModel.create(data); } }src/services/UserService.ts
import { inject, injectable } from "inversify"; import TYPES from "../types"; import { IUserService } from "../interfaces/IUserService"; import { IUserRepository } from "../interfaces/IUserRepository"; import { IUser } from "../entities/User"; import { DomainError } from "../errors/DomainError"; @injectable() export class UserService implements IUserService { constructor( @inject(TYPES.UserRepository) private userRepository: IUserRepository ) {} async getUsers(): Promise<IUser[]> { return this.userRepository.findAll(); } async getUser(id: string): Promise<IUser> { const user = await this.userRepository.findById(id); if (!user) { throw new DomainError(`User with id ${id} not found`, 404); } return user; } async createUser(data: { email: string; name: string }): Promise<IUser> { // simple domain validation example if (!data.email.includes("@")) { throw new DomainError("Invalid email format"); } return this.userRepository.create(data); } }src/controllers/UserController.ts
import { Request, Response, NextFunction, Router } from "express"; import { inject, injectable } from "inversify"; import TYPES from "../types"; import { IUserService } from "../interfaces/IUserService"; @injectable() export class UserController { public router: Router; constructor(@inject(TYPES.UserService) private userService: IUserService) { this.router = Router(); this.initializeRoutes(); } private initializeRoutes() { this.router.get("/", this.getAll); this.router.get("/:id", this.getById); this.router.post("/", this.create); } private getAll = async (req: Request, res: Response, next: NextFunction) => { try { const users = await this.userService.getUsers(); res.json(users); } catch (err) { next(err); } }; private getById = async (req: Request, res: Response, next: NextFunction) => { try { const user = await this.userService.getUser(req.params.id); res.json(user); } catch (err) { next(err); } }; private create = async (req: Request, res: Response, next: NextFunction) => { try { const user = await this.userService.createUser(req.body); res.status(201).json(user); } catch (err) { next(err); } }; }src/inversify.config.ts
import "reflect-metadata"; import { Container } from "inversify"; import TYPES from "./types"; import { IUserRepository } from "./interfaces/IUserRepository"; import { UserRepository } from "./repositories/UserRepository"; import { IUserService } from "./interfaces/IUserService"; import { UserService } from "./services/UserService"; import { UserController } from "./controllers/UserController"; const container = new Container(); // repositories container.bind<IUserRepository>(TYPES.UserRepository).to(UserRepository); // services container.bind<IUserService>(TYPES.UserService).to(UserService); // controllers container.bind<UserController>(TYPES.UserController).to(UserController); export { container };src/app.ts
import express from "express"; import bodyParser from "body-parser"; import mongoose from "mongoose"; import { container } from "./inversify.config"; import TYPES from "./types"; import { UserController } from "./controllers/UserController"; import { errorHandler } from "./errors/errorHandler"; export const createApp = async () => { const app = express(); // Body parsing app.use(bodyParser.json()); // MongoDB await mongoose.connect(process.env.MONGO_URI as string); // Controllers const userController = container.get<UserController>(TYPES.UserController); app.use("/users", userController.router); // Global error handler app.use(errorHandler); return app; };src/index.ts
import "reflect-metadata"; import dotenv from "dotenv"; import { createApp } from "./app"; dotenv.config(); const port = process.env.PORT || 3000; (async () => { try { const app = await createApp(); app.listen(port, () => { console.log(`Server running on port ${port}`); }); } catch (err) { // If something fails before Express error middleware, log and exit console.error("Failed to start server:", err); process.exit(1); } })();
Notes
DomainErrorextendsAppErrorto represent business rule violations.AppErroris for operational errors and top-level error handling. You can add additional subclasses as needed.- The global error handler sanitizes the stack trace (removing absolute paths and internal frames) and only includes it in non-production environments.
inversify.config.tswires up the repository, service, and controller. Controllers expose their own routers to keep composition clean.mongoose.connectis awaited increateAppfor simplicity. You can extract DB connection to its own module if you want more layering.- Run with
npm run dev(after installing dependencies). Usenpm run build && npm startin production.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.