mongoose-paginate-v2

What is mongoose-paginate-v2?

mongoose-paginate-v2 is a pagination library for Mongoose, which is a MongoDB object modeling tool designed to work in an asynchronous environment. This package simplifies the process of adding pagination to Mongoose queries, making it easier to handle large datasets by breaking them into manageable chunks.

What are mongoose-paginate-v2's main functionalities?

Basic Pagination

This feature allows you to paginate through documents in a Mongoose model. The example demonstrates how to set up a schema with the pagination plugin and perform a basic pagination query.

const mongoose = require('mongoose');
const mongoosePaginate = require('mongoose-paginate-v2');

const schema = new mongoose.Schema({ name: String });
schema.plugin(mongoosePaginate);
const Model = mongoose.model('Model', schema);

Model.paginate({}, { page: 1, limit: 10 }).then(result => {
  console.log(result);
});

Custom Pagination Options

This feature provides various options to customize the pagination query, such as sorting, selecting specific fields, and populating related documents. The example shows how to use these options in a pagination query.

const options = {
  page: 1,
  limit: 10,
  sort: { name: 1 },
  select: 'name',
  populate: 'relatedModel'
};

Model.paginate({}, options).then(result => {
  console.log(result);
});

Aggregation Pagination

This feature allows you to paginate the results of an aggregation query. The example demonstrates how to use the `aggregatePaginate` method to paginate through aggregation results.

const aggregate = Model.aggregate([{ $match: { name: 'example' } }]);

Model.aggregatePaginate(aggregate, { page: 1, limit: 10 }).then(result => {
  console.log(result);
});

Other packages similar to mongoose-paginate-v2

mongoose-paginate

mongoose-paginate is another pagination library for Mongoose. It provides similar functionality to mongoose-paginate-v2 but lacks some advanced features like aggregation pagination and custom labels. It is simpler and might be suitable for basic use cases.

mongoose-aggregate-paginate-v2

mongoose-aggregate-paginate-v2 is specifically designed for paginating aggregation queries in Mongoose. It offers more specialized functionality for aggregation pagination compared to mongoose-paginate-v2, but it does not support regular query pagination.

mongoose-paginate-ts

mongoose-paginate-ts is a TypeScript-friendly pagination library for Mongoose. It provides type definitions and is designed to work seamlessly with TypeScript projects. It offers similar functionality to mongoose-paginate-v2 but with better TypeScript support.

README

mongoose-paginate-v2

A cursor based custom pagination library for Mongoose with customizable labels.

Installation

npm install mongoose-paginate-v2

Usage

Add plugin to a schema and then use model paginate method:

var mongoose         = require('mongoose');
var mongoosePaginate = require('mongoose-paginate-v2');

var mySchema = new mongoose.Schema({ 
    /* your schema definition */ 
});

mySchema.plugin(mongoosePaginate);

var myModel = mongoose.model('SampleModel',  mySchema); 

myModel.paginate().then({}) // Usage

Model.paginate([query], [options], [callback])

Returns promise

Parameters

• [query] {Object} - Query criteria. Documentation
• [options] {Object}
  • [select] {Object | String} - Fields to return (by default returns all fields). Documentation
  • [sort] {Object | String} - Sort order. Documentation
  • [populate] {Array | Object | String} - Paths which should be populated with other documents. Documentation
  • [lean=false] {Boolean} - Should return plain javascript objects instead of Mongoose documents? Documentation
  • [leanWithId=true] {Boolean} - If lean and leanWithId are true, adds id field with string representation of _id to every document
  • [offset=0] {Number} - Use offset or page to set skip position
  • [page=1] {Number}
  • [limit=10] {Number}
  • [customLabels] {Object} - Developers can provide custom labels for manipulating the response data.
• [callback(err, result)] - If specified the callback is called once pagination results are retrieved or when an error has occurred

Return value

Promise fulfilled with object having properties:

• docs {Array} - Array of documents
• totalDocs {Number} - Total number of documents in collection that match a query
• limit {Number} - Limit that was used
• hasPrevPage {Bool} - Availability of prev page.
• hasNextPage {Bool} - Availability of next page.
• page {Number} - Current page number
• totalPages {Number} - Total number of pages.
• offset {Number} - Only if specified or default page/offset values were used
• prevPage {Number} - Previous page number if available or NULL
• nextPage {Number} - Next page number if available or NULL

Please note that the above properties can be renamed by setting customLabel attribute.

Sample Usage

Return first 10 documents from 100

const options = {
    page: 1,
    limit: 10
};

Model.paginate({}, options, function(err, result) {
    // result.docs
    // result.totalDocs = 100
    // result.limit = 10
    // result.page = 1
    // result.totalPages = 10    
    // result.hasNextPage = true
    // result.nextPage = 2
    // result.hasPrevPage = false
    // result.prevPage = null
    
});

With custom return labels

Now developers can specify the return field names if they want. Below are the list of attributes whose name can be changed.

• totalDocs
• docs
• limit
• page
• nextPage
• prevPage
• totalPages

You should pass the names of the properties you wish to changes using customLabels object in options.

Same query with custom labels

const myCustomLabels = {
    totalDocs: 'itemCount',
    docs: 'itemsList',
    limit: 'perPage',
    page: 'currentPage',
    nextPage: 'next',
    prevPage: 'prev',
    totalPages: 'pageCount'
};

const options = {
    page: 1,
    limit: 10,
    customLabels: myCustomLabels
};

Model.paginate({}, options, function(err, result) {
    // result.itemsList [here docs become itemsList]
    // result.itemCount = 100 [here totalDocs becomes itemCount]
    // result.perPage = 10 [here limit becomes perPage]
    // result.currentPage = 1 [here page becomes currentPage]
    // result.pageCount = 10 [here totalPages becomes pageCount]
    // result.next = 2 [here nextPage becomes next]
    // result.prev = null [here prevPage becomes prev]
    
    // result.hasNextPage = true [not changeable]
    // result.hasPrevPage = false [not changeable]
});

Other Examples

Using offset and limit:

Model.paginate({}, { offset: 30, limit: 10 }, function(err, result) {
    // result.docs
    // result.totalPages
    // result.limit - 10
    // result.offset - 30
});

With promise:

Model.paginate({}, { offset: 30, limit: 10 }).then(function(result) {
    // ...
});

More advanced example

var query   = {};
var options = {
    select:   'title date author',
    sort:     { date: -1 },
    populate: 'author',
    lean:     true,
    offset:   20, 
    limit:    10
};

Book.paginate(query, options).then(function(result) {
    // ...
});

Zero limit

You can use limit=0 to get only metadata:

Model.paginate({}, { offset: 100, limit: 0 }).then(function(result) {
    // result.docs - empty array
    // result.totalDocs
    // result.limit - 0
    // result.offset - 100
});

Set custom default options for all queries

config.js:

var mongoosePaginate = require('mongoose-paginate-v2');

mongoosePaginate.paginate.options = { 
    lean:  true,
    limit: 20
};

controller.js:

Model.paginate().then(function(result) {
    // result.docs - array of plain javascript objects
    // result.limit - 20
});

Thanks

This is a advanced version of mongoose-paginate forked from Mongoose Paginate. Thanks to the initial author Edward Hotchkiss

License

MIT