Skip to content
TheChatArchiveThe Chat Archive
GPT 5.1 Codex Max· openaiHugging Face Frontier Reasoning Traces

Create an Express + TypeScript + MongoDB API boilerplate with repository pattern and…

  1. 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.

  2. 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:
    Set NODE_ENV=development to get stack traces in error responses. Run with npm install, then npm start to 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.ts
    

    package.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=development
    

    src/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

    • DomainError extends AppError to represent business rule violations. AppError is 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.ts wires up the repository, service, and controller. Controllers expose their own routers to keep composition clean.
    • mongoose.connect is awaited in createApp for simplicity. You can extract DB connection to its own module if you want more layering.
    • Run with npm run dev (after installing dependencies). Use npm run build && npm start in production.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.