@tomsd/mongodbclient 3.0.12 → 3.0.14

package/README.md

@@ -7,7 +7,7 @@ See [mongodbclient.netlify.app](https://mongodbclient.netlify.app/) for details.
 ![NPM](https://img.shields.io/npm/l/@tomsd/mongodbclient)
 ![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/2023)
+![Maintenance](https://img.shields.io/maintenance/yes/2024)
 ![depends on mongodb@4](https://img.shields.io/badge/depends%20on-mongodb@4-informational)
 
 ## Installation

package/dist/esm/mongodbclient.d.ts

@@ -3,7 +3,7 @@
  * (c) 2020 tom
  * License: MIT
  */
-import { Db, Collection, CollStats, DeleteResult, Document, InsertManyResult, UpdateResult, WithId } from "mongodb";
+import type { Db, Collection, CollStats, DeleteResult, Document, InsertManyResult, UpdateResult, WithId } from "mongodb";
 declare const MongoClient: any;
 export declare class MongoConnection {
     private readonly _client;

package/dist/esm/mongodbclient.js

@@ -52,6 +52,7 @@ export class MClient {
             return 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);
             });
         });
@@ -68,10 +69,11 @@ export class MClient {
             }
         });
     }
-    read(condition = {}, opt) {
-        return __awaiter(this, void 0, void 0, function* () {
+    read() {
+        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();
             }
             finally {
@@ -79,11 +81,14 @@ export class MClient {
             }
         });
     }
-    distinct(key, condition = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    distinct(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, condition = {}) {
             const connection = yield this.getConnected();
             try {
-                return (yield connection.collection.distinct(key, condition));
+                // eslint-disable-next-line
+                return (yield connection.collection.distinct(key, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                condition));
             }
             finally {
                 connection.client.close();
@@ -94,6 +99,7 @@ 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 },
                 });
@@ -114,11 +120,14 @@ export class MClient {
             }
         });
     }
-    count(condition = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
+    count() {
+        return __awaiter(this, arguments, void 0, function* (condition = {}) {
             const connection = yield this.getConnected();
             try {
-                return (yield connection.collection.countDocuments(condition));
+                // eslint-disable-next-line
+                return (yield connection.collection.countDocuments(
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                condition));
             }
             finally {
                 connection.client.close();
@@ -130,6 +139,7 @@ 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 },
                 });

package/dist/mongodbclient.cjs.js

@@ -0,0 +1,183 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mongodbclient.ts
+var mongodbclient_exports = {};
+__export(mongodbclient_exports, {
+  MClient: () => MClient,
+  MongoConnection: () => MongoConnection,
+  default: () => mongodbclient_default
+});
+module.exports = __toCommonJS(mongodbclient_exports);
+var import_uuid = require("uuid");
+var MongoClient = require("mongodb").MongoClient;
+var MongoConnection = class {
+  _client;
+  _db;
+  _collection;
+  constructor(client, db, collection) {
+    this._client = client;
+    this._db = db;
+    this._collection = collection;
+  }
+  get client() {
+    return this._client;
+  }
+  get db() {
+    return this._db;
+  }
+  get collection() {
+    return this._collection;
+  }
+};
+var MClient = class {
+  m_uri;
+  m_db;
+  m_collection;
+  constructor(uri, db, collection) {
+    this.m_uri = uri;
+    this.m_db = db;
+    this.m_collection = collection;
+  }
+  get uri() {
+    return this.m_uri;
+  }
+  get db() {
+    return this.m_db;
+  }
+  get collection() {
+    return this.m_collection;
+  }
+  async connect() {
+    return await this.getConnected();
+  }
+  async getConnected() {
+    const client = new MongoClient(this.m_uri, { useUnifiedTopology: true });
+    return client.connect().then((client2) => {
+      const db = client2.db(this.m_db);
+      const collection = db.collection(this.m_collection);
+      return new MongoConnection(client2, db, collection);
+    });
+  }
+  async upsert(pobj) {
+    const savingObj = {
+      _id: (0, import_uuid.v4)(),
+      ...pobj
+    };
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.updateOne(
+        { _id: savingObj._id },
+        { $set: savingObj },
+        { upsert: true, writeConcern: { w: 1 } }
+      );
+    } finally {
+      connection.client.close();
+    }
+  }
+  async read(condition = {}, opt) {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.find(condition, opt).toArray();
+    } finally {
+      connection.client.close();
+    }
+  }
+  async distinct(key, condition = {}) {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.distinct(
+        key,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        condition
+      );
+    } finally {
+      connection.client.close();
+    }
+  }
+  async remove(condition) {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.deleteMany(condition, {
+        writeConcern: { w: 1 }
+      });
+    } finally {
+      connection.client.close();
+    }
+  }
+  async stats() {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.stats();
+    } finally {
+      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();
+    }
+  }
+  async insertMany(items) {
+    const connection = await this.getConnected();
+    const savingItems = items.map((item) => ({
+      _id: (0, import_uuid.v4)(),
+      ...item
+    }));
+    try {
+      return await connection.collection.insertMany(savingItems, {
+        writeConcern: { w: 1 }
+      });
+    } finally {
+      connection.client.close();
+    }
+  }
+  async dbStats() {
+    const connection = await this.getConnected();
+    try {
+      return await connection.db.stats();
+    } finally {
+      connection.client.close();
+    }
+  }
+  async getCollections() {
+    const connection = await this.getConnected();
+    try {
+      return await connection.db.collections();
+    } finally {
+      connection.client.close();
+    }
+  }
+};
+var mongodbclient_default = MClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MClient,
+  MongoConnection
+});
+/*!
+ * @license mongodbclient
+ * (c) 2020 tom
+ * License: MIT
+ */

package/dist/mongodbclient.esm.js

@@ -0,0 +1,166 @@
+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;
+var MongoConnection = class {
+  _client;
+  _db;
+  _collection;
+  constructor(client, db, collection) {
+    this._client = client;
+    this._db = db;
+    this._collection = collection;
+  }
+  get client() {
+    return this._client;
+  }
+  get db() {
+    return this._db;
+  }
+  get collection() {
+    return this._collection;
+  }
+};
+var MClient = class {
+  m_uri;
+  m_db;
+  m_collection;
+  constructor(uri, db, collection) {
+    this.m_uri = uri;
+    this.m_db = db;
+    this.m_collection = collection;
+  }
+  get uri() {
+    return this.m_uri;
+  }
+  get db() {
+    return this.m_db;
+  }
+  get collection() {
+    return this.m_collection;
+  }
+  async connect() {
+    return await this.getConnected();
+  }
+  async getConnected() {
+    const client = new MongoClient(this.m_uri, { useUnifiedTopology: true });
+    return client.connect().then((client2) => {
+      const db = client2.db(this.m_db);
+      const collection = db.collection(this.m_collection);
+      return new MongoConnection(client2, db, collection);
+    });
+  }
+  async upsert(pobj) {
+    const savingObj = {
+      _id: uuidv4(),
+      ...pobj
+    };
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.updateOne(
+        { _id: savingObj._id },
+        { $set: savingObj },
+        { upsert: true, writeConcern: { w: 1 } }
+      );
+    } finally {
+      connection.client.close();
+    }
+  }
+  async read(condition = {}, opt) {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.find(condition, opt).toArray();
+    } finally {
+      connection.client.close();
+    }
+  }
+  async distinct(key, condition = {}) {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.distinct(
+        key,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        condition
+      );
+    } finally {
+      connection.client.close();
+    }
+  }
+  async remove(condition) {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.deleteMany(condition, {
+        writeConcern: { w: 1 }
+      });
+    } finally {
+      connection.client.close();
+    }
+  }
+  async stats() {
+    const connection = await this.getConnected();
+    try {
+      return await connection.collection.stats();
+    } finally {
+      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();
+    }
+  }
+  async insertMany(items) {
+    const connection = await this.getConnected();
+    const savingItems = items.map((item) => ({
+      _id: uuidv4(),
+      ...item
+    }));
+    try {
+      return await connection.collection.insertMany(savingItems, {
+        writeConcern: { w: 1 }
+      });
+    } finally {
+      connection.client.close();
+    }
+  }
+  async dbStats() {
+    const connection = await this.getConnected();
+    try {
+      return await connection.db.stats();
+    } finally {
+      connection.client.close();
+    }
+  }
+  async getCollections() {
+    const connection = await this.getConnected();
+    try {
+      return await connection.db.collections();
+    } finally {
+      connection.client.close();
+    }
+  }
+};
+var mongodbclient_default = MClient;
+export {
+  MClient,
+  MongoConnection,
+  mongodbclient_default as default
+};
+/*!
+ * @license mongodbclient
+ * (c) 2020 tom
+ * License: MIT
+ */

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "@tomsd/mongodbclient",
-  "version": "3.0.12",
+  "version": "3.0.14",
   "description": "It's a handy mongodb client for easy-use.",
-  "main": "dist/cjs/mongodbclient.js",
-  "module": "dist/esm/mongodbclient.js",
+  "main": "dist/mongodbclient.cjs.js",
+  "module": "dist/mongodbclient.esm.js",
   "types": "dist/esm/mongodbclient.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc --project tsconfig.cjs.json && tsc --project tsconfig.esm.json",
+    "build": "tsup && tsc --project tsconfig.esm.json",
     "format": "npm run format:src && npm run format:test",
     "format:document": "prettier --write docs/**/*.html",
     "format:src": "prettier --write src/**/*.ts",
-    "format:test": "prettier --write test/**/*.ts",
-    "lint:src": "eslint src/**/*.ts",
-    "lint:test": "eslint test/**/*.ts",
-    "prepare": "husky install",
+    "format:test": "prettier --write __test__/**/*.ts",
+    "lint:src": "ESLINT_USE_FLAT_CONFIG=false eslint src/**/*.ts",
+    "lint:test": "ESLINT_USE_FLAT_CONFIG=false eslint __test__/**/*.ts",
+    "prepare": "husky",
     "serve:doc": "mdbook --serve --directory docs",
-    "test": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register \"test/mclient.test.ts\" --timeout 30000",
-    "test_with_dburi": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register \"test/with_dburi.test.ts\" --timeout 30000"
+    "test": "vitest"
   },
   "lint-staged": {
     "docs/**/*.html": [
@@ -26,7 +28,7 @@
       "npm run lint:src",
       "npm run format:src"
     ],
-    "test/**/*.ts": [
+    "__test__/**/*.ts": [
       "npm run lint:test",
       "npm run format:test"
     ]
@@ -41,29 +43,25 @@
     "url": "https://github.com/tomsdoo/mongodbclient"
   },
   "dependencies": {
-    "mongodb": "^4.7.0",
-    "uuid": "^8.3.2"
+    "mongodb": "4.7.0",
+    "uuid": "9.0.1"
   },
   "devDependencies": {
-    "@tomsd/md-book": "^0.16.0",
-    "@types/mocha": "^9.1.1",
-    "@types/node": "^14.14.5",
-    "@types/sinon": "^10.0.13",
-    "@types/uuid": "^8.3.4",
-    "@typescript-eslint/eslint-plugin": "^5.38.0",
-    "dotenv": "^16.0.1",
-    "eslint": "^8.24.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-config-standard-with-typescript": "^23.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-n": "^15.3.0",
-    "eslint-plugin-promise": "^6.0.1",
-    "husky": "^8.0.1",
-    "lint-staged": "^13.0.3",
-    "mocha": "^7.2.0",
-    "prettier": "^2.7.1",
-    "sinon": "^14.0.0",
-    "ts-node": "^10.8.1",
-    "typescript": "^4.8.3"
+    "@tomsd/md-book": "1.2.0",
+    "@types/node": "20.12.12",
+    "@types/uuid": "9.0.8",
+    "@typescript-eslint/eslint-plugin": "7.9.0",
+    "dotenv": "16.4.5",
+    "eslint": "8.57.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-n": "17.7.0",
+    "eslint-plugin-promise": "6.1.1",
+    "husky": "9.0.11",
+    "lint-staged": "15.2.2",
+    "prettier": "3.2.5",
+    "tsup": "8.0.2",
+    "typescript": "5.4.5",
+    "vitest": "1.6.0"
   }
 }

package/dist/cjs/mongodbclient.js

@@ -1,170 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MClient = exports.MongoConnection = void 0;
-const uuid_1 = require("uuid");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const MongoClient = require("mongodb").MongoClient;
-class MongoConnection {
-    constructor(client, db, collection) {
-        this._client = client;
-        this._db = db;
-        this._collection = collection;
-    }
-    get client() {
-        return this._client;
-    }
-    get db() {
-        return this._db;
-    }
-    get collection() {
-        return this._collection;
-    }
-}
-exports.MongoConnection = MongoConnection;
-class MClient {
-    constructor(uri, db, collection) {
-        this.m_uri = uri;
-        this.m_db = db;
-        this.m_collection = collection;
-    }
-    get uri() {
-        return this.m_uri;
-    }
-    get db() {
-        return this.m_db;
-    }
-    get collection() {
-        return this.m_collection;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.getConnected();
-        });
-    }
-    getConnected() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const client = new MongoClient(this.m_uri, { useUnifiedTopology: true });
-            return client.connect().then((client) => {
-                const db = client.db(this.m_db);
-                const collection = db.collection(this.m_collection);
-                return new MongoConnection(client, db, collection);
-            });
-        });
-    }
-    upsert(pobj) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const savingObj = Object.assign({ _id: (0, uuid_1.v4)() }, pobj);
-            const connection = yield this.getConnected();
-            try {
-                return yield connection.collection.updateOne({ _id: savingObj._id }, { $set: savingObj }, { upsert: true, writeConcern: { w: 1 } });
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    read(condition = {}, opt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return yield connection.collection.find(condition, opt).toArray();
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    distinct(key, condition = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return (yield connection.collection.distinct(key, condition));
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    remove(condition) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return yield connection.collection.deleteMany(condition, {
-                    writeConcern: { w: 1 },
-                });
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    stats() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return yield connection.collection.stats();
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    count(condition = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return (yield connection.collection.countDocuments(condition));
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    insertMany(items) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            const savingItems = items.map((item) => (Object.assign({ _id: (0, uuid_1.v4)() }, item)));
-            try {
-                return yield connection.collection.insertMany(savingItems, {
-                    writeConcern: { w: 1 },
-                });
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    dbStats() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return yield connection.db.stats();
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-    getCollections() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.getConnected();
-            try {
-                return yield connection.db.collections();
-            }
-            finally {
-                connection.client.close();
-            }
-        });
-    }
-}
-exports.MClient = MClient;
-exports.default = MClient;