Simplify Troubles with the Mongoose-auto populate Plugin: A Guide

Recently, I've been developing a catalog service withcontrollers to manage models for Products and Categories.

Below is the MongoDB schema definition for the Product model:

//Foucusing
const productSchema = new Schema(
    {
        name: {
            type: String,
            required: true,
        },
        description: {
            type: String,
            required: true,
        },
        image: {
            type: [String],
            required: true,
        },
        priceConfiguration: {
            type: Map,
            of: priceConfigurationSchema,
            required: true,
        },
        attributes: {
            type: Map,
            of: mongoose.Schema.Types.Mixed,
            required: true,
        },
        tenantId: {
            type: String,
            required: true,
        },

//Main focus of this article is on the categoryId field
        categoryId: {
            type: mongoose.Schema.Types.ObjectId,
            ref: "Category",
            required: true,
            autopopulate: true,
        },
        isPublish: {
            type: Boolean,
            default: true,
        },
    },
    { timestamps: true },
);

const Product = mongoose.model("Product", productSchema);

export default Product;

Similarly, the Category schema is defined as follows:

const categorySchema = new Schema(
    {
        name: {
            type: String,
            required: true,
        },
        priceConfiguration: {
            type: Map,
            of: priceConfigurationSchema,
            required: true,
        },
        attributes: {
            type: [attributeSchema],
            required: true,
        },
    },
    { timestamps: true },
);

export default mongoose.model("Category", categorySchema);

Yes, every product is associated with a category that connects to the Category model.

So, what is the actual problem I am facing? Everything seems perfect, right?

Let me explain each issue one by one.

I developed a route to list all products, supporting query parameters like search terms, category filters, page size, and limits.

http://localhost:3002/product?currentPage=1&pageSize=2&search=Maize

For the retrieval of data, I initially used Mongoose aggregation, which works fine for retrieving a list of products but does not populate category details within the returned data.

The aggregation pipeline code is as follows.

 const results = await Product.aggregate([
            {
                $match: filteredQueryParams,
            },
            {
                $facet: {
                    totalCounts: [{ $count: "count" }],
                    data: [
                        { $sort: { createdAt: -1 } },
                        { $skip: (currentPage - 1) * pageSize },
                        { $limit: pageSize },
                    ],
                },
            },
        ]);

At this point, if I populate inside of aggregation, it looks messier and feels uneasy. So I prefer to use a plugin that helps me. I have obtained paginated data through this aggregation and want to use the special plugin Mongoose-autopopulate to populate categoryId by setting it during schema definition. This allows me to eliminate the need for extra lines of code in every controller for the data population.

To implement the mongoose-autopopulate plugin, follow these steps:

Installation

npm install mongoose-autopopulate

Schema Integration

const mongoose = require('mongoose');
const autopopulate = require('mongoose-autopopulate');

const productSchema = new mongoose.Schema({
  // schema fields
  categoryId: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Category',
    autopopulate: true,   
  },
  // other fields
});

productSchema.plugin(autopopulate);

const Product = mongoose.model('Product', productSchema);

In this setup, the autopopulate plugin is added to the productSchema, and the categoryId field is configured to populate automatically.

After implementing the plugin, I simplified the data retrieval process as follows:

This plugin doesnot works with aggregate function.

//code changed after messy aggregation pipeline code
const results= await Product.find(filteredQueryParams)
            .sort({ createdAt: -1 })
            .skip((currentPage - 1) * pageSize)
            .limit(pageSize);

This approach is more readable and maintainable compared to the previous aggregation pipeline.

Isn't it simpler than the previous version?

In conclusion, using the Mongoose-autopopulate plugin can significantly simplify your code by automatically populating fields, reducing the need for repetitive code in your controllers. By transitioning from complex aggregation pipelines to more straightforward solutions, you can enhance the readability and maintainability of your codebase.

Feel free to share your thoughts or any other Mongoose plugins you find useful in the comments below. Your insights could greatly benefit the community!