@tomsd/mongodbclient 3.0.13 → 4.0.0

package/README.md

@@ -8,7 +8,7 @@ See [mongodbclient.netlify.app](https://mongodbclient.netlify.app/) for details.
 ![npms.io (quality)](https://img.shields.io/npms-io/quality-score/@tomsd/mongodbclient)
 ![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/npm/@tomsd/mongodbclient)
 ![Maintenance](https://img.shields.io/maintenance/yes/2024)
-![depends on mongodb@4](https://img.shields.io/badge/depends%20on-mongodb@4-informational)
+![depends on mongodb@6](https://img.shields.io/badge/depends%20on-mongodb@6-informational)
 
 ## Installation
 ``` sh
@@ -49,9 +49,6 @@ const items = [
   const names = await mdbc.distinct("name");
   console.log(`distinct names: ${names.length}`); // 4
 
-  const { storageSize } = await mdbc.stats();
-  console.log(`storageSize: ${storageSize}`);
-
   const itemLength = await mdbc.count();
   console.log(`count: ${itemLength}`); // 4
 

package/dist/esm/mongodbclient.d.ts

@@ -1,16 +1,11 @@
-/*!
- * @license mongodbclient
- * (c) 2020 tom
- * License: MIT
- */
-import type { Db, Collection, CollStats, DeleteResult, Document, InsertManyResult, UpdateResult, WithId } from "mongodb";
-declare const MongoClient: any;
+import type { Db, Collection, DeleteResult, Document, InsertManyResult, UpdateResult, WithId } from "mongodb";
+import { MongoClient } from "mongodb";
 export declare class MongoConnection {
     private readonly _client;
     private readonly _db;
     private readonly _collection;
-    constructor(client: typeof MongoClient, db: Db, collection: Collection);
-    get client(): typeof MongoClient;
+    constructor(client: MongoClient, db: Db, collection: Collection);
+    get client(): MongoClient;
     get db(): Db;
     get collection(): Collection;
 }
@@ -28,7 +23,7 @@ export declare class MClient {
     read(condition?: any, opt?: any): Promise<Array<WithId<Document>>>;
     distinct(key: string, condition?: any): Promise<any[]>;
     remove(condition: any): Promise<DeleteResult>;
-    stats(): Promise<CollStats>;
+    stats(): Promise<Document | null>;
     count(condition?: any): Promise<number>;
     insertMany(items: any[]): Promise<InsertManyResult<Document>>;
     dbStats(): Promise<Document>;

package/dist/esm/mongodbclient.js

@@ -8,8 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { v4 as uuidv4 } from "uuid";
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const MongoClient = require("mongodb").MongoClient;
+import { MongoClient, ServerApiVersion } from "mongodb";
 export class MongoConnection {
     constructor(client, db, collection) {
         this._client = client;
@@ -48,11 +47,12 @@ export class MClient {
     }
     getConnected() {
         return __awaiter(this, void 0, void 0, function* () {
-            const client = new MongoClient(this.m_uri, { useUnifiedTopology: true });
-            return client.connect().then((client) => {
+            const client = new MongoClient(this.m_uri, {
+                serverApi: ServerApiVersion.v1,
+            });
+            return yield client.connect().then((client) => {
                 const db = client.db(this.m_db);
                 const collection = db.collection(this.m_collection);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return new MongoConnection(client, db, collection);
             });
         });
@@ -65,7 +65,7 @@ export class MClient {
                 return yield connection.collection.updateOne({ _id: savingObj._id }, { $set: savingObj }, { upsert: true, writeConcern: { w: 1 } });
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -73,11 +73,12 @@ export class MClient {
         return __awaiter(this, arguments, void 0, function* (condition = {}, opt) {
             const connection = yield this.getConnected();
             try {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                return yield connection.collection.find(condition, opt).toArray();
+                return yield connection.collection
+                    .find(condition, opt)
+                    .toArray();
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -85,13 +86,10 @@ export class MClient {
         return __awaiter(this, arguments, void 0, function* (key, condition = {}) {
             const connection = yield this.getConnected();
             try {
-                // eslint-disable-next-line
-                return (yield connection.collection.distinct(key, 
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                condition));
+                return (yield connection.collection.distinct(key, condition));
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -99,13 +97,12 @@ export class MClient {
         return __awaiter(this, void 0, void 0, function* () {
             const connection = yield this.getConnected();
             try {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                 return yield connection.collection.deleteMany(condition, {
                     writeConcern: { w: 1 },
                 });
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -113,10 +110,29 @@ export class MClient {
         return __awaiter(this, void 0, void 0, function* () {
             const connection = yield this.getConnected();
             try {
-                return yield connection.collection.stats();
+                const [collStats] = yield connection.collection
+                    .aggregate([
+                    {
+                        $collStats: {
+                            latencyStats: {
+                                histograms: true,
+                            },
+                            count: {},
+                            queryExecStats: {},
+                            storageStats: {
+                                scale: 1,
+                            },
+                        },
+                    },
+                ])
+                    .toArray();
+                return collStats;
+            }
+            catch (e) {
+                return null;
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -124,13 +140,10 @@ export class MClient {
         return __awaiter(this, arguments, void 0, function* (condition = {}) {
             const connection = yield this.getConnected();
             try {
-                // eslint-disable-next-line
-                return (yield connection.collection.countDocuments(
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                condition));
+                return (yield connection.collection.countDocuments(condition));
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -139,13 +152,12 @@ export class MClient {
             const connection = yield this.getConnected();
             const savingItems = items.map((item) => (Object.assign({ _id: uuidv4() }, item)));
             try {
-                // eslint-disable-next-line
                 return yield connection.collection.insertMany(savingItems, {
                     writeConcern: { w: 1 },
                 });
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -156,7 +168,7 @@ export class MClient {
                 return yield connection.db.stats();
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }
@@ -167,7 +179,7 @@ export class MClient {
                 return yield connection.db.collections();
             }
             finally {
-                connection.client.close();
+                yield connection.client.close();
             }
         });
     }

package/dist/mongodbclient.cjs.js

@@ -25,7 +25,7 @@ __export(mongodbclient_exports, {
 });
 module.exports = __toCommonJS(mongodbclient_exports);
 var import_uuid = require("uuid");
-var MongoClient = require("mongodb").MongoClient;
+var import_mongodb = require("mongodb");
 var MongoConnection = class {
   _client;
   _db;
@@ -67,8 +67,10 @@ var MClient = class {
     return await this.getConnected();
   }
   async getConnected() {
-    const client = new MongoClient(this.m_uri, { useUnifiedTopology: true });
-    return client.connect().then((client2) => {
+    const client = new import_mongodb.MongoClient(this.m_uri, {
+      serverApi: import_mongodb.ServerApiVersion.v1
+    });
+    return await client.connect().then((client2) => {
       const db = client2.db(this.m_db);
       const collection = db.collection(this.m_collection);
       return new MongoConnection(client2, db, collection);
@@ -87,15 +89,18 @@ var MClient = class {
         { upsert: true, writeConcern: { w: 1 } }
       );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async read(condition = {}, opt) {
     const connection = await this.getConnected();
     try {
-      return await connection.collection.find(condition, opt).toArray();
+      return await connection.collection.find(
+        condition,
+        opt
+      ).toArray();
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async distinct(key, condition = {}) {
@@ -103,40 +108,57 @@ var MClient = class {
     try {
       return await connection.collection.distinct(
         key,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         condition
       );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async remove(condition) {
     const connection = await this.getConnected();
     try {
-      return await connection.collection.deleteMany(condition, {
-        writeConcern: { w: 1 }
-      });
+      return await connection.collection.deleteMany(
+        condition,
+        {
+          writeConcern: { w: 1 }
+        }
+      );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async stats() {
     const connection = await this.getConnected();
     try {
-      return await connection.collection.stats();
+      const [collStats] = await connection.collection.aggregate([
+        {
+          $collStats: {
+            latencyStats: {
+              histograms: true
+            },
+            count: {},
+            queryExecStats: {},
+            storageStats: {
+              scale: 1
+            }
+          }
+        }
+      ]).toArray();
+      return collStats;
+    } catch (e) {
+      return null;
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async count(condition = {}) {
     const connection = await this.getConnected();
     try {
       return await connection.collection.countDocuments(
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         condition
       );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async insertMany(items) {
@@ -146,11 +168,14 @@ var MClient = class {
       ...item
     }));
     try {
-      return await connection.collection.insertMany(savingItems, {
-        writeConcern: { w: 1 }
-      });
+      return await connection.collection.insertMany(
+        savingItems,
+        {
+          writeConcern: { w: 1 }
+        }
+      );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async dbStats() {
@@ -158,7 +183,7 @@ var MClient = class {
     try {
       return await connection.db.stats();
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async getCollections() {
@@ -166,7 +191,7 @@ var MClient = class {
     try {
       return await connection.db.collections();
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
 };
@@ -176,8 +201,3 @@ var mongodbclient_default = MClient;
   MClient,
   MongoConnection
 });
-/*!
- * @license mongodbclient
- * (c) 2020 tom
- * License: MIT
- */

package/dist/mongodbclient.esm.js

@@ -1,14 +1,6 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/mongodbclient.ts
 import { v4 as uuidv4 } from "uuid";
-var MongoClient = __require("mongodb").MongoClient;
+import { MongoClient, ServerApiVersion } from "mongodb";
 var MongoConnection = class {
   _client;
   _db;
@@ -50,8 +42,10 @@ var MClient = class {
     return await this.getConnected();
   }
   async getConnected() {
-    const client = new MongoClient(this.m_uri, { useUnifiedTopology: true });
-    return client.connect().then((client2) => {
+    const client = new MongoClient(this.m_uri, {
+      serverApi: ServerApiVersion.v1
+    });
+    return await client.connect().then((client2) => {
       const db = client2.db(this.m_db);
       const collection = db.collection(this.m_collection);
       return new MongoConnection(client2, db, collection);
@@ -70,15 +64,18 @@ var MClient = class {
         { upsert: true, writeConcern: { w: 1 } }
       );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async read(condition = {}, opt) {
     const connection = await this.getConnected();
     try {
-      return await connection.collection.find(condition, opt).toArray();
+      return await connection.collection.find(
+        condition,
+        opt
+      ).toArray();
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async distinct(key, condition = {}) {
@@ -86,40 +83,57 @@ var MClient = class {
     try {
       return await connection.collection.distinct(
         key,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         condition
       );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async remove(condition) {
     const connection = await this.getConnected();
     try {
-      return await connection.collection.deleteMany(condition, {
-        writeConcern: { w: 1 }
-      });
+      return await connection.collection.deleteMany(
+        condition,
+        {
+          writeConcern: { w: 1 }
+        }
+      );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async stats() {
     const connection = await this.getConnected();
     try {
-      return await connection.collection.stats();
+      const [collStats] = await connection.collection.aggregate([
+        {
+          $collStats: {
+            latencyStats: {
+              histograms: true
+            },
+            count: {},
+            queryExecStats: {},
+            storageStats: {
+              scale: 1
+            }
+          }
+        }
+      ]).toArray();
+      return collStats;
+    } catch (e) {
+      return null;
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async count(condition = {}) {
     const connection = await this.getConnected();
     try {
       return await connection.collection.countDocuments(
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         condition
       );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async insertMany(items) {
@@ -129,11 +143,14 @@ var MClient = class {
       ...item
     }));
     try {
-      return await connection.collection.insertMany(savingItems, {
-        writeConcern: { w: 1 }
-      });
+      return await connection.collection.insertMany(
+        savingItems,
+        {
+          writeConcern: { w: 1 }
+        }
+      );
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async dbStats() {
@@ -141,7 +158,7 @@ var MClient = class {
     try {
       return await connection.db.stats();
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
   async getCollections() {
@@ -149,7 +166,7 @@ var MClient = class {
     try {
       return await connection.db.collections();
     } finally {
-      connection.client.close();
+      await connection.client.close();
     }
   }
 };
@@ -159,8 +176,3 @@ export {
   MongoConnection,
   mongodbclient_default as default
 };
-/*!
- * @license mongodbclient
- * (c) 2020 tom
- * License: MIT
- */

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@tomsd/mongodbclient",
-  "version": "3.0.13",
+  "version": "4.0.0",
   "description": "It's a handy mongodb client for easy-use.",
   "main": "dist/mongodbclient.cjs.js",
   "module": "dist/mongodbclient.esm.js",
   "types": "dist/esm/mongodbclient.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup && tsc --project tsconfig.esm.json",
     "format": "npm run format:src && npm run format:test",
@@ -40,7 +43,7 @@
     "url": "https://github.com/tomsdoo/mongodbclient"
   },
   "dependencies": {
-    "mongodb": "4.7.0",
+    "mongodb": "6.6.2",
     "uuid": "9.0.1"
   },
   "devDependencies": {

package/.eslintrc-love-temp.cjs

@@ -1,416 +0,0 @@
-const rules = {
-  '@typescript-eslint/adjacent-overload-signatures': ['error'],
-  '@typescript-eslint/array-type': ['error', { default: 'array-simple' }],
-  '@typescript-eslint/await-thenable': ['error'],
-  '@typescript-eslint/ban-ts-comment': ['error', {
-    'ts-expect-error': 'allow-with-description',
-    'ts-ignore': true,
-    'ts-nocheck': true,
-    'ts-check': false,
-    minimumDescriptionLength: 3
-  }],
-  '@typescript-eslint/ban-tslint-comment': ['error'],
-  '@typescript-eslint/ban-types': ['error', {
-    extendDefaults: false,
-    types: {
-      String: {
-        message: 'Use string instead',
-        fixWith: 'string'
-      },
-      Boolean: {
-        message: 'Use boolean instead',
-        fixWith: 'boolean'
-      },
-      Number: {
-        message: 'Use number instead',
-        fixWith: 'number'
-      },
-      Symbol: {
-        message: 'Use symbol instead',
-        fixWith: 'symbol'
-      },
-      BigInt: {
-        message: 'Use bigint instead',
-        fixWith: 'bigint'
-      },
-      Function: {
-        message: [
-          'The `Function` type accepts any function-like value.',
-          'It provides no type safety when calling the function, which can be a common source of bugs.',
-          'It also accepts things like class declarations, which will throw at runtime as they will not be called with `new`.',
-          'If you are expecting the function to accept certain arguments, you should explicitly define the function shape.'
-        ].join('\n')
-      },
-      // object typing
-      Object: {
-        message: [
-          'The `Object` type actually means "any non-nullish value", so it is marginally better than `unknown`.',
-          '- If you want a type meaning "any object", you probably want `Record<string, unknown>` instead.',
-          '- If you want a type meaning "any value", you probably want `unknown` instead.'
-        ].join('\n')
-      },
-      '{}': {
-        message: [
-          '`{}` actually means "any non-nullish value".',
-          '- If you want a type meaning "any object", you probably want `Record<string, unknown>` instead.',
-          '- If you want a type meaning "any value", you probably want `unknown` instead.'
-        ].join('\n')
-      }
-    }
-  }],
-  '@typescript-eslint/block-spacing': ['error', 'always'],
-  '@typescript-eslint/brace-style': ['error', '1tbs', { allowSingleLine: true }],
-  '@typescript-eslint/class-literal-property-style': ['error', 'fields'],
-  '@typescript-eslint/comma-dangle': ['error', {
-    arrays: 'never',
-    objects: 'never',
-    imports: 'never',
-    exports: 'never',
-    functions: 'never',
-    enums: 'ignore',
-    generics: 'ignore',
-    tuples: 'ignore'
-  }],
-  '@typescript-eslint/comma-spacing': ['error', { before: false, after: true }],
-  '@typescript-eslint/consistent-generic-constructors': ['error', 'constructor'],
-  '@typescript-eslint/consistent-indexed-object-style': ['error', 'record'],
-  '@typescript-eslint/consistent-type-assertions': [
-    'error',
-    {
-      assertionStyle: 'as',
-      objectLiteralTypeAssertions: 'never'
-    }
-  ],
-  '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
-  '@typescript-eslint/consistent-type-exports': ['error', {
-    fixMixedExportsWithInlineTypeSpecifier: true
-  }],
-  '@typescript-eslint/consistent-type-imports': ['error', {
-    prefer: 'type-imports',
-    disallowTypeAnnotations: true,
-    fixStyle: 'inline-type-imports'
-  }],
-  '@typescript-eslint/dot-notation': ['error',
-    {
-      allowIndexSignaturePropertyAccess: false,
-      allowKeywords: true,
-      allowPattern: '',
-      allowPrivateClassPropertyAccess: false,
-      allowProtectedClassPropertyAccess: false
-    }
-  ],
-  '@typescript-eslint/explicit-function-return-type': ['error', {
-    allowExpressions: true,
-    allowHigherOrderFunctions: true,
-    allowTypedFunctionExpressions: true,
-    allowDirectConstAssertionInArrowFunctions: true
-  }],
-  '@typescript-eslint/func-call-spacing': ['error', 'never'],
-  '@typescript-eslint/indent': ['error', 2, {
-    SwitchCase: 1,
-    VariableDeclarator: 1,
-    outerIIFEBody: 1,
-    MemberExpression: 1,
-    FunctionDeclaration: { parameters: 1, body: 1 },
-    FunctionExpression: { parameters: 1, body: 1 },
-    CallExpression: { arguments: 1 },
-    ArrayExpression: 1,
-    ObjectExpression: 1,
-    ImportDeclaration: 1,
-    flatTernaryExpressions: false,
-    ignoreComments: false,
-    ignoredNodes: [
-      'TemplateLiteral *',
-      'JSXElement',
-      'JSXElement > *',
-      'JSXAttribute',
-      'JSXIdentifier',
-      'JSXNamespacedName',
-      'JSXMemberExpression',
-      'JSXSpreadAttribute',
-      'JSXExpressionContainer',
-      'JSXOpeningElement',
-      'JSXClosingElement',
-      'JSXFragment',
-      'JSXOpeningFragment',
-      'JSXClosingFragment',
-      'JSXText',
-      'JSXEmptyExpression',
-      'JSXSpreadChild'
-    ],
-    offsetTernaryExpressions: true
-  }],
-  '@typescript-eslint/key-spacing': ['error', { beforeColon: false, afterColon: true }],
-  '@typescript-eslint/keyword-spacing': ['error', { before: true, after: true }],
-  '@typescript-eslint/lines-between-class-members': ['error', 'always', { exceptAfterOverload: true, exceptAfterSingleLine: true }],
-  '@typescript-eslint/member-delimiter-style': [
-    'error',
-    {
-      multiline: { delimiter: 'none' },
-      singleline: { delimiter: 'comma', requireLast: false }
-    }
-  ],
-  '@typescript-eslint/method-signature-style': ['error'],
-  '@typescript-eslint/naming-convention': ['error', {
-    selector: 'variableLike',
-    leadingUnderscore: 'allow',
-    trailingUnderscore: 'allow',
-    format: ['camelCase', 'PascalCase', 'UPPER_CASE']
-  }],
-  '@typescript-eslint/no-array-constructor': ['error'],
-  '@typescript-eslint/no-base-to-string': ['error'],
-  '@typescript-eslint/no-confusing-void-expression': ['error', { ignoreArrowShorthand: false, ignoreVoidOperator: false }],
-  '@typescript-eslint/no-dupe-class-members': ['error'],
-  '@typescript-eslint/no-dynamic-delete': ['error'],
-  '@typescript-eslint/no-empty-interface': ['error', { allowSingleExtends: true }],
-  '@typescript-eslint/no-extra-non-null-assertion': ['error'],
-  '@typescript-eslint/no-extra-parens': ['error', 'functions'],
-  '@typescript-eslint/no-extraneous-class': ['error', { allowWithDecorator: true }],
-  '@typescript-eslint/no-floating-promises': ['error'],
-  '@typescript-eslint/no-for-in-array': ['error'],
-  '@typescript-eslint/no-implied-eval': ['error'],
-  '@typescript-eslint/no-invalid-void-type': ['error'],
-  '@typescript-eslint/no-loss-of-precision': ['error'],
-  '@typescript-eslint/no-misused-new': ['error'],
-  '@typescript-eslint/no-misused-promises': ['error'],
-  '@typescript-eslint/no-namespace': ['error'],
-  '@typescript-eslint/no-non-null-asserted-optional-chain': ['error'],
-  '@typescript-eslint/no-non-null-assertion': ['error'],
-  '@typescript-eslint/no-redeclare': ['error', { builtinGlobals: false }],
-  '@typescript-eslint/no-this-alias': ['error', { allowDestructuring: true }],
-  '@typescript-eslint/no-throw-literal': ['error'],
-  '@typescript-eslint/no-unnecessary-boolean-literal-compare': ['error'],
-  '@typescript-eslint/no-unnecessary-type-assertion': ['error'],
-  '@typescript-eslint/no-unnecessary-type-constraint': ['error'],
-  '@typescript-eslint/no-unsafe-argument': ['error'],
-  '@typescript-eslint/no-unused-expressions': ['error', {
-    allowShortCircuit: true,
-    allowTernary: true,
-    allowTaggedTemplates: true,
-    enforceForJSX: false
-  }],
-  '@typescript-eslint/no-unused-vars': ['error', {
-    args: 'none',
-    caughtErrors: 'none',
-    ignoreRestSiblings: true,
-    vars: 'all'
-  }],
-  '@typescript-eslint/no-use-before-define': ['error', {
-    functions: false,
-    classes: false,
-    enums: false,
-    variables: false,
-    typedefs: false
-  }],
-  '@typescript-eslint/no-useless-constructor': ['error'],
-  '@typescript-eslint/no-var-requires': ['error'],
-  '@typescript-eslint/non-nullable-type-assertion-style': ['error'],
-  '@typescript-eslint/object-curly-spacing': ['error', 'always'],
-  '@typescript-eslint/prefer-function-type': ['error'],
-  '@typescript-eslint/prefer-includes': ['error'],
-  '@typescript-eslint/prefer-nullish-coalescing': ['error', { ignoreConditionalTests: false, ignoreMixedLogicalExpressions: false }],
-  '@typescript-eslint/prefer-optional-chain': ['error'],
-  '@typescript-eslint/prefer-promise-reject-errors': ['error'],
-  '@typescript-eslint/prefer-readonly': ['error'],
-  '@typescript-eslint/prefer-reduce-type-parameter': ['error'],
-  '@typescript-eslint/prefer-return-this-type': ['error'],
-  '@typescript-eslint/prefer-ts-expect-error': ['error'],
-  '@typescript-eslint/promise-function-async': ['error'],
-  '@typescript-eslint/quotes': ['error', 'single', { avoidEscape: true, allowTemplateLiterals: false }],
-  '@typescript-eslint/require-array-sort-compare': ['error', { ignoreStringArrays: true }],
-  '@typescript-eslint/restrict-plus-operands': ['error', { skipCompoundAssignments: false }],
-  '@typescript-eslint/restrict-template-expressions': ['error', { allowNumber: true }],
-  '@typescript-eslint/return-await': ['error', 'always'],
-  '@typescript-eslint/semi': ['error', 'never'],
-  '@typescript-eslint/space-before-blocks': ['error', 'always'],
-  '@typescript-eslint/space-before-function-paren': ['error', 'always'],
-  '@typescript-eslint/space-infix-ops': ['error'],
-  '@typescript-eslint/strict-boolean-expressions': ['error', {
-    allowString: false,
-    allowNumber: false,
-    allowNullableObject: false,
-    allowNullableBoolean: false,
-    allowNullableString: false,
-    allowNullableNumber: false,
-    allowAny: false
-  }],
-  '@typescript-eslint/triple-slash-reference': ['error', { lib: 'never', path: 'never', types: 'never' }],
-  '@typescript-eslint/type-annotation-spacing': ['error'],
-  '@typescript-eslint/unbound-method': ['error', { ignoreStatic: false }],
-
-  'accessor-pairs': ['error', { setWithoutGet: true, getWithoutSet: false, enforceForClassMembers: true }],
-  'array-bracket-spacing': ['error', 'never'],
-  'array-callback-return': ['error', {
-    allowImplicit: false,
-    allowVoid: false,
-    checkForEach: false
-  }],
-  'arrow-spacing': ['error', { before: true, after: true }],
-  'comma-style': ['error', 'last'],
-  'computed-property-spacing': ['error', 'never', { enforceForClassMembers: true }],
-  'constructor-super': ['error'],
-  curly: ['error', 'multi-line'],
-  'default-case-last': ['error'],
-  'dot-location': ['error', 'property'],
-  'eol-last': ['error'],
-  eqeqeq: ['error', 'always', { null: 'ignore' }],
-  'generator-star-spacing': ['error', { before: true, after: true }],
-  'multiline-ternary': ['error', 'always-multiline'],
-  'new-cap': ['error', { newIsCap: true, capIsNew: false, properties: true }],
-  'new-parens': ['error'],
-  'no-async-promise-executor': ['error'],
-  'no-caller': ['error'],
-  'no-case-declarations': ['error'],
-  'no-class-assign': ['error'],
-  'no-compare-neg-zero': ['error'],
-  'no-cond-assign': ['error'],
-  'no-const-assign': ['error'],
-  'no-constant-condition': ['error', { checkLoops: false }],
-  'no-control-regex': ['error'],
-  'no-debugger': ['error'],
-  'no-delete-var': ['error'],
-  'no-dupe-args': ['error'],
-  'no-dupe-keys': ['error'],
-  'no-duplicate-case': ['error'],
-  'no-useless-backreference': ['error'],
-  'no-empty': ['error', { allowEmptyCatch: true }],
-  'no-empty-character-class': ['error'],
-  'no-empty-pattern': ['error'],
-  'no-eval': ['error'],
-  'no-ex-assign': ['error'],
-  'no-extend-native': ['error'],
-  'no-extra-bind': ['error'],
-  'no-extra-boolean-cast': ['error'],
-  'no-fallthrough': ['error'],
-  'no-floating-decimal': ['error'],
-  'no-func-assign': ['error'],
-  'no-global-assign': ['error'],
-  'no-import-assign': ['error'],
-  'no-invalid-regexp': ['error'],
-  'no-irregular-whitespace': ['error'],
-  'no-iterator': ['error'],
-  'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
-  'no-lone-blocks': ['error'],
-  'no-misleading-character-class': ['error'],
-  'no-prototype-builtins': ['error'],
-  'no-useless-catch': ['error'],
-  'no-mixed-operators': ['error', {
-    groups: [
-      ['==', '!=', '===', '!==', '>', '>=', '<', '<='],
-      ['&&', '||'],
-      ['in', 'instanceof']
-    ],
-    allowSamePrecedence: true
-  }],
-  'no-mixed-spaces-and-tabs': ['error'],
-  'no-multi-spaces': ['error'],
-  'no-multi-str': ['error'],
-  'no-multiple-empty-lines': ['error', { max: 1, maxBOF: 0, maxEOF: 0 }],
-  'no-new': ['error'],
-  'no-new-func': ['error'],
-  'no-new-object': ['error'],
-  'no-new-symbol': ['error'],
-  'no-new-wrappers': ['error'],
-  'no-obj-calls': ['error'],
-  'no-octal': ['error'],
-  'no-octal-escape': ['error'],
-  'no-proto': ['error'],
-  'no-regex-spaces': ['error'],
-  'no-return-assign': ['error', 'except-parens'],
-  'no-self-assign': ['error', { props: true }],
-  'no-self-compare': ['error'],
-  'no-sequences': ['error'],
-  'no-shadow-restricted-names': ['error'],
-  'no-sparse-arrays': ['error'],
-  'no-tabs': ['error'],
-  'no-template-curly-in-string': ['error'],
-  'no-this-before-super': ['error'],
-  'no-trailing-spaces': ['error'],
-  'no-undef-init': ['error'],
-  'no-unexpected-multiline': ['error'],
-  'no-unmodified-loop-condition': ['error'],
-  'no-unneeded-ternary': ['error', { defaultAssignment: false }],
-  'no-unreachable': ['error'],
-  'no-unreachable-loop': ['error'],
-  'no-unsafe-finally': ['error'],
-  'no-unsafe-negation': ['error'],
-  'no-useless-call': ['error'],
-  'no-useless-computed-key': ['error'],
-  'no-useless-escape': ['error'],
-  'no-useless-rename': ['error'],
-  'no-useless-return': ['error'],
-  'no-var': ['warn'],
-  'no-void': ['error', { allowAsStatement: true }],
-  'no-whitespace-before-property': ['error'],
-  'no-with': ['error'],
-  'object-curly-newline': ['error', { multiline: true, consistent: true }],
-  'object-property-newline': ['error', { allowMultiplePropertiesPerLine: true, allowAllPropertiesOnSameLine: false }],
-  'object-shorthand': ['warn', 'properties'],
-  'one-var': ['error', { initialized: 'never' }],
-  'operator-linebreak': ['error', 'after', { overrides: { '?': 'before', ':': 'before', '|>': 'before' } }],
-  'padded-blocks': ['error', { blocks: 'never', switches: 'never', classes: 'never' }],
-  'prefer-const': ['error', { destructuring: 'all', ignoreReadBeforeAssign: false }],
-  'prefer-regex-literals': ['error', { disallowRedundantWrapping: true }],
-  'quote-props': ['error', 'as-needed'],
-  'rest-spread-spacing': ['error', 'never'],
-  'semi-spacing': ['error', { before: false, after: true }],
-  'space-in-parens': ['error', 'never'],
-  'space-unary-ops': ['error', { words: true, nonwords: false }],
-  'spaced-comment': ['error', 'always', {
-    line: { markers: ['*package', '!', '/', ',', '='] },
-    block: { balanced: true, markers: ['*package', '!', ',', ':', '::', 'flow-include'], exceptions: ['*'] }
-  }],
-  'symbol-description': ['error'],
-  'template-curly-spacing': ['error', 'never'],
-  'template-tag-spacing': ['error', 'never'],
-  'unicode-bom': ['error', 'never'],
-  'use-isnan': ['error', {
-    enforceForSwitchCase: true,
-    enforceForIndexOf: true
-  }],
-  'valid-typeof': ['error', { requireStringLiterals: true }],
-  'wrap-iife': ['error', 'any', { functionPrototypeMethods: true }],
-  'yield-star-spacing': ['error', 'both'],
-  yoda: ['error', 'never'],
-
-  'import/export': ['error'],
-  'import/first': ['error'],
-  'import/no-absolute-path': ['error', { esmodule: true, commonjs: true, amd: false }],
-  'import/no-duplicates': ['error'],
-  'import/no-named-default': ['error'],
-  'import/no-webpack-loader-syntax': ['error'],
-
-  'n/handle-callback-err': ['error', '^(err|error)$'],
-  'n/no-callback-literal': ['error'],
-  'n/no-deprecated-api': ['error'],
-  'n/no-exports-assign': ['error'],
-  'n/no-new-require': ['error'],
-  'n/no-path-concat': ['error'],
-  'n/process-exit-as-throw': ['error'],
-
-  'promise/param-names': ['error']
-}
-
-// const eslintRuleNames = [...(new TSESLint.Linter()).getRules().keys()]
-// const namesOfEslintRulesForWhichWeAreUsingTsEquivalents = eslintRuleNames
-//   .filter(name => Object.hasOwn(rules, `@typescript-eslint/${name}`))
-
-const config = {
-  plugins: [
-    '@typescript-eslint',
-    'import',
-    'n',
-    'promise'
-  ],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    project: true
-  },
-  rules: {
-    // ...Object.fromEntries(namesOfEslintRulesForWhichWeAreUsingTsEquivalents.map(name => [name, ['off']])),
-    ...rules
-  }
-
-}
-
-module.exports = config;

package/.eslintrc.json

@@ -1,17 +0,0 @@
-{
-  "env": {
-    "es2021": true,
-    "node": true
-  },
-  "extends": [
-    "./.eslintrc-love-temp.cjs",
-    "prettier"
-  ],
-  "overrides": [],
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module",
-    "project": "./tsconfig.base.json"
-  },
-  "rules": {}
-}

package/tsup.config.js

@@ -1,12 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/mongodbclient.ts"],
-  clean: true,
-  format: ["esm","cjs"],
-  outExtension({ format }) {
-    return {
-      js: `.${format}.js`,
-    };
-  },
-});