@geekbears/gb-mongoose-query-parser 1.2.1

package/lib/query-parser.js

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongooseQueryParser = void 0;
+var Moment = require("moment");
+var qs = require("querystring");
+var _ = require("lodash");
+var MongooseQueryParser = /** @class */ (function () {
+    function MongooseQueryParser(options) {
+        var _this = this;
+        if (options === void 0) { options = {}; }
+        this.options = options;
+        this.defaultDateFormat = [Moment.ISO_8601];
+        this.builtInCaster = {
+            string: function (val) { return String(val); },
+            date: function (val) {
+                var m = Moment(val, _this.options.dateFormat);
+                if (m.isValid()) {
+                    return m.toDate();
+                }
+                else {
+                    throw new Error("Invalid date string: [" + val + "]");
+                }
+            },
+        };
+        this.operators = [
+            { operator: 'select', method: this.castSelect, defaultKey: 'select' },
+            { operator: 'populate', method: this.castPopulate, defaultKey: 'populate' },
+            { operator: 'sort', method: this.castSort, defaultKey: 'sort' },
+            { operator: 'skip', method: this.castSkip, defaultKey: 'skip' },
+            { operator: 'limit', method: this.castLimit, defaultKey: 'limit' },
+            { operator: 'filter', method: this.castFilter, defaultKey: 'filter' },
+            { operator: 'deepPopulate', method: this.castDeepPopulate, defaultKey: 'deepPopulate' },
+            { operator: 'lean', method: this.castLean, defaultKey: 'lean' },
+        ];
+        // add default date format as ISO_8601
+        this.options.dateFormat = options.dateFormat || this.defaultDateFormat;
+        // add builtInCaster
+        this.options.casters = Object.assign(this.builtInCaster, options.casters);
+        // build blacklist
+        this.options.blacklist = options.blacklist || [];
+        this.operators.forEach(function (_a) {
+            var operator = _a.operator, method = _a.method, defaultKey = _a.defaultKey;
+            _this.options.blacklist.push(_this.options[operator + "Key"] || defaultKey);
+        });
+    }
+    /**
+     * parses query string/object to Mongoose friendly query object/QueryOptions
+     * @param {string | Object} query
+     * @param {Object} [context]
+     * @return {QueryOptions}
+     */
+    MongooseQueryParser.prototype.parse = function (query, context) {
+        var _this = this;
+        var params = _.isString(query) ? qs.parse(query) : query;
+        var options = this.options;
+        var result = {};
+        this.operators.forEach(function (_a) {
+            var operator = _a.operator, method = _a.method, defaultKey = _a.defaultKey;
+            var key = options[operator + "Key"] || defaultKey;
+            var value = params[key];
+            if (value || operator === 'filter') {
+                result[operator] = method.call(_this, value, params);
+            }
+        }, this);
+        result = this.parsePredefinedQuery(result, context);
+        return result;
+    };
+    /**
+     * 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
+     */
+    MongooseQueryParser.prototype.parseValue = function (value, key) {
+        var me = this;
+        var options = this.options;
+        // Apply casters
+        // Match type casting operators like: string(true), _caster(123), $('test')
+        var casters = options.casters;
+        var casting = value.match(/^([a-zA-Z_$][0-9a-zA-Z_$]*)\((.*)\)$/);
+        if (casting && casters[casting[1]]) {
+            return casters[casting[1]](casting[2]);
+        }
+        // Apply casters per params
+        if (key && options.castParams && options.castParams[key] && casters[options.castParams[key]]) {
+            return casters[options.castParams[key]](value);
+        }
+        // cast array
+        if (value.includes(',')) {
+            return value.split(',').map(function (val) { return me.parseValue(val, key); });
+        }
+        // Apply type casting for Number, RegExp, Date, Boolean and null
+        // Match regex operators like /foo_\d+/i
+        var regex = value.match(/^\/(.*)\/(i?)$/);
+        if (regex) {
+            return new RegExp(regex[1], regex[2]);
+        }
+        // Match boolean values
+        if (value === 'true') {
+            return true;
+        }
+        if (value === 'false') {
+            return false;
+        }
+        // Match null
+        if (value === 'null') {
+            return null;
+        }
+        // Match numbers (string padded with zeros are not numbers)
+        if (value !== '' && !isNaN(Number(value)) && !/^0[0-9]+/.test(value)) {
+            return Number(value);
+        }
+        // Match dates
+        var m = Moment(value, options.dateFormat);
+        if (m.isValid()) {
+            return m.toDate();
+        }
+        return value;
+    };
+    MongooseQueryParser.prototype.castFilter = function (filter, params) {
+        var _this = this;
+        var options = this.options;
+        var parsedFilter = filter ? this.parseFilter(filter) : {};
+        return Object.keys(params)
+            .map(function (val) {
+            var join = params[val] ? val + "=" + params[val] : val;
+            // Separate key, operators and value
+            var _a = join.match(/(!?)([^><!=]+)([><]=?|!?=|)(.*)/), prefix = _a[1], key = _a[2], op = _a[3], value = _a[4];
+            return { prefix: prefix, key: key, op: _this.parseOperator(op), value: _this.parseValue(value, key) };
+        })
+            .filter(function (_a) {
+            var key = _a.key;
+            return options.blacklist.indexOf(key) === -1;
+        })
+            .reduce(function (result, _a) {
+            var prefix = _a.prefix, key = _a.key, op = _a.op, value = _a.value;
+            if (!result[key]) {
+                result[key] = {};
+            }
+            if (Array.isArray(value)) {
+                result[key][op === '$ne' ? '$nin' : '$in'] = value;
+            }
+            else if (op === '$exists') {
+                result[key][op] = prefix !== '!';
+            }
+            else if (op === '$eq') {
+                result[key] = value;
+            }
+            else if (op === '$ne' && typeof value === 'object') {
+                result[key].$not = value;
+            }
+            else {
+                result[key][op] = value;
+            }
+            return result;
+        }, parsedFilter);
+    };
+    MongooseQueryParser.prototype.parseFilter = function (filter) {
+        try {
+            if (typeof filter === 'object') {
+                return filter;
+            }
+            return JSON.parse(filter);
+        }
+        catch (err) {
+            throw new Error("Invalid JSON string: " + filter);
+        }
+    };
+    MongooseQueryParser.prototype.parseOperator = function (operator) {
+        if (operator === '=') {
+            return '$eq';
+        }
+        else if (operator === '!=') {
+            return '$ne';
+        }
+        else if (operator === '>') {
+            return '$gt';
+        }
+        else if (operator === '>=') {
+            return '$gte';
+        }
+        else if (operator === '<') {
+            return '$lt';
+        }
+        else if (operator === '<=') {
+            return '$lte';
+        }
+        else if (!operator) {
+            return '$exists';
+        }
+    };
+    /**
+     * 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
+     */
+    MongooseQueryParser.prototype.castSelect = function (val) {
+        var fields = this.parseUnaries(val, { plus: 1, minus: 0 });
+        /*
+        From the MongoDB documentation:
+        "A projection cannot contain both include and exclude specifications, except for the exclusion of the _id field."
+      */
+        var hasMixedValues = Object.keys(fields).reduce(function (set, key) {
+            if (key !== '_id') {
+                set.add(fields[key]);
+            }
+            return set;
+        }, new Set()).size > 1;
+        if (hasMixedValues) {
+            Object.keys(fields).forEach(function (key) {
+                if (fields[key] === 1) {
+                    delete fields[key];
+                }
+            });
+        }
+        return fields;
+    };
+    /**
+     * cast populate query to object like:
+     * populate=field1.p1,field1.p2,field2
+     * =>
+     * [{path: 'field1', select: 'p1 p2'}, {path: 'field2'}]
+     * @param val
+     */
+    MongooseQueryParser.prototype.castPopulate = function (val) {
+        return val
+            .split(',')
+            .map(function (qry) {
+            var _a = qry.split('.', 2), p = _a[0], s = _a[1];
+            return s ? { path: p, select: s } : { path: p };
+        })
+            .reduce(function (prev, curr, key) {
+            // consolidate population array
+            var path = curr.path;
+            var select = curr.select;
+            var found = false;
+            prev.forEach(function (e) {
+                if (e.path === path) {
+                    found = true;
+                    if (select) {
+                        e.select = e.select ? e.select + ' ' + select : select;
+                    }
+                }
+            });
+            if (!found) {
+                prev.push(curr);
+            }
+            return prev;
+        }, []);
+    };
+    /**
+     * cast deep populate query to object like:
+     * populate={"path":"any", select="deep"}
+     * =>
+     * {path: 'field1', select: 'deep'}
+     * @param deepPopulate
+     */
+    MongooseQueryParser.prototype.castDeepPopulate = function (deepPopulate) {
+        return this.parseDeepPopulate(deepPopulate);
+    };
+    MongooseQueryParser.prototype.parseDeepPopulate = function (deepPopulate) {
+        try {
+            if (typeof deepPopulate === 'object') {
+                return deepPopulate;
+            }
+            return JSON.parse(deepPopulate);
+        }
+        catch (err) {
+            throw new Error("Invalid JSON string: " + deepPopulate);
+        }
+    };
+    /**
+     * cast sort query to object like
+     * sort=-a,b
+     * =>
+     * {sort: {a: -1, b: 1}}
+     * @param sort
+     */
+    MongooseQueryParser.prototype.castSort = function (sort) {
+        return this.parseUnaries(sort);
+    };
+    /**
+     * Map/reduce helper to transform list of unaries
+     * like '+a,-b,c' to {a: 1, b: -1, c: 1}
+     */
+    MongooseQueryParser.prototype.parseUnaries = function (unaries, values) {
+        if (values === void 0) { values = { plus: 1, minus: -1 }; }
+        var unariesAsArray = _.isString(unaries) ? unaries.split(',') : unaries;
+        return unariesAsArray
+            .map(function (x) { return x.match(/^(\+|-)?(.*)/); })
+            .reduce(function (result, _a) {
+            var val = _a[1], key = _a[2];
+            result[key.trim()] = val === '-' ? values.minus : values.plus;
+            return result;
+        }, {});
+    };
+    /**
+     * cast skip query to object like
+     * skip=100
+     * =>
+     * {skip: 100}
+     * @param skip
+     */
+    MongooseQueryParser.prototype.castSkip = function (skip) {
+        return Number(skip);
+    };
+    /**
+     * cast limit query to object like
+     * limit=10
+     * =>
+     * {limit: 10}
+     * @param limit
+     */
+    MongooseQueryParser.prototype.castLimit = function (limit) {
+        return Number(limit);
+    };
+    /**
+     * cast lean option like
+     * lean=true
+     * =>
+     * {lean: true}
+     * @param lean
+     */
+    MongooseQueryParser.prototype.castLean = function (lean) {
+        return lean === 'true' ? true : false;
+    };
+    /**
+     * transform predefined query strings defined in query string to the actual query object out of the given context
+     * @param query
+     * @param context
+     */
+    MongooseQueryParser.prototype.parsePredefinedQuery = function (query, context) {
+        if (context) {
+            // check if given string is the format as predefined query i.e. ${query}
+            var _match_1 = function (str) {
+                var reg = /^\$\{([a-zA-Z_$][0-9a-zA-Z_$]*)\}$/;
+                var match = str.match(reg);
+                var val = undefined;
+                if (match) {
+                    val = _.property(match[1])(context);
+                    if (val === undefined) {
+                        throw new Error("No predefined query found for the provided reference [" + match[1] + "]");
+                    }
+                }
+                return { match: !!match, val: val };
+            };
+            var _transform_1 = function (obj) {
+                return _.reduce(obj, function (prev, curr, key) {
+                    var _a, _b;
+                    var val = undefined, match = undefined;
+                    if (_.isString(key)) {
+                        (_a = _match_1(key), match = _a.match, val = _a.val);
+                        if (match) {
+                            if (_.has(curr, '$exists')) {
+                                // 1). as a key: {'${qry}': {$exits: true}} => {${qry object}}
+                                return _.merge(prev, val);
+                            }
+                            else if (_.isString(val)) {
+                                // 1). as a key: {'${qry}': 'something'} => {'${qry object}': 'something'}
+                                key = val;
+                            }
+                            else {
+                                throw new Error("Invalid query string at " + key);
+                            }
+                        }
+                    }
+                    if (_.isString(curr)) {
+                        (_b = _match_1(curr), match = _b.match, val = _b.val);
+                        if (match) {
+                            _.isNumber(key)
+                                ? prev.push(val) // 3). as an item of array: ['${qry}', ...] => [${qry object}, ...]
+                                : (prev[key] = val); // 2). as a value: {prop: '${qry}'} => {prop: ${qry object}}
+                            return prev;
+                        }
+                    }
+                    if (_.isObject(curr) && !_.isRegExp(curr) && !_.isDate(curr)) {
+                        // iterate all props & keys recursively
+                        _.isNumber(key) ? prev.push(_transform_1(curr)) : (prev[key] = _transform_1(curr));
+                    }
+                    else {
+                        _.isNumber(key) ? prev.push(curr) : (prev[key] = curr);
+                    }
+                    return prev;
+                }, _.isArray(obj) ? [] : {});
+            };
+            return _transform_1(query);
+        }
+        return query;
+    };
+    return MongooseQueryParser;
+}());
+exports.MongooseQueryParser = MongooseQueryParser;
+//# sourceMappingURL=query-parser.js.map

package/lib/test.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test.spec.js

@@ -0,0 +1,211 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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 });
+var mocha_1 = require("@testdeck/mocha");
+var chai_1 = require("chai");
+var _1 = require("./");
+var Tester = /** @class */ (function () {
+    function Tester() {
+    }
+    Tester.prototype.generalParse = function () {
+        var parser = new _1.MongooseQueryParser();
+        var qry = 'date=2016-01-01&boolean=true&integer=10&regexp=/foobar/i&null=null';
+        var parsed = parser.parse(qry);
+        chai_1.assert.isNotNull(parsed.filter);
+        chai_1.assert.isOk(parsed.filter['date'] instanceof Date);
+        chai_1.assert.isOk(parsed.filter['boolean'] === true);
+        chai_1.assert.isOk(parsed.filter['integer'] === 10);
+        chai_1.assert.isOk(parsed.filter['regexp'] instanceof RegExp);
+        chai_1.assert.isOk(parsed.filter['null'] === null);
+    };
+    Tester.prototype.generalParse2 = function () {
+        var parser = new _1.MongooseQueryParser();
+        var predefined = {
+            vip: { name: { $in: ['Google', 'Microsoft', 'NodeJs'] } },
+            sentStatus: 'sent',
+        };
+        var parsed = parser.parse('${vip}&status=${sentStatus}&timestamp>2017-10-01&author.firstName=/john/i&limit=100&skip=50&sort=-timestamp&select=name&populate=children', predefined);
+        chai_1.assert.isOk(parsed.filter['status'] === predefined.sentStatus);
+        chai_1.assert.isOk(parsed.filter['name'].$in.length === 3); // checking parsing of ${vip}
+        chai_1.assert.isOk(parsed.filter['timestamp']['$gt'] instanceof Date);
+        chai_1.assert.isOk(parsed.filter['author.firstName'] instanceof RegExp);
+        chai_1.assert.isOk(parsed.limit === 100);
+        chai_1.assert.isOk(parsed.skip === 50);
+        chai_1.assert.isNotNull(parsed.sort);
+        chai_1.assert.isNotNull(parsed.select);
+        chai_1.assert.isNotNull(parsed.populate);
+    };
+    Tester.prototype.populateParse = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var parser, qry, parsed;
+            return __generator(this, function (_a) {
+                parser = new _1.MongooseQueryParser();
+                qry = '_id=1&populate=serviceSalesOrders,customer.category,customer.name';
+                parsed = parser.parse(qry);
+                chai_1.assert.isOk(parsed.populate.length === 2);
+                return [2 /*return*/];
+            });
+        });
+    };
+    Tester.prototype.builtInCastersTest = function () {
+        var parser = new _1.MongooseQueryParser();
+        var qry = 'key1=string(10)&key2=date(2017-10-01)&key3=string(null)';
+        var parsed = parser.parse(qry);
+        chai_1.assert.isOk(typeof parsed.filter['key1'] === 'string');
+        chai_1.assert.isOk(parsed.filter['key2'] instanceof Date);
+        chai_1.assert.isOk(typeof parsed.filter['key3'] === 'string');
+    };
+    Tester.prototype.parseCaster = function () {
+        var parser = new _1.MongooseQueryParser({
+            casters: { $: function (val) { return '$' + val; } },
+        });
+        var qry = '_id=$(1)';
+        var parsed = parser.parse(qry);
+        chai_1.assert.equal('$1', parsed.filter['_id']);
+    };
+    Tester.prototype.parseJsonFilter = function () {
+        var parser = new _1.MongooseQueryParser();
+        var obj = {
+            $or: [{ key1: 'value1' }, { key2: 'value2' }],
+        };
+        var qry = "filter=" + JSON.stringify(obj) + "&name=Google";
+        var parsed = parser.parse(qry);
+        chai_1.assert.isArray(parsed.filter['$or']);
+        chai_1.assert.isOk(parsed.filter['name'] === 'Google');
+    };
+    Tester.prototype.parsePredefined = function () {
+        var parser = new _1.MongooseQueryParser();
+        var preDefined = {
+            isActive: { status: { $in: ['In Progress', 'Pending'] } },
+            vip: ['KFC', 'Google', 'MS'],
+            secret: 'my_secret',
+            mykey: 'realkey',
+        };
+        // test predefined query as key
+        var qry = '${isActive}&name&${mykey}=1';
+        var parsed = parser.parse(qry, preDefined);
+        chai_1.assert.isNotNull(parsed.filter['status']);
+        chai_1.assert.isOk(!parsed.filter['${isActive}']);
+        chai_1.assert.isOk(parsed.filter['realkey'] === 1);
+        // test predefined query as value
+        qry = 'secret=${secret}';
+        parsed = parser.parse(qry, preDefined);
+        chai_1.assert.isOk(parsed.filter['secret'] === preDefined.secret);
+        // test predefined query in json
+        qry = 'filter={"$and": ["${isActive}", {"customer": "VDF"}]}';
+        parsed = parser.parse(qry, preDefined);
+        chai_1.assert.isNotNull(parsed.filter['$and'][0].status);
+    };
+    Tester.prototype.parseLean = function () {
+        var parser = new _1.MongooseQueryParser();
+        var qryTrue = 'lean=true';
+        var qryFalse = 'lean=false';
+        var qryUndefined = 'lean=';
+        var qryNotBoolean = 'lean=any';
+        var parsedTrue = parser.parse(qryTrue);
+        var parsedFalse = parser.parse(qryFalse);
+        var parsedUndefined = parser.parse(qryUndefined);
+        var parsedNotBoolean = parser.parse(qryNotBoolean);
+        chai_1.assert.isTrue(parsedTrue.lean);
+        chai_1.assert.isFalse(parsedFalse.lean);
+        chai_1.assert.notNestedProperty(parsedUndefined, 'lean');
+        chai_1.assert.isFalse(parsedNotBoolean.lean);
+    };
+    __decorate([
+        (0, mocha_1.test)('should parse general query'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "generalParse", null);
+    __decorate([
+        (0, mocha_1.test)('should parse query with string templates'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "generalParse2", null);
+    __decorate([
+        (0, mocha_1.test)('should parse populate query'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], Tester.prototype, "populateParse", null);
+    __decorate([
+        (0, mocha_1.test)('should parse built in casters'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "builtInCastersTest", null);
+    __decorate([
+        (0, mocha_1.test)('should parse custom caster'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "parseCaster", null);
+    __decorate([
+        (0, mocha_1.test)('should parse json filter'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "parseJsonFilter", null);
+    __decorate([
+        (0, mocha_1.test)('should parse predefined query objects'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "parsePredefined", null);
+    __decorate([
+        (0, mocha_1.test)('should parse lean'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Tester.prototype, "parseLean", null);
+    Tester = __decorate([
+        (0, mocha_1.suite)('Tester')
+    ], Tester);
+    return Tester;
+}());
+//# sourceMappingURL=test.spec.js.map

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './parser-options.type';
+export * from './query-options.type';

package/lib/types/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("./parser-options.type"), exports);
+__exportStar(require("./query-options.type"), exports);
+//# sourceMappingURL=index.js.map

package/lib/types/parser-options.type.d.ts

@@ -0,0 +1,18 @@
+export interface ParserOptions {
+    dateFormat?: any;
+    blacklist?: string[];
+    casters?: {
+        [key: string]: (val: string) => any;
+    };
+    castParams?: {
+        [key: string]: string;
+    };
+    selectKey?: string;
+    populateKey?: string;
+    deepPopulateKey?: string;
+    sortKey?: string;
+    skipKey?: string;
+    limitKey?: string;
+    filterKey?: string;
+    leanKey?: string;
+}

package/lib/types/parser-options.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=parser-options.type.js.map

package/lib/types/query-options.type.d.ts

@@ -0,0 +1,15 @@
+import { SortOrder } from 'mongoose';
+export interface QueryOptions {
+    filter: Object;
+    sort?: string | {
+        [key: string]: SortOrder | {
+            $meta: 'textScore';
+        };
+    } | [string, SortOrder][] | undefined | null;
+    limit?: number;
+    skip?: number;
+    select?: string | Object;
+    populate?: string | Object;
+    deepPopulate?: string | Object;
+    lean?: boolean;
+}

package/lib/types/query-options.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=query-options.type.js.map