Node.js and MongoDB are a match made in heaven for building scalable, high-performance web applications. If you’re looking to level up your Node.js skills and dive into the world of NoSQL databases, you’re in for a treat. Let’s explore how to use MongoDB with Mongoose to create robust, data-driven applications.

First things first, let’s get our environment set up. Make sure you have Node.js installed on your machine. If not, head over to the official Node.js website and download the latest version. Once that’s done, create a new project directory and initialize it with npm:

mkdir advanced-nodejs-mongodb
cd advanced-nodejs-mongodb
npm init -y

Now, let’s install the necessary dependencies:

npm install express mongoose dotenv

We’ll be using Express as our web framework, Mongoose as our ODM (Object Document Mapper) for MongoDB, and dotenv to manage our environment variables.

Let’s create our main server file, app.js:

const express = require('express');
const mongoose = require('mongoose');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware
app.use(express.json());

// Connect to MongoDB
mongoose.connect(process.env.MONGODB_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})
.then(() => console.log('Connected to MongoDB'))
.catch((err) => console.error('MongoDB connection error:', err));

// Routes
app.get('/', (req, res) => {
  res.send('Welcome to our Advanced Node.js with MongoDB API!');
});

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

This sets up a basic Express server and connects to MongoDB using Mongoose. Make sure to create a .env file in your project root and add your MongoDB connection string:

MONGODB_URI=mongodb://localhost:27017/your_database_name

Now, let’s dive into the fun part - working with MongoDB and Mongoose. One of the key concepts in Mongoose is the Schema. It allows you to define the structure of your documents and add validation, defaults, and more.

Let’s create a simple blog post schema. Create a new file called models/Post.js:

const mongoose = require('mongoose');

const postSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true,
    trim: true,
  },
  content: {
    type: String,
    required: true,
  },
  author: {
    type: String,
    required: true,
  },
  tags: [String],
  createdAt: {
    type: Date,
    default: Date.now,
  },
});

module.exports = mongoose.model('Post', postSchema);

This schema defines the structure of our blog posts, including validation rules and default values. Now, let’s create some routes to interact with our database.

Create a new file called routes/posts.js:

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

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

// Create a new post
router.post('/', async (req, res) => {
  const post = new Post({
    title: req.body.title,
    content: req.body.content,
    author: req.body.author,
    tags: req.body.tags,
  });

  try {
    const newPost = await post.save();
    res.status(201).json(newPost);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

// Get a specific post
router.get('/:id', getPost, (req, res) => {
  res.json(res.post);
});

// Update a post
router.patch('/:id', getPost, async (req, res) => {
  if (req.body.title != null) {
    res.post.title = req.body.title;
  }
  if (req.body.content != null) {
    res.post.content = req.body.content;
  }
  if (req.body.author != null) {
    res.post.author = req.body.author;
  }
  if (req.body.tags != null) {
    res.post.tags = req.body.tags;
  }

  try {
    const updatedPost = await res.post.save();
    res.json(updatedPost);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

// Delete a post
router.delete('/:id', getPost, async (req, res) => {
  try {
    await res.post.remove();
    res.json({ message: 'Post deleted' });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// Middleware to get a post by ID
async function getPost(req, res, next) {
  let post;
  try {
    post = await Post.findById(req.params.id);
    if (post == null) {
      return res.status(404).json({ message: 'Post not found' });
    }
  } catch (err) {
    return res.status(500).json({ message: err.message });
  }

  res.post = post;
  next();
}

module.exports = router;

This file sets up CRUD (Create, Read, Update, Delete) operations for our blog posts. Now, let’s update our app.js to use these routes:

// ... (previous code)

const postsRouter = require('./routes/posts');
app.use('/posts', postsRouter);

// ... (rest of the code)

Great! We now have a fully functional API for managing blog posts using MongoDB and Mongoose. But let’s not stop there - we can make our code even more robust and efficient.

One of the powerful features of Mongoose is middleware. We can use it to perform operations before or after certain events, like saving a document. Let’s add a middleware function to our Post schema that automatically generates a slug for our blog posts:

const mongoose = require('mongoose');
const slugify = require('slugify');

const postSchema = new mongoose.Schema({
  // ... (previous schema fields)
  slug: {
    type: String,
    unique: true,
  },
});

postSchema.pre('save', function(next) {
  if (!this.slug) {
    this.slug = slugify(this.title, { lower: true });
  }
  next();
});

module.exports = mongoose.model('Post', postSchema);

Don’t forget to install the slugify package:

npm install slugify

This middleware automatically generates a URL-friendly slug based on the post title before saving the document.

Another powerful feature of Mongoose is population. It allows you to reference documents in other collections and automatically replace the specified paths in the document with document(s) from other collection(s).

Let’s create a new schema for users and update our Post schema to reference users:

// models/User.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
  email: {
    type: String,
    required: true,
    unique: true,
  },
  bio: String,
});

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

// models/Post.js
const mongoose = require('mongoose');
const slugify = require('slugify');

const postSchema = new mongoose.Schema({
  // ... (previous schema fields)
  author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true,
  },
});

// ... (rest of the code)

Now, when we query for posts, we can populate the author field with the actual user document:

// routes/posts.js
router.get('/', async (req, res) => {
  try {
    const posts = await Post.find().populate('author');
    res.json(posts);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

This will return the full user object instead of just the user ID in the author field.

As our application grows, we might need to handle more complex queries. Mongoose provides a powerful query API that allows us to build complex queries easily. Let’s add a route to search for posts:

// routes/posts.js
router.get('/search', async (req, res) => {
  try {
    const { q, tags, author } = req.query;
    let query = {};

    if (q) {
      query.$or = [
        { title: new RegExp(q, 'i') },
        { content: new RegExp(q, 'i') },
      ];
    }

    if (tags) {
      query.tags = { $in: tags.split(',') };
    }

    if (author) {
      query.author = author;
    }

    const posts = await Post.find(query).populate('author');
    res.json(posts);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

This route allows searching posts by title or content, filtering by tags, and filtering by author.

As our application scales, we might need to handle large amounts of data efficiently. Mongoose supports pagination out of the box, which is crucial for improving performance when dealing with large datasets. Let’s update our main posts route to include pagination:

// routes/posts.js
router.get('/', async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;

    const posts = await Post.find()
      .populate('author')
      .skip(skip)
      .limit(limit)
      .sort({ createdAt: -1 });

    const total = await Post.countDocuments();

    res.json({
      posts,
      currentPage: page,
      totalPages: Math.ceil(total / limit),
      totalPosts: total,
    });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

This implementation allows clients to request specific pages of results and set the number of items per page.

When working with MongoDB, it’s important to consider indexing to improve query performance. Mongoose makes it easy to add indexes to your schema:

// models/Post.js
const postSchema = new mongoose.Schema({
  // ... (previous schema fields)
});

postSchema.index({ title: 'text', content: 'text' });
postSchema.index({ tags: 1 });
postSchema.index({ createdAt: -1 });

module.exports = mongoose.model('Post', postSchema);

These indexes will speed up our text searches, tag filtering, and sorting by creation date.

As your application grows, you might need to perform more complex operations or aggregate data. MongoDB’s aggregation pipeline is a powerful tool for this, and Mongoose provides a nice interface for it. Let’s add a route to get post statistics:

// routes/posts.js
router.get('/stats', async (req, res) => {
  try {
    const stats = await Post.aggregate([
      {
        $group: {
          _id: null,
          totalPosts: { $sum: 1 },
          avgWordCount: { $avg: { $size: { $split: ['$content', ' '] } } },
          maxWordCount: { $max: { $size: { $split: ['$content', ' '] } } },
          minWordCount: { $min: { $size: { $split: ['$content', ' '] } } },
        },
      },
      {