@r5v/mongoose-paginate 1.0.13 → 1.0.15

package/README.md

@@ -82,7 +82,49 @@ PagingQuery(Express.Request, mongoose.Model, options )
 | $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              |   
+| $postFilter | Any Json Object                                                                   | creates and additional filter and in aggregation queries is appended to the end of the pipeline                                                                                                                | AggregationPagingQuery              |
+
+#### Example URLs
+
+```bash
+# Basic pagination
+GET /api/books?$limit=10&$skip=20
+
+# Filter by field (JSON format)
+GET /api/books?$filter={"genre":"Horror"}
+
+# Filter with operators
+GET /api/books?$filter={"price.amount":{"$gte":20,"$lte":50}}
+
+# Sort (space-separated: field direction)
+GET /api/books?$sort=price.amount%20desc
+GET /api/books?$sort=title%20asc,createdAt%20desc
+
+# Select specific fields
+GET /api/books?$select=title,isbn,price
+
+# Populate references
+GET /api/books?$populate=author,publisher
+
+# Deep populate with field selection
+GET /api/books?$populate=author[firstName,lastName],publisher[name]
+
+# Aggregation with preSort (sorts before pipeline)
+GET /api/books?$preSort=createdAt%20desc
+
+# Aggregation with postFilter (filters on computed fields)
+GET /api/books?$postFilter={"priceCategory":"expensive"}
+
+# Count array fields
+GET /api/books?$count=authors,tags
+# Result includes: authors_count, tags_count
+
+# Disable paging (returns array instead of paged object)
+GET /api/books?$paging=false
+
+# Lean query (returns plain objects)
+GET /api/books?$lean=true
+```
 
 #### Options
 
@@ -97,12 +139,143 @@ PagingQuery(Express.Request, mongoose.Model, options )
 | 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 \(REMOVED\) | boolean              | auto remove protected (select: false) for root Model                                                                                                                     | AggregationPagingQuery              |          | false   |
+| removeProtected             | boolean              | **EXPERIMENTAL** - auto remove protected fields (those with `select: false` in schema) from aggregation results. Use with caution and test thoroughly in your environment | AggregationPagingQuery              |          | false   |
 
 ## Utilities
-|Name| Description                                                                                      |
-|:---|:-------------------------------------------------------------------------------------------------|
-|buildPopulate| creates a populate object from dot notation string "author\[name\].books,user.publisher\[name\]" |
+
+All utilities can be imported directly from the main package or from the `/utils` subpath:
+
+```typescript
+// Direct import
+import { buildPopulate, parseSortString, getPropertyFromDotNotation } from '@r5v/mongoose-paginate'
+
+// Subpath import (all utilities)
+import * as utils from '@r5v/mongoose-paginate/utils'
+```
+
+### Populate Utilities
+
+| Name | Signature | Description |
+|:-----|:----------|:------------|
+| `buildPopulate` | `(pathString: string) => PopulateItem[]` | Creates a Mongoose populate object from dot notation string. Supports deep population with field selection using bracket notation: `"author[name].books[title],publisher[name]"` |
+
+```typescript
+import { buildPopulate } from '@r5v/mongoose-paginate'
+
+const populate = buildPopulate('author[name,email].books[title],publisher')
+// Result: [
+//   { path: 'author', select: 'name email', populate: [{ path: 'books', select: 'title' }] },
+//   { path: 'publisher' }
+// ]
+```
+
+### Sort Utilities
+
+| Name | Signature | Description |
+|:-----|:----------|:------------|
+| `parseSortString` | `(sortString: string) => [string, SortOrder][]` | Parses a sort string into Mongoose sort array format. Example: `"name -createdAt"` → `[["name", 1], ["createdAt", -1]]` |
+| `parseAggregateSortString` | `(sortString: string) => {[key: string]: SortOrder}` | Parses a sort string into aggregation pipeline sort object. Example: `"name -createdAt"` → `{ name: 1, createdAt: -1 }` |
+
+```typescript
+import { parseSortString, parseAggregateSortString } from '@r5v/mongoose-paginate'
+
+const sortArray = parseSortString('name 1, createdAt -1')
+// Result: [["name", 1], ["createdAt", -1]]
+
+const sortObj = parseAggregateSortString('name 1, createdAt -1')
+// Result: { name: 1, createdAt: -1 }
+```
+
+### Dot Notation Utilities
+
+| Name | Signature | Description |
+|:-----|:----------|:------------|
+| `getPropertyFromDotNotation` | `(obj: any, path: string) => any` | Gets a nested property value using dot notation path |
+| `dotNotationToObject` | `(dotString: string, value?: unknown) => object` | Converts a dot notation string to a nested object |
+| `createObjectFromDotNotation` | `(dotNotationMap: {[key: string]: any}) => object` | Creates a nested object from multiple dot notation key-value pairs |
+| `setPropertyFromDotNotation` | `(obj: Record<string, unknown>, path: string, value: unknown) => object` | Sets a nested property value (mutates original object) |
+| `setPropertiesFromDotNotation` | `(obj: Record<string, unknown>, dotNotationMap: Record<string, unknown>) => object` | Sets multiple nested properties (mutates original object) |
+| `setPropertyFromDotNotationImmutable` | `(obj: Record<string, unknown>, path: string, value: unknown) => object` | Sets a nested property value (returns new object) |
+| `setPropertiesFromDotNotationImmutable` | `(obj: Record<string, unknown>, dotNotationMap: Record<string, unknown>) => object` | Sets multiple nested properties (returns new object) |
+
+```typescript
+import {
+  getPropertyFromDotNotation,
+  dotNotationToObject,
+  setPropertyFromDotNotation
+} from '@r5v/mongoose-paginate'
+
+// Get nested value
+const user = { profile: { name: 'John', address: { city: 'NYC' } } }
+getPropertyFromDotNotation(user, 'profile.address.city') // 'NYC'
+
+// Create nested object from dot notation
+dotNotationToObject('user.profile.name', 'John')
+// Result: { user: { profile: { name: 'John' } } }
+
+// Set nested property
+const obj = { user: { name: 'John' } }
+setPropertyFromDotNotation(obj, 'user.email', 'john@example.com')
+// Result: { user: { name: 'John', email: 'john@example.com' } }
+```
+
+### Validation Utilities
+
+| Name | Signature | Description |
+|:-----|:----------|:------------|
+| `isJsonString` | `(str: string) => boolean` | Checks if a string is valid JSON |
+| `isValidDateString` | `(value: string) => boolean` | Checks if a string is a valid ISO 8601 date format |
+
+```typescript
+import { isJsonString, isValidDateString } from '@r5v/mongoose-paginate'
+
+isJsonString('{"name": "John"}')  // true
+isJsonString('invalid')           // false
+
+isValidDateString('2024-01-15')                    // true
+isValidDateString('2024-01-15T10:30:00.000Z')     // true
+isValidDateString('invalid-date')                  // false
+```
+
+### Schema Traversal Utilities
+
+| Name | Signature | Description |
+|:-----|:----------|:------------|
+| `buildFullPath` | `(parentPath: string, childPath: string) => string` | Builds a dot-notation path from parent and child segments |
+| `traverseSchemaObject` | `(obj: any, callback: (obj, path) => void, currentPath?: string) => void` | Recursively traverses a Mongoose schema object, calling callback for each node |
+
+```typescript
+import { buildFullPath, traverseSchemaObject } from '@r5v/mongoose-paginate'
+
+// Build dot-notation paths
+buildFullPath('user', 'profile')      // 'user.profile'
+buildFullPath('', 'name')             // 'name'
+buildFullPath('parent', '')           // 'parent'
+
+// Traverse schema objects
+traverseSchemaObject(schemaType, (obj, currentPath) => {
+  if (obj.options?.ref) {
+    console.log(`Found ref at ${currentPath}: ${obj.options.ref}`)
+  }
+})
+```
+
+## Types
+
+All TypeScript types are exported and can be imported:
+
+```typescript
+import type {
+  PagingQueryOptions,
+  AggregateQueryOptions,
+  QueryParameters,
+  PagingQueryParsedRequestParams,
+  AggregateQueryParsedRequestParams
+} from '@r5v/mongoose-paginate'
+
+// Or from the types subpath
+import type * from '@r5v/mongoose-paginate/types'
+```
 
 ## Build
 
@@ -123,18 +296,38 @@ $ 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
-
-
-## NOTES
-1. removeProtected removed from aggregation query due to inconsistent results after publication
+1. First pipeline stage (if `$search`, `$searchMeta`, or `$geoNear`)
+2. `$match` combining: `staticFilter` + `$filter` (if `enableFilter`) + first pipeline `$match` stage
+3. `$preSort` (if `enablePreSort` is true)
+4. Remaining pipeline stages
+5. `$select` / `$project`
+6. `$count` (adds `_count` fields for array sizes)
+7. `$postFilter` combining: `staticPostFilter` + `$postFilter` (if `enablePostFilter`)
+8. `$sort` (final sorting, can sort on computed fields)
+9. Apply pagination (`$skip`, `$limit`) and options
+
+
+### 1.0.15
+  - **Re-enabled `removeProtected` option** for `AggregationPagingQuery` (EXPERIMENTAL) - Automatically excludes fields marked with `select: false` in your schema (e.g., passwords, secret keys) from aggregation results. Use with caution and test thoroughly in your environment.
+  - Uses refactored `findProtectedPaths` utility which safely traverses schemas without JSON serialization
+
+### 1.0.14
+  - Added proper TypeScript package exports with subpaths (`/utils`, `/types`)
+  - Exported all utility functions (dot notation, sort parsing, validation)
+  - Exported all TypeScript types
+  - **Fixed Express Request type compatibility** - Added `RequestLike` interface to allow custom request types without index signature issues
+  - Fixed JSON.parse crash on malformed `$filter`/`$postFilter` parameters
+  - Fixed regex global flag bug in populate parsing
+  - Added input validation to constructors
+  - Improved type safety (reduced `any` usage)
+  - Removed deprecated `$includes` parameter
+  - Replaced `JSON.parse(JSON.stringify())` with `structuredClone()`
+  - Fixed inconsistent equality operator (`==` to `===`)
+  - **Fixed empty pipeline crash** - `AggregationPagingQuery.initQuery` no longer crashes when pipeline is empty
+  - **Refactored `buildPopulate`** - Extracted inner functions to module level for better testability
+  - **Refactored `findProtectedPaths`** - Removed JSON.stringify that could fail on circular references
+  - **Refactored `getPathsWithRef`** - Simplified input handling, removed brittle string parsing
+  - **Added `schemaTraversal` utility** - Shared `buildFullPath` and `traverseSchemaObject` functions for schema traversal
 
 ### 1.0.13
   - Fix issue where disablePaging was not working on aggregation query

package/dist/{types/aggregationPagingQuery.d.ts → aggregationPagingQuery.d.ts}

@@ -1,25 +1,24 @@
 import { Model, Aggregate } from "mongoose";
-import type { Request } from "express";
-import type { AggregateQueryOptions, QueryParameters, AggregateQueryParsedRequestParams } from './types';
+import type { AggregateQueryOptions, AggregateQueryParsedRequestParams, RequestLike } from './types';
 export declare class AggregationPagingQuery {
     params: AggregateQueryParsedRequestParams;
     options: AggregateQueryOptions;
-    query: Aggregate<Array<any>> | undefined;
+    query: Aggregate<unknown[]> | undefined;
     protectedPaths: string[];
     model: Model<any>;
-    constructor(req: Request<{}, any, any, Partial<QueryParameters>>, model: Model<any>, options: AggregateQueryOptions);
+    constructor(req: RequestLike, model: Model<any>, options: AggregateQueryOptions);
     findProtectedPaths: (model: Model<any>) => string[];
     parseParams: (defaultParams: import("./types").PagingQueryParsedRequestParams | AggregateQueryParsedRequestParams, params: import("qs").ParsedQs, isAggregate?: boolean) => import("./types").PagingQueryParsedRequestParams | AggregateQueryParsedRequestParams;
     isValidDateString: (value: string) => boolean;
     isJsonString: (str: string) => boolean;
     parseSortString: (sortString: string) => [string, import("mongoose").SortOrder][];
-    parseAggregateSortString: (sortString: any) => {
+    parseAggregateSortString: (sortString: string) => {
         [key: string]: import("mongoose").SortOrder;
     };
     createCounts: () => void;
     initQuery: () => Promise<void>;
-    typeCastObject: (strOrObj: any) => any;
+    typeCastObject: <T>(strOrObj: T) => T;
     private removeProtectedFields;
-    exec: () => Promise<any>;
+    exec: () => Promise<unknown>;
 }
 //# 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,qBAAqB,EAAE,iCAAiC,EAAE,WAAW,EAAC,MAAM,SAAS,CAAA;AAQlG,qBAAa,sBAAsB;IAC/B,MAAM,EAAG,iCAAiC,CAYzC;IACD,OAAO,EAAE,qBAAqB,CAM7B;IACD,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAA;IACvC,cAAc,EAAE,MAAM,EAAE,CAAK;IAC7B,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;gBACL,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,qBAAqB;IAoB/E,kBAAkB,kCAAqB;IACvC,WAAW,sPAAc;IACzB,iBAAiB,6BAAoB;IACrC,YAAY,2BAAe;IAC3B,eAAe,mEAAkB;IACjC,wBAAwB;;MAA2B;IACnD,YAAY,aAOX;IACD,SAAS,sBAsDR;IACD,cAAc,GAAI,CAAC,EAAE,UAAU,CAAC,KAAG,CAAC,CAmCnC;IAED,OAAO,CAAC,qBAAqB,CAS5B;IACD,IAAI,yBAgCH;CAEJ"}

package/dist/aggregationPagingQuery.js

@@ -36,7 +36,6 @@ class AggregationPagingQuery {
             $sort: {},
             $paging: true,
             $populate: [],
-            $includes: [], // to be removed
             $select: "",
             $count: [],
             $postFilter: {},
@@ -46,6 +45,7 @@ class AggregationPagingQuery {
             enableFilter: false,
             enablePostFilter: false,
             enablePreSort: true,
+            removeProtected: false,
             pipeline: []
         };
         this.protectedPaths = [];
@@ -66,7 +66,7 @@ class AggregationPagingQuery {
         };
         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, pipeline } = _a, options = __rest(_a, ["enableFilter", "enablePreSort", "enablePostFilter", "staticFilter", "staticPostFilter", "pipeline"]);
+            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)] };
@@ -84,7 +84,7 @@ class AggregationPagingQuery {
             }
             const typeCastFilter = this.typeCastObject(filterObj);
             const typeCastPostFilter = this.typeCastObject(postFilterObj);
-            if (Object.keys(p1).some(k => ["$search", "$searchMeta", "$geoNear"].includes(k))) {
+            if (p1 && Object.keys(p1).some(k => ["$search", "$searchMeta", "$geoNear"].includes(k))) {
                 this.query.append(p1);
                 firstObj = true;
             }
@@ -94,13 +94,16 @@ class AggregationPagingQuery {
             if (this.options.enablePreSort && Object.keys($preSort).length) {
                 this.query.sort($preSort);
             }
-            if (!firstObj) {
+            if (!firstObj && p1) {
                 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();
             }
@@ -180,9 +183,21 @@ class AggregationPagingQuery {
             const req = yield this.query.exec();
             return req[0];
         });
+        if (!req || typeof req.query !== 'object') {
+            throw new Error('Invalid request object: must have a query property');
+        }
+        if (!model || typeof model.aggregate !== 'function') {
+            throw new Error('Invalid model: must be a Mongoose model');
+        }
+        if (!options || !Array.isArray(options.pipeline)) {
+            throw new Error('Invalid options: pipeline must be an array');
+        }
         this.options = Object.assign(Object.assign({}, this.options), options);
         this.model = model;
         this.params = this.parseParams(this.params, req.query, true);
+        if (this.options.removeProtected) {
+            this.protectedPaths = this.findProtectedPaths(model);
+        }
         this.initQuery();
     }
 }

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { PagingQuery } from './pagingQuery';
+export { AggregationPagingQuery } from './aggregationPagingQuery';
+export type { RequestLike, QueryParameters, StandardParsedRequestParams, PagingQueryParsedRequestParams, AggregateQueryParsedRequestParams, StandardQueryOptions, PagingQueryOptions, AggregateQueryOptions } from './types';
+export { buildPopulate } from './utils/buildPopulateFromString';
+export { parseSortString, parseAggregateSortString } from './utils/parseSortString';
+export { getPropertyFromDotNotation, dotNotationToObject, createObjectFromDotNotation, setPropertyFromDotNotation, setPropertiesFromDotNotation, setPropertyFromDotNotationImmutable, setPropertiesFromDotNotationImmutable } from './utils/dotNotation';
+export { isJsonString } from './utils/isJsonString';
+export { isValidDateString } from './utils/isValidDateString';
+//# 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":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AAGjE,YAAY,EACR,WAAW,EACX,eAAe,EACf,2BAA2B,EAC3B,8BAA8B,EAC9B,iCAAiC,EACjC,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACxB,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AACnF,OAAO,EACH,0BAA0B,EAC1B,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,EAC1B,4BAA4B,EAC5B,mCAAmC,EACnC,qCAAqC,EACxC,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/index.js

@@ -1,9 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildPopulate = exports.AggregationPagingQuery = exports.PagingQuery = void 0;
+exports.isValidDateString = exports.isJsonString = exports.setPropertiesFromDotNotationImmutable = exports.setPropertyFromDotNotationImmutable = exports.setPropertiesFromDotNotation = exports.setPropertyFromDotNotation = exports.createObjectFromDotNotation = exports.dotNotationToObject = exports.getPropertyFromDotNotation = exports.parseAggregateSortString = exports.parseSortString = exports.buildPopulate = exports.AggregationPagingQuery = exports.PagingQuery = void 0;
+// Main classes
 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; } });
+// Utilities - re-export for convenience
 var buildPopulateFromString_1 = require("./utils/buildPopulateFromString");
 Object.defineProperty(exports, "buildPopulate", { enumerable: true, get: function () { return buildPopulateFromString_1.buildPopulate; } });
+var parseSortString_1 = require("./utils/parseSortString");
+Object.defineProperty(exports, "parseSortString", { enumerable: true, get: function () { return parseSortString_1.parseSortString; } });
+Object.defineProperty(exports, "parseAggregateSortString", { enumerable: true, get: function () { return parseSortString_1.parseAggregateSortString; } });
+var dotNotation_1 = require("./utils/dotNotation");
+Object.defineProperty(exports, "getPropertyFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.getPropertyFromDotNotation; } });
+Object.defineProperty(exports, "dotNotationToObject", { enumerable: true, get: function () { return dotNotation_1.dotNotationToObject; } });
+Object.defineProperty(exports, "createObjectFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.createObjectFromDotNotation; } });
+Object.defineProperty(exports, "setPropertyFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.setPropertyFromDotNotation; } });
+Object.defineProperty(exports, "setPropertiesFromDotNotation", { enumerable: true, get: function () { return dotNotation_1.setPropertiesFromDotNotation; } });
+Object.defineProperty(exports, "setPropertyFromDotNotationImmutable", { enumerable: true, get: function () { return dotNotation_1.setPropertyFromDotNotationImmutable; } });
+Object.defineProperty(exports, "setPropertiesFromDotNotationImmutable", { enumerable: true, get: function () { return dotNotation_1.setPropertiesFromDotNotationImmutable; } });
+var isJsonString_1 = require("./utils/isJsonString");
+Object.defineProperty(exports, "isJsonString", { enumerable: true, get: function () { return isJsonString_1.isJsonString; } });
+var isValidDateString_1 = require("./utils/isValidDateString");
+Object.defineProperty(exports, "isValidDateString", { enumerable: true, get: function () { return isValidDateString_1.isValidDateString; } });

package/dist/{types/pagingQuery.d.ts → pagingQuery.d.ts}

@@ -1,16 +1,15 @@
-import type { PagingQueryParsedRequestParams, PagingQueryOptions } from './types';
-import { Model, QueryWithHelpers } from "mongoose";
-import type { Request } from 'express';
+import type { PagingQueryParsedRequestParams, PagingQueryOptions, RequestLike } from './types';
+import { Model, QueryWithHelpers, SortOrder } from "mongoose";
 export declare class PagingQuery {
     params: PagingQueryParsedRequestParams;
     options: PagingQueryOptions;
-    query: QueryWithHelpers<any, any> | null;
+    query: QueryWithHelpers<unknown, unknown> | null;
     model: Model<any>;
-    constructor(req: Request, model: Model<any>, options?: Partial<PagingQueryOptions>);
+    constructor(req: RequestLike, model: Model<any>, options?: Partial<PagingQueryOptions>);
     private isJsonString;
     private initQuery;
-    parseSortString: (sortString: string) => [string, import("mongoose").SortOrder][];
+    parseSortString: (sortString: string) => [string, SortOrder][];
     parseParams: (defaultParams: PagingQueryParsedRequestParams | import("./types").AggregateQueryParsedRequestParams, params: import("qs").ParsedQs, isAggregate?: boolean) => PagingQueryParsedRequestParams | import("./types").AggregateQueryParsedRequestParams;
-    exec: () => Promise<any>;
+    exec: () => Promise<unknown>;
 }
 //# 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,EAAE,WAAW,EAAC,MAAM,SAAS,CAAA;AAC5F,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAC,MAAM,UAAU,CAAC;AAS7D,qBAAa,WAAW;IACpB,MAAM,EAAE,8BAA8B,CASrC;IACD,OAAO,EAAE,kBAAkB,CAAK;IAChC,KAAK,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI,CAAO;IACvD,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;gBAEL,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,GAAE,OAAO,CAAC,kBAAkB,CAAM;IAY1F,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,SAAS,CAqChB;IACD,eAAe,gDAAkB;IACjC,WAAW,sPAAc;IACzB,IAAI,yBAuBH;CACJ"}

package/dist/pagingQuery.js

@@ -34,7 +34,6 @@ class PagingQuery {
             $sort: [],
             $paging: true,
             $populate: [],
-            $includes: [], // to be removed
             $select: "",
             $lean: false
         };
@@ -45,7 +44,7 @@ class PagingQuery {
             const { $filter, $sort, $select, $skip, $limit, $populate, $lean } = this.params;
             const _a = this.options, { single, staticFilter, disablePaging, disableFilter } = _a, options = __rest(_a, ["single", "staticFilter", "disablePaging", "disableFilter"]);
             const filter = disableFilter ? Object.assign({}, staticFilter) : Object.assign(Object.assign({}, $filter), staticFilter);
-            this.query = single ? this.model.findOne(filter) : this.model.find(filter);
+            this.query = (single ? this.model.findOne(filter) : this.model.find(filter));
             this.query.setOptions(options);
             if (disablePaging || single) {
                 this.params.$paging = false;
@@ -89,11 +88,17 @@ class PagingQuery {
                 skip: $skip,
                 items: []
             };
-            resObj.items = yield this.query.exec();
+            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;
         });
+        if (!req || typeof req.query !== 'object') {
+            throw new Error('Invalid request object: must have a query property');
+        }
+        if (!model || typeof model.find !== 'function') {
+            throw new Error('Invalid model: must be a Mongoose model');
+        }
         this.options = options;
         this.model = model;
         this.params = this.parseParams(this.params, req.query);

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

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

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

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