Integrating MongoDB with Express.js

Introduction

Integrating MongoDB with Express.js is a fundamental skill for building modern web applications and RESTful APIs. MongoDB, a NoSQL database, provides a flexible, document-based approach to data storage, while Express.js, built on Node.js, offers a simple and scalable framework for creating web applications and APIs. Together, these technologies allow developers to handle data efficiently, perform CRUD operations, and structure robust server-side applications.

In this post, we will explore the steps to integrate MongoDB with Express.js, covering project structure, setting up Mongoose models, connecting to the database, and handling data through API routes. By the end, you will understand how to create and retrieve data via API endpoints, forming a foundation for more complex full-stack applications.

---

1. Setting Up the Project

Before integrating MongoDB, you need to set up a basic Node.js and Express.js project.

1.1. Create a Project Directory

Create a new project directory and initialize it as a Node.js project:

mkdir express-mongo-app
cd express-mongo-app
npm init -y

This creates a package.json file, which manages dependencies and scripts for your project.

1.2. Install Required Packages

You need to install Express.js for the web server and Mongoose to interact with MongoDB:

npm install express mongoose

You may also install nodemon for automatic server restarts during development:

npm install --save-dev nodemon

In package.json, update the scripts section to use nodemon:

"scripts": {
  "start": "node app.js",
  "dev": "nodemon app.js"
}

---

2. Project Structure

A clean project structure helps organize routes, models, and other components efficiently. A typical Express-MongoDB project might look like this:

express-mongo-app/
│
├── models/          # Mongoose models
│   └── User.js
├── routes/          # API routes
│   └── userRoutes.js
├── app.js           # Entry point of the application
├── package.json
└── package-lock.json

• models/: Contains the MongoDB schemas and models.
• routes/: Contains Express route definitions.
• app.js: Main server file where Express and MongoDB are connected.

---

3. Connecting to MongoDB

To connect MongoDB with Express, you use Mongoose, which simplifies working with MongoDB and provides schema-based modeling.

3.1. Local MongoDB Connection

If you have MongoDB installed locally, you can connect using:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/myapp', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('Connected to MongoDB'))
.catch((err) => console.error('MongoDB connection error:', err));

3.2. MongoDB Atlas Connection

For a cloud-hosted MongoDB, sign up at MongoDB Atlas, create a cluster, and obtain a connection URI. Then connect like this:

mongoose.connect('mongodb+srv://username:[email protected]/myapp?retryWrites=true&w=majority', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('Connected to MongoDB Atlas'))
.catch((err) => console.error('MongoDB Atlas connection error:', err));

---

4. Setting Up Mongoose Models

A model defines the structure of your MongoDB documents and allows you to interact with the database using JavaScript.

4.1. Creating a User Model

In the models folder, create a file named User.js:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
type: String,
required: true
  },
  email: {
type: String,
required: true,
unique: true
  },
  age: {
type: Number,
required: true
  },
  createdAt: {
type: Date,
default: Date.now
  }
});

const User = mongoose.model('User', userSchema);
module.exports = User;

• name, email, and age are required fields.
• email is unique to prevent duplicate entries.
• createdAt automatically sets the timestamp for when the user is created.

---

5. Structuring API Routes

To handle HTTP requests and interact with MongoDB, we create routes in the routes folder.

5.1. User Routes

Create routes/userRoutes.js:

const express = require('express');
const router = express.Router();
const User = require('../models/User');

// Create a new user
router.post('/users', async (req, res) => {
  try {
const user = new User(req.body);
const savedUser = await user.save();
res.status(201).json(savedUser);
  } catch (err) {
res.status(400).json({ error: err.message });
  }
});

// Get all users
router.get('/users', async (req, res) => {
  try {
const users = await User.find();
res.status(200).json(users);
  } catch (err) {
res.status(500).json({ error: err.message });
  }
});

// Get a user by ID
router.get('/users/:id', async (req, res) => {
  try {
const user = await User.findById(req.params.id);
if (!user) return res.status(404).json({ message: 'User not found' });
res.status(200).json(user);
  } catch (err) {
res.status(500).json({ error: err.message });
  }
});

// Update a user by ID
router.put('/users/:id', async (req, res) => {
  try {
const updatedUser = await User.findByIdAndUpdate(
  req.params.id,
  req.body,
  { new: true, runValidators: true }
);
if (!updatedUser) return res.status(404).json({ message: 'User not found' });
res.status(200).json(updatedUser);
  } catch (err) {
res.status(400).json({ error: err.message });
  }
});

// Delete a user by ID
router.delete('/users/:id', async (req, res) => {
  try {
const deletedUser = await User.findByIdAndDelete(req.params.id);
if (!deletedUser) return res.status(404).json({ message: 'User not found' });
res.status(204).send();
  } catch (err) {
res.status(500).json({ error: err.message });
  }
});

module.exports = router;

• POST /users: Creates a new user.
• GET /users: Retrieves all users.
• GET /users/:id: Retrieves a user by their ID.
• PUT /users/:id: Updates a user by ID.
• DELETE /users/:id: Deletes a user by ID.

---

6. Integrating Routes into Express App

Finally, import and use the routes in app.js:

const express = require('express');
const mongoose = require('mongoose');
const userRoutes = require('./routes/userRoutes');

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

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/myapp', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('MongoDB connected'))
.catch(err => console.error('MongoDB connection error:', err));

// Use user routes
app.use('/api', userRoutes);

// Root route
app.get('/', (req, res) => {
  res.send('Welcome to the Express MongoDB App');
});

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(Server is running on http://localhost:${PORT});
});

• We set up middleware to parse JSON request bodies.
• We mount the userRoutes under /api. For example, POST /api/users creates a new user.

---

7. Testing the Integration

You can now test your Express-MongoDB integration using tools like Postman, cURL, or your front-end application.

7.1. Creating a User

Request: POST http://localhost:3000/api/users

Body (JSON):

{
  "name": "Alice Johnson",
  "email": "[email protected]",
  "age": 28
}

Response:

{
  "_id": "60f7b8f3e7c6f12abc123456",
  "name": "Alice Johnson",
  "email": "[email protected]",
  "age": 28,
  "createdAt": "2023-10-07T10:00:00.000Z",
  "__v": 0
}

7.2. Retrieving All Users

Request: GET http://localhost:3000/api/users

Response:

[
  {
"_id": "60f7b8f3e7c6f12abc123456",
"name": "Alice Johnson",
"email": "[email protected]",
"age": 28,
"createdAt": "2023-10-07T10:00:00.000Z",
"__v": 0
  }
]

7.3. Updating a User

Request: PUT http://localhost:3000/api/users/60f7b8f3e7c6f12abc123456

Body (JSON):

{
  "age": 29
}

Response:

{
  "_id": "60f7b8f3e7c6f12abc123456",
  "name": "Alice Johnson",
  "email": "[email protected]",
  "age": 29,
  "createdAt": "2023-10-07T10:00:00.000Z",
  "__v": 0
}

7.4. Deleting a User

Request: DELETE http://localhost:3000/api/users/60f7b8f3e7c6f12abc123456

Response: Status 204 No Content

---

8. Best Practices

When integrating MongoDB with Express.js, consider the following best practices:

1. Environment Variables: Store sensitive information like database URIs in .env files using the dotenv package.
2. Validation: Use Mongoose schema validation to enforce data integrity.
3. Error Handling: Implement centralized error-handling middleware to manage errors consistently.
4. Project Structure: Keep models, routes, controllers, and middlewares organized for maintainability.
5. Indexes: Add indexes for fields like email to improve query performance.