@geekbears/gb-mongoose-query-parser 1.2.3 → 1.3.1

package/README.md

@@ -1,6 +1,5 @@
 # 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)
 
@@ -103,25 +102,6 @@ const parsed = parser.parse('${vip}&status=${sentStatus}&timestamp>2017-10-01&au
 
 ```
 
-## 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
 
@@ -404,7 +384,7 @@ const parser = new MongooseQueryParser({
     int: val => parseInt(val, 10),
   },
   castParams: {
-   key3: 'lowercase' 
+   key3: 'lowercase'
   }});
 parser.parse('key1=lowercase(VALUE)&key2=int(10.5)&key3=ABC');
 // {

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

@@ -21,20 +21,47 @@ export declare class QueryParser {
     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
+     * @deprecated The method should not be used, please use ```docsByQuery```
      * @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
+     * @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 docsByQuery<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
+     * @deprecated The method should not be used, please use ```docsByQueryToCursor```
      * @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;
+    /**
+     * 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 docsByQueryToCursor<T = any>(model: Model<T>, query: ParsedQs): IDocByQueryCursorRes;
+    /**
+     * Build a Mongoose `findOne` or `find` query on a given model with additional params
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param singleMode this defines if the query should be for many or just one item
+     * @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 parseFromCustomFilterToQuery<T = any>(model: Model<T>, singleMode: boolean, filter: FilterQuery<T>, query: ParsedQs): Query<any, T>;
     /**
      * Build a Mongoose `findOne` query on a given model with additional params
      * @param model a Mongoose `Model` object to perform the query on
@@ -51,6 +78,24 @@ export declare class QueryParser {
      * @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>>;
+    /**
+     * Get a document matching the provided query for a given model
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param singleMode this defines if the query should be for many or just one item
+     * @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 docsFromCustomFilterToCursor<T = any>(model: Model<T>, singleMode: boolean, filter: FilterQuery<T>, query: ParsedQs): IDocByQueryCursorRes<T>;
+    /**
+     * Get a document matching the provided query for a given model
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param singleMode this defines if the query should be for many or just one item
+     * @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 docsByFilter<T = any>(model: Model<T>, singleMode: boolean, 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

package/lib/query-parser-helper.js

@@ -96,6 +96,7 @@ var QueryParser = /** @class */ (function () {
     };
     /**
      * Get all documents matching the provided query for a given model
+     * @deprecated The method should not be used, please use ```docsByQuery```
      * @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
@@ -121,8 +122,36 @@ var QueryParser = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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
+     */
+    QueryParser.docsByQuery = function (model, query, count) {
+        if (count === void 0) { count = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var error_2;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        _a = {};
+                        return [4 /*yield*/, QueryParser.parseQuery(model, query, count).exec()];
+                    case 1: return [2 /*return*/, (_a.data = _b.sent(), _a)];
+                    case 2:
+                        error_2 = _b.sent();
+                        throw new Error(error_2);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Get all documents matching the provided query for a given model to a  mongodb cursor resource
+     * @deprecated The method should not be used, please use ```docsByQueryToCursor```
      * @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
@@ -138,6 +167,48 @@ var QueryParser = /** @class */ (function () {
             throw new Error(error);
         }
     };
+    /**
+     * 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
+     */
+    QueryParser.docsByQueryToCursor = function (model, query) {
+        try {
+            return {
+                data: QueryParser.parseQuery(model, query, false).cursor(),
+            };
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    };
+    /**
+     * Build a Mongoose `findOne` or `find` query on a given model with additional params
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param singleMode this defines if the query should be for many or just one item
+     * @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
+     */
+    QueryParser.parseFromCustomFilterToQuery = function (model, singleMode, filter, query) {
+        var docQuery;
+        docQuery = singleMode ? model.findOne(__assign({}, filter)) : model.find(__assign({}, filter));
+        if (!(0, lodash_1.isEmpty)(query)) {
+            var parser = new query_parser_1.MongooseQueryParser({
+                blacklist: ['filter', 'sort', 'limit', 'skip'],
+            });
+            var queryParams = parser.parse(query);
+            if (queryParams.populate)
+                docQuery = docQuery.populate(queryParams.populate);
+            if (queryParams.deepPopulate)
+                docQuery = docQuery.populate(queryParams.deepPopulate);
+            if (queryParams.select)
+                docQuery = docQuery.select(queryParams.select);
+        }
+        return docQuery;
+    };
     /**
      * Build a Mongoose `findOne` query on a given model with additional params
      * @param model a Mongoose `Model` object to perform the query on
@@ -171,7 +242,7 @@ var QueryParser = /** @class */ (function () {
      */
     QueryParser.docByFilter = function (model, filter, query) {
         return __awaiter(this, void 0, void 0, function () {
-            var error_2;
+            var error_3;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -182,8 +253,54 @@ var QueryParser = /** @class */ (function () {
                     case 1: return [2 /*return*/, (_a.data = _b.sent(),
                             _a)];
                     case 2:
-                        error_2 = _b.sent();
-                        throw new Error(error_2);
+                        error_3 = _b.sent();
+                        throw new Error(error_3);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get a document matching the provided query for a given model
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param singleMode this defines if the query should be for many or just one item
+     * @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
+     */
+    QueryParser.docsFromCustomFilterToCursor = function (model, singleMode, filter, query) {
+        try {
+            return {
+                data: QueryParser.parseFromCustomFilterToQuery(model, singleMode, filter, query).cursor(),
+            };
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    };
+    /**
+     * Get a document matching the provided query for a given model
+     * @param model a Mongoose `Model` object to perform the query on
+     * @param singleMode this defines if the query should be for many or just one item
+     * @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
+     */
+    QueryParser.docsByFilter = function (model, singleMode, filter, query) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_4;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        _a = {};
+                        return [4 /*yield*/, QueryParser.parseFromCustomFilterToQuery(model, singleMode, filter, query).exec()];
+                    case 1: return [2 /*return*/, (_a.data = _b.sent(),
+                            _a)];
+                    case 2:
+                        error_4 = _b.sent();
+                        throw new Error(error_4);
                     case 3: return [2 /*return*/];
                 }
             });

package/lib/test.spec.js

@@ -48,6 +48,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var mocha_1 = require("@testdeck/mocha");
 var chai_1 = require("chai");
 var _1 = require("./");
+var lodash_1 = require("lodash");
 var Tester = /** @class */ (function () {
     function Tester() {
     }
@@ -155,6 +156,28 @@ var Tester = /** @class */ (function () {
         chai_1.assert.notNestedProperty(parsedUndefined, 'lean');
         chai_1.assert.isFalse(parsedNotBoolean.lean);
     };
+    Tester.prototype.parseComplex = function () {
+        var parser = new _1.MongooseQueryParser();
+        var preDefined = {
+            $and: [
+                { $or: [{ __keywords: { $elemMatch: { $regex: 'Stranger', $options: 'i' } } }] },
+                { dailyRate: { $gte: 0, $lte: 60 } },
+                {
+                    geolocation: {
+                        $near: {
+                            $geometry: { type: 'Point', coordinates: [-122.16106, 37.37646] },
+                            $minDistance: 0,
+                            $maxDistance: 10,
+                        },
+                    },
+                },
+                { unavailableDates: { $nin: [] } },
+            ],
+        };
+        var query = 'filter={"$and":[{"$or":[{"__keywords":{"$elemMatch":{"$regex":"Stranger","$options":"i"}}}]},{"dailyRate":{"$gte":0,"$lte":60}},{"geolocation":{"$near":{"$geometry":{"type":"Point","coordinates":[-122.16106,37.37646]},"$minDistance":0,"$maxDistance":10}}},{"unavailableDates":{"$nin":[]}}]}';
+        var parsed = parser.parse(query);
+        chai_1.assert.isOk((0, lodash_1.isEqual)(parsed.filter, preDefined));
+    };
     __decorate([
         (0, mocha_1.test)('should parse general query'),
         __metadata("design:type", Function),
@@ -203,6 +226,12 @@ var Tester = /** @class */ (function () {
         __metadata("design:paramtypes", []),
         __metadata("design:returntype", void 0)
     ], Tester.prototype, "parseLean", null);
+    __decorate([
+        (0, mocha_1.test)('should parse complex'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "parseComplex", null);
     Tester = __decorate([
         (0, mocha_1.suite)('Tester')
     ], Tester);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbears/gb-mongoose-query-parser",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "description": "Convert url query string to MongooseJs friendly query object including advanced filtering, sorting, population, deep population, string template, type casting and many more...",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",