@itentialopensource/adapter-utils 4.44.7 → 4.45.0

package/lib/dbUtil.js

@@ -6,7 +6,6 @@
 
 const fs = require('fs-extra');
 const uuid = require('uuid');
-const path = require('path');
 
 /* Fetch in the other needed components for the this Adaptor */
 const { MongoClient } = require('mongodb');
@@ -15,8 +14,18 @@ const { MongoClient } = require('mongodb');
 let adapterDir = '';
 let saveFS = false;
 let storDir = `${adapterDir}/storage`;
+let entityDir = `${adapterDir}/entities`;
 let id = null;
 
+const Storage = {
+  UNDEFINED: 0,
+  DBINFO: 1,
+  ADAPTERDB: 2,
+  FILESYSTEM: 3,
+  IAPDB: 4
+};
+Object.freeze(Storage);
+
 /* DB UTILS INTERNAL FUNCTIONS         */
 /** getFromJson
  * @summary returns information from a json file on the file system
@@ -52,6 +61,55 @@ function getFromJson(fileName, filter) {
   }
 
   try {
+    if (fileName === 'adapter_configs') {
+      const retEntity = filter.entity;
+      if (!retEntity || !fs.existsSync(`${entityDir}`) || !fs.existsSync(`${entityDir}/${retEntity}`)) {
+        log.warn(`${origin}: Could not find adapter entity directory ${retEntity} - nothing to retrieve`);
+        return null;
+      }
+      if (!fs.existsSync(`${entityDir}/${retEntity}/action.json`)) {
+        log.warn(`${origin}: Could not find action.json for entity ${retEntity} - nothing to retrieve`);
+        return null;
+      }
+
+      // load the mockdatafiles
+      let files = fs.readdirSync(`${entityDir}/${retEntity}`);
+      const mockdatafiles = {};
+      if (files.includes('mockdatafiles') && fs.lstatSync(`${entityDir}/${retEntity}/mockdatafiles`).isDirectory()) {
+        fs.readdirSync(`${entityDir}/${retEntity}/mockdatafiles`).forEach((file) => {
+          if (file.split('.').pop() === 'json') {
+            const mockpath = `${entityDir}/${retEntity}/mockdatafiles/${file}`;
+            const data = JSON.parse(fs.readFileSync(mockpath));
+            mockdatafiles[mockpath.split('/').pop()] = data;
+          }
+        });
+      }
+
+      // load the action data
+      let actions;
+      if (files.includes('action.json')) {
+        actions = JSON.parse(fs.readFileSync(`${entityDir}/${retEntity}/action.json`));
+      }
+
+      // Load schema.json and other schemas in remaining json files
+      files = files.filter((f) => (f !== 'action.json') && f.endsWith('.json'));
+      const schema = [];
+      files.forEach((file) => {
+        const data = JSON.parse(fs.readFileSync(`${entityDir}/${retEntity}/${file}`));
+        schema.push({
+          name: file,
+          schema: data
+        });
+      });
+
+      // return the data
+      return {
+        actions: actions.actions,
+        schema,
+        mockdatafiles
+      };
+    }
+
     // make sure what we need exists and has been provided
     if (!fs.existsSync(`${storDir}`)) {
       log.warn(`${origin}: Could not find adapter storage directory - nothing to retrieve`);
@@ -72,21 +130,29 @@ function getFromJson(fileName, filter) {
         });
       } else {
         // if not metric must match the items in the filter
-        const key = Object.keys(useFilter);
+        // if no filter, match everything
+        let key = [];
+        if (useFilter && useFilter.length > 0) {
+          key = Object.keys(useFilter);
+        }
         content.table.forEach((item) => {
           let push = true;
+          // check each key - if it does not match a key do not add to return data
           key.forEach((fil) => {
             if (useFilter[fil] !== item[fil]) push = false;
           });
           if (push) toReturn.push(item);
         });
       }
+      // not sure why we do this - a little different than above.
       const filtered = content.table.filter((el) => {
-        Object.keys(useFilter).forEach((obj) => {
-          if (el[obj] !== useFilter[obj]) {
-            return false;
-          }
-        });
+        if (useFilter) {
+          Object.keys(useFilter).forEach((obj) => {
+            if (el[obj] !== useFilter[obj]) {
+              return false;
+            }
+          });
+        }
         return true;
       });
       return toReturn;
@@ -393,7 +459,9 @@ class DBUtil {
     this.baseDir = directory;
     adapterDir = this.baseDir;
     storDir = `${adapterDir}/storage`;
+    entityDir = `${adapterDir}/entities`;
     this.props = properties;
+    this.adapterMongoClient = null;
 
     // set up the properties I care about
     this.refreshProperties(properties);
@@ -509,6 +577,43 @@ class DBUtil {
     }
   }
 
+  /**
+   * Call to determine the storage target. If the storage is a Mongo database, then
+   * the client connection and database is returned.
+   *
+   * @function determineStorage
+   * @param {object} dbInfo - the url for the database to connect to (dburl, dboptions, database)
+   * @param {callback} callback - the error, the storage, the Mongo client connection, the Mongo database
+   */
+  determineStorage(dbInfo, callback) {
+    const origin = `${this.myid}-dbUtil-determineStorage`;
+
+    if (dbInfo) {
+      // priority 1 - use the dbInfo passed in
+      if (dbInfo.dburl && dbInfo.database) {
+        MongoClient.connect(dbInfo.dburl, dbInfo.dboptions, (err, mongoClient) => {
+          if (err) {
+            log.error(`${origin}: Error! Failed to connect to database: ${err}`);
+            return callback(err, null, null, null);
+          }
+          log.debug('using dbinfo');
+          return callback(null, Storage.DBINFO, mongoClient, dbInfo.database);
+        });
+      } else {
+        const err = 'Error! Marlformed dbInfo';
+        return callback(err, null, null, Storage.DBINFO);
+      }
+    } else if (this.adapterMongoClient) {
+      // priority 2 - use the adapter database
+      log.debug('using adapter db');
+      return callback(null, Storage.ADAPTERDB, this.adapterMongoClient, this.database);
+    } else if (this.dburl === null && dbInfo === null) {
+      // priority 3 - use the filesystem
+      log.debug('using filesystem');
+      return callback(null, Storage.FILESYSTEM, null, null);
+    }
+  }
+
   /**
    * Call to connect and authenticate to the adapter database
    *
@@ -544,6 +649,7 @@ class DBUtil {
           } else {
             log.info(`${origin}: MONGO CONNECTION BACK...`);
             this.alive = true;
+            this.adapterMongoClient = mongoClient;
           }
         });
       });
@@ -567,6 +673,7 @@ class DBUtil {
 
       log.info(`${origin}: mongo running @${this.dburl}/${this.database}`);
       this.clientDB = mongoClient.db(this.database);
+      this.adapterMongoClient = mongoClient;
 
       // we don't have authentication defined but we still need to check if Mongo does not
       // require one, so we just list collections to test if it's doable.
@@ -577,12 +684,24 @@ class DBUtil {
         } else {
           log.info(`${origin}: MongoDB connection has been established`);
           this.alive = true;
+          this.adapterMongoClient = mongoClient;
         }
         return callback(this.alive, mongoClient);
       });
     });
   }
 
+  /**
+   * Call to disconnect from the adapter database
+   *
+   * @function disconnect
+   */
+  disconnect() {
+    if (this.adapterMongoClient) {
+      this.adapterMongoClient.close();
+    }
+  }
+
   /**
    * createCollection creates the provided collection in the file system or database.
    *
@@ -595,11 +714,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-createCollection`;
     log.trace(origin);
 
-    // set the default adapter database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName || (typeof collectionName !== 'string')) {
@@ -607,68 +721,51 @@ class DBUtil {
         return callback(`${origin}: Missing Collection Name or not string`, null);
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // if there is no adapter directory - can not do anything so error
-        if (!fs.existsSync(`${this.baseDir}`)) {
-          log.warn(`${origin}: Not able to create storage - missing base directory!`);
-          return callback(`${origin}: Not able to create storage - missing base directory!`, null);
-        }
-        // if there is no storage directory - create it
-        if (!fs.existsSync(`${this.baseDir}/storage`)) {
-          fs.mkdirSync(`${this.baseDir}/storage`);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        // if the collection already exists - no need to create it
-        if (fs.existsSync(`${this.baseDir}/storage/${collectionName}`)) {
-          log.debug(`${origin}: storage file collection already exists`);
-          return callback(null, collectionName);
-        }
-        // create the new collection on the file system
-        fs.mkdirSync(`${this.baseDir}/storage/${collectionName}`);
-        log.debug(`${origin}: storage file collection ${collectionName} created`);
-        return callback(null, collectionName);
-      }
-
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
 
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // No Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // if there is no adapter directory - can not do anything so error
+          if (!fs.existsSync(`${this.baseDir}`)) {
+            log.warn(`${origin}: Not able to create storage - missing base directory!`);
+            return callback(`${origin}: Not able to create storage - missing base directory!`, null);
+          }
+          // if there is no storage directory - create it
+          if (!fs.existsSync(`${this.baseDir}/storage`)) {
+            fs.mkdirSync(`${this.baseDir}/storage`);
+          }
+          // if the collection already exists - no need to create it
+          if (fs.existsSync(`${this.baseDir}/storage/${collectionName}`)) {
+            log.debug(`${origin}: storage file collection already exists`);
+            return callback(null, collectionName);
+          }
+          // create the new collection on the file system
+          fs.mkdirSync(`${this.baseDir}/storage/${collectionName}`);
+          log.debug(`${origin}: storage file collection ${collectionName} created`);
+          return callback(null, collectionName);
         }
 
-        // Add the collection to the database
-        return db.db(usedb).createCollection(collectionName, (err, res) => {
-          db.close();
-          if (err) {
-            // error we get back if the collection already existed - not a true error
-            if (err.codeName === 'NamespaceExists') {
-              log.debug(`${origin}: database collection already exists`);
-              return callback(null, collectionName);
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          return mongoClient.db(database).createCollection(collectionName, (err, res) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            if (err) {
+              // error we get back if the collection already existed - not a true error
+              if (err.codeName === 'NamespaceExists') {
+                log.debug(`${origin}: database collection already exists`);
+                return callback(null, collectionName);
+              }
+              log.warn(`${origin}: Error creating collection ${err}`);
+              return callback(`${origin}: Error creating collection ${err}`, null);
             }
-            log.warn(`${origin}: Error creating collection ${error}`);
-            return callback(`${origin}: Error creating collection ${error}`, null);
-          }
-          log.spam(`${origin}: db response ${res}`);
-          log.debug(`${origin}: database collection ${collectionName} created`);
-          return callback(null, collectionName);
-        });
+            log.spam(`${origin}: db response ${res}`);
+            log.debug(`${origin}: database collection ${collectionName} created`);
+            return callback(null, collectionName);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -688,11 +785,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-removeCollection`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName || (typeof collectionName !== 'string')) {
@@ -700,66 +792,49 @@ class DBUtil {
         return callback(`${origin}: Missing Collection Name or not string`, null);
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        const deld = deleteJSON(collectionName);
-        if (deld) {
-          log.debug(`${origin}: storage file collection ${collectionName} removed`);
-          return callback(null, deld);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.debug(`${origin}: could not remove storage file collection`);
-        return callback(`${origin}: could not remove storage file collection`, null);
-      }
-
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
 
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
-
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          const deld = deleteJSON(collectionName);
+          if (deld) {
+            log.debug(`${origin}: storage file collection ${collectionName} removed`);
+            return callback(null, deld);
+          }
+          log.debug(`${origin}: could not remove storage file collection`);
+          return callback(`${origin}: could not remove storage file collection`, null);
         }
 
-        // get the list of collections from the database - can we just drop?
-        return db.db(usedb).listCollections().toArray((err, result) => {
-          if (err) {
-            log.warn(`${origin}: Failed to get collections ${err}`);
-            return callback(`${origin}: Failed to get collections ${err}`, null);
-          }
-          // go through the collections to get the correct one for removal
-          for (let e = 0; e < result.length; e += 1) {
-            if (result[e].name === collectionName) {
-              // now that we found it, remove it
-              return db.db(usedb).collection(collectionName).drop({}, (err1, res) => {
-                db.close();
-                if (err1) {
-                  log.warn(`${origin}: Failed to remove collection ${err1}`);
-                  return callback(`${origin}: Failed to remove collection ${err1}`, null);
-                }
-                log.spam(`${origin}: db response ${res}`);
-                log.debug(`${origin}: database collection ${collectionName} removed`);
-                return callback(null, collectionName);
-              });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // get the list of collections from the database - can we just drop?
+          return mongoClient.db(database).listCollections().toArray((err, result) => {
+            if (err) {
+              log.warn(`${origin}: Failed to get collections ${err}`);
+              return callback(`${origin}: Failed to get collections ${err}`, null);
             }
-          }
-          db.close();
-          return callback(null, collectionName);
-        });
+            // go through the collections to get the correct one for removal
+            for (let e = 0; e < result.length; e += 1) {
+              if (result[e].name === collectionName) {
+                // now that we found it, remove it
+                return mongoClient.db(database).collection(collectionName).drop({}, (err1, res) => {
+                  if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+                  if (err1) {
+                    log.warn(`${origin}: Failed to remove collection ${err1}`);
+                    return callback(`${origin}: Failed to remove collection ${err1}`, null);
+                  }
+                  log.spam(`${origin}: db response ${res}`);
+                  log.debug(`${origin}: database collection ${collectionName} removed`);
+                  return callback(null, collectionName);
+                });
+              }
+            }
+            return callback(null, collectionName);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -780,11 +855,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-create`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName) {
@@ -806,54 +876,38 @@ class DBUtil {
         dataInfo._id = uuid.v4();
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // save it to file in the adapter storage directory
-        const saved = saveAsJson(collectionName, data);
-        if (!saved) {
-          log.warn(`${origin}: Data has not been saved to file storage`);
-          return callback(`${origin}: Data has not been saved to file storage`, null);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.debug(`${origin}: Data saved in file storage`);
-        return callback(null, saved);
-      }
 
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
-
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // save it to file in the adapter storage directory
+          const saved = saveAsJson(collectionName, data);
+          if (!saved) {
+            log.warn(`${origin}: Data has not been saved to file storage`);
+            return callback(`${origin}: Data has not been saved to file storage`, null);
+          }
+          log.debug(`${origin}: Data saved in file storage`);
+          return callback(null, saved);
         }
 
-        // Add the data to the database
-        // insertOne has only 2 parameters: the data to be added & callback. Not an identifier.
-        return db.db(usedb).collection(collectionName).insertOne(dataInfo, (err, result) => {
-          db.close();
-          if (err) {
-            log.warn(`${origin}: Failed to insert data in collection ${err}`);
-            return callback(`${origin}: Failed to insert data in collection ${err}`, null);
-          }
-          log.spam(`${origin}: db response ${result}`);
-          log.debug(`${origin}: Data saved in database`);
-          return callback(null, data);
-        });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // Add the data to the database
+          // insertOne has only 2 parameters: the data to be added & callback. Not an identifier.
+          return mongoClient.db(database).collection(collectionName).insertOne(dataInfo, (err, result) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            if (err) {
+              log.warn(`${origin}: Failed to insert data in collection ${err}`);
+              return callback(`${origin}: Failed to insert data in collection ${err}`, null);
+            }
+            log.spam(`${origin}: db response ${result}`);
+            log.debug(`${origin}: Data saved in database`);
+            return callback(null, data);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -873,11 +927,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-createIndex`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName) {
@@ -889,47 +938,31 @@ class DBUtil {
         return callback(`${origin}: Missing Specs`, null);
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null) {
-        // no database - no index
-        log.warn(`${origin}: No database - no index`);
-        return callback(`${origin}: No database - no index`, null);
-      }
-
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
+        }
 
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // no database - no index
+          log.warn(`${origin}: No database - no index`);
+          return callback(`${origin}: No database - no index`, null);
         }
 
-        // create the index on the collection
-        return db.db(usedb).collection(collectionName).createIndex(fieldOrSpec, options || {}, (err, res) => {
-          db.close();
-          if (err) {
-            log.warn(`${origin}: Failed to index data in collection ${err}`);
-            return callback(`${origin}: Failed to index data in collection ${err}`, null);
-          }
-          log.debug(`${origin}: Data in collection indexed`);
-          return callback(null, res);
-        });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // create the index on the collection
+          return mongoClient.db(database).collection(collectionName).createIndex(fieldOrSpec, options || {}, (err, res) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            if (err) {
+              log.warn(`${origin}: Failed to index data in collection ${err}`);
+              return callback(`${origin}: Failed to index data in collection ${err}`, null);
+            }
+            log.debug(`${origin}: Data in collection indexed`);
+            return callback(null, res);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -950,11 +983,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-countDocuments`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName) {
@@ -962,52 +990,36 @@ class DBUtil {
         return callback(`${origin}: Missing Collection Name`, null);
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // get a count from the JSON
-        const data = countJSON(collectionName, query);
-        if (!data || data === -1) {
-          log.warn(`${origin}: Could not count data from file storage`);
-          return callback(`${origin}: Could not count data from file storage`, null);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.debug(`${origin}: Count from file storage ${data}`);
-        return callback(null, data);
-      }
 
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
-
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // get a count from the JSON
+          const data = countJSON(collectionName, query);
+          if (!data || data === -1) {
+            log.warn(`${origin}: Could not count data from file storage`);
+            return callback(`${origin}: Could not count data from file storage`, null);
+          }
+          log.debug(`${origin}: Count from file storage ${data}`);
+          return callback(null, data);
         }
 
-        // get the count from mongo
-        return db.db(usedb).collection(collectionName).count(query, options, (err, res) => {
-          db.close();
-          if (err) {
-            log.warn(`${origin}: Failed to count collection ${err}`);
-            return callback(`${origin}: Failed to count collection ${err}`, null);
-          }
-          log.debug(`${origin}: Count from database ${res}`);
-          return callback(null, res);
-        });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // get the count from mongo
+          return mongoClient.db(database).collection(collectionName).count(query, options, (err, res) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            if (err) {
+              log.warn(`${origin}: Failed to count collection ${err}`);
+              return callback(`${origin}: Failed to count collection ${err}`, null);
+            }
+            log.debug(`${origin}: Count from database ${res}`);
+            return callback(null, res);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -1028,11 +1040,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-delete`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName) {
@@ -1048,51 +1055,46 @@ class DBUtil {
         return callback(`${origin}: Missing Multiple flag`, null);
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // verify the collection exists
-        if (!fs.existsSync(`${adapterDir}/storage/${collectionName}.json`)) {
-          log.warn(`${origin}: Collection ${collectionName} does not exist`);
-          return callback(null, `${origin}: Collection ${collectionName} does not exist`);
-        }
-        // remove the item from the collection
-        const deld = removeFromJSON(collectionName, filter, multiple);
-        if (!deld) {
-          log.warn(`${origin}: Data has not been deleted from file storage`);
-          return callback(`${origin}: Data has not been deleted from file storage`, null);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.debug(`${origin}: Data has been deleted from file storage`);
-        return callback(null, deld);
-      }
 
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
-
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // verify the collection exists
+          if (!fs.existsSync(`${adapterDir}/storage/${collectionName}.json`)) {
+            log.warn(`${origin}: Collection ${collectionName} does not exist`);
+            return callback(null, `${origin}: Collection ${collectionName} does not exist`);
+          }
+          // remove the item from the collection
+          const deld = removeFromJSON(collectionName, filter, multiple);
+          if (!deld) {
+            log.warn(`${origin}: Data has not been deleted from file storage`);
+            return callback(`${origin}: Data has not been deleted from file storage`, null);
+          }
+          log.debug(`${origin}: Data has been deleted from file storage`);
+          return callback(null, deld);
         }
 
-        if (!multiple) {
-          // delete the single item from mongo
-          return db.db(usedb).collection(collectionName).deleteOne(filter, options, (err, res) => {
-            db.close();
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          if (!multiple) {
+            // delete the single item from mongo
+            return mongoClient.db(database).collection(collectionName).deleteOne(filter, options, (err, res) => {
+              if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+              if (err) {
+                log.warn(`${origin}: Failed to delete data from database ${err}`);
+                return callback(`${origin}: Failed delete data from database ${err}`, null);
+              }
+              log.debug(`${origin}: Data has been deleted from database`);
+              return callback(null, res);
+            });
+          }
+
+          // delete the multiple items from mongo
+          return mongoClient.db(database).collection(collectionName).deleteMany(filter, options, (err, res) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
             if (err) {
               log.warn(`${origin}: Failed to delete data from database ${err}`);
               return callback(`${origin}: Failed delete data from database ${err}`, null);
@@ -1101,17 +1103,6 @@ class DBUtil {
             return callback(null, res);
           });
         }
-
-        // delete the multiple items from mongo
-        return db.db(usedb).collection(collectionName).deleteMany(filter, options, (err, res) => {
-          db.close();
-          if (err) {
-            log.warn(`${origin}: Failed to delete data from database ${err}`);
-            return callback(`${origin}: Failed delete data from database ${err}`, null);
-          }
-          log.debug(`${origin}: Data has been deleted from database`);
-          return callback(null, res);
-        });
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -1133,11 +1124,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-replaceOne`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName) {
@@ -1153,58 +1139,42 @@ class DBUtil {
         return callback(`${origin}: Missing Document`, null);
       }
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // remove the data from the collection
-        const rem = removeFromJSON(collectionName, filter, false);
-        if (rem) {
-          // add the data into the collection
-          const sav = saveAsJson(collectionName, doc);
-          if (sav) {
-            log.debug(`${origin}: Data replaced in file storage`);
-            return callback(null, sav);
-          }
-          log.warn(`${origin}: Could not save doc into file storage`);
-          return callback(`${origin}: Could not save doc into file storage`, null);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.warn(`${origin}: Could not delete from file storage`);
-        return callback(`${origin}: Could not delete from file storage`, null);
-      }
-
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
 
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // remove the data from the collection
+          const rem = removeFromJSON(collectionName, filter, false);
+          if (rem) {
+            // add the data into the collection
+            const sav = saveAsJson(collectionName, doc);
+            if (sav) {
+              log.debug(`${origin}: Data replaced in file storage`);
+              return callback(null, sav);
+            }
+            log.warn(`${origin}: Could not save doc into file storage`);
+            return callback(`${origin}: Could not save doc into file storage`, null);
+          }
+          log.warn(`${origin}: Could not delete from file storage`);
+          return callback(`${origin}: Could not delete from file storage`, null);
         }
 
-        // replace an items in mongo
-        return db.db(usedb).collection(collectionName).replaceOne(filter, doc, options, (err, res) => {
-          db.close();
-          if (err) {
-            log.warn(`${origin}: Failed to replace data in database ${err}`);
-            return callback(`${origin}: Failed replace data in database ${err}`, null);
-          }
-          log.debug(`${origin}: Data replaced in file storage`);
-          return callback(null, res);
-        });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // replace an items in mongo
+          return mongoClient.db(database).collection(collectionName).replaceOne(filter, doc, options, (err, res) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            if (err) {
+              log.warn(`${origin}: Failed to replace data in database ${err}`);
+              return callback(`${origin}: Failed replace data in database ${err}`, null);
+            }
+            log.debug(`${origin}: Data replaced in file storage`);
+            return callback(null, res);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -1231,11 +1201,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-find`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (!collectionName) {
@@ -1276,55 +1241,45 @@ class DBUtil {
         return key;
       });
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // Find it from file in the adapter
-        let toReturn = getFromJson(collectionName, filter);
-        if (toReturn && toReturn.length > limit) {
-          let curEnd = start + limit;
-          if (curEnd < toReturn.length) {
-            curEnd = toReturn.length;
-          }
-          toReturn = toReturn.slice(start, curEnd);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.trace(`${origin}: Data retrieved from file storage`);
-        return callback(null, toReturn);
-      }
-
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
 
-      // work with the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error || !db) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // Find it from file in the adapter
+          let toReturn = getFromJson(collectionName, options);
+          if (collectionName === 'adapter_configs') {
+            log.debug(`${origin}: Data retrieved from file storage`);
+            return callback(null, [toReturn]);
+          }
+          if (toReturn && toReturn.length > limit) {
+            let curEnd = start + limit;
+            if (curEnd < toReturn.length) {
+              curEnd = toReturn.length;
+            }
+            toReturn = toReturn.slice(start, curEnd);
+          }
+          log.debug(`${origin}: Data retrieved from file storage`);
+          return callback(null, toReturn);
         }
 
-        // Find the data in the database
-        return db.db(usedb).collection(collectionName).find(filter).sort(sort)
-          .skip(start)
-          .limit(limit)
-          .toArray()
-          .then((value) => {
-            db.close();
-            log.debug(`${origin}: Data retrieved from database`);
-            return callback(null, value);
-          });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // Find the data in the database
+          return mongoClient.db(database).collection(collectionName).find(filter).sort(sort)
+            .skip(start)
+            .limit(limit)
+            .toArray()
+            .then((value) => {
+              log.debug(`${origin}: Data retrieved from database`);
+              return callback(null, value);
+            })
+            .finally(() => {
+              if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);
@@ -1350,11 +1305,6 @@ class DBUtil {
     const origin = `${this.myid}-dbUtil-findAndModify`;
     log.trace(origin);
 
-    // set the default database
-    let usedburl = this.dburl;
-    let usedbopt = this.dboptions;
-    let usedb = this.database;
-
     try {
       // verify the required data has been provided
       if (collectionName === undefined || collectionName === null || collectionName === '') {
@@ -1372,54 +1322,36 @@ class DBUtil {
         returnOriginal: false
       };
 
-      // if using file storage
-      if (this.dburl === null && dbInfo === null && fsWrite === true) {
-        // save it to file in the adapter storage directory
-        const saved = saveAsJson(collectionName, data);
-        if (!saved) {
-          log.error(`${origin}: Data has not been saved`);
-          return callback(`${origin}: Data has not been saved`, null);
+      return this.determineStorage(dbInfo, (storageError, storage, mongoClient, database) => {
+        if (storageError) {
+          return callback(`${origin}: ${storageError}`, null);
         }
-        log.debug(`${origin}: Data modified in file storage`);
-        return callback(null, saved);
-      }
 
-      // if we were passed in dbInfo, verify it contains all the pieces we want
-      if (!dbInfo || !dbInfo.dburl || !dbInfo.database) {
-        log.warn(`${origin}: Improper dbInfo provided should have dburl and database! Using default database`);
-      }
-      // if we were passed in dbInfo, that should supercede the default database
-      if (dbInfo && dbInfo.dburl && dbInfo.database) {
-        usedburl = dbInfo.dburl;
-        usedbopt = dbInfo.dboptions;
-        usedb = dbInfo.database;
-      }
-
-      if (!usedburl || !usedb) {
-        log.warn(`${origin}: Did not find database to connect to`);
-        return callback(`${origin}: Did not find database to connect to`, null);
-      }
-
-      // connect to the provided database
-      return MongoClient.connect(usedburl, usedbopt, (error, db) => {
-        if (error) {
-          // no Database connection available
-          log.warn(`${origin}: Error connecting to Mongo ${error}`);
-          return callback(`${origin}: Error connecting to Mongo ${error}`, null);
+        // if using file storage
+        if (storage === Storage.FILESYSTEM) {
+          // save it to file in the adapter storage directory
+          const saved = saveAsJson(collectionName, data);
+          if (!saved) {
+            log.error(`${origin}: Data has not been saved`);
+            return callback(`${origin}: Data has not been saved`, null);
+          }
+          log.debug(`${origin}: Data modified in file storage`);
+          return callback(null, saved);
         }
 
-        // find and modify the data in the database
-        return db.db(usedb).collection(collectionName).findOneAndUpdate((filter || {}), data, options, (err, result) => {
-          // close the database connexton
-          db.close();
-
-          if (err) {
-            log.warn(`${origin}: Failed to modified data in database ${err}`);
-            return callback(`${origin}: Failed modified data in database ${err}`, null);
-          }
-          log.debug(`${origin}: Data modified in database`);
-          return callback(null, result);
-        });
+        // if using MongoDB storage
+        if (storage === Storage.DBINFO || storage === Storage.ADAPTERDB) {
+          // find and modify the data in the database
+          return mongoClient.db(database).collection(collectionName).findOneAndUpdate((filter || {}), data, options, (err, result) => {
+            if (storage === Storage.DBINFO && mongoClient) mongoClient.close();
+            if (err) {
+              log.warn(`${origin}: Failed to modified data in database ${err}`);
+              return callback(`${origin}: Failed modified data in database ${err}`, null);
+            }
+            log.debug(`${origin}: Data modified in database`);
+            return callback(null, result);
+          });
+        }
       });
     } catch (ex) {
       log.warn(`${origin}: Caught Exception - ${ex}`);