@geekbears/gb-mongoose-query-parser 1.2.1

package/lib/query-parser-helper.js

@@ -0,0 +1,235 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryParser = void 0;
+var mongoose_1 = require("mongoose");
+var lodash_1 = require("lodash");
+var query_parser_1 = require("./query-parser");
+/**
+ * Helper class
+ * Implements the `MongooseQueryParser` and exposes a single method to execute queries on models
+ */
+var QueryParser = /** @class */ (function () {
+    function 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
+     */
+    QueryParser.parseQuery = function (model, query, count) {
+        if (count === void 0) { count = false; }
+        var docsQuery;
+        var countQueryDocuments;
+        docsQuery = model.find({});
+        countQueryDocuments = count ? model.countDocuments() : null;
+        if (!(0, lodash_1.isEmpty)(query)) {
+            var parser = new query_parser_1.MongooseQueryParser();
+            var queryParams = parser.parse(query);
+            (0, lodash_1.forOwn)(transformFilter(queryParams.filter), function (value, key) {
+                docsQuery = docsQuery.where(key, value);
+                if (countQueryDocuments)
+                    countQueryDocuments = countQueryDocuments.where(key, value);
+            });
+            if (queryParams.populate)
+                docsQuery = docsQuery.populate(queryParams.populate);
+            if (queryParams.deepPopulate)
+                docsQuery = docsQuery.populate(queryParams.deepPopulate);
+            if (queryParams.sort)
+                docsQuery = docsQuery.sort(queryParams.sort);
+            if (queryParams.limit)
+                docsQuery = docsQuery.limit(queryParams.limit);
+            if (queryParams.select)
+                docsQuery = docsQuery.select(queryParams.select);
+            if (queryParams.skip)
+                docsQuery = docsQuery.skip(queryParams.skip);
+        }
+        return count && countQueryDocuments ? countQueryDocuments : docsQuery;
+    };
+    /**
+     * 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.docByQuery = function (model, query, count) {
+        if (count === void 0) { count = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var error_1;
+            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_1 = _b.sent();
+                        throw new Error(error_1);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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.docByQueryToCursor = function (model, query) {
+        try {
+            return {
+                data: QueryParser.parseQuery(model, query, false).cursor(),
+            };
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    };
+    /**
+     * 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
+     */
+    QueryParser.parseFilterQuery = function (model, filter, query) {
+        var docQuery;
+        docQuery = model.findOne(__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;
+    };
+    /**
+     * 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
+     */
+    QueryParser.docByFilter = function (model, filter, query) {
+        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.parseFilterQuery(model, filter, query).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*/];
+                }
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    QueryParser.parseByIdQuery = function (model, _id, query) {
+        return QueryParser.parseFilterQuery(model, { _id: _id }, query);
+    };
+    /**
+     * 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
+     */
+    QueryParser.docById = function (model, _id, query) {
+        return QueryParser.docByFilter(model, { _id: _id }, query);
+    };
+    return QueryParser;
+}());
+exports.QueryParser = QueryParser;
+/**
+ * Transforms the filter param to correctly support `ObjectId`s
+ * @param filter the filter param
+ * @returns a casted filter
+ */
+function transformFilter(filter) {
+    var walk = function (obj) {
+        for (var key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                var value = obj[key];
+                if (typeof value === 'object')
+                    walk(obj[key]);
+                else
+                    obj[key] = mongoose_1.Types.ObjectId.isValid(value) ? new mongoose_1.Types.ObjectId(value) : value;
+            }
+        }
+        return obj;
+    };
+    return walk(__assign({}, filter));
+}
+//# sourceMappingURL=query-parser-helper.js.map

package/lib/query-parser.d.ts

@@ -0,0 +1,96 @@
+import { ParserOptions } from './types/parser-options.type';
+import { QueryOptions } from './types/query-options.type';
+export declare class MongooseQueryParser {
+    private options;
+    private readonly defaultDateFormat;
+    private readonly builtInCaster;
+    private readonly operators;
+    constructor(options?: ParserOptions);
+    /**
+     * parses query string/object to Mongoose friendly query object/QueryOptions
+     * @param {string | Object} query
+     * @param {Object} [context]
+     * @return {QueryOptions}
+     */
+    parse(query: string | Object, context?: Object): QueryOptions;
+    /**
+     * parses string to typed values
+     * This methods will apply auto type casting on Number, RegExp, Date, Boolean and null
+     * Also, it will apply defined casters in given options of the instance
+     * @param {string} value
+     * @param {string} key
+     * @return {any} typed value
+     */
+    parseValue(value: string, key?: string): any;
+    private castFilter;
+    private parseFilter;
+    private parseOperator;
+    /**
+     * cast select query to object like:
+     * select=a,b or select=-a,-b
+     * =>
+     * {select: { a: 1, b: 1 }} or {select: { a: 0, b: 0 }}
+     * @param val
+     */
+    private castSelect;
+    /**
+     * cast populate query to object like:
+     * populate=field1.p1,field1.p2,field2
+     * =>
+     * [{path: 'field1', select: 'p1 p2'}, {path: 'field2'}]
+     * @param val
+     */
+    private castPopulate;
+    /**
+     * cast deep populate query to object like:
+     * populate={"path":"any", select="deep"}
+     * =>
+     * {path: 'field1', select: 'deep'}
+     * @param deepPopulate
+     */
+    private castDeepPopulate;
+    private parseDeepPopulate;
+    /**
+     * cast sort query to object like
+     * sort=-a,b
+     * =>
+     * {sort: {a: -1, b: 1}}
+     * @param sort
+     */
+    private castSort;
+    /**
+     * Map/reduce helper to transform list of unaries
+     * like '+a,-b,c' to {a: 1, b: -1, c: 1}
+     */
+    private parseUnaries;
+    /**
+     * cast skip query to object like
+     * skip=100
+     * =>
+     * {skip: 100}
+     * @param skip
+     */
+    private castSkip;
+    /**
+     * cast limit query to object like
+     * limit=10
+     * =>
+     * {limit: 10}
+     * @param limit
+     */
+    private castLimit;
+    /**
+     * cast lean option like
+     * lean=true
+     * =>
+     * {lean: true}
+     * @param lean
+     */
+    private castLean;
+    /**
+     * transform predefined query strings defined in query string to the actual query object out of the given context
+     * @param query
+     * @param context
+     */
+    private parsePredefinedQuery;
+}