@tomsd/mongodbclient 2.0.0 → 2.1.1

package/dist/{mongodbclient.js → cjs/mongodbclient.js}

@@ -66,7 +66,7 @@ class MClient {
         return new Promise(function (resolve, reject) {
             that.getConnected()
                 .then(function (conn) {
-                conn.collection.updateOne({ _id: pobj._id }, { $set: pobj }, { upsert: true, w: 1 })
+                conn.collection.updateOne({ _id: pobj._id }, { $set: pobj }, { upsert: true, writeConcern: { w: 1 } })
                     .then(function (r) {
                     conn.client.close();
                     resolve(r);
@@ -118,7 +118,7 @@ class MClient {
         return new Promise(function (resolve, reject) {
             that.getConnected()
                 .then(function (conn) {
-                conn.collection.deleteMany(condition, { w: 1 })
+                conn.collection.deleteMany(condition, { writeConcern: { w: 1 } })
                     .then(function (r) {
                     conn.client.close();
                     resolve(r);
@@ -172,7 +172,7 @@ class MClient {
         return new Promise(function (resolve, reject) {
             that.getConnected()
                 .then(function (conn) {
-                conn.collection.insertMany(items, { w: 1 })
+                conn.collection.insertMany(items, { writeConcern: { w: 1 } })
                     .then(function (r) {
                     conn.client.close();
                     resolve(r);

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,11 +1,12 @@
 {
   "name": "@tomsd/mongodbclient",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "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"
   },
@@ -16,7 +17,7 @@
   "license": "MIT",
   "dependencies": {
     "@tomsd/rand": "^3.0.0",
-    "mongodb": "^3.6.2"
+    "mongodb": "^3.6.6"
   },
   "devDependencies": {
     "@types/mongodb": "^3.5.31",

package/test/test.js

@@ -3,7 +3,7 @@ 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 MClient = require("../dist/cjs/mongodbclient.js").MClient;
 
 const mdbc = new MClient(mongouri, dbName, collName);
 
@@ -14,71 +14,45 @@ const items = [
   {name:"alice"}
 ];
 
-describe("MClient", function(){
-  it("insertMany()",function(done){
-    mdbc.insertMany(items)
-    .then(function(r){
-      assert.equal(r.insertedCount, items.length);
-      done();
-    });
+describe("MClient", () => {
+  it("insertMany()", async () => {
+    const { insertedCount } = await mdbc.insertMany(items)
+    assert.equal(insertedCount, items.length);
   });
 
-  it("getCollections()", function(done){
-    mdbc.getCollections()
-    .then(function(collections){
-      assert(collections.length > 0);
-      done();
-    });
+  it("getCollections()", async () => {
+    const collections = await mdbc.getCollections();
+    assert(collections.length > 0);
   });
 
-  it("read()", function(done){
-    mdbc.read()
-    .then(function(docs){
-      assert.equal(docs.length, items.length);
-      done();
-    });
+  it("read()", async () => {
+    const docs = await mdbc.read();
+    assert.equal(docs.length, items.length);
   });
 
-  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("upsert()", async () => {
+    const docs = await mdbc.read();
+    const { modifiedCount } = await mdbc.upsert({ _id: docs[0]._id, name: "david" });
+    assert.equal(modifiedCount, 1);
   });
 
-  it("distinct()", function(done){
-    mdbc.distinct("name")
-    .then(function(names){
-      assert.equal(names.length, 4);
-      done();
-    });
+  it("distinct()", async () => {
+    const names = await mdbc.distinct("name");
+    assert.equal(names.length, 4);
   });
 
-  it("stats()", function(done){
-    mdbc.stats()
-    .then(function(r){
-      assert(r.storageSize > 0);
-      done();
-    });
+  it("stats()", async () => {
+    const { storageSize } = await mdbc.stats();
+    assert(storageSize > 0);
   });
 
-  it("count()", function(done){
-    mdbc.count({name:"alice"})
-    .then(function(n){
-      assert.equal(n,1);
-      done();
-    });
+  it("count()", async () => {
+    const n = await mdbc.count({name:"alice"});
+    assert.equal(n,1);
   });
 
-  it("remove()", function(done){
-    mdbc.remove()
-    .then(function(r){
-      assert.equal(r.deletedCount, items.length);
-      done();
-    });
+  it("remove()", async () => {
+    const { deletedCount } = await mdbc.remove();
+    assert.equal(deletedCount, items.length);
   });
 });