@r5v/mongoose-paginate 1.0.0

package/README.md

@@ -0,0 +1,126 @@
+
+
+@r5v/mongoose-pagination is a powerful yet lightweight utility that bridges the gap between HTTP query parameters and MongoDB queries. It provides an intuitive wrapper around Mongoose models, allowing you to easily transform Express request objects into sophisticated database queries with pagination, filtering, and sorting capabilities.
+
+Simple, Fast, Efficient
+
+This project was designed to accomodate more than 80% of your ddaily workflow. to remove the overhead of boilerplate code in handling each endpoint and keeping queries and query params simple. We didn't want you to have to learn a new language to use this product
+
+## Basic Usage
+
+### PagingQuery
+```typescript
+// userController.ts
+import {PagingQuery} from '@r5v/@r5v/mongoose-paginate'
+import {UserModel} from "./models"
+
+const getUsersController: RequestHandler = async (res, res) => {
+    
+    const query = new PagingQuery(req, User, {})
+    const users = await query.exec()
+    
+    res.send(users)
+}
+```
+
+#### Results
+
+```
+{
+    totalRows: 0,
+    rows: 0,
+    limit: 25,
+    skip: 0,
+    items: [ <UserObject>]
+}
+```
+
+### AggregationPagingQuery
+```typescript
+// userController.ts
+import {AggregationPagingQuery} from '@r5v/@r5v/mongoose-paginate'
+import {UserModel} from "./models"
+
+const getUsersController: RequestHandler = async (res, res) => {
+    
+    const query = new AggregationPagingQuery(req, User, {
+        pipeline: [ {$match:{name:/^Steve/}}]
+    })
+    const users = await query.exec()
+    
+    res.send(users)
+}
+```
+
+#### Results
+
+```
+{
+    totalRows: 0,
+    rows: 0,
+    limit: 25,
+    skip: 0,
+    items: [ <UserObject>]
+}
+```
+
+### Definition
+
+PagingQuery(Express.Request, mongoose.Model, options )
+
+#### Query Parameters
+
+| Name        | Value                                                                             | Description                                                                                                                                                                                                    | Class Availability                  |
+|:------------|:----------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------|
+| $filter     | Mongo Filter Object                                                               | any json string can be passed in this parameter. be sure to turn on sanitizeFilter if you allow dynamic filters                                                                                                | PagingQuery, AggregationPagingQuery |
+| $limit      | number                                                                            | limit the number of returned objects                                                                                                                                                                           | PagingQuery, AggregationPagingQuery |
+| $skip       | number                                                                            | skip to the next object on the request                                                                                                                                                                         | PagingQuery, AggregationPagingQuery |
+| $paging     | 'false'\|0\|'no'                                                                  | turn off paging, on by default                                                                                                                                                                                 | PagingQuery, AggregationPagingQuery |
+| $populate   | comma separated dot notation string \n books,publishers                           | using refs and virtuals, a dot notation string will populate the model using .populate                                                                                                                         | PagingQuery                         |
+| $select     | comma separated dot notation string \n books,-_id \| -_id,-name,address.-address1 | using the select notation uses the mongoose name \| -name syntax to filter the output. use this in conjunction with the $populate query to filter keys \n ie books.title,books.publisher \| -name,books.-title | PagingQuery, AggregationPagingQuery |   
+| $lean       | no value needed, this will return a lean query result                             | returns a lean result. does not require a value                                                                                                                                                                | PagingQuery                         |   
+| $sort       | space separated mongoose sort string \n name -value                               | inserts sort into the query. In aggregation queries this will insert a sort after the existing pipeline                                                                                                        | PagingQuery, AggregationPagingQuery | 
+| $preSort    | comma separated dot notation string \n books,-_id \| -_id,-name,address.-address1 | in aggregate queries this will insert a sort object after the initial match in the pipeline.                                                                                                                   | AggregationPagingQuery              |
+| $count      | comma separated dot notation string                                               | this comma separate string will traverse the results and insert a new field  with the $size of the selected key/value . this new name field will be appended with `_count`                                     | AggregationPagingQuery              |   
+| $postFilter | Any Json Object                                                                   | creates and additional filter and in aggregation queries is appended to the end of the pipeline                                                                                                                | AggregationPagingQuery              |   
+
+#### Options
+
+| Key              | Value                | Description                                                                                                                                                              | Class Availability                  | Required | Default |
+|:-----------------|:---------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:------------------------------------|:---------|:--------|
+| disablePaging    | boolean              | disables paging and $paging param use                                                                                                                                    | PagingQuery, AggregationPagingQuery |          | false   |
+| enableFilter     | boolean              | disables the $filter param on req.                                                                                                                                       | PagingQuery, AggregationPagingQuery |          | false   |
+| single           | boolean              | disables paging on the query. converts from .find query to .findOne()                                                                                                    | PagingQuery, AggregationPagingQuery |          | true    |
+| enablePostFilter | boolean              | disables the ability to create a dynamic filter per request                                                                                                              | AggregationPagingQuery              |          | false   |
+| staticPostFilter | Mongo Filter Object  | create a filter on the pipeline that is added after all the pipeline stages. this cannot be overwritten by params                                                        | AggregationPagingQuery              |          | {}      |
+| staticFilter     | Mongo Filter Object  | create a filter on the pipeline that is added before all the pipeline stages. on find requests, this is added to the filter object. this cannot be overwritten by params | AggregationPagingQuery              |          | {}      |
+| pipeline         | MongoPipelineStage[] | pipeline request object. if the first item in pipeline stage is a $match or another required first stage operator. it will be placed before all other modifiers          | AggregationPagingQuery              | true     | []      |
+| removeProtected  | boolean              | auto remove protected (select: false) for root Model                                                                                                                     | AggregationPagingQuery              |          | false   |
+
+## Build
+
+```text
+### build and run test server
+
+$ yarn 
+$ yarn run build
+$ cd test_server
+$ yarn
+$ yarn add ../ #adds the package to the local server
+$ echo MONGODB_URI=http://localhost:27017/bookstore >> .env
+$ yarn run seed 
+  ### load seed data into bookstore database
+$ yarn run start
+```
+
+
+#### Aggregations Order of operations
+
+1. staticFilter \| \$filter \| $match (if first item in pipeline)
+2. \$preSort
+3. apply pipeline
+4. \$select \| project
+5. remove protected fields
+6. \$count
+7. \$sort
+8. apply options

package/dist/aggregationPagingQuery.d.ts

@@ -0,0 +1,25 @@
+import { Model, Aggregate } from "mongoose";
+import type { Request } from "express";
+import type { AggregateQueryOptions, ExpressQuery, AggregateQueryParsedRequestParams } from './index.d';
+export declare class AggregationPagingQuery {
+    params: AggregateQueryParsedRequestParams;
+    options: AggregateQueryOptions;
+    query: Aggregate<Array<any>> | undefined;
+    protectedPaths: string[];
+    model: Model<any>;
+    constructor(req: Request<{}, any, any, Partial<ExpressQuery>>, model: Model<any>, options: AggregateQueryOptions);
+    findProtectedPaths: (model: Model<any>) => string[];
+    parseParams: (defaultParams: import("./index.d").PagingQueryParsedRequestParams | AggregateQueryParsedRequestParams, params: import("qs").ParsedQs, isAggregate?: boolean) => import("./index.d").PagingQueryParsedRequestParams | AggregateQueryParsedRequestParams;
+    isValidDateString: (value: string) => boolean;
+    isJsonString: (str: string) => boolean;
+    parseSortString: (sortString: string) => [string, import("mongoose").SortOrder][];
+    parseAggregateSortString: (sortString: any) => {
+        [key: string]: import("mongoose").SortOrder;
+    };
+    createCounts: () => void;
+    initQuery: () => Promise<void>;
+    typeCastObject: (strOrObj: any) => any;
+    private removeProtectedFields;
+    exec: () => Promise<any>;
+}
+//# sourceMappingURL=aggregationPagingQuery.d.ts.map

package/dist/aggregationPagingQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregationPagingQuery.d.ts","sourceRoot":"","sources":["../src/aggregationPagingQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,EACL,SAAS,EAKZ,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAC,qBAAqB,EAAE,YAAY,EAAE,iCAAiC,EAAC,MAAM,WAAW,CAAA;AAQrG,qBAAa,sBAAsB;IAC/B,MAAM,EAAG,iCAAiC,CAazC;IACD,OAAO,EAAE,qBAAqB,CAM7B;IACD,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAA;IACxC,cAAc,EAAE,MAAM,EAAE,CAAK;IAC7B,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;gBACL,GAAG,EAAE,OAAO,CAAC,EAAE,EAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,qBAAqB;IAQ/G,kBAAkB,kCAAqB;IACvC,WAAW,0PAAc;IACzB,iBAAiB,6BAAoB;IACrC,YAAY,2BAAe;IAC3B,eAAe,mEAAkB;IACjC,wBAAwB;;MAA2B;IACnD,YAAY,aAOX;IACD,SAAS,sBAsDR;IACD,cAAc,GAAI,UAAU,GAAG,KAAG,GAAG,CAmCpC;IAED,OAAO,CAAC,qBAAqB,CAS5B;IACD,IAAI,qBAgCH;CAEJ"}

package/dist/aggregationPagingQuery.js

@@ -0,0 +1,194 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationPagingQuery = void 0;
+const mongoose_1 = require("mongoose");
+const parseParams_1 = require("./utils/parseParams");
+const isJsonString_1 = require("./utils/isJsonString");
+const isValidDateString_1 = require("./utils/isValidDateString");
+const parseSortString_1 = require("./utils/parseSortString");
+const findProtectedPaths_1 = require("./utils/findProtectedPaths");
+class AggregationPagingQuery {
+    constructor(req, model, options) {
+        this.params = {
+            $filter: {},
+            $limit: 25,
+            $skip: 0,
+            $sort: {},
+            $paging: true,
+            $populate: [],
+            $includes: [], // to be removed
+            $select: "",
+            $count: [],
+            $postFilter: {},
+            $preSort: {}
+        };
+        this.options = {
+            removeProtected: true,
+            enableFilter: false,
+            enablePostFilter: false,
+            enablePreSort: true,
+            pipeline: []
+        };
+        this.protectedPaths = [];
+        this.findProtectedPaths = findProtectedPaths_1.findProtectedPaths;
+        this.parseParams = parseParams_1.parseParams;
+        this.isValidDateString = isValidDateString_1.isValidDateString;
+        this.isJsonString = isJsonString_1.isJsonString;
+        this.parseSortString = parseSortString_1.parseSortString;
+        this.parseAggregateSortString = parseSortString_1.parseAggregateSortString;
+        this.createCounts = () => {
+            var _a;
+            const counts = this.params.$count;
+            const addFieldsObj = counts.reduce((acc, curr) => {
+                acc[`${curr}_count`] = { $size: `$${curr}` };
+                return acc;
+            }, {});
+            (_a = this.query) === null || _a === void 0 ? void 0 : _a.addFields(addFieldsObj);
+        };
+        this.initQuery = () => __awaiter(this, void 0, void 0, function* () {
+            const { $filter, $sort, $preSort, $select, $count, $postFilter } = this.params;
+            const _a = this.options, { enableFilter, enablePreSort, enablePostFilter, staticFilter, staticPostFilter, removeProtected, pipeline } = _a, options = __rest(_a, ["enableFilter", "enablePreSort", "enablePostFilter", "staticFilter", "staticPostFilter", "removeProtected", "pipeline"]);
+            this.query = this.model.aggregate();
+            const [p1, ...pipes] = pipeline;
+            const filterObj = { $and: [Object.assign({}, staticFilter)] };
+            const postFilterObj = { $and: [Object.assign({}, staticPostFilter)] };
+            let firstObj = false;
+            if (enableFilter) {
+                filterObj.$and.push(Object.assign({}, $filter));
+            }
+            if (p1 && p1.$match) {
+                filterObj.$and.push(Object.assign({}, p1.$match));
+                firstObj = true;
+            }
+            if (enablePostFilter) {
+                postFilterObj.$and.push(Object.assign({}, $postFilter));
+            }
+            const typeCastFilter = this.typeCastObject(filterObj);
+            const typeCastPostFilter = this.typeCastObject(postFilterObj);
+            if (Object.keys(p1).some(k => ["$search", "$searchMeta", "$geoNear"].includes(k))) {
+                this.query.append(p1);
+                firstObj = true;
+            }
+            if (Object.keys(typeCastFilter).length !== 0) {
+                this.query.match(typeCastFilter);
+            }
+            if (this.options.enablePresort && Object.keys($preSort).length) {
+                this.query.sort($preSort);
+            }
+            if (!firstObj) {
+                this.query.append(p1);
+            }
+            pipes.forEach(item => { var _a; return (_a = this.query) === null || _a === void 0 ? void 0 : _a.append(item); });
+            if ($select) {
+                this.query.project($select);
+            }
+            if (removeProtected) {
+                this.removeProtectedFields();
+            }
+            if ($count.length) {
+                this.createCounts();
+            }
+            if (Object.keys($postFilter).length !== 0) {
+                this.query.match(typeCastPostFilter);
+            }
+            if (Object.keys($sort).length) {
+                this.query.sort($sort);
+            }
+            this.query.option(Object.assign({ allowDiskUse: true }, options));
+        });
+        this.typeCastObject = (strOrObj) => {
+            if (strOrObj instanceof mongoose_1.Types.ObjectId) {
+                return strOrObj;
+            }
+            if (typeof strOrObj === "number" || !isNaN(strOrObj)) {
+                return strOrObj;
+            }
+            if (typeof strOrObj === "string" || strOrObj instanceof String) {
+                const idObjectId = (0, mongoose_1.isObjectIdOrHexString)(strOrObj);
+                if (idObjectId) {
+                    return new mongoose_1.Types.ObjectId(strOrObj);
+                }
+                if (this.isValidDateString(strOrObj)) {
+                    return new Date(strOrObj);
+                }
+                return strOrObj;
+            }
+            if (Array.isArray(strOrObj)) {
+                return strOrObj.map((item) => this.typeCastObject(item));
+            }
+            const keys = Object.keys(strOrObj);
+            const o = {};
+            keys.forEach((k) => {
+                o[k] = this.typeCastObject(strOrObj[k]);
+            });
+            return o;
+        };
+        this.removeProtectedFields = () => {
+            const projections = this.protectedPaths.reduce((acc, curr) => {
+                acc[curr] = 0;
+                return acc;
+            }, {});
+            if (Object.keys(projections).length > 0) {
+                this.query.project(projections);
+            }
+        };
+        this.exec = () => __awaiter(this, void 0, void 0, function* () {
+            const { $skip, $limit, $paging, $filter } = this.params;
+            const { staticFilter } = this.options;
+            if (!this.query) {
+                throw new Error("No Query Present in AggregationQuery");
+            }
+            if (!$paging) {
+                this.query.skip($skip);
+                this.query.limit($limit);
+                return yield this.query.exec();
+            }
+            const query = this.query;
+            query.facet({
+                items: [{ $skip: $skip }, { $limit: $limit }],
+                paging: [
+                    { $count: "totalRows" },
+                    {
+                        $addFields: { limit: $limit, skip: $skip }
+                    }
+                ]
+            });
+            query.unwind({ path: "$paging", preserveNullAndEmptyArrays: true });
+            query.project({
+                items: 1,
+                totalRows: { $ifNull: ["$paging.totalRows", 0] },
+                limit: { $ifNull: ["$paging.limit", $limit] },
+                skip: { $ifNull: ["$paging.skip", $skip] },
+                rows: { $size: "$items" }
+            });
+            const req = yield this.query.exec();
+            return req[0];
+        });
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        this.model = model;
+        this.params = this.parseParams(this.params, req.query, true);
+        this.protectedPaths = this.findProtectedPaths(model);
+        this.initQuery();
+    }
+}
+exports.AggregationPagingQuery = AggregationPagingQuery;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { PagingQuery } from './pagingQuery';
+export { AggregationPagingQuery } from './aggregationPagingQuery';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAA;AACzC,OAAO,EAAC,sBAAsB,EAAC,MAAM,0BAA0B,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationPagingQuery = exports.PagingQuery = void 0;
+var pagingQuery_1 = require("./pagingQuery");
+Object.defineProperty(exports, "PagingQuery", { enumerable: true, get: function () { return pagingQuery_1.PagingQuery; } });
+var aggregationPagingQuery_1 = require("./aggregationPagingQuery");
+Object.defineProperty(exports, "AggregationPagingQuery", { enumerable: true, get: function () { return aggregationPagingQuery_1.AggregationPagingQuery; } });

package/dist/pagingQuery.d.ts

@@ -0,0 +1,16 @@
+import type { PagingQueryParsedRequestParams, PagingQueryOptions } from './index.d';
+import { Model, QueryWithHelpers } from "mongoose";
+import type { Request } from 'express';
+export declare class PagingQuery {
+    params: PagingQueryParsedRequestParams;
+    options: PagingQueryOptions;
+    query: QueryWithHelpers<any, any> | null;
+    model: Model<any>;
+    constructor(req: Request, model: Model<any>, options?: Partial<PagingQueryOptions>);
+    private isJsonString;
+    private initQuery;
+    parseSortString: (sortString: string) => [string, import("mongoose").SortOrder][];
+    parseParams: (defaultParams: PagingQueryParsedRequestParams | import("./index.d").AggregateQueryParsedRequestParams, params: import("qs").ParsedQs, isAggregate?: boolean) => PagingQueryParsedRequestParams | import("./index.d").AggregateQueryParsedRequestParams;
+    exec: () => Promise<any>;
+}
+//# sourceMappingURL=pagingQuery.d.ts.map

package/dist/pagingQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagingQuery.d.ts","sourceRoot":"","sources":["../src/pagingQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,8BAA8B,EAAE,kBAAkB,EAAC,MAAM,WAAW,CAAA;AACjF,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAC,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,SAAS,CAAA;AAQpC,qBAAa,WAAW;IACpB,MAAM,EAAE,8BAA8B,CAUrC;IACD,OAAO,EAAE,kBAAkB,CAAK;IAChC,KAAK,EAAE,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAAO;IAC/C,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;gBAEL,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,GAAE,OAAO,CAAC,kBAAkB,CAAM;IAMtF,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,SAAS,CAqChB;IACD,eAAe,mEAAkB;IACjC,WAAW,0PAAc;IACzB,IAAI,qBAuBH;CACJ"}

package/dist/pagingQuery.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PagingQuery = void 0;
+const parseSortString_1 = require("./utils/parseSortString");
+const parsePopulateQuery_1 = require("./utils/parsePopulateQuery");
+const parseParams_1 = require("./utils/parseParams");
+const isJsonString_1 = require("./utils/isJsonString");
+class PagingQuery {
+    constructor(req, model, options = {}) {
+        this.params = {
+            $filter: {},
+            $limit: 25,
+            $skip: 0,
+            $sort: [],
+            $paging: true,
+            $populate: [],
+            $includes: [], // to be removed
+            $select: "",
+            $lean: false
+        };
+        this.options = {};
+        this.query = null;
+        this.isJsonString = isJsonString_1.isJsonString;
+        this.initQuery = () => {
+            const { $filter, $sort, $select, $skip, $limit, $populate, $lean } = this.params;
+            const _a = this.options, { single, staticFilter, disablePaging, enableFilter } = _a, options = __rest(_a, ["single", "staticFilter", "disablePaging", "enableFilter"]);
+            const filter = enableFilter ? Object.assign({}, staticFilter) : Object.assign(Object.assign({}, $filter), staticFilter);
+            this.query = single ? this.model.findOne(filter) : this.model.find(filter);
+            this.query.setOptions(options);
+            if (disablePaging) {
+                this.params.$paging = false;
+            }
+            if ($sort && $sort.length > 0) {
+                this.query.sort($sort);
+            }
+            if ($populate) {
+                const selectArr = $select && $select.split(",").map((v) => v.trim()) || [];
+                const popArr = (0, parsePopulateQuery_1.parsePopulateArray)($populate, selectArr);
+                popArr.forEach(path => {
+                    this.query.populate(path);
+                });
+            }
+            if ($select) {
+                let selectStr = $select;
+                if (!this.isJsonString($select)) {
+                    selectStr = $select
+                        .split(",")
+                        .filter(item => !($populate || []).some(p => item.trim().startsWith("p")))
+                        .join(" ");
+                }
+                this.query.select(selectStr);
+            }
+            if ($lean) {
+                this.query.lean();
+            }
+            this.query.skip($skip).limit($limit);
+        };
+        this.parseSortString = parseSortString_1.parseSortString;
+        this.parseParams = parseParams_1.parseParams;
+        this.exec = () => __awaiter(this, void 0, void 0, function* () {
+            const { $skip, $limit, $paging, $filter } = this.params;
+            const { staticFilter } = this.options;
+            if (!$paging) {
+                return yield this.query.exec();
+            }
+            const resObj = {
+                totalRows: 0,
+                rows: 0,
+                limit: $limit,
+                skip: $skip,
+                items: []
+            };
+            resObj.items = yield this.query.exec();
+            resObj.totalRows = yield this.model.countDocuments(Object.assign(Object.assign({}, $filter), staticFilter));
+            resObj.rows = resObj.items.length;
+            return resObj;
+        });
+        this.options = options;
+        this.model = model;
+        this.params = this.parseParams(this.params, req.query);
+        this.initQuery();
+    }
+}
+exports.PagingQuery = PagingQuery;

package/dist/tests/dotNotation.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dotNotation.spec.d.ts.map

package/dist/tests/dotNotation.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotNotation.spec.d.ts","sourceRoot":"","sources":["../../src/tests/dotNotation.spec.ts"],"names":[],"mappings":""}