@geekbears/gb-mongoose-query-parser 1.2.1

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "bracketSpacing": true,
+  "singleQuote": true,
+  "printWidth": 120,
+  "trailingComma": "all",
+  "tabWidth": 4,
+  "semi": true,
+  "arrowParens": "avoid"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Leodinas Hao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,420 @@
+# gb-mongoose-query-parser
+
+## Moved to: [@geekbears/gb-mongoose-quey-parser](https://www.npmjs.com/package/@geekbears/gb-mongoose-query-parser)
+
+#### This is a fork from: [mongoose-quey-parser](https://github.com/leodinas-hao/mongoose-query-parser)
+
+Convert url query string to MongooseJs friendly query object including advanced filtering, sorting, lean, population, string template, type casting and many more...
+
+The library is built highly inspired by [api-query-params](https://github.com/loris/api-query-params)
+
+## Features
+
+- Supports the most of MongoDB operators (`$in`, `$regexp`, `$exists`) and features including skip, sort, limit, lean & MongooseJS population
+- Auto type casting of `Number`, `RegExp`, `Date`, `Boolean` and `null`
+- String templates/predefined queries (i.e. `firstName=${my_vip_list}`)
+- Allows customization of keys and options in query string
+
+## Installation
+```
+npm install gb-mongoose-query-parser -S
+```
+
+## Basic Usage
+
+This package exposes a helper class: `QueryParser`
+
+### Get documents based on query string
+
+Import the helper and make sure to have the model available. Call the `docByQuery` method, specifying the generic type to avoid type inference.
+The result will be available in the `data` property of the response.
+
+```typescript
+import { QueryParser } from '@geekbears/gb-mongoose-query-parser';
+
+const res = await QueryParser.docByQuery<UserDocument>(userModel, query);
+const data = res.data as UserDocument[];
+```
+
+### Count documents based on query string
+
+Import the helper and make sure to have the model available. Call the `docByQuery` method, specifying the generic type to avoid type inference. **Set the `count` flag to true**
+The result will be available in the `data` property of the response.
+
+```typescript
+import { QueryParser } from '@geekbears/gb-mongoose-query-parser';
+
+const res = await QueryParser.docByQuery<UserDocument>(userModel, query, true);
+const data = res.data as number;
+```
+
+### Promise rejection
+
+The `docByQuery` method returns a Promise. In the event of a runtime error, the promise will be rejected.
+
+## Advanced Usage
+
+### API
+```
+import { MongooseQueryParser } from '@geekbears/gb-mongoose-query-parser';
+
+const parser = new MongooseQueryParser(options?: ParserOptions)
+parser.parse(query: string, predefined: any) : QueryOptions
+```
+
+##### Arguments
+- `ParserOptions`: object for advanced options (See below) [optional]
+- `query`: query string part of the requested API URL (ie, `firstName=John&limit=10`). Works with already parsed object too (ie, `{status: 'success'}`) [required]
+- `predefined`: object for predefined queries/string templates [optional]
+
+#### Returns
+- `QueryOptions`: object contains the following properties:
+    - `filter` which contains the query criteria
+    - `populate` which contains the query population. Please see [Mongoose Populate](http://mongoosejs.com/docs/populate.html) for more details
+    - `deepPopulate` which contains the query population Oobject. Please see [Mongoose Deep Populate](https://mongoosejs.com/docs/populate.html#deep-populate) for more details
+    - `select` which contains the query projection
+    - `lean` which contains the definition of the query records format
+    - `sort`, `skip`, `limit`, which contains the cursor modifiers for paging purpose
+
+### Example
+```js
+import { MongooseQueryParser } from '@geekbears/gb-mongoose-query-parser';
+
+const parser = new MongooseQueryParser();
+const predefined = {
+  vip: { name: { $in: ['Google', 'Microsoft', 'NodeJs'] } },
+  sentStatus: 'sent'
+};
+const parsed = parser.parse('${vip}&status=${sentStatus}&timestamp>2017-10-01&author.firstName=/john/i&limit=100&skip=50&sort=-timestamp&select=name&populate=children.firstName,children.lastName&lean=true', predefined);
+{
+  select: { name : 1 },
+  populate: [{ path: 'children', select: 'firstName lastName' }],
+  sort: { timestamp: -1 },
+  skip: 50,
+  limit: 100,
+  lean: true,
+  filter: {
+    name: {{ $in: ['Google', 'Microsoft', 'NodeJs'] }},
+    status: 'sent',
+    timestamp: { '$gt': 2017-09-30T14:00:00.000Z },
+    'author.firstName': /john/i
+  }
+}
+
+```
+
+## NestJS Swagger Decorator
+
+This package includes a `@nestjs/swagger` decorator to simplify the documentation of query parameters. The `@ApiStandardQuery()` decorator acts as an alias to `@ApiQuery()` and wraps all the standard query parameters used by Geekbears on `find` and `count` operations.
+
+### Usage
+
+Import the decorator and use it on the corresponding method on the controller class.
+
+```typescript
+import { ApiStandardQuery } from '@geekbears/gb-mongoose-query-parser';
+
+@Get()
+@ApiStandardQuery()
+async find(@Query() query: any): Promise<any> {
+    // Do something
+}
+
+```
+
+
+## Supported features
+
+#### Filtering operators
+
+| MongoDB   | URI                  | Example                 | Result                                                   |
+| --------- | -------------------- | ----------------------- | -------------------------------------------------------- |
+| `$eq`     | `key=val`            | `type=public`           | `{filter: {type: 'public'}}`                             |
+| `$gt`     | `key>val`            | `count>5`               | `{filter: {count: {$gt: 5}}}`                            |
+| `$gte`    | `key>=val`           | `rating>=9.5`           | `{filter: {rating: {$gte: 9.5}}}`                        |
+| `$lt`     | `key<val`            | `createdAt<2017-10-01`  | `{filter: {createdAt: {$lt: 2017-09-30T14:00:00.000Z}}}` |
+| `$lte`    | `key<=val`           | `score<=-5`             | `{filter: {score: {$lte: -5}}}`                          |
+| `$ne`     | `key!=val`           | `status!=success`       | `{filter: {status: {$ne: 'success'}}}`                   |
+| `$in`     | `key=val1,val2`      | `country=GB,US`         | `{filter: {country: {$in: ['GB', 'US']}}}`               |
+| `$nin`    | `key!=val1,val2`     | `lang!=fr,en`           | `{filter: {lang: {$nin: ['fr', 'en']}}}`                 |
+| `$exists` | `key`                | `phone`                 | `{filter: {phone: {$exists: true}}}`                     |
+| `$exists` | `!key`               | `!email`                | `{filter: {email: {$exists: false}}}`                    |
+| `$regex`  | `key=/value/<opts>`  | `email=/@gmail\.com$/i` | `{filter: {email: /@gmail.com$/i}}`                      |
+| `$regex`  | `key!=/value/<opts>` | `phone!=/^06/`          | `{filter: {phone: { $not: /^06/}}}`                      |
+
+For more advanced usage (`$or`, `$type`, `$elemMatch`, etc.), pass any MongoDB query filter object as JSON string in the `filter` query parameter, ie:
+
+```js
+parser.parse('filter={"$or":[{"key1":"value1"},{"key2":"value2"}]}&name=Telstra');
+// {
+//   filter: {
+//     $or: [
+//       { key1: 'value1' },
+//       { key2: 'value2' }
+//     ],
+//     name: 'Telstra'
+//   },
+// }
+```
+
+#### Populate operators
+
+- Useful to populate sub-document(s) in query. Works with `MongooseJS`. Please see [Mongoose Populate](http://mongoosejs.com/docs/populate.html) for more details
+- Allows to populate only selected fields
+- Clean, leaner and easier syntax
+- Default operator key is `populate`
+
+```js
+parser.parse('populate=class,school.name');
+// {
+//   populate: [{
+//     path: 'class'
+//   }, {
+//     path: 'school',
+//     select: 'name'
+//   }]
+// }
+```
+#### Deep Populate operators
+
+- For more advanced usage (Deep field population) Please see [Mongoose Deep Populate](https://mongoosejs.com/docs/populate.html#deep-populate) for more details
+- Allows to populate multiple paths with multiple fields
+- Default operator key is `deepPopulate`
+- Can be used along with the populate option
+
+```js
+parser.parse('deepPopulate={"path":"path",  "populate": { "path":"deepPath", "select":"deepField"  }}');
+
+// {
+//   populate: {
+//     path: 'path'
+//     populate:{
+//        path:"deepPath",
+//        select:"deepField"
+//     }
+//  }
+//
+```
+
+
+
+#### Skip / Limit operators
+
+- Useful to limit the number of records returned
+- Default operator keys are `skip` and `limit`
+
+```js
+parser.parse('skip=5&limit=10');
+// {
+//   skip: 5,
+//   limit: 10
+// }
+```
+
+#### Select operator
+
+- Useful to limit fields to return in each records
+- Default operator key is `select`
+- It accepts a comma-separated list of fields. Default behavior is to specify fields to return. Use `-` prefixes to return all fields except some specific fields
+- Due to a MongoDB limitation, you cannot combine inclusion and exclusion semantics in a single projection with the exception of the _id field
+
+```js
+parser.parse('select=id,url');
+// {
+//   select: { id: 1, url: 1}
+// }
+```
+
+```js
+parser.parse('select=-_id,-email');
+// {
+//   select: { _id: 0, email: 0 }
+// }
+```
+
+#### Sort operator
+
+- Useful to sort returned records
+- Default operator key is `sort`
+- It accepts a comma-separated list of fields. Default behavior is to sort in ascending order. Use `-` prefixes to sort in descending order
+
+```js
+parser.parse('sort=-points,createdAt');
+//  {
+//    sort: { points: -1, createdAt: 1 }
+//  }
+```
+#### Lean operator
+
+- Useful to get leaner records
+- Default operator key is `lean`
+- If lean is set true, it will return `true`, otherwise it will retun `false`. If not value provided, the lean operator wil be omitted from the parsed object.
+
+```js
+parser.parse('lean=true');
+//  {
+//    lean: true
+//  }
+```
+
+#### Keys with multiple values
+
+Any operators which process a list of fields (`$in`, `$nin`, sort and projection) can accept a comma-separated string or multiple pairs of key/value:
+
+- `country=GB,US` is equivalent to `country=GB&country=US`
+- `sort=-createdAt,lastName` is equivalent to `sort=-createdAt&sort=lastName`
+
+#### Embedded documents using `.` notation
+
+Any operators can be applied on deep properties using `.` notation:
+
+```js
+parser.parse('followers[0].id=123&sort=-metadata.created_at');
+// {
+//   filter: {
+//     'followers[0].id': 123,
+//   },
+//   sort: { 'metadata.created_at': -1 }
+// }
+```
+
+#### Automatic type casting
+
+The following types are automatically casted: `Number`, `RegExp`, `Date`, `Boolean` and `null` string is also casted:
+
+```js
+parser.parse('date=2017-10-01&boolean=true&integer=10&regexp=/foobar/i&null=null');
+// {
+//   filter: {
+//     date: 2017-09-30T14:00:00.000Z,
+//     boolean: true,
+//     integer: 10,
+//     regexp: /foobar/i,
+//     null: null
+//   }
+// }
+```
+
+If you need to disable or force type casting, you can wrap the values with `string()`, `date()` built-in casters or by specifying your own custom functions (See below):
+
+```js
+parser.parse('key1=string(10)&key2=date(2017-10-01)&key3=string(null)');
+// {
+//   filter: {
+//     key1: '10',
+//     key2: 2017-09-30T14:00:00.000Z,
+//     key3: 'null'
+//   }
+// }
+```
+
+## String template for predefined query/variable
+
+Best to reducing the complexity/length of the query string with the ES template literal delimiter as an "interpolate" delimiter (i.e. `${something}`)
+
+```js
+const parser = new MongooseQueryParser();
+const preDefined = {
+  isActive: { status: { $in: ['In Progress', 'Pending'] } },
+  secret: 'my_secret'
+};
+parser.parse('${isActive}&secret=${secret}', preDefined);
+// {
+//   filter: {
+//     status: { $in: ['In Progress', 'Pending'] },
+//     secret: 'my_secret'
+//   }
+// }
+```
+
+## Available options (`opts`)
+
+#### Customize operator keys
+
+The following options are useful to change the operator default keys:
+
+- `populateKey`: custom populate operator key (default is `populate`)
+- `skipKey`: custom skip operator key (default is `skip`)
+- `leanKey`: custom lean operator key (default is `lean`)
+- `limitKey`: custom limit operator key (default is `limit`)
+- `selectKey`: custom select operator key (default is `select`)
+- `sortKey`: custom sort operator key (default is `sort`)
+- `filterKey`: custom filter operator key (default is `filter`)
+- `deepPopulateKey`: custom filter operator key (default is `deepPopulate`)
+
+```js
+const parser = new MongooseQueryParser({
+  limitKey: 'max',
+  skipKey: 'offset',
+  leanKey: 'planeRecords'
+});
+parser.parse('organizationId=123&offset=10&max=125');
+// {
+//   filter: {
+//     organizationId: 123,
+//   },
+//   skip: 10,
+//   limit: 125,
+//   lean: true
+// }
+```
+
+#### Date format
+- `dateFormat`: set date format for auto date casting. Default is ISO_8601 format
+- Allows multiple formats. Works with [moment](https://momentjs.com/docs/#/parsing/string/)
+
+```js
+const parser = new MongooseQueryParser({dateFormat: ['YYYYMMDD', 'YYYY-MM-DD']});
+parser.parse('date1=20171001&date2=2017-10-01');
+// {
+//   filter: {
+//     date1: 2017-09-30T14:00:00.000Z
+//     date2: 2017-09-30T14:00:00.000Z
+//   }
+// }
+```
+
+#### Blacklist
+
+The following options are useful to specify which keys to use in the `filter` object. (ie, avoid that authentication parameter like `apiKey` ends up in a mongoDB query). All operator keys are (`sort`, `limit`, etc.) already ignored.
+
+- `blacklist`: filter on all keys except the ones specified
+
+```js
+parser.parse('id=e9117e5c-c405-489b-9c12-d9f398c7a112&apiKey=foobar', {
+  blacklist: ['apiKey']
+});
+// {
+//   filter: {
+//     id: 'e9117e5c-c405-489b-9c12-d9f398c7a112',
+//   }
+// }
+```
+
+#### Add custom casting functions
+
+You can specify you own casting functions to apply to query parameter values, either by explicitly wrapping the value in URL with your custom function name (See example below) or by implicitly mapping a key to a function
+
+- `casters`: object to specify custom casters, key is the caster name, and value is a function which is passed the query parameter value as parameter.
+
+```js
+const parser = new MongooseQueryParser({
+  casters: {
+    lowercase: val => val.toLowerCase(),
+    int: val => parseInt(val, 10),
+  },
+  castParams: {
+   key3: 'lowercase' 
+  }});
+parser.parse('key1=lowercase(VALUE)&key2=int(10.5)&key3=ABC');
+// {
+//   filter: {
+//     key1: 'value',
+//     key2: 10,
+//     key3: 'abc'
+//   }
+// }
+```
+
+## License
+MIT

package/lib/decorators/api-single-query.decorator.d.ts

@@ -0,0 +1 @@
+export declare const ApiSingleQuery: () => MethodDecorator;

package/lib/decorators/api-single-query.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSingleQuery = void 0;
+var common_1 = require("@nestjs/common");
+var swagger_1 = require("@nestjs/swagger");
+var ApiSingleQuery = function () {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiQuery)({
+        name: 'populate',
+        description: 'A comma-separated list of virtual fields to populate',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'deepPopulate',
+        description: 'A stringified populate JSON object',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'select',
+        description: 'A comma-separated list of fields to select',
+        schema: { type: 'string' },
+        required: false,
+    }));
+};
+exports.ApiSingleQuery = ApiSingleQuery;
+//# sourceMappingURL=api-single-query.decorator.js.map

package/lib/decorators/api-standard-query.decorator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Add geekbears standard query parameters
+ * @description Swagger decorator. Adds all standard query parameters
+ * @returns A method decorator wrapping calls to `@ApiQuery()` decorator
+ */
+export declare const ApiStandardQuery: () => MethodDecorator;

package/lib/decorators/api-standard-query.decorator.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiStandardQuery = void 0;
+var common_1 = require("@nestjs/common");
+var swagger_1 = require("@nestjs/swagger");
+/**
+ * Add geekbears standard query parameters
+ * @description Swagger decorator. Adds all standard query parameters
+ * @returns A method decorator wrapping calls to `@ApiQuery()` decorator
+ */
+var ApiStandardQuery = function () {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiQuery)({
+        name: 'filter',
+        description: 'A stringified filter JSON object',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'populate',
+        description: 'A comma-separated list of virtual fields to populate',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'deepPopulate',
+        description: 'A stringified populate JSON object',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'sort',
+        description: 'The sorting configuration to apply to returned elements',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'limit',
+        description: 'The max amount of records to return',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'select',
+        description: 'A comma-separated list of fields to select',
+        schema: { type: 'string' },
+        required: false,
+    }), (0, swagger_1.ApiQuery)({
+        name: 'skip',
+        description: 'The amount of records to skip before returning',
+        schema: { type: 'string' },
+        required: false,
+    }));
+};
+exports.ApiStandardQuery = ApiStandardQuery;
+//# sourceMappingURL=api-standard-query.decorator.js.map

package/lib/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './api-standard-query.decorator';
+export * from './api-single-query.decorator';

package/lib/decorators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-standard-query.decorator"), exports);
+__exportStar(require("./api-single-query.decorator"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './query-parser';
+export * from './query-parser-helper';
+export * from './decorators';
+export * from './types';

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./query-parser"), exports);
+__exportStar(require("./query-parser-helper"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/lib/query-parser-helper.d.ts

@@ -0,0 +1,70 @@
+import { Model, Query, Types, Document, FilterQuery, Cursor, QueryOptions } from 'mongoose';
+import { ParsedQs } from 'qs';
+export interface IDocByQueryRes<T = Document> {
+    data: T[] | T | number;
+}
+export interface IDocByQueryCursorRes<T = any> {
+    data: Cursor<T, QueryOptions<any>>;
+}
+/**
+ * Helper class
+ * Implements the `MongooseQueryParser` and exposes a single method to execute queries on models
+ */
+export declare class QueryParser {
+    /**
+     * Build a Mongoose query on a given model from the parsed query string
+     * @param model a mongoose `Model` object to perform the query on
+     * @param query a query string object received by the controller
+     * @param count an optional flag that indicates wether a `count` operation should be performed
+     * @returns a Mongoose query on the provided model
+     */
+    static parseQuery<T = any>(model: Model<T>, query: ParsedQs, count?: boolean): Query<any, T>;
+    /**
+     * Get all documents matching the provided query for a given model
+     * @param model a mongoose `Model` object to perform the query on
+     * @param query a query string object received by the controller
+     * @param count an optional flag that indicates wether a `count` operation should be performed
+     * @returns the result of executing the provided query on the provided model
+     */
+    static docByQuery<T = any>(model: Model<T>, query: ParsedQs, count?: boolean): Promise<IDocByQueryRes<T>>;
+    /**
+     * Get all documents matching the provided query for a given model to a  mongodb cursor resource
+     * @param model a mongoose `Model` object to perform the query on
+     * @param query a query string object received by the controller
+     * @param count an optional flag that indicates wether a `count` operation should be performed
+     * @returns the cursor of executing the provided query on the provided model
+     */
+    static docByQueryToCursor<T = any>(model: Model<T>, query: ParsedQs): IDocByQueryCursorRes;
+    /**
+     * Build a Mongoose `findOne` query on a given model with additional params
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param filter a Mongoose filter query on the provided model
+     * @param query a query string object received by the controller
+     * @returns a Mongoose query on the provided model
+     */
+    static parseFilterQuery<T = any>(model: Model<T>, filter: FilterQuery<T>, query: ParsedQs): Query<any, T>;
+    /**
+     * Get a document matching the provided query for a given model
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param filter a Mongoose filter query on the provided model
+     * @param query a query string object received by the controller
+     * @returns the result of executing the provided query on the provided model
+     */
+    static docByFilter<T = any>(model: Model<T>, filter: FilterQuery<T>, query: ParsedQs): Promise<IDocByQueryRes<T>>;
+    /**
+     * Build a Mongoose `findOneById` query on a given model with additional params
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param _id the resource id
+     * @param query a query string object received by the controller
+     * @returns a Mongoose query on the provided model
+     */
+    static parseByIdQuery<T = any>(model: Model<T>, _id: string | Types.ObjectId, query: ParsedQs): Query<any, T>;
+    /**
+     * Get a document matching the provided query for a given model
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param _id the resource id
+     * @param query a query string object received by the controller
+     * @returns the result of executing the provided query on the provided model
+     */
+    static docById<T = any>(model: Model<T>, _id: string, query: ParsedQs): Promise<IDocByQueryRes<T>>;
+}