DEV Community: William Onyejiaka

Debugging a BSONVersionError in Mongoose: What It Actually Means and How I Fixed It

William Onyejiaka — Sun, 05 Jul 2026 23:35:48 +0000

If you've been building backend services with Node.js and MongoDB long enough, you'll eventually run into an error that looks something like this:

BSONVersionError: buffer must be an instance of Buffer or Uint8Array

or a variation of it thrown somewhere deep inside Mongoose's internals, usually when you least expect it — right after a routine npm install, a Docker rebuild, or a deploy to a new environment. No code changes on your end, yet suddenly your queries are exploding.

Here's what I learned digging into this, and how I resolved it in one of my Node.js/TypeScript services.

What Is a BSONVersionError, Really?

BSON (Binary JSON) is the binary-encoded serialization format MongoDB uses under the hood to store and transmit documents. Mongoose relies on the bson package (usually pulled in transitively through the MongoDB Node.js driver) to encode and decode data between your JavaScript objects and what actually gets sent to MongoDB.

A BSONVersionError shows up when there's a version mismatch or duplication of the bson package in your node_modules tree. In practice, this almost always means:

Your project has two different versions of bson installed simultaneously (one required directly, one pulled in as a dependency of mongodb or mongoose), and
Objects created by one version's BSON classes (like ObjectId) are being passed into functions expecting the other version's internal class structure.

BSON's internal checks use something stricter than a plain instanceof in newer versions — they check for a _bsontype tag and sometimes a Symbol-based marker. So if you have bson@5.x and bson@6.x both installed, an ObjectId created by one is not recognized as valid by the other, even though they look identical on the surface.

How I Ran Into It

In my case, this surfaced after adding a new package to one of my services that depended on a newer MongoDB driver internally. My own package.json had mongoose pinned to a version that resolved an older bson. npm's dependency resolution ended up hoisting two separate bson versions into node_modules.

Everything worked fine locally in isolated test cases, but broke specifically when:

An ObjectId was created in one part of the codebase (via the newer nested bson), and
That same ObjectId was passed into a Mongoose query or passed through JSON.stringify/deserialization logic that touched the older bson copy.

The error message itself is famously unhelpful — it just complains about buffer types or invalid BSON instances, with no indication that the real problem is a duplicate dependency.

How to Diagnose It

The fastest way to confirm this is a version-duplication issue rather than a real data problem:

npm ls bson

If you see something like:

├─ bson@6.2.0
└─ mongodb@5.9.0
   └─ bson@5.5.1

— that's your smoking gun. Two versions in the tree means two separate module instances, each with their own class definitions for ObjectId, Binary, Decimal128, etc.

You can also confirm at runtime by logging the actual constructor:

console.log(someId.constructor === mongoose.Types.ObjectId); // false if duplicated

The Fix

There are a few ways to resolve it, depending on your setup:

1. Deduplicate via npm/yarn overrides

The cleanest fix is forcing a single bson version across the entire dependency tree. In package.json:

"overrides": {
  "bson": "6.2.0"
}

(Yarn users: use resolutions instead of overrides.)

Then do a clean reinstall:

rm -rf node_modules package-lock.json
npm install
npm ls bson

Confirm only one version shows up in the tree afterward.

2. Upgrade Mongoose and the MongoDB driver together

Sometimes the mismatch comes from an outdated Mongoose version pulling in an old MongoDB driver that hasn't caught up to the bson version your other dependencies expect. Bumping Mongoose to the latest major version usually aligns everything, since Mongoose pins compatible driver/BSON versions internally.

3. Avoid manually constructing ObjectIds with a different import path

If you're doing something like:

import { ObjectId } from "bson";

instead of using mongoose.Types.ObjectId or the driver's own export, you can end up with IDs built from a different bson module instance than the one Mongoose uses internally — even if the version numbers match, in some monorepo/workspace setups. Standardize on one import source across the codebase.

Takeaway

BSONVersionError isn't really about your data — it's almost always a dependency hygiene issue. The BSON error messages don't say "you have two versions installed," so it's easy to burn hours suspecting your schema, your query logic, or corrupted documents before realizing npm ls bson would've told you everything in five seconds.

If you hit this: check npm ls bson first, before anything else.

A Beginner’s Guide to Building a CRUD API with Express, TypeScript, and Mongoose

William Onyejiaka — Mon, 20 Oct 2025 09:43:54 +0000

When building APIs with Node.js and TypeScript, Express is often the framework of choice for handling routes and middleware. To interact with MongoDB, we use Mongoose, a popular ODM (Object Data Modeling) library that provides a schema-based solution to model our data.

In this post, you’ll learn how to set up a simple Express + TypeScript project using Mongoose to perform CRUD operations — Create, Read, Update, and Delete — on a single resource.

We’ll build a simple API to manage a collection of Books, where each book has:

title
author
year
isPublished

What is Mongoose?

Mongoose simplifies working with MongoDB by providing:

Schema validation
Query helpers and middleware
Model methods
TypeScript type support

Essentially, it helps you structure your MongoDB collections more predictably and safely.

Prerequisites

Node.js (v16 or higher)
Basic knowledge of Express and TypeScript
MongoDB running locally or a MongoDB Atlas account
Code editor (e.g., VS Code)

Step 1: Set Up the Project

Initialize the project:

Create a new directory and set up a Node.js project:

mkdir express-mongoose-ts
cd express-mongoose-ts
npm init -y

Install dependencies:

Install Express, TypeScript, and necessary type definitions:

npm install express mongoose
npm install -D typescript @types/node @types/express ts-node nodemon

Set up TypeScript:

Initialize TypeScript configuration:

npx tsc --init

Update tsconfig.json to include:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "rootDir": "./src",
    "outDir": "./dist",
    "esModuleInterop": true,
    "strict": true
  }
}

Configure scripts:

Update package.json with:

"scripts": {
  "start": "node dist/server.js",
  "build": "tsc p .",
  "dev": "nodemon src/server.ts"
}

Project Structure

Here’s how your folder should look:

express-mongoose-ts/
├── src/
│   ├── config/
│   │   └── db.ts
│   ├── models/
│   │   └── book.model.ts
│   ├── routes/
│   │   └── book.route.ts
│   ├── controllers/
│   │   └── book.controller.ts
│   └── server.ts
├── package.json
├── tsconfig.json

Connecting to MongoDB

Insidesrc/config/db.ts:

import mongoose from "mongoose";

export async function connectDB(): Promise<void> {
  try {
    const conn = await mongoose.connect("mongodb://localhost:27017/express_mongoose_ts");
    console.log(`MongoDB connected: ${conn.connection.host}`);
  } catch (err) {
    console.error("Database connection failed:", err);
    process.exit(1);
  }
}

Defining the Mongoose Model

Create src/models/book.model.ts:

import { Schema, model } from "mongoose";

const bookSchema = new Schema(
  {
    title: { type: String, required: true },
    author: { type: String, required: true },
    year: { type: Number, required: true },
    isPublished: { type: Boolean, default: false },
  },
  { timestamps: true }
);

export const Book = model("Book", bookSchema);

Here, we:

Create a Mongoose schema
Export a model called Book

Writing the Controller Functions

Create src/controllers/book.controller.ts:

import { Request, Response } from "express";
import { Book } from "../models/book.model";

// Create a new book
export async function createBook(req: Request, res: Response) {
  try {
    const book = await Book.create(req.body);
    res.status(201).json(book);
  } catch (error) {
    res.status(400).json({ message: "Error creating book", error });
  }
}

// Get all books
export async function getBooks(req: Request, res: Response) {
  try {
    const books = await Book.find();
    res.status(200).json(books);
  } catch (error) {
    res.status(500).json({ message: "Error fetching books", error });
  }
}

// Get a single book by ID
export async function getBookById(req: Request, res: Response) {
  try {
    const book = await Book.findById(req.params.id);
    if (!book) return res.status(404).json({ message: "Book not found" });
    res.status(200).json(book);
  } catch (error) {
    res.status(500).json({ message: "Error fetching book", error });
  }
}

// Update a book
export async function updateBook(req: Request, res: Response) {
  try {
    const book = await Book.findByIdAndUpdate(req.params.id, req.body, {
      new: true,
    });
    if (!book) return res.status(404).json({ message: "Book not found" });
    res.status(200).json(book);
  } catch (error) {
    res.status(500).json({ message: "Error updating book", error });
  }
}

// Delete a book
export async function deleteBook(req: Request, res: Response) {
  try {
    const book = await Book.findByIdAndDelete(req.params.id);
    if (!book) return res.status(404).json({ message: "Book not found" });
    res.status(200).json({ message: "Book deleted successfully" });
  } catch (error) {
    res.status(500).json({ message: "Error deleting book", error });
  }
}

Creating the Express Routes

Create src/routes/book.route.ts:

import { Router } from "express";
import {
  createBook,
  getBooks,
  getBookById,
  updateBook,
  deleteBook,
} from "../controllers/book.controller";

const router = Router();

router.post("/", createBook);
router.get("/", getBooks);
router.get("/:id", getBookById);
router.put("/:id", updateBook);
router.delete("/:id", deleteBook);

export default router;

Setting Up the App Entry Point

Create src/server.ts:

import express, { Application } from "express";
import { connectDB } from "./config/db";
import bookRouter from "./routes/book.route";

const app: Application = express();

// Enable URL-encoded form data parsing
app.use(express.urlencoded({ extended: true }));

// Middleware to parse JSON
app.use(express.json());

// Routes
app.use("/api/books", bookRouter);

// Start Server
const PORT = process.env.PORT || 4000;

app.listen(PORT, async () => {
  await connectDB();
  console.log(`Server running on http://localhost:${PORT}`);
});

Testing the API

Start the server:

npm run dev

If you see:

MongoDB connected successfully
Server running on http://localhost:4000

You’re ready to test using Postman or cURL.

Examples:

POST /api/books

{
  "title": "The Alchemist",
  "author": "Paulo Coelho",
  "year": 1988,
  "isPublished": true
}

GET /api/books
→ Returns all books
GET /api/books/:id
→ Returns one book
PUT /api/books/:id
→ Updates a book
DELETE /api/books/:id
→ Deletes a book

Conclusion

You’ve just built a simple CRUD API using Express + Mongoose + TypeScript.
In a real-world project, you’d add features like:

Input validation with express-validator or zod
Environment variables using dotenv
Better error handling and logging

But this setup is a strong foundation for learning backend development with TypeScript and MongoDB.

The code for this blog is here.

Building a Robust Express API with TypeScript and express-validator

William Onyejiaka — Fri, 17 Oct 2025 00:59:04 +0000

Introduction

When you build an API, users send data to your backend — things like email addresses, usernames, and passwords. But what happens if that data is invalid or missing?

That’s where validation comes in. Validation means checking that the incoming data is correct before using it.

In this guide, you’ll learn how to use express-validator in a TypeScript + Express project to validate and sanitize user input. We’ll go step by step, so even if you’re new to TypeScript or Express, you’ll be able to follow along easily.

Why You Need express-validator

express-validator is a middleware that makes input validation simple and readable.

Instead of manually checking if req.body.email looks like an email or if the password is long enough, you just describe the rules, and express-validator does the checking for you.

For example:

body("email").isEmail().withMessage("Please enter a valid email");

This line says: “The email field must be a valid email.”
If it’s not, express-validator automatically collects the error for you.

Project Structure

Before diving into the code, here’s what your project structure will look like when we’re done:

express-ts-validator/
│
├── src/
│   ├── server.ts
│   ├── routes/
│   │   └── user.ts
│   ├── middlewares/
│   │   └── validate.ts
│
├── tsconfig.json
├── package.json

What each file does:

server.ts – sets up Express, middlewares,routes and starts the Express server.
routes/user.ts – holds all user-related routes (like registration).
middlewares/validate.ts – reusable function to handle validation errors.
tsconfig.json – TypeScript configuration file.

Setting Up the Project

Step 1: Initialize the Project

Create a new folder and initialize npm.

mkdir express-ts-validator
cd express-ts-validator
npm init -y

Step 2: Install Dependencies

npm install express express-validator
npm install --save-dev nodemon typescript ts-node @types/express @types/node

Step 3: Configure TypeScript

Initialize TypeScript configuration:

npx tsc --init

Update tsconfig.json to include:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "rootDir": "./src",
    "outDir": "./dist",
    "esModuleInterop": true,
    "strict": true
  }
}

This tells TypeScript how to compile your code.

Step 4: Configure scripts

Update package.json with:

"scripts": {
  "start": "node dist/server.js",
  "build": "tsc p .",
  "dev": "nodemon src/server.ts"
}

Setting Up Express with TypeScript

Create a basic Express server in src/server.ts:

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

const PORT = 3000;
const app = express();

// Enable URL-encoded form data parsing
app.use(express.urlencoded({ extended: true }));

// Middleware to parse JSON
app.use(express.json());

app.get("/", (req: Request, res: Response) => {
  res.json({ message: "Hello from Express with TypeScript" });
});

// Start server
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Run your app:

npm run dev

Then visit:

http://localhost:3000

You should see:

{ "message": "Hello, Express with TypeScript!" }

Validating Input with express-validator

Let’s make a POST endpoint for user registration.

We’ll check:

Email is valid.
Password is at least 6 characters.
Username is not empty and has at least 3 characters.
Create a new folder src/routes/ and inside it a file user.ts.

src/routes/user.ts

import { Router, Request, Response } from "express";
import { body, validationResult } from "express-validator";

const router = Router();

router.post(
  "/register",
  [
    body("email").isEmail().withMessage("Please enter a valid email"),
    body("password")
      .isLength({ min: 6 })
      .withMessage("Password must be at least 6 characters long"),
    body("username")
      .notEmpty()
      .isLength({ min: 3 })
      .withMessage("Username must be at least 3 characters long")
  ],
  (req: Request, res: Response) => {
    const errors = validationResult(req);

    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    const { email, username } = req.body;
    res.json({ message: "User registered successfully", data: { email, username } });
  }
);

export default router;

Then, connect the route to your app in src/server.ts:

import express, { Request, Response } from "express";
import userRoutes from "./routes/user";

const PORT = 3000;
const app = express();

// Enable URL-encoded form data parsing
app.use(express.urlencoded({ extended: true }));

// Middleware to parse JSON
app.use(express.json());

// Connecting user route to your app
app.use("/api/users", userRoutes);

app.get("/", (req: Request, res: Response) => {
  res.json({ message: "Hello from Express with TypeScript" });
});

// Start server
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Now if you send a POST request,using a tool like Postman, to:

http://localhost:3000/api/users/register

with invalid data, you’ll get clear error messages from express-validator.

Handling Validation Errors

Right now, every route has its own validationResult logic.
If your project grows, that can get repetitive.

Let’s move that logic into its own file so we can reuse it anywhere.

Creating a Reusable Validation Middleware

Create a new folder src/middlewares/ and add a file called validate.ts.

src/middlewares/validate.ts

import { Request, Response, NextFunction } from "express";
import { validationResult } from "express-validator";

export function validate(req: Request, res: Response, next: NextFunction) {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }
  next();
}

Now, you can import and use it anywhere like this:

import { Router,Request,Response } from "express";
import { body } from "express-validator";
import { validate } from "./../middlewares/validate"; // Importing the validate middleware

const router = Router();

router.post(
  "/register",
  [
    body("email").isEmail().withMessage("Invalid email"),
    body("password").isLength({ min: 6 }).withMessage("Password too short"),
    body("username").notEmpty().withMessage("Username is required")
  ],
  validate,// Registering the middleware in the register route
  (req: Request, res: Response) => {
    const { email, username } = req.body;
    res.json({ message: "User registered successfully", data: { email, username } });
  }
);

This approach keeps your routes clean and easy to maintain.

Wrapping Up

You’ve just built a clean, type-safe Express API that validates user input with express-validator.

Here’s what you learned:

How to set up an Express + TypeScript project.
How to validate user input using express-validator.
How to handle validation errors using a reusable middleware.

From here, you can improve your project by:

Adding sanitization (e.g., trimming whitespace).
Writing custom validators (like checking if an email already exists).
Organizing routes and validators into separate files for bigger apps.

By learning this pattern early, you’re building a solid foundation for writing secure and maintainable backend applications.

The code for this blog is here.

Mastering Routing in Express with TypeScript

William Onyejiaka — Sat, 04 Oct 2025 00:43:47 +0000

Routing is a core concept in web development, enabling your application to handle different HTTP requests at specific endpoints. In this blog, we’ll explore how to implement routing in an Express application using TypeScript, leveraging type safety to build robust APIs. By the end, you’ll understand how to create, organize, and manage routes effectively.

What is Routing in Express?

In Express, routing refers to how an application responds to client requests based on the HTTP method (e.g., GET, POST, PUT, DELETE) and URL path. Each route maps to a specific handler function that processes the request and sends a response.
With TypeScript, we can add type safety to our routes, ensuring that request and response objects are properly typed, reducing errors and improving maintainability.

Prerequisites

Node.js (v16 or higher)
Basic knowledge of Express and TypeScript
Code editor (e.g., VS Code)

Step 1: Set Up the Project

Initialize the project:

Create a new directory and set up a Node.js project:

mkdir express-ts-routing
cd express-ts-routing
npm init -y

Install dependencies:

Install Express, TypeScript, and necessary type definitions:

npm install express
npm install --save-dev nodemon typescript ts-node @types/express @types/node

Set up TypeScript:

Initialize TypeScript configuration:

npx tsc --init

Update tsconfig.json to include:

{
   "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true
  },
}

Configure scripts:

Update package.json with:

"scripts": {
  "start": "node dist/server.js",
  "build": "tsc p .",
  "dev": "nodemon src/server.ts"
}

Step 2: Project Structure

Organize your project for scalability:

express-ts-routing/
├── src/
│   ├── routes/
│   │   ├── userRoutes.ts
│   │   └── postRoutes.ts
│   ├── server.ts
├── package.json
├── tsconfig.json

Step 3: Create the Express Server

Create src/server.ts to set up the Express server:

import express, { Application } from 'express';

const app: Application = express();
const PORT = 3000;

// Enable URL-encoded form data parsing
app.use(express.urlencoded({ extended: true }));

// Middleware to parse JSON
app.use(express.json());

// Basic route
app.get('/', (req, res) => {
  res.send('Welcome to the Express TypeScript API!');
});

// Start server
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Here, we initialize an Express app, apply URL-encoded middleware for parsing form data and JSON middleware.

Step 4: Define Routes with TypeScript

User Routes

Create src/routes/userRoutes.ts for user-related endpoints:

import express, { Router, Request, Response } from 'express';

const userRouter: Router = express.Router();

// GET: Fetch all users
userRouter.get('/', (req: Request, res: Response) => {
  res.json({ message: 'List of users', users: [] });
});

// GET: Fetch a user by ID
userRouter.get('/:id', (req: Request, res: Response) => {
  const id = req.params.id;
  res.json({ message: `User with ID ${id}`, user: {} });
});

// POST: Create a user
userRouter.post('/', (req: Request, res: Response) => {
  const { name, email } = req.body;
  res.json({ message: 'User created', user: { name, email } });
});

// PUT: Update a user
userRouter.put('/:id', (req: Request, res: Response) => {
  const id = req.params.id;
  const { name, email } = req.body;
  res.json({ message: `User ${id} updated`, user: { name, email } });
});

// DELETE: Delete a user
userRouter.delete('/:id', (req: Request, res: Response) => {
  const id = req.params.id;
  res.json({ message: `User ${id} deleted` });
});

export default userRouter;

Post Routes

Create src/routes/postRoutes.ts for post-related endpoints:

import express, { Router, Request, Response } from 'express';

const postRouter: Router = express.Router();

// GET: Fetch all posts
postRouter.get('/', (req: Request, res: Response) => {
  res.json({ message: 'List of posts', posts: [] });
});

// GET: Fetch a post by ID
postRouter.get('/:id', (req: Request, res: Response) => {
  const id = req.params.id;
  res.json({ message: `Post with ID ${id}`, post: {} });
});

// POST: Create a post
postRouter.post('/', (req: Request, res: Response) => {
  const { title, content } = req.body;
  res.json({ message: 'Post created', post: { title, content } });
});

export default postRouter;

Key Points:

Type Safety: The Request and Response types from Express ensure proper typing for request parameters, body, and response methods.
Router: The express.Router() method creates modular route handlers, improving code organization.
HTTP Methods: Each route handles specific HTTP methods (GET, POST, PUT, DELETE) for CRUD operations.

Step 5: Mount the Routes

We import and mount route modules under specific prefixes (/api/users, /api/posts) in the server.ts file.

Here is the updated server.ts file:

import express, { Application } from 'express';
import userRouter from './routes/userRoutes';
import postRouter from './routes/postRoutes';

const app: Application = express();
const PORT = 3000;

// Enable URL-encoded form data parsing
app.use(express.urlencoded({ extended: true }));

// Middleware to parse JSON
app.use(express.json());

// Mount routes
app.use('/api/users', userRouter);
app.use('/api/posts', postRouter);

// Basic route
app.get('/', (req, res) => {
  res.send('Welcome to the Express TypeScript API!');
});

// Start server
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Step 6: Run the Application

Start the server:

Run the development server:

npm run dev

The server will start on http://localhost:3000.

Test the routes:

Use Postman or cURL to test the endpoints:

GET http://localhost:3000/api/users: List all users.
POST http://localhost:3000/api/users: Create a user (e.g., { "name": "John", "email": "john@example.com" }).
GET http://localhost:3000/api/posts: List all posts.

Enhancements

Input Validation: Use express-validator to validate request bodies and query parameters.
Authentication: Integrate JWT or OAuth middleware for secure routes.
Route Prefixing: Group related routes under a common prefix (e.g., /api/users).
Version Your API: Prefix routes with a version (e.g., /api/v1/users) to manage API updates.
Documentation: Use tools like Swagger to document your API endpoints.

Conclusion

Routing in Express with TypeScript combines the flexibility of Express with the type safety of TypeScript, resulting in scalable and maintainable APIs. By modularizing routes, typing request/response objects, and following best practices, you can build robust APIs with confidence.
Try extending this setup with a database like MongoDB or adding authentication to secure your routes. Happy coding!

The code for this blog is here.

Setting Up an Express TypeScript Server: A Step-by-Step Guide

William Onyejiaka — Fri, 03 Oct 2025 00:58:54 +0000

Express is a fast, minimalist web framework for Node.js, and combining it with TypeScript brings type safety and better tooling to your server-side development. In this blog, I'll walk you through setting up a basic Express server with TypeScript from scratch. By the end, you'll have a working server with proper configuration, ready for building robust APIs.

Prerequisites

Before we dive in, ensure you have the following installed:

Node.js (v16 or higher recommended)
npm
A code editor like VS Code or any one that you feel comfortable with
Basic knowledge of TypeScript and Express

Step 1: Initialize Your Project

mkdir express-ts-server
cd express-ts-server
npm init -y

This creates a folder named express-ts-server and a package.json file with default settings.

Step 2: Install Dependencies

Install the necessary dependencies for Express and TypeScript:

npm install express
npm install --save-dev typescript @types/node @types/express ts-node nodemon

Explanation of Dependencies

express: The Express framework for building the server.
typescript: The TypeScript compiler.
@types/node and @types/express: Type definitions for Node.js and Express to ensure TypeScript compatibility.
ts-node: Allows running TypeScript files directly without pre-compiling.
nodemon: Automatically restarts the server during development when files change.

Step 3: Set Up TypeScript Configuration

Create a tsconfig.json file to configure TypeScript. Run the following command to generate a basic configuration:

npx tsc --init

Modify the tsconfig.json file to include the following settings:

{
  "compilerOptions": {
    "module": "commonjs",                                
    "rootDir": "./src",
    "outDir": "./dist",  
    "moduleResolution": "node10", 
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
}

Key Settings

target: Specifies the ECMAScript version (ES2020 is modern and widely supported).
module: Uses CommonJS for Node.js compatibility.
outDir: Outputs compiled JavaScript to the dist folder.
rootDir: Keeps source files in the src folder. It can be any folder of your choosing.
strict: Enables strict type-checking for better code quality.

Step 4: Set Up Project Structure

Create a src directory to hold your TypeScript files:

mkdir src
touch src/server.ts

Your project structure should look like this:

express-ts-server/
├── node_modules/
├── src/
│   └── server.ts
├── package.json
├── tsconfig.json

If its not, go back to the previous steps.

Step 5: Create the Express Server

Open src/server.ts and add the following code to set up a basic Express server:

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

const app: Application = express();
const port = 3000; // The port your express server will be running on.

// Enable URL-encoded form data parsing
app.use(express.urlencoded({ extended: true }));

// Middleware to parse JSON bodies
app.use(express.json());

// Basic route
app.get('/', (req: Request, res: Response) => {
  res.send('Hello, TypeScript + Express!');
});

// Start the server
app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

Explanation

We import express and the Application, Request and Response types from Express.
The server listens on port 3000.
A simple GET route at / responds with a greeting.
express.urlencoded({ extended: true }) middleware that parses incoming requests with URL-encoded payloads
express.json() middleware that parses incoming JSON requests.

Step 6: Configure Scripts in `package.json`

Update the scripts section in package.json to simplify development and building:

"scripts": {
  "start": "node dist/server.js",
  "build": "tsc -p .",
  "dev": "nodemon src/server.ts"
}

Script Details

start: Runs the compiled JavaScript code.
build: Compiles TypeScript to JavaScript in the dist folder,set in your tsconfig.json.
dev: Uses nodemon to run the server and auto-restart on changes.

Step 7: Test the Server

Run the development server:

npm run dev

You should see:

Server is running on http://localhost:3000

Open your browser or use a tool like Postman to visit http://localhost:3000. You should see:

Hello, TypeScript + Express!

Step 8: Build for Production

To compile your TypeScript code to JavaScript for production:

npm run build

This generates a dist folder with compiled JavaScript. Run the production server:

npm start

Conclusion

You now have a fully functional Express server with TypeScript! This setup provides a solid foundation for building scalable APIs with type safety. From here, you can add more routes, connect to a database, or deploy to a platform like Railway or Render.

The full code is here.

DEV Community: William Onyejiaka

Debugging a BSONVersionError in Mongoose: What It Actually Means and How I Fixed It

What Is a BSONVersionError, Really?

How I Ran Into It

How to Diagnose It

The Fix

Takeaway

A Beginner’s Guide to Building a CRUD API with Express, TypeScript, and Mongoose

What is Mongoose?

Prerequisites

Step 1: Set Up the Project

Project Structure

Connecting to MongoDB

Defining the Mongoose Model

Writing the Controller Functions

Creating the Express Routes

Setting Up the App Entry Point

Testing the API

Examples:

Conclusion

Building a Robust Express API with TypeScript and express-validator

Introduction

Why You Need express-validator

Project Structure

What each file does:

Setting Up the Project

Step 1: Initialize the Project

Step 2: Install Dependencies

Step 3: Configure TypeScript

Step 4: Configure scripts

Setting Up Express with TypeScript

Validating Input with express-validator

src/routes/user.ts

Handling Validation Errors

Creating a Reusable Validation Middleware

src/middlewares/validate.ts

Wrapping Up

Mastering Routing in Express with TypeScript

What is Routing in Express?

Prerequisites

Step 1: Set Up the Project

Step 2: Project Structure

Step 3: Create the Express Server

Step 4: Define Routes with TypeScript

User Routes

Post Routes

Key Points:

Step 5: Mount the Routes

Step 6: Run the Application

Enhancements

Conclusion

Setting Up an Express TypeScript Server: A Step-by-Step Guide

Prerequisites

Step 1: Initialize Your Project

Step 2: Install Dependencies

Explanation of Dependencies

Step 3: Set Up TypeScript Configuration

Key Settings

Step 4: Set Up Project Structure

Step 5: Create the Express Server

Explanation

Step 6: Configure Scripts in package.json

Script Details

Step 7: Test the Server

Step 8: Build for Production

Conclusion

Step 6: Configure Scripts in `package.json`