@tomsd/mongodbclient 2.0.1 → 2.2.0

package/dist/esm/mongodbclient.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * @license mongodbclient
+ * (c) 2020 tom
+ * License: MIT
+*/
+declare const MongoClient: any;
+declare const Db: any;
+export declare class MongoConnection {
+    private _client;
+    private _db;
+    private _collection;
+    constructor(client: typeof MongoClient, db: typeof Db, collection: any);
+    get client(): typeof MongoClient;
+    get db(): typeof Db;
+    get collection(): any;
+}
+export declare class MClient {
+    private m_uri;
+    private m_db;
+    private m_collection;
+    constructor(uri: string, db: string, collection: string);
+    get uri(): string;
+    get db(): string;
+    get collection(): string;
+    connect(): Promise<MongoConnection>;
+    protected getConnected(): Promise<MongoConnection>;
+    upsert(pobj: any): Promise<unknown>;
+    read(condition: any, opt?: any): Promise<unknown>;
+    distinct(key: string, condition: any): Promise<unknown>;
+    remove(condition: any): Promise<unknown>;
+    stats(): Promise<unknown>;
+    count(condition: any): Promise<number>;
+    insertMany(items: any[]): Promise<unknown>;
+    dbStats(): Promise<unknown>;
+    getCollections(): Promise<any[]>;
+}
+export default MClient;

package/dist/esm/mongodbclient.js

@@ -0,0 +1,218 @@
+/*!
+ * @license mongodbclient
+ * (c) 2020 tom
+ * License: MIT
+*/
+const MongoClient = require("mongodb").MongoClient;
+const Db = require("mongodb").Db;
+const { Collection, UpdateWriteOpResult, deleteWriteOpResult, insertWriteOpResult } = require("mongodb");
+const rand = require("@tomsd/rand").default;
+export 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;
+    }
+}
+export 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 this.getConnected();
+    }
+    getConnected() {
+        const that = this;
+        const client = new MongoClient(that.m_uri, { useUnifiedTopology: true });
+        return new Promise(function (resolve, reject) {
+            client.connect()
+                .then(function (client) {
+                const db = client.db(that.m_db);
+                const collection = db.collection(that.m_collection);
+                resolve(new MongoConnection(client, db, collection));
+            })
+                .catch(function (e) {
+                reject(e);
+            });
+        });
+    }
+    upsert(pobj) {
+        const that = this;
+        pobj._id = "_id" in pobj ? pobj._id : rand.id(rand.char());
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.updateOne({ _id: pobj._id }, { $set: pobj }, { upsert: true, writeConcern: { w: 1 } })
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+    read(condition, opt) {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.find(condition, opt)
+                    .toArray()
+                    .then(function (docs) {
+                    conn.client.close();
+                    resolve(docs);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            });
+        });
+    }
+    distinct(key, condition) {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.distinct(key, condition)
+                    .then(function (values) {
+                    conn.client.close();
+                    resolve(values);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            });
+        });
+    }
+    remove(condition) {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.deleteMany(condition, { writeConcern: { w: 1 } })
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+    stats() {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.stats()
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+    count(condition) {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.countDocuments(condition)
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+    insertMany(items) {
+        const that = this;
+        items.forEach(function (item) {
+            item._id = item._id ? item._id : rand.id(rand.char());
+        });
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.collection.insertMany(items, { writeConcern: { w: 1 } })
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+    dbStats() {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.db.stats()
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+    getCollections() {
+        const that = this;
+        return new Promise(function (resolve, reject) {
+            that.getConnected()
+                .then(function (conn) {
+                conn.db.collections()
+                    .then(function (r) {
+                    conn.client.close();
+                    resolve(r);
+                })
+                    .catch(function (e) {
+                    conn.client.close();
+                    reject(e);
+                });
+            }, reject);
+        });
+    }
+}
+export default MClient;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@tomsd/mongodbclient",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "",
-  "main": "dist/mongodbclient.js",
-  "types": "dist/mongodbclient.d.ts",
+  "main": "dist/cjs/mongodbclient.js",
+  "module": "dist/esm/mongodbclient.js",
+  "types": "dist/esm/mongodbclient.d.ts",
   "scripts": {
-    "build": "tsc --build tsconfig.json",
+    "build": "tsc --project tsconfig.cjs.json && tsc --project tsconfig.esm.json",
     "test": "exit 0",
-    "test_with_dburi": "mocha test/test.js --timeout 20000"
+    "test_with_dburi": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' mocha -r ts-node/register \"test/test.ts\" --timeout 30000"
   },
   "keywords": [
     "mongodb"
@@ -19,9 +20,13 @@
     "mongodb": "^3.6.6"
   },
   "devDependencies": {
+    "@types/mocha": "^9.1.1",
     "@types/mongodb": "^3.5.31",
     "@types/node": "^14.14.5",
+    "@types/uuid": "^8.3.4",
     "mocha": "^7.0.1",
-    "typescript": "^4.0.5"
+    "ts-node": "^10.8.1",
+    "typescript": "^4.0.5",
+    "uuid": "^8.3.2"
   }
 }

package/test/test.ts

@@ -0,0 +1,60 @@
+import {describe, it } from "mocha";
+import { MClient } from "../src/mongodbclient";
+import { strict as assert } from "assert";
+import { v4 as uuidv4 } from "uuid";
+
+const mongouri = "mongodb+srv://...";
+const dbName = uuidv4();
+const collName = uuidv4();
+
+const mdbc = new MClient(mongouri, dbName, collName);
+
+const items = [
+  {name:"alice"},
+  {name:"bob"},
+  {name:"charlie"},
+  {name:"alice"}
+];
+
+describe("MClient", () => {
+  it("insertMany()", async () => {
+    const { insertedCount } = (await mdbc.insertMany(items)) as { insertedCount: number };
+    assert.equal(insertedCount, items.length);
+  });
+
+  it("getCollections()", async () => {
+    const collections = await mdbc.getCollections();
+    assert(collections.length > 0);
+  });
+
+  it("read()", async () => {
+    const docs = (await mdbc.read({})) as any[];
+    assert.equal(docs.length, items.length);
+  });
+
+  it("upsert()", async () => {
+    const docs = (await mdbc.read({})) as any[];
+    const { modifiedCount } = (await mdbc.upsert({ _id: docs[0]._id, name: "david" })) as { modifiedCount: number };
+    assert.equal(modifiedCount, 1);
+  });
+
+  it("distinct()", async () => {
+    const names = (await mdbc.distinct("name", {})) as string[];
+    assert.equal(names.length, 4);
+  });
+
+  it("stats()", async () => {
+    const { storageSize } = (await mdbc.stats()) as { storageSize: number };
+    assert(storageSize > 0);
+  });
+
+  it("count()", async () => {
+    const n = await mdbc.count({name:"alice"});
+    assert.equal(n,1);
+  });
+
+  it("remove()", async () => {
+    const { deletedCount } = (await mdbc.remove({})) as { deletedCount: number };
+    assert.equal(deletedCount, items.length);
+  });
+});

package/test/test.js

@@ -1,84 +0,0 @@
-const mongouri = "mongodb+srv://...";
-const dbName = `db${(new Date()).getTime().toString()}`;
-const collName = `col${(new Date()).getTime().toString()}`;
-
-const assert = require("assert");
-const MClient = require("../dist/mongodbclient.js").MClient;
-
-const mdbc = new MClient(mongouri, dbName, collName);
-
-const items = [
-  {name:"alice"},
-  {name:"bob"},
-  {name:"charlie"},
-  {name:"alice"}
-];
-
-describe("MClient", function(){
-  it("insertMany()",function(done){
-    mdbc.insertMany(items)
-    .then(function(r){
-      assert.equal(r.insertedCount, items.length);
-      done();
-    });
-  });
-
-  it("getCollections()", function(done){
-    mdbc.getCollections()
-    .then(function(collections){
-      assert(collections.length > 0);
-      done();
-    });
-  });
-
-  it("read()", function(done){
-    mdbc.read()
-    .then(function(docs){
-      assert.equal(docs.length, items.length);
-      done();
-    });
-  });
-
-  it("upsert()", function(done){
-    mdbc.read()
-    .then(function(docs){
-      return mdbc.upsert({_id:docs[0]._id, name:"david"});
-    })
-    .then(function(r){
-      assert.equal(r.modifiedCount, 1);
-      done();
-    });
-  });
-
-  it("distinct()", function(done){
-    mdbc.distinct("name")
-    .then(function(names){
-      assert.equal(names.length, 4);
-      done();
-    });
-  });
-
-  it("stats()", function(done){
-    mdbc.stats()
-    .then(function(r){
-      assert(r.storageSize > 0);
-      done();
-    });
-  });
-
-  it("count()", function(done){
-    mdbc.count({name:"alice"})
-    .then(function(n){
-      assert.equal(n,1);
-      done();
-    });
-  });
-
-  it("remove()", function(done){
-    mdbc.remove()
-    .then(function(r){
-      assert.equal(r.deletedCount, items.length);
-      done();
-    });
-  });
-});