@geekbears/gb-mongoose-query-parser 1.3.20 → 1.3.22

package/eslint.config.mjs

@@ -0,0 +1,203 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default [...compat.extends(
+    "plugin:@typescript-eslint/recommended",
+    "plugin:@typescript-eslint/recommended-requiring-type-checking",
+    "prettier",
+), {
+    plugins: {
+
+
+        "@typescript-eslint": typescriptEslint,
+    },
+
+    languageOptions: {
+        globals: {
+            ...globals.node,
+        },
+
+        parser: tsParser,
+        ecmaVersion: 5,
+        sourceType: "module",
+
+        parserOptions: {
+            project: "tsconfig.json",
+        },
+    },
+
+    rules: {
+        "@typescript-eslint/adjacent-overload-signatures": "error",
+
+        "@typescript-eslint/array-type": ["error", {
+            default: "array",
+        }],
+
+
+
+        "@typescript-eslint/consistent-type-assertions": "error",
+        "@typescript-eslint/dot-notation": "error",
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/indent": "off",
+
+        "@typescript-eslint/member-delimiter-style": ["off", {
+            multiline: {
+                delimiter: "none",
+                requireLast: true,
+            },
+
+            singleline: {
+                delimiter: "semi",
+                requireLast: false,
+            },
+        }],
+
+        "@typescript-eslint/naming-convention": ["error", {
+            selector: "variable",
+            format: ["camelCase", "UPPER_CASE", "PascalCase"],
+            leadingUnderscore: "allow",
+            trailingUnderscore: "forbid",
+        }],
+
+        "@typescript-eslint/no-empty-function": "error",
+        "@typescript-eslint/no-empty-interface": "error",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-misused-new": "error",
+        "@typescript-eslint/no-namespace": "error",
+        "@typescript-eslint/no-parameter-properties": "off",
+        "@typescript-eslint/no-unsafe-assignment": "warn",
+        "@typescript-eslint/no-unsafe-argument": "warn",
+        "@typescript-eslint/no-unsafe-call": "warn",
+        "@typescript-eslint/no-floating-promises": "warn",
+        "@typescript-eslint/no-unsafe-member-access": "warn",
+        "@typescript-eslint/no-unsafe-return": "warn",
+        "@typescript-eslint/no-misused-promises": "warn",
+        "@typescript-eslint/no-unused-expressions": "off",
+        "@typescript-eslint/no-unsafe-argument": "warn",
+        "@typescript-eslint/no-unused-vars": "warn",
+        "@typescript-eslint/unbound-method": "warn",
+        "@typescript-eslint/no-base-to-string": "warn",
+        "id-denylist": "off",
+        "@typescript-eslint/no-this-alias": [
+            "error",
+            {
+                "allowDestructuring": true, // Allow `const { props, state } = this`; false by default
+                "allowedNames": ["me"] // Allow `const vm= this`; `[]` by default
+            }
+        ],
+
+        "@typescript-eslint/no-shadow": ["error", {
+            hoist: "all",
+        }],
+
+        "@typescript-eslint/no-unused-expressions": "error",
+        "@typescript-eslint/no-use-before-define": "off",
+        "@typescript-eslint/no-var-requires": "error",
+        "@typescript-eslint/prefer-for-of": "error",
+        "@typescript-eslint/prefer-function-type": "error",
+        "@typescript-eslint/prefer-namespace-keyword": "error",
+        "@typescript-eslint/quotes": "off",
+        "@typescript-eslint/semi": ["off", null],
+
+        "@typescript-eslint/triple-slash-reference": ["error", {
+            path: "always",
+            types: "prefer-import",
+            lib: "always",
+        }],
+
+        "@typescript-eslint/type-annotation-spacing": "off",
+        "@typescript-eslint/typedef": "off",
+        "@typescript-eslint/unified-signatures": "error",
+        "arrow-parens": ["off", "always"],
+        "brace-style": ["off", "off"],
+        "comma-dangle": "off",
+        complexity: "off",
+        "constructor-super": "error",
+        "dot-notation": "off",
+        "eol-last": "off",
+        eqeqeq: ["error", "smart"],
+        "guard-for-in": "error",
+
+        "id-denylist": [
+            "error",
+            "any",
+            "Number",
+            "number",
+            "String",
+            "string",
+            "Boolean",
+            "boolean",
+            "Undefined",
+            "undefined",
+        ],
+
+        "id-match": "error",
+        indent: "off",
+        "linebreak-style": "off",
+        "max-classes-per-file": ["error", 1],
+        "max-len": "off",
+        "new-parens": "off",
+        "newline-per-chained-call": "off",
+        "no-bitwise": "error",
+        "no-caller": "error",
+        "no-cond-assign": "error",
+
+        "no-debugger": "error",
+        "no-empty": "error",
+        "no-empty-function": "off",
+        "no-eval": "error",
+        "no-extra-semi": "off",
+        "no-fallthrough": "off",
+        "no-invalid-this": "off",
+        "no-irregular-whitespace": "off",
+        "no-multiple-empty-lines": "off",
+        "no-new-wrappers": "error",
+        "no-shadow": "off",
+        "no-throw-literal": "error",
+        "no-trailing-spaces": "off",
+        "no-undef-init": "error",
+        "no-underscore-dangle": "off",
+        "no-unsafe-finally": "error",
+        "no-unused-expressions": "off",
+        "no-unused-labels": "error",
+        "no-use-before-define": "off",
+        "no-var": "error",
+        "object-shorthand": "error",
+        "one-var": ["error", "never"],
+
+        "padded-blocks": ["off", {
+            blocks: "never",
+        }, {
+                allowSingleLineBlocks: true,
+            }],
+        "prefer-const": "error",
+        "quote-props": "off",
+        quotes: "off",
+        radix: "error",
+
+        semi: "off",
+        "space-before-function-paren": "off",
+        "space-in-parens": ["off", "never"],
+
+        "spaced-comment": ["error", "always", {
+            markers: ["/"],
+        }],
+
+        "use-isnan": "error",
+        "valid-typeof": "off",
+    },
+}];

package/lib/query-parser.d.ts

@@ -12,7 +12,7 @@ export declare class MongooseQueryParser {
      * @param {Object} [context]
      * @return {QueryOptions}
      */
-    parse(query: string | Object, context?: Object): 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

package/lib/query-parser.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongooseQueryParser = void 0;
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
 const Moment = require("moment");
 const qs_1 = require("qs");
 const lodash_1 = require("lodash");
@@ -9,6 +11,7 @@ class MongooseQueryParser {
         this.options = options;
         this.defaultDateFormat = [Moment.ISO_8601];
         this.builtInCaster = {
+            // eslint-disable-next-line id-denylist
             string: val => String(val),
             date: val => {
                 const m = Moment(val, this.options.dateFormat);
@@ -108,7 +111,7 @@ class MongooseQueryParser {
             return Number(value);
         }
         // Match dates
-        let m = Moment(value, options.dateFormat);
+        const m = Moment(value, options.dateFormat);
         if (m.isValid()) {
             return m.toDate();
         }
@@ -327,18 +330,19 @@ class MongooseQueryParser {
             const _match = str => {
                 const reg = /^\$\{([a-zA-Z_$][0-9a-zA-Z_$]*)\}$/;
                 const match = str.match(reg);
-                let val = undefined;
+                let val;
                 if (match) {
                     val = (0, lodash_1.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 };
+                return { match: !!match, val };
             };
             const _transform = obj => {
                 return (0, lodash_1.reduce)(obj, (prev, curr, key) => {
-                    let val = undefined, match = undefined;
+                    let val;
+                    let match;
                     if ((0, lodash_1.isString)(key)) {
                         ({ match, val } = _match(key));
                         if (match) {

package/lib/test.spec.d.ts

@@ -1 +1,16 @@
-export {};
+export declare class Tester {
+    generalParse(): void;
+    generalParse2(): void;
+    populateParse(): void;
+    builtInCastersTest(): void;
+    parseCaster(): void;
+    parseJsonFilter(): void;
+    parsePredefined(): void;
+    parseLean(): void;
+    parseComplex(): void;
+    parseId(): void;
+    transformFilter(): void;
+    transformFilterNull(): void;
+    transformFilter2(): void;
+    transformFilterAggregate(): void;
+}

package/lib/test.spec.js

@@ -9,6 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tester = void 0;
 const mocha_1 = require("@testdeck/mocha");
 const chai_1 = require("chai");
 const _1 = require("./");
@@ -16,15 +17,15 @@ const mongoose_1 = require("mongoose");
 const lodash_1 = require("lodash");
 let Tester = class Tester {
     generalParse() {
-        let parser = new _1.MongooseQueryParser();
-        let qry = 'date=2016-01-01&boolean=true&integer=10&regexp=/foobar/i&null=null';
-        let parsed = parser.parse(qry);
+        const parser = new _1.MongooseQueryParser();
+        const qry = 'date=2016-01-01&boolean=true&integer=10&regexp=/foobar/i&null=null';
+        const 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);
+        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);
     }
     generalParse2() {
         const parser = new _1.MongooseQueryParser();
@@ -33,9 +34,9 @@ let Tester = class Tester {
             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', 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.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);
@@ -43,41 +44,41 @@ let Tester = class Tester {
         chai_1.assert.isNotNull(parsed.select);
         chai_1.assert.isNotNull(parsed.populate);
     }
-    async populateParse() {
-        let parser = new _1.MongooseQueryParser();
-        let qry = '_id=1&populate=serviceSalesOrders,customer.category,customer.name';
-        let parsed = parser.parse(qry);
+    populateParse() {
+        const parser = new _1.MongooseQueryParser();
+        const qry = '_id=1&populate=serviceSalesOrders,customer.category,customer.name';
+        const parsed = parser.parse(qry);
         chai_1.assert.isOk(parsed.populate.length === 2);
     }
     builtInCastersTest() {
-        let parser = new _1.MongooseQueryParser();
-        let qry = 'key1=string(10)&key2=date(2017-10-01)&key3=string(null)';
-        let 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');
+        const parser = new _1.MongooseQueryParser();
+        const qry = 'key1=string(10)&key2=date(2017-10-01)&key3=string(null)';
+        const 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');
     }
     parseCaster() {
-        let parser = new _1.MongooseQueryParser({
+        const parser = new _1.MongooseQueryParser({
             casters: { $: val => '$' + val },
         });
-        let qry = '_id=$(1)';
-        let parsed = parser.parse(qry);
-        chai_1.assert.equal('$1', parsed.filter['_id']);
+        const qry = '_id=$(1)';
+        const parsed = parser.parse(qry);
+        chai_1.assert.equal('$1', parsed.filter._id);
     }
     parseJsonFilter() {
-        let parser = new _1.MongooseQueryParser();
-        let obj = {
+        const parser = new _1.MongooseQueryParser();
+        const obj = {
             $or: [{ key1: 'value1' }, { key2: 'value2' }],
         };
-        let qry = `filter=${JSON.stringify(obj)}&name=Google`;
-        let parsed = parser.parse(qry);
-        chai_1.assert.isArray(parsed.filter['$or']);
-        chai_1.assert.isOk(parsed.filter['name'] === 'Google');
+        const qry = `filter=${JSON.stringify(obj)}&name=Google`;
+        const parsed = parser.parse(qry);
+        chai_1.assert.isArray(parsed.filter.$or);
+        chai_1.assert.isOk(parsed.filter.name === 'Google');
     }
     parsePredefined() {
-        let parser = new _1.MongooseQueryParser();
-        let preDefined = {
+        const parser = new _1.MongooseQueryParser();
+        const preDefined = {
             isActive: { status: { $in: ['In Progress', 'Pending'] } },
             vip: ['KFC', 'Google', 'MS'],
             secret: 'my_secret',
@@ -86,35 +87,35 @@ let Tester = class Tester {
         // test predefined query as key
         let qry = '${isActive}&name&${mykey}=1';
         let parsed = parser.parse(qry, preDefined);
-        chai_1.assert.isNotNull(parsed.filter['status']);
+        chai_1.assert.isNotNull(parsed.filter.status);
         chai_1.assert.isOk(!parsed.filter['${isActive}']);
-        chai_1.assert.isOk(parsed.filter['realkey'] === 1);
+        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);
+        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);
+        chai_1.assert.isNotNull(parsed.filter.$and[0].status);
     }
     parseLean() {
-        let parser = new _1.MongooseQueryParser();
-        let qryTrue = 'lean=true';
-        let qryFalse = 'lean=false';
-        let qryUndefined = 'lean=';
-        let qryNotBoolean = 'lean=any';
-        let parsedTrue = parser.parse(qryTrue);
-        let parsedFalse = parser.parse(qryFalse);
-        let parsedUndefined = parser.parse(qryUndefined);
-        let parsedNotBoolean = parser.parse(qryNotBoolean);
+        const parser = new _1.MongooseQueryParser();
+        const qryTrue = 'lean=true';
+        const qryFalse = 'lean=false';
+        const qryUndefined = 'lean=';
+        const qryNotBoolean = 'lean=any';
+        const parsedTrue = parser.parse(qryTrue);
+        const parsedFalse = parser.parse(qryFalse);
+        const parsedUndefined = parser.parse(qryUndefined);
+        const 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);
     }
     parseComplex() {
-        let parser = new _1.MongooseQueryParser();
+        const parser = new _1.MongooseQueryParser();
         const preDefined = {
             $and: [
                 { $or: [{ __keywords: { $elemMatch: { $regex: 'Stranger', $options: 'i' } } }] },
@@ -132,11 +133,11 @@ let Tester = class Tester {
             ],
         };
         const 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":[]}}]}';
-        let parsed = parser.parse(query);
+        const parsed = parser.parse(query);
         chai_1.assert.isOk((0, lodash_1.isEqual)(parsed.filter, preDefined));
     }
     parseId() {
-        let parser = new _1.MongooseQueryParser();
+        const parser = new _1.MongooseQueryParser();
         const filter = {
             dailyRate: { $gte: 0, $lte: 60 },
             geolocation: {
@@ -149,13 +150,13 @@ let Tester = class Tester {
             unavailableDates: { $nin: [] },
             _org: new mongoose_1.Types.ObjectId(),
         };
-        let parsed = parser.parse({ filter });
-        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(parsed.filter['_org']));
+        const parsed = parser.parse({ filter });
+        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(parsed.filter._org));
         chai_1.assert.isObject(parsed.filter);
-        chai_1.assert.isObject(parsed.filter['dailyRate']);
+        chai_1.assert.isObject(parsed.filter.dailyRate);
     }
     transformFilter() {
-        let parser = new _1.MongooseQueryParser();
+        const parser = new _1.MongooseQueryParser();
         const filter = {
             dailyRate: { $gte: 0, $lte: 60 },
             geolocation: {
@@ -169,32 +170,32 @@ let Tester = class Tester {
             _org: new mongoose_1.Types.ObjectId().toString(),
             _org2: { $in: [new mongoose_1.Types.ObjectId().toString()] },
         };
-        let parsed = parser.parse({ filter });
-        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(parsed.filter['_org']));
+        const parsed = parser.parse({ filter });
+        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(parsed.filter._org));
         chai_1.assert.isObject(parsed.filter);
-        chai_1.assert.isObject(parsed.filter['dailyRate']);
-        chai_1.assert.isObject(parsed.filter['_org2']);
+        chai_1.assert.isObject(parsed.filter.dailyRate);
+        chai_1.assert.isObject(parsed.filter._org2);
         const transformedFilter = _1.QueryParser.transformFilter(parsed);
         chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(transformedFilter.filter._org));
-        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(transformedFilter.filter._org2['$in'][0]));
+        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(transformedFilter.filter._org2.$in[0]));
     }
     transformFilterNull() {
-        let parser = new _1.MongooseQueryParser();
+        const parser = new _1.MongooseQueryParser();
         const filter = {
             dailyRate: { $eq: null },
         };
-        let parsed = parser.parse({ filter });
+        const parsed = parser.parse({ filter });
         chai_1.assert.isObject(parsed.filter);
     }
     transformFilter2() {
-        let parser = new _1.MongooseQueryParser();
+        const parser = new _1.MongooseQueryParser();
         const filter = {
             _tags: { $in: ['66885d0e304ef564c27f5315'] },
         };
         const query = { filter, populate: 'tags' };
-        let parsed = parser.parse(query);
+        const parsed = parser.parse(query);
         const transformedFilter = _1.QueryParser.transformFilter(parsed);
-        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(transformedFilter.filter._tags['$in'][0]));
+        chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(transformedFilter.filter._tags.$in[0]));
     }
     transformFilterAggregate() {
         // let parser = new MongooseQueryParser();
@@ -247,6 +248,7 @@ let Tester = class Tester {
         chai_1.assert.isOk((0, mongoose_1.isObjectIdOrHexString)(transformComplexLookupFilter.$lookup.pipeline[0].$match.$expr.$eq[0]));
     }
 };
+exports.Tester = Tester;
 __decorate([
     (0, mocha_1.test)('should parse general query'),
     __metadata("design:type", Function),
@@ -263,7 +265,7 @@ __decorate([
     (0, mocha_1.test)('should parse populate query'),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
+    __metadata("design:returntype", void 0)
 ], Tester.prototype, "populateParse", null);
 __decorate([
     (0, mocha_1.test)('should parse built in casters'),
@@ -331,7 +333,7 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], Tester.prototype, "transformFilterAggregate", null);
-Tester = __decorate([
+exports.Tester = Tester = __decorate([
     (0, mocha_1.suite)('Tester')
 ], Tester);
 //# sourceMappingURL=test.spec.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbears/gb-mongoose-query-parser",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "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",
@@ -10,7 +10,7 @@
     "prepublishOnly": "npm run compile",
     "pretest": "npm run compile",
     "test": "mocha ./lib/**/*.spec.js",
-    "lint": "tslint src/**/*.ts",
+    "lint": "eslint -c eslint.config.mjs src/*.ts --fix",
     "format": "prettier --write \"src/**/*.ts\""
   },
   "repository": {
@@ -32,26 +32,30 @@
   "homepage": "https://gitlab.com/geekbears/utilities/backend/gb-mongoose-query-parser#readme",
   "devDependencies": {
     "@testdeck/mocha": "^0.3.3",
-    "@types/chai": "^4.3.17",
-    "@types/lodash": "^4.17.7",
-    "@types/mocha": "^10.0.7",
-    "@types/node": "^22.4.0",
-    "@types/qs": "^6.9.15",
+    "@types/chai": "^5.0.1",
+    "@types/lodash": "^4.17.13",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.9.3",
+    "@types/qs": "^6.9.17",
+    "@typescript-eslint/eslint-plugin": "^8.16.0",
+    "@typescript-eslint/parser": "^8.16.0",
     "chai": "^4.5.0",
-    "mocha": "^10.7.3",
+    "eslint": "^9.15.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "mocha": "^10.8.2",
     "prettier": "^3.3.3",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "tslint": "^6.1.3",
-    "typescript": "^5.5.4"
+    "typescript": "^5.7.2"
   },
   "dependencies": {
     "lodash": "^4.17.21",
     "moment": "^2.30.1"
   },
   "peerDependencies": {
+    "class-validator": "0.10 - 0.15",
     "mongoose": "7 - 9",
-    "qs": "^6.10.1",
-    "class-validator": "0.10 - 0.15"
+    "qs": "^6.10.1"
   }
 }

package/tslint.json

@@ -1,62 +0,0 @@
-{
-  "rules": {
-    "no-inferrable-types": true,
-    "class-name": true,
-    "comment-format": [
-      true,
-      "check-space"
-    ],
-    "indent": [
-      true,
-      "spaces"
-    ],
-    "eofline": true,
-    "no-duplicate-variable": true,
-    "no-eval": true,
-    "no-arg": true,
-    "no-internal-module": true,
-    "no-trailing-whitespace": true,
-    "no-bitwise": true,
-    "no-unused-expression": true,
-    "no-var-keyword": true,
-    "one-line": [
-      true,
-      "check-catch",
-      "check-else",
-      "check-open-brace",
-      "check-whitespace"
-    ],
-    "quotemark": [
-      true,
-      "single",
-      "avoid-escape"
-    ],
-    "semicolon": [true, "always"],
-    "typedef-whitespace": [
-      true,
-      {
-        "call-signature": "nospace",
-        "index-signature": "nospace",
-        "parameter": "nospace",
-        "property-declaration": "nospace",
-        "variable-declaration": "nospace"
-      }
-    ],
-    "curly": true,
-    "variable-name": [
-      true,
-      "ban-keywords",
-      "check-format",
-      "allow-leading-underscore",
-      "allow-pascal-case"
-    ],
-    "whitespace": [
-      true,
-      "check-branch",
-      "check-decl",
-      "check-operator",
-      "check-separator",
-      "check-type"
-    ]
-  }
-}