The $group stage in MongoDB’s aggregation framework is a powerful tool for grouping documents by a specified field and performing various operations on the grouped data, such as calculating totals, averages, and other aggregates. When combined with Node.js, this allows for efficient data processing and analysis within your application. This article will guide you through the process of using $group in MongoDB queries with Node.js.

$group Operator 

The $group operator in MongoDB is used in the aggregation pipeline to group documents by a specified key and perform aggregate operations, such as sum, count, or average, on grouped data. It allows for sophisticated data transformation and computation within collections.

Aggregation in MongoDB is an operation that groups values from multiple documents together and can perform a variety of operations on the grouped data to return a single result. And $group is one of the operations that aggregation performs.

Syntax:

{
    $group:
    {
        _id: <expression>,
        <field>: { <accumulator> : <expression> }
    }
}

• _id: It is the field by which you want to group the documents.
• field: It is an optional parameter, and it is the computed field after performing certain accumulator operations on the grouped data.

Approach

To use $group in a MongoDB query with Node.js:

• Connect to MongoDB using Mongoose or native driver.
• Define aggregation pipeline stages, including $group for grouping documents.
• Execute aggregation using .aggregate() method on the collection.
• Handle results or errors in the callback or promise chain.

Installation Steps

Step 1: Make a folder structure for the project.

mkdir myapp

Step 2: Navigate to the project directory

cd myapp

Step 3: Initialize the NodeJs project inside the myapp folder.

npm init -y

Step 3: Install the necessary packages/libraries in your project using the following commands.

npm install mongoose

Project Structure:

The updated dependencies in package.json file will look like:

"dependencies": {
    "express": "^8.4.4",
}

Database

We have already created a collection named employees in our database GFG with the following entries show in the image below:

Collection employees in the database GFG

Example: Implementation to show the use of $group for a MongoDB query in NodeJS.

// app.js

// Requiring module
const mongoose = require('mongoose');

// Connecting to database
mongoose.connect('mongodb://localhost:27017/GFG',
    {
        useNewUrlParser: true,
        useUnifiedTopology: true,
        useFindAndModify: false
    });

// Schema of employee collection
const employeeSchema = new mongoose.Schema({
    name: String,
    city: String,
    salary: Number,
    department: String
})

// Model of employees collection
const Employee = mongoose.model(
        'employee', employeeSchema)

// Group employees by department field
// and computing total no. of employees
// and average salary in each department
Employee.aggregate([
    {
        $group:
        {
            _id: { department: "$department" },
            totalEmployee: { $sum: 1 },
            averageSalary: { $avg: "$salary" }
        }
    }
])
    .then(result => {
        console.log(result)
    })
    .catch(error => {
        console.log(error)
    })

Step to Run Application: Run the application using the following command from the root directory of the project

node app.js

Output: In the console, we are getting documents grouped by department and computed fields totalEmployee and averageSalary in each group.Here we have grouped employees by department field and computing separate fields totalEmployee which contains the total number of employees in each group and averageSalary which gives the average salary of employees in each group, using accumulation operators $sum and $avg.

Output after executing main.js