mongo-aggregate-helper

A lightweight and user-friendly helper library for easily constructing and executing MongoDB aggregation pipelines. Streamline your data processing with a clean API and versatile functionality.

1.3.0

latest

Source

npm

Version published: 8 months ago

Weekly downloads: 2

Maintainers: 0

Weekly downloads

Created: 8 months ago

Source

Mongo Aggregate Helper

npm npm

The Mongo Aggregate Helper is a lightweight and intuitive library designed to streamline the construction and execution of MongoDB aggregation pipelines. With a focus on simplicity and usability, this library empowers developers to efficiently build complex aggregation queries without the overhead of verbose code.

Features
Installation
Usage
- Using MongoClient
- Using Mongoose
API
Contributing
License

Features

User-Friendly Interface: The library offers a straightforward API that abstracts away the complexities of MongoDB's aggregation framework, allowing developers to focus on logic rather than syntax.
Versatile Functionality: It supports a wide range of aggregation operations, including but not limited to $group, $match, $project, and more, making it suitable for various data processing tasks.
Enhanced Code Readability: By promoting a clean and organized coding style, this helper facilitates maintainable and scalable projects, which is essential for both small and large applications.
Seamless Integration: Easily integrate the library into any Node.js application with minimal setup, making it a great addition for projects that rely on MongoDB for data handling.

Whether you're building data-centric applications or performing data analysis, the Mongo Aggregate Helper simplifies your MongoDB aggregation queries and enhances your development experience.

Installation

To install the package, run the following command:

npm install mongo-aggregate-helper

Methods Available

match(condition): Adds a $match stage.
group(grouping): Adds a $group stage.
sort(order): Adds a $sort stage
project(fields): Adds a $project stage.
lookup(from, localField, foreignField, as): Adds a $lookup stage.
unwind(path): Adds a $unwind stage.
addFields(fields): Adds a $addFields stage.
paginate(skip, limit): Adds pagination using $skip and $limit.
search(field, keyword, exactMatch): Adds a search capability, Allowing both exact and regex-based matching.
facet(stages): Adds a $facet stage.
count(fieldName): Adds a $count stage.
execute(): Execute the aggregation pipeline and return results.

Usage

Using MongoClient

const MongoClient = require('mongodb').MongoClient;
const Aggregator = require("mongo-aggregate-helper");

// Example MongoDB connection (replace with your connection URI)
const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);

async function runAggregation() {
    try {
        await client.connect();
        const database = client.db('your_database_name');
        const collection = database.collection('your_collection_name');

        const aggregator = new Aggregator(collection);

        // Build your aggregation pipeline
        const result = await aggregator
            .match({ status: 'active' })            // Example match stage
            .group({ _id: '$country', count: { $sum: 1 } }) // Example group stage
            .execute(); // Execute the aggregation

        console.log(result);
    } finally {
        await client.close();
    }
}

runAggregation().catch(console.error);

Notes:

Ensure that the placeholders such as your_database_name and your_collection_name in the usage example are replaced with actual values relevant to your application.
You can add any specific sections or information that you feel would enhance the usability of your package for developers.
Make sure to include any additional dependencies or setup details that may be necessary for using your library effectively.

Using Mongoose

const mongoose = require('mongoose');
const Aggregator = require("mongo-aggregate-helper");

// Connect to your MongoDB database
mongoose.connect('mongodb://localhost:27017/your_database_name', {
    useNewUrlParser: true,
    useUnifiedTopology: true
});

// Define a Mongoose schema
const exampleSchema = new mongoose.Schema({
    name: String,
    country: String,
    status: String,
});

// Create a Mongoose model
const ExampleModel = mongoose.model('Example', exampleSchema);

async function runAggregation() {
    try {
        // Ensure the connection is established
        await mongoose.connection.once('open', () => {
            console.log('Connected to MongoDB');
        });

        const aggregator = new Aggregator(ExampleModel); // Pass the Mongoose model

        // Build your aggregation pipeline
        const result = await aggregator
            .match({ status: 'active' }) // Example match stage
            .group({ _id: '$country', count: { $sum: 1 } }) // Example group stage
            .execute(); // Execute the aggregation

        console.log(result); // Output the aggregation results
    } catch (error) {
        console.error('Aggregation error:', error);
    } finally {
        await mongoose.connection.close(); // Close the connection
    }
}

// Run the aggregation
runAggregation().catch(console.error);

Notes

Replace your_database_name in the MongoDB connection string with the actual name of your MongoDB database.
Adjust the schema according to the fields and structure of your actual collection.
Make sure the necessary error handling and connection management is applied as relevant for your use case.

API

Aggregator

`new Aggregator(model)`

Creates a new Aggregator instance.

Parameters:
- model: The Mongoose model to aggregate.