Forem: William Onyejiaka

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.

Forem: William Onyejiaka

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`