gmongo 2.0.8 → 3.0.0

package/.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "editor.defaultFormatter": "rvest.vs-code-prettier-eslint",
+  "editor.formatOnPaste": false, // required
+  "editor.formatOnType": false, // required
+  "editor.formatOnSave": true, // optional
+  "editor.formatOnSaveMode": "file", // required to format on save
+  "files.autoSave": "onFocusChange" // optional but recommended
+}

package/README.md

@@ -24,18 +24,22 @@ Mongo is the preferred database format for NodeJS based systems. It supports mul
 
 ### To connect to a server use Mongo.start()
 
-```
+When using a x509 certificate, the path must be a local path on the device, username and password should be null, on the contrary, when using a username and password, the x509 should be null.
+
+```node
+const Mongo = require( 'gmongo' )
+
 Mongo.start(
   <Is Atlas DB>, //Boolean
-  <Database Name>, //String
-  <IP>, //String
+  <Collection Name>, //String
+  <IP or host>, //String
   <Port>, //Number or NULL
   <User>, //String or NULL
   <Password>, //String or NULL
   <x509 Certificate Path>, //String or NULL
   <Timeout in milliseconds>, //Number or NULL
 )
-  .then( _=> console.log('Im Connected!'))
+  .then( ()=> console.log('Im Connected!'))
 ```
 
 Example:
@@ -74,7 +78,7 @@ Mongo.start( false, 'MyDatabase', '127.0.0.1', 27017, null, null, null, 20000 )
 
 ### To INSERT a new row or a set of rows, use Mongo.insert()
 
-```
+```node
 Mongo.insert(
   <Database Name>, //String
   <Collection Name>, //String
@@ -85,17 +89,20 @@ Mongo.insert(
 Example:
 
 ```node
-Mongo.insert('MyDatabase', 'users', {
+const data = {
   username: 'jose',
   pass: '123',
   active: false,
-  added: new Date().getTime()
-}).then(result => console.log('all done'))
+  added: new Date().getTime(),
+}
+Mongo.insert('MyDatabase', 'users', data).then((result) =>
+  console.log('all done', data._id, result.insertedId)
+)
 ```
 
 ### To DELETE rows from the collection, use Mongo.delete()
 
-```
+```node
 Mongo.delete(
   <Database Name>, //String
   <Collection Name>, //String
@@ -107,13 +114,13 @@ Example:
 
 ```node
 Mongo.delete('MyDatabase', 'users', {
-  myuser: Mongo.id(user._id)
-}).then(result => console.log('all done'))
+  myuser: Mongo.id(user._id),
+}).then((result) => console.log('all done'))
 ```
 
 ### To UPDATE rows in the collection use Mongo.update
 
-```
+```node
 Mongo.update(
   <Database Name>, //String
   <Collection Name>, //String
@@ -129,17 +136,17 @@ Mongo.update(
   'MyDatabase',
   'users',
   {
-    active: false
+    active: false,
   },
   {
-    active: true
+    active: true,
   }
-).then(result => console.log('all done'))
+).then((result) => console.log('all done'))
 ```
 
 ### To QUERY the collection use Mongo.query()
 
-```
+```node
 Mongo.query(
   <Database Name>, //String
   <Collection Name>, //String
@@ -151,13 +158,13 @@ Example:
 
 ```node
 Mongo.query('MyDatabase', 'users', {
-  active: true
-}).then(rowsFromQuery => console.log(rowsFromQuery))
+  active: true,
+}).then((rowsFromQuery) => console.log(rowsFromQuery))
 ```
 
 ### To QUERY with a SORT use Mongo.querySort
 
-```
+```node
 Mongo.querySort(
   <Database Name>, //String
   <Collection Name>, //String
@@ -169,17 +176,14 @@ Mongo.querySort(
 Example:
 
 ```node
-Mongo.querySort(
-  'MyDatabase',
-  'users',
-  { added: 1 },
-  { active: true }
-).then(rowsFromQuery => console.log(rowsFromQuery))
+Mongo.querySort('MyDatabase', 'users', { added: 1 }, { active: true }).then(
+  (rowsFromQuery) => console.log(rowsFromQuery)
+)
 ```
 
 ### To QUERY with a SORT and LIMIT, use Mongo.queryLimitSort
 
-```
+```node
 Mongo.queryLimitSort(
   <Database Name>, //String
   <Collection Name>, //String
@@ -198,14 +202,14 @@ Mongo.queryLimitSort(
   100,
   { added: 1 },
   { active: true }
-).then(rowsFromQuery => console.log(rowsFromQuery))
+).then((rowsFromQuery) => console.log(rowsFromQuery))
 ```
 
 ### For a SINGLE QUERY the collection use Mongo.singleQuery()
 
 Note: singleQuery should only ever query **ONE ROW**.
 
-```
+```node
 Mongo.singleQuery(
   <Database Name>, //String
   <Collection Name>, //String
@@ -217,21 +221,21 @@ Example:
 
 ```node
 Mongo.singleQuery('MyDatabase', 'users', {
-  myuser: Mongo.id(user._id)
-}).then(rowFromQuery => console.log(rowFromQuery))
+  myuser: Mongo.id(user._id),
+}).then((rowFromQuery) => console.log(rowFromQuery))
 ```
 
 This **singleQuery** is very useful in the authentication methods, e.g.
 
 ```node
 Mongo.singleQuery('MyDatabase', 'users', {
-  loginSessionKey: req.sessionKey
-}).then(rowsFromQuery => res.json(rowFromQuery ? true : false))
+  loginSessionKey: req.sessionKey,
+}).then((rowsFromQuery) => res.json(rowFromQuery ? true : false))
 ```
 
 ### To JOIN a SINGLE COLLECTION to another, use Mongo.join()
 
-```
+```node
 Mongo.join(
   <Database Name>, //String
   <Collection Name>, //String
@@ -256,7 +260,43 @@ Mongo.join(
   'photos',
   { added: 1 },
   { myuser: Mongo.id(user._id) }
-).then(rowFromQuery => console.log(rowFromQuery))
+).then((rowFromQuery) => console.log(rowFromQuery))
+```
+
+### Adding/Querying Encryption at rest to data queries
+
+Many times applications require secure secure data at rest for safe storage of personal information. This package includes this automatically in the following functions:
+
+| Function       |
+| -------------- |
+| insert         |
+| update         |
+| query          |
+| singleQuery    |
+| querySort      |
+| queryLimitSort |
+| join           |
+
+To use this feature you first need to define a Key and IV for the encrypted columns selected. Save these to a very safe and not public location for usage in the functions.
+
+```node
+const key = Mongo.aes.makeKey()
+const iv = Mongo.aes.makeIv()
+```
+
+To make use of the automatic encryption and decryption, please add the following fields to the end of the function as shown in the following example:
+
+```node
+const key = Mongo.aes.makeKey()
+const iv = Mongo.aes.makeIv()
+Mongo.query(
+  'TestCollection',
+  'TestTable',
+  {},
+  ['encryptedColumn'],
+  key,
+  iv
+).then((rowFromQuery) => console.log(rowFromQuery))
 ```
 
 ---

package/examples/encryptDataAtRest.js

@@ -0,0 +1,173 @@
+const MGO = require('../mongo.js')
+
+const keys = {
+  test: {
+    columns: ['name', 'dob'],
+    key: MGO.aes.format.key(
+      '6233616364623234393935616165333332633466376134663031633833643262'
+    ),
+    iv: MGO.aes.format.iv('62323166666532663034393535346233'),
+  },
+}
+
+const start = async (_) => {
+  console.log('test connect')
+  const DBName = 'Account'
+  const DBHost = 'test.mongodb.net'
+  const DBPort = null
+  const DBUser = null
+  const DBPass = null
+  const DBx509 = ''
+  await MGO.start(true, DBName, DBHost, DBPort, DBUser, DBPass, DBx509, 20000)
+  console.log('connected')
+  console.log(keys.test)
+  if (false) {
+    console.log('insert test')
+    const data = {
+      added: new Date(),
+      incrementer: 2,
+      test: 'TEST String',
+    }
+    console.log(
+      await MGO.insert(
+        DBName,
+        'TestTable',
+        data,
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+    console.log(data)
+  }
+  if (false) {
+    console.log('delete test')
+    console.log(
+      await MGO.delete(DBName, 'TestTable', {
+        _id: MGO.id('655003e5d765319d61037ceb'),
+      })
+    )
+  }
+  if (false) {
+    console.log('update test')
+    console.log(
+      await MGO.update(
+        DBName,
+        'TestTable',
+        {
+          _id: MGO.id('655003c9506eaf7ed924e885'),
+        },
+        { test: 'My favourite data' },
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+  }
+  if (false) {
+    console.log('query test')
+    console.log(
+      await MGO.query(
+        DBName,
+        'TestTable',
+        {},
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+  }
+  if (false) {
+    console.log('single query test')
+    console.log(
+      await MGO.singleQuery(
+        DBName,
+        'TestTable',
+        {
+          _id: MGO.id('65500e6decab789298f5a32e'),
+        },
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+  }
+  if (false) {
+    console.log('query sort test')
+    console.log(
+      await MGO.querySort(
+        DBName,
+        'TestTable',
+        { added: 1 },
+        {},
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+  }
+  if (false) {
+    console.log('query limit sort test')
+    console.log(
+      await MGO.queryLimitSort(
+        DBName,
+        'TestTable',
+        1,
+        { added: -1 },
+        {},
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+  }
+  if (false) {
+    console.log('join test')
+    console.log(
+      await MGO.join(
+        DBName,
+        'TestTable',
+        'incrementer',
+        'TestTable1',
+        'incrementer',
+        'innerObject',
+        { added: 1 },
+        {},
+        ['test'],
+        keys.test.key,
+        keys.test.iv
+      )
+    )
+  }
+
+  console.log(MGO.aes.makeIv())
+  console.log(MGO.aes.makeKey())
+  process.exit()
+  /*
+  console.log(MGO.aes.makeIv())
+  console.log(MGO.aes.makeKey())
+
+    await MGO.insert(
+      'this',
+      'test',
+      [
+        { name: 'James Encke', dob: '2021-01-01' },
+        { name: 'Matthew Encke', dob: '2021-01-01' }
+      ],
+      keys.test.columns,
+      keys.test.key,
+      keys.test.iv
+    )
+    await MGO.query(
+      'this',
+      'test',
+      {},
+      keys.test.columns,
+      keys.test.key,
+      keys.test.iv
+    )
+
+    */
+}
+
+start()

package/mongo.js

@@ -32,22 +32,22 @@ const db = {
   updateList: {},
   databaseList: {},
   aes: aes,
-  id: name =>
+  id: (name) =>
     typeof name != 'string' || name.length % 12 == 0 ? objectId(name) : null,
   start: (isAtlas, dbName, ip, port, user, pass, x509, timeoutInMS) =>
     new Promise((resolve, reject) => {
       if (!Array.isArray(dbName)) {
         dbName = [dbName]
       }
-      const connectDB = _ => {
+      const connectDB = (_) => {
         const thisDB = dbName && dbName.length > 0 ? dbName.shift() : null
         if (thisDB) {
           connect(isAtlas, thisDB, ip, port, user, pass, x509, timeoutInMS)
-            .then(dbObject => {
+            .then((dbObject) => {
               db.databaseList[thisDB] = dbObject
               connectDB()
             })
-            .catch(err => {
+            .catch((err) => {
               console.log('Database Connection Error', err)
               reject()
             })
@@ -58,7 +58,7 @@ const db = {
       connectDB()
     }),
   insert: (dbName, table, rowOrRows, columsOfRowOrRowsToEncrypt, key, iv) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
         if (columsOfRowOrRowsToEncrypt && key && iv) {
           if (Array.isArray(rowOrRows)) {
@@ -81,98 +81,113 @@ const db = {
             }
           }
         }
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection[
+        const collection = await db.databaseList[dbName].collection(table)
+        resFmt(
+          null,
+          await collection[
             Array.isArray(rowOrRows) ? 'insertMany' : 'insertOne'
-          ](rowOrRows, (err, result) => resFmt(err, result, resolve, reject))
+          ](rowOrRows),
+          resolve,
+          reject
         )
       } else {
         reject('No Connection')
       }
     }),
   delete: (dbName, table, dataToRemove) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection.deleteMany(dataToRemove, (err, result) =>
-            resFmt(err, result, resolve, reject)
-          )
-        )
+        const collection = await db.databaseList[dbName].collection(table)
+        resFmt(null, await collection.deleteMany(dataToRemove), resolve, reject)
       } else {
         reject('No Connection')
       }
     }),
-  update: (dbName, table, dataToUpdate, newData) =>
-    new Promise((resolve, reject) => {
+  update: (
+    dbName,
+    table,
+    dataToUpdate,
+    newData,
+    columsOfRowOrRowsToEncrypt,
+    key,
+    iv
+  ) =>
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection.updateMany(
-            dataToUpdate,
-            { $set: newData },
-            (err, result) => resFmt(err, result, resolve, reject)
-          )
+        if (columsOfRowOrRowsToEncrypt && key && iv) {
+          for (let n = 0; n < columsOfRowOrRowsToEncrypt.length; n++) {
+            newData[columsOfRowOrRowsToEncrypt[n]] = aes.encrypt(
+              key,
+              iv,
+              newData[columsOfRowOrRowsToEncrypt[n]]
+            )
+          }
+        }
+        const collection = await db.databaseList[dbName].collection(table)
+        resFmt(
+          null,
+          await collection.updateMany(dataToUpdate, { $set: newData }),
+          resolve,
+          reject
         )
       } else {
         reject('No Connection')
       }
     }),
   singleQuery: (dbName, table, query, columnsToDecrypt, key, iv) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection.findOne(query, (err, result) =>
-            resFmt(
-              err,
-              result && !err && columnsToDecrypt && key && iv
-                ? decrypt([result], columnsToDecrypt, key, iv)[0]
-                : result,
-              resolve,
-              reject
-            )
-          )
+        const collection = await db.databaseList[dbName].collection(table)
+        const result = await collection.findOne(query)
+        resFmt(
+          null,
+          result && columnsToDecrypt && key && iv
+            ? decrypt([result], columnsToDecrypt, key, iv)[0]
+            : result,
+          resolve,
+          reject
         )
       } else {
         reject('No Connection')
       }
     }),
   query: (dbName, table, query, columnsToDecrypt, key, iv) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection
-            .find(query)
-            .toArray((err, result) =>
-              resFmt(
-                err,
-                result && result.length > 0 && columnsToDecrypt && key && iv
-                  ? decrypt(result, columnsToDecrypt, key, iv)
-                  : result,
-                resolve,
-                reject
-              )
-            )
+        const collection = await db.databaseList[dbName].collection(table)
+        const results = await collection.find(query)
+        const result = []
+        while (await results.hasNext()) {
+          result.push(await results.next())
+        }
+        resFmt(
+          null,
+          result && result.length > 0 && columnsToDecrypt && key && iv
+            ? decrypt(result, columnsToDecrypt, key, iv)
+            : result,
+          resolve,
+          reject
         )
       } else {
         reject('No Connection')
       }
     }),
   querySort: (dbName, table, sort, query, columnsToDecrypt, key, iv) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection
-            .find(query)
-            .sort(sort)
-            .toArray((err, result) =>
-              resFmt(
-                err,
-                result && result.length > 0 && columnsToDecrypt && key && iv
-                  ? decrypt(result, columnsToDecrypt, key, iv)
-                  : result,
-                resolve,
-                reject
-              )
-            )
+        const collection = await db.databaseList[dbName].collection(table)
+        const results = await (await collection.find(query)).sort(sort)
+        const result = []
+        while (await results.hasNext()) {
+          result.push(await results.next())
+        }
+        resFmt(
+          null,
+          result && result.length > 0 && columnsToDecrypt && key && iv
+            ? decrypt(result, columnsToDecrypt, key, iv)
+            : result,
+          resolve,
+          reject
         )
       } else {
         reject('No Connection')
@@ -188,23 +203,23 @@ const db = {
     key,
     iv
   ) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) =>
-          collection
-            .find(query)
-            .limit(max)
-            .sort(sort)
-            .toArray((err, result) =>
-              resFmt(
-                err,
-                result && result.length > 0 && columnsToDecrypt && key && iv
-                  ? decrypt(result, columnsToDecrypt, key, iv)
-                  : result,
-                resolve,
-                reject
-              )
-            )
+        const collection = await db.databaseList[dbName].collection(table)
+        const results = await (
+          await (await collection.find(query)).limit(max)
+        ).sort(sort)
+        const result = []
+        while (await results.hasNext()) {
+          result.push(await results.next())
+        }
+        resFmt(
+          null,
+          result && result.length > 0 && columnsToDecrypt && key && iv
+            ? decrypt(result, columnsToDecrypt, key, iv)
+            : result,
+          resolve,
+          reject
         )
       } else {
         reject('No Connection')
@@ -218,67 +233,116 @@ const db = {
     joinToIDField,
     joinedToElement,
     sort,
-    query
+    query,
+    columnsToDecrypt,
+    key,
+    iv
   ) =>
-    new Promise((resolve, reject) => {
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.aggregate(dbName, table, query, sort, [
-          {
-            $lookup: {
-              from: joinTo,
-              localField: tableIDField,
-              foreignField: joinToIDField,
-              as: joinedToElement
-            }
-          }
-        ])
-          .then(result => resolve(result))
-          .catch(err => reject(err))
+        const collection = await db.databaseList[dbName].collection(table)
+        resolve(
+          await db.aggregate(
+            dbName,
+            table,
+            query,
+            sort,
+            [
+              {
+                $lookup: {
+                  from: joinTo,
+                  localField: tableIDField,
+                  foreignField: joinToIDField,
+                  as: joinedToElement,
+                },
+              },
+            ],
+            columnsToDecrypt,
+            key,
+            iv
+          )
+        )
       } else {
         reject('No Connection')
       }
     }),
-  joins: (dbName, table, joinedToList, sort, query) =>
-    new Promise((resolve, reject) => {
+  joins: (
+    dbName,
+    table,
+    joinedToList,
+    sort,
+    query,
+    columnsToDecrypt,
+    key,
+    iv
+  ) =>
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) => {
-          let aggregrateList = []
-          for (let i = 0; i < joinedToList.length; i++) {
-            aggregrateList.push({
-              $lookup: {
-                from: joinedToList[i].to.name,
-                localField: joinedToList[i].from,
-                foreignField: joinedToList[i].to.id,
-                as: joinedToList[i].name
-              }
-            })
-          }
-          db.aggregate(dbName, table, query, sort, aggregrateList)
-            .then(result => resolve(result))
-            .catch(err => reject(err))
-        })
+        const collection = await db.databaseList[dbName].collection(table)
+        let aggregrateList = []
+        for (let i = 0; i < joinedToList.length; i++) {
+          aggregrateList.push({
+            $lookup: {
+              from: joinedToList[i].to.name,
+              localField: joinedToList[i].from,
+              foreignField: joinedToList[i].to.id,
+              as: joinedToList[i].name,
+            },
+          })
+        }
+        resolve(
+          await db.aggregate(
+            dbName,
+            table,
+            query,
+            sort,
+            aggregrateList,
+            columnsToDecrypt,
+            key,
+            iv
+          )
+        )
       } else {
         reject('No Connection')
       }
     }),
-  aggregate: (dbName, table, query, sort, aggregates) =>
-    new Promise((resolve, reject) => {
+  aggregate: (
+    dbName,
+    table,
+    query,
+    sort,
+    aggregates,
+    columnsToDecrypt,
+    key,
+    iv
+  ) =>
+    new Promise(async (resolve, reject) => {
       if (db.databaseList[dbName]) {
-        db.databaseList[dbName].collection(table, (err, collection) => {
-          if (query) {
-            aggregates.unshift({ $match: query })
-          }
-          if (sort) {
-            aggregates.push({ $sort: sort })
-          }
-          collection
-            .aggregate(aggregates)
-            .toArray((err, result) => resFmt(err, result, resolve, reject))
-        })
+        const collection = await db.databaseList[dbName].collection(table)
+        if (query) {
+          aggregates.unshift({ $match: query })
+        }
+        if (sort) {
+          aggregates.push({ $sort: sort })
+        }
+        const result = []
+        const results = collection.aggregate(aggregates)
+        for await (const row of results) {
+          result.push(row)
+        }
+        console.log({ columnsToDecrypt, key, iv })
+        resFmt(
+          null,
+          columnsToDecrypt && columnsToDecrypt.length > 0 && key && iv
+            ? decrypt(result, columnsToDecrypt, key, iv)
+            : result,
+          resolve,
+          reject
+        )
       } else {
         reject('No Connection')
       }
-    })
+    }),
 }
 
 module.exports = db

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gmongo",
-  "version": "2.0.8",
+  "version": "3.0.0",
   "description": "MongoDB Connection Class",
   "main": "mongo.js",
   "scripts": {
@@ -17,7 +17,9 @@
   },
   "homepage": "https://github.com/GnomeGroup/gmongo#readme",
   "dependencies": {
-    "mongodb": "^3.6.6"
+    "eslint": "^8.39.0",
+    "mongodb": "^6.2.0",
+    "prettier": "^2.8.8"
   },
   "prettier": {
     "singleQuote": true,

package/services/aes.js

@@ -1,5 +1,11 @@
 const crypto = require('crypto')
 
+const getBufferFromData = (bytes, data) => {
+  const newData = Buffer.alloc(bytes)
+  newData.write(data, 'utf-8')
+  return newData.toString('hex')
+}
+
 module.exports = {
   encrypt: (key, iv, plainData) => {
     const encipher = crypto.createCipheriv(
@@ -32,5 +38,9 @@ module.exports = {
       .createHash('sha256')
       .update(crypto.randomBytes(256))
       .digest()
-      .toString('hex')
+      .toString('hex'),
+  format: {
+    iv: value => getBufferFromData(16, value),
+    key: value => getBufferFromData(32, value)
+  }
 }

package/services/connect.js

@@ -1,51 +1,37 @@
 const mongo = require('mongodb').MongoClient
 
-module.exports = (
-  isAtlas,
-  dbName,
-  ip,
-  port,
-  user,
-  pass,
-  x509,
-  timeoutInMS,
-  callback
-) =>
-  new Promise(function(resolve, reject) {
+module.exports = (isAtlas, dbName, ip, port, user, pass, x509, timeoutInMS) =>
+  new Promise(function (resolve, reject) {
     let connectOptions = {
       serverSelectionTimeoutMS: timeoutInMS
         ? parseInt(timeoutInMS)
         : CFG.defaults.timeout,
-      useNewUrlParser: true,
-      useUnifiedTopology: true
     }
-    if (x509) {
-      connectOptions.tls = true
-      connectOptions.tlsCertificateKeyFile = x509
-    }
-    mongo.connect(
-      'mongodb' +
+    try {
+      const url =
+        'mongodb' +
         (isAtlas ? '+srv' : '') +
         '://' +
-        (user ? escape(user) : '') +
+        (user ? encodeURIComponent(user) : '') +
         (user && pass ? ':' : '') +
-        (pass ? escape(pass) : '') +
+        (pass ? encodeURIComponent(pass) : '') +
         (user || pass ? '@' : '') +
-        escape(ip) +
+        encodeURIComponent(ip) +
         (isAtlas ? '' : ':' + parseInt(port).toString()) +
         '/' +
-        escape(dbName) +
+        encodeURIComponent(dbName) +
         '?retryWrites=true&w=majority' +
-        (x509 ? '&authMechanism=MONGODB-X509&ssl=true' : ''),
-      connectOptions,
-      (err, dataBase) => {
-        if (!err && dataBase) {
-          const dbObject = dataBase.db(dbName)
-          dbObject.collection(dbName)
-          resolve(dbObject)
-        } else {
-          reject(err)
-        }
+        (x509
+          ? '&authMechanism=MONGODB-X509&tls=true&tlsCertificateKeyFile=' +
+            encodeURIComponent(x509)
+          : '&authMechanism=DEFAULT')
+      const dataBase = new mongo(url, connectOptions)
+      if (dataBase) {
+        const dbObject = dataBase.db(dbName)
+        dbObject.collection(dbName)
+        resolve(dbObject)
+        return
       }
-    )
+    } catch (err) {}
+    reject()
   })

package/services/objectId.js

@@ -1,3 +1,3 @@
-const objectid = require('mongodb').ObjectID
+const objectid = require('mongodb').ObjectId
 
-module.exports = id => objectid(id)
+module.exports = (id) => new objectid(id)