@itentialopensource/adapter-meraki 0.7.3 → 0.8.0

package/utils/addAuth.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-plusplus */
+/* eslint global-require: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const rls = require('readline-sync');
+const path = require('path');
+const fs = require('fs');
+
+function getQuestions(props, obj) {
+  const questions = props.map((p) => `${p}: ${(obj[p] !== undefined) ? `(${obj[p]})` : ''} `);
+  return questions;
+}
+
+// function outputs each property for user to edit/confirm
+// props are the fields that need to be changed depending on what the user selects
+// obj is the JSON object that's being updated
+function confirm(props, obj) {
+  // create array of questions
+  const updatedObj = obj;
+  getQuestions(props, obj).forEach((q) => {
+    const answer = rls.question(q);
+    // only update the field if the answer is NOT and empty string
+    if (answer) {
+      updatedObj[q.split(':')[0].trim()] = answer;
+    }
+  });
+  return updatedObj;
+}
+
+const updateBasicAuth = (auth) => {
+  const propsToUpdate = ['username', 'password', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+const updateStaticTokenAuth = (auth) => {
+  const propsToUpdate = ['token', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+function updateTokenSchemas(user, pw, token) {
+  let schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenReq.json');
+  const reqSchema = require(schemaPath);
+  reqSchema.properties.username.external_name = user;
+  reqSchema.properties.password.external_name = pw;
+  fs.writeFileSync(schemaPath, JSON.stringify(reqSchema, null, 2));
+  schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenResp.json');
+  const respSchema = require(schemaPath);
+  respSchema.properties.token.external_name = token;
+  fs.writeFileSync(schemaPath, JSON.stringify(respSchema, null, 2));
+}
+
+function updateRequestToken(auth) {
+  const propsToUpdate = [
+    'username',
+    'password',
+    'auth_field',
+    'auth_field_format',
+    'token_user_field',
+    'token_password_field',
+    'token_result_field',
+    'token_URI_path'
+  ];
+  const newAuth = confirm(propsToUpdate, auth);
+  updateTokenSchemas(newAuth.token_user_field, newAuth.token_password_field, newAuth.token_result_field);
+
+  return newAuth;
+}
+
+// prompt users to pick an auth method from the list above
+const addAuthInfo = (props) => {
+  const authOptions = [
+    'basic user_password',
+    'static_token',
+    'request_token',
+    'no_authentication'
+  ];
+  const newProps = confirm(['host', 'port', 'base_path'], props);
+
+  const newAuthMethod = authOptions[rls.keyInSelect(authOptions, 'Which authentication method?')];
+  newProps.authentication.auth_method = newAuthMethod;
+
+  if (newAuthMethod === 'basic user_password') {
+    newProps.authentication = updateBasicAuth(newProps.authentication);
+  } else if (newAuthMethod === 'static_token') {
+    newProps.authentication = updateStaticTokenAuth(newProps.authentication);
+  } else if (newAuthMethod === 'request_token') {
+    newProps.authentication = updateRequestToken(newProps.authentication);
+  }
+  console.log('Connectivity and authentication properties have been configured');
+  console.log('If you want to make changes, rerun this script to reinstall the adapter');
+  return newProps;
+};
+
+module.exports = { addAuthInfo };

package/utils/basicGet.js

@@ -4,6 +4,7 @@
 /* eslint import/no-extraneous-dependencies: warn */
 /* eslint global-require: warn */
 /* eslint import/no-unresolved: warn */
+/* eslint import/no-dynamic-require: warn */
 
 const winston = require('winston');
 
@@ -43,20 +44,6 @@ const basicGet = {
       adapter.id,
       adapterProps
     );
-  },
-
-  /**
-   * @summary connect to mongodb
-   *
-   * @function connect
-   * @param {Object} properties - pronghornProps
-   */
-  connect: async function connect(properties) {
-    // Connect to Mongo
-    const { MongoDBConnection } = require('@itential/database');
-    const connection = new MongoDBConnection(properties.mongoProps);
-    const database = await connection.connect(true);
-    return database;
   }
 };
 

package/utils/entitiesToDB.js

@@ -0,0 +1,224 @@
+/* @copyright Itential, LLC 2021 */
+
+// Set globals
+/* global log */
+
+/* eslint import/no-dynamic-require: warn */
+/* eslint global-require: warn */
+/* eslint no-unused-vars: warn */
+/* eslint import/no-unresolved: warn */
+
+/**
+ *  This script is used to read through an adapter's entities files
+ *  and then creates documents and enters them into the IAP mongodb
+ */
+
+const fs = require('fs');
+const { MongoClient } = require('mongodb');
+const path = require('path');
+// const { argv } = require('process');
+// const { string } = require('yargs');
+
+// get the pronghorn database information
+const getPronghornProps = async (iapDir) => {
+  log.trace('Retrieving properties.json file...');
+  const rawProps = require(path.join(iapDir, 'properties.json'));
+  log.trace('Decrypting properties...');
+  const { PropertyEncryption } = require('@itential/itential-utils');
+  const propertyEncryption = new PropertyEncryption();
+  const pronghornProps = await propertyEncryption.decryptProps(rawProps);
+  log.trace('Found properties.\n');
+  return pronghornProps;
+};
+
+/**
+ *  Function used to take a file path to a entity directory and build
+ *  a document that corresponds to the entity files.
+ */
+const buildDoc = (pathstring) => {
+  let files = fs.readdirSync(pathstring);
+
+  // load the mockdatafiles
+  const mockdatafiles = {};
+  if (files.includes('mockdatafiles') && fs.lstatSync(`${pathstring}/mockdatafiles`).isDirectory()) {
+    fs.readdirSync(`${pathstring}/mockdatafiles`).forEach((file) => {
+      if (file.split('.').pop() === 'json') {
+        const mockpath = `${pathstring}/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(`${pathstring}/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(`${pathstring}/${file}`));
+    schema.push({
+      name: file,
+      schema: data
+    });
+  });
+
+  // return the data
+  return {
+    actions: actions.actions,
+    schema,
+    mockdatafiles
+  };
+};
+
+/**
+ *  Function used to get the database from the options or a provided directory
+ */
+const optionsHandler = (options) => {
+  // if the database properties were provided in the options - return them
+  if (options.pronghornProps) {
+    if (typeof options.pronghornProps === 'string') {
+      return JSON.parse(options.pronghornProps);
+    }
+    return new Promise((resolve, reject) => resolve(options.pronghornProps));
+  }
+
+  // if the directory was provided, get the pronghorn props from the directory
+  if (options.iapDir) {
+    return getPronghornProps(options.iapDir);
+  }
+
+  // if nothing was provided, error
+  return new Promise((resolve, reject) => reject(new Error('Neither pronghornProps nor iapDir defined in options!')));
+};
+
+/**
+ *  Function used to put the adapter configuration into the provided database
+ */
+const moveEntitiesToDB = (targetPath, options) => {
+  // set local variables
+  let myOpts = options;
+  let myPath = targetPath;
+
+  // if we got a string parse into a JSON object
+  if (typeof myOpts === 'string') {
+    myOpts = JSON.parse(myOpts);
+  }
+
+  // if there is no target collection - set the collection to the default
+  if (!myOpts.targetCollection) {
+    myOpts.targetCollection = 'adapter_configs';
+  }
+
+  // if there is no id error since we need an id for the entities
+  if (!myOpts.id) {
+    throw new Error('Adapter ID required!');
+  }
+
+  // get the pronghorn database properties
+  optionsHandler(options).then((currentProps) => {
+    let mongoUrl;
+    let dbName;
+
+    // find the mongo properties so we can connect
+    if (currentProps.mongoProps) {
+      mongoUrl = currentProps.mongoProps.url;
+      dbName = currentProps.mongoProps.db;
+    } else if (currentProps.mongo) {
+      if (currentProps.mongo.url) {
+        mongoUrl = currentProps.mongo.url;
+      } else {
+        mongoUrl = `mongodb://${currentProps.mongo.host}:${currentProps.mongo.port}`;
+      }
+      dbName = currentProps.mongo.database;
+    } else {
+      throw new Error('Mongo properties are not specified in adapter preferences!');
+    }
+
+    // Check valid filepath provided
+    if (!myPath) {
+      // if no path use the current directory without the utils
+      myPath = path.join(__dirname, '../');
+    } else if (myPath.slice(-1) === '/') {
+      myPath = myPath.slice(0, -1);
+    }
+
+    // verify set the entity path
+    const entitiesPath = `${myPath}/entities`;
+    if (!fs.existsSync(entitiesPath)) {
+      throw new Error(`Entities path does not exist in filesystem: ${entitiesPath}`);
+    } else {
+      log.trace('Target found on filesystem');
+    }
+
+    // Get adapter details
+    if (!fs.existsSync(`${myPath}/pronghorn.json`)) {
+      throw new Error(`pronghorn.json does not exist in path: ${myPath}`);
+    } else {
+      log.trace('pronghorn.json found on filesystem');
+    }
+    const adapterData = JSON.parse(fs.readFileSync(`${myPath}/pronghorn.json`));
+
+    // Load files from the filesystem
+    const docs = [];
+    const entities = fs.readdirSync(entitiesPath);
+    entities.forEach((entity) => {
+      const entityPath = `${entitiesPath}/${entity}`;
+      const isDir = fs.lstatSync(entitiesPath).isDirectory();
+
+      // Build doc for entity
+      if (isDir) {
+        let doc = buildDoc(entityPath);
+        doc = {
+          id: myOpts.id,
+          type: adapterData.id,
+          entity,
+          ...doc
+        };
+        docs.push(doc);
+      }
+    });
+
+    // Upload documents to db collection
+    MongoClient.connect(mongoUrl, (err, db) => {
+      if (err) {
+        log.error(JSON.stringify(err));
+        throw err;
+      }
+
+      // get the proper collection
+      const collection = db.db(dbName).collection(myOpts.targetCollection);
+      // insert the documents into the collection
+      collection.insertMany(docs, { checkKeys: false }, (error, res) => {
+        if (error) {
+          log.error(JSON.stringify(error));
+          throw error;
+        }
+        // log the insertion, close the database and return
+        log.debug(`Inserted ${docs.length} documents to ${dbName}.${myOpts.targetCollection} with response ${JSON.stringify(res)}`);
+        db.close();
+        return res;
+      });
+    });
+  });
+};
+
+// const args = process.argv.slice(2);
+
+// throw new SyntaxError(args[0]);
+
+// if (args.length === 0) {
+//   console.error('ERROR: target path not specified!');
+// } else if (args[0] === 'help') {
+//   log.trace('node ./entitiesToDB <target path> <options object: {iapDir: string, pronghornProps: string, targetCollection: string}>');
+// } else if (args.length === 1) {
+//   console.error('ERROR: IAP directory not specified');
+// } else {
+//   moveEntitiesToDB(args[0], args[1]);
+// }
+
+module.exports = { moveEntitiesToDB };

package/utils/modify.js

@@ -3,7 +3,7 @@ const Ajv = require('ajv');
 const rls = require('readline-sync');
 const { execSync } = require('child_process');
 const { existsSync } = require('fs-extra');
-const { getAdapterConfig } = require('./troubleshootingAdapter');
+const { getAdapterConfig } = require('./tbUtils');
 const { name } = require('../package.json');
 const propertiesSchema = require('../propertiesSchema.json');
 

package/utils/patches2bundledDeps.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const semverSatisfies = require('semver/functions/satisfies');
+const packageJson = require('../package.json');
+
+try {
+  // pattern supplied by semver.org via https://regex101.com/r/vkijKf/1/ but removed gm from end to only match a single semver
+  // const semverPat = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+  // pattern supplied by semver.org via https://regex101.com/r/Ly7O1x/3/ with following changes
+  // removed P's from before capturing group names and
+  // removed  gm from end to only match a single semver
+  // const semverPat = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+  const patches = (fs.existsSync('./patches')) ? fs.readdirSync('./patches', { withFileTypes: true }) : [];
+  if (!patches.length) {
+    console.error('\nno patches - nothing to do\n');
+    process.exitCode = 1;
+  }
+
+  const dependencies = packageJson.dependencies || {};
+  if (!Object.keys(dependencies).length) {
+    console.error('\nno dependencies - nothing to do\n');
+    process.exitCode = 1;
+  }
+
+  let changed = false;
+  console.error('\nprocessing patches');
+  const bundledDependencies = packageJson.bundledDependencies || packageJson.bundleDependencies || [];
+
+  patches.forEach((patch) => {
+    if (!patch.isFile()) {
+      console.error(`${patch.name} skipped, is not a regular file`);
+      return;
+    }
+    if (!patch.name.endsWith('.patch')) {
+      console.error(`${patch.name} skipped, does not end with .patch`);
+      return;
+    }
+    const splits = patch.name.slice(0, -6).split('+');
+    if (splits.length > 4) {
+      console.error(`${patch.name} skipped, does not follow the naming convention (cannot use '+' other than to separate scope/package/semver and at most once within semver)`);
+      return;
+    }
+    const scope = splits[0][0] === '@' ? splits.shift() : null;
+    const packageName = splits.shift();
+    const semver = splits.join('+');
+    // const { groups } = semver.match(semverPat);
+    const file = scope ? `${scope}/${packageName}` : packageName;
+    if (dependencies[file] && semverSatisfies(semver, dependencies[file])) {
+      if (!bundledDependencies.includes(file)) {
+        bundledDependencies.push(file);
+        console.error(`added ${file} to bundledDependencies`);
+        changed = true;
+      } else {
+        console.error(`bundledDependencies already has ${file}`);
+      }
+    } else {
+      const depmsg = dependencies[file] ? `version mismatch (${dependencies[file]}) in dependencies` : 'not found in dependencies';
+      console.error(`patch ${patch.name} ${depmsg}`);
+    }
+  });
+
+  if (!packageJson.bundledDependencies && bundledDependencies.length) {
+    delete packageJson.bundleDependencies;
+    packageJson.bundledDependencies = bundledDependencies;
+    console.error('renaming bundleDependencies to bundledDependencies');
+    changed = true;
+  }
+  if (changed) {
+    fs.writeFileSync('./package.json.new', JSON.stringify(packageJson, null, 2));
+    console.error('wrote package.json.new');
+    fs.renameSync('./package.json', './package.json.old');
+    console.error('moved package.json to package.json.old');
+    fs.renameSync('./package.json.new', './package.json');
+    console.error('moved package.json.new to package.json');
+  } else {
+    console.error('no changes\n');
+    process.exitCode = 1;
+  }
+} catch (e) {
+  if (e) {
+    // caught error, exit with status 2 to signify abject failure
+    console.error(`\ncaught exception - ${e}\n`);
+    process.exitCode = 2;
+  } else {
+    // caught false, exit with status 1 to signify nothing done
+    process.exitCode = 1;
+  }
+} finally {
+  console.error('done\n');
+}

package/utils/removeHooks.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+
+/**
+ * This script will uninstall pre-commit or pre-push hooks in case there's ever a need to
+ * commit/push something that has issues
+ */
+
+const precommitPath = '.git/hooks/pre-commit';
+const prepushPath = '.git/hooks/pre-push';
+fs.unlink(precommitPath, (err) => {
+  if (err && err.code !== 'ENOENT') {
+    console.log(`${err.message}`);
+  }
+});
+
+fs.unlink(prepushPath, (err) => {
+  if (err && err.code !== 'ENOENT') {
+    console.log(`${err.message}`);
+  }
+});

package/utils/tbScript.js

@@ -15,13 +15,18 @@ const basicGet = require('./basicGet');
 const { name } = require('../package.json');
 const sampleProperties = require('../sampleProperties.json');
 const adapterPronghorn = require('../pronghorn.json');
+const { addAuthInfo } = require('./addAuth');
 
-const { troubleshoot, getAdapterConfig, offline } = require('./troubleshootingAdapter');
+const { troubleshoot, offline } = require('./troubleshootingAdapter');
 
 const main = async (command) => {
-  const iapDir = path.join(__dirname, '../../../../');
+  const dirname = utils.getDirname();
+  const iapDir = path.join(dirname, '../../../');
   if (!utils.withinIAP(iapDir)) {
-    if (command === 'connectivity') {
+    if (command === 'install') {
+      console.log('Not currently in IAP directory - installation not possible');
+      process.exit(0);
+    } else if (command === 'connectivity') {
       const { host } = sampleProperties.properties;
       console.log(`perform networking diagnositics to ${host}`);
       await utils.runConnectivity(host);
@@ -43,7 +48,7 @@ const main = async (command) => {
   if (command === undefined) {
     await troubleshoot({}, true, true);
   } else if (command === 'install') {
-    const { database, serviceItem, pronghornProps } = await getAdapterConfig();
+    const { database, serviceItem, pronghornProps } = await utils.getAdapterConfig();
     const filter = { id: pronghornProps.id };
     const profileItem = await database.collection(utils.IAP_PROFILES_COLLECTION).findOne(filter);
     if (!profileItem) {
@@ -74,14 +79,16 @@ const main = async (command) => {
         process.exit(0);
       }
     } else {
-      utils.verifyInstallationDir(__dirname, name);
-      utils.npmInstall();
+      utils.verifyInstallationDir(dirname, name);
       utils.runTest();
       if (rls.keyInYN(`Do you want to install ${name} to IAP?`)) {
         console.log('Creating database entries...');
         const adapter = utils.createAdapter(
           pronghornProps, profileItem, sampleProperties, adapterPronghorn
         );
+
+        adapter.properties.properties = await addAuthInfo(adapter.properties.properties);
+
         await database.collection(utils.SERVICE_CONFIGS_COLLECTION).insertOne(adapter);
         profileItem.services.push(adapter.name);
         const update = { $set: { services: profileItem.services } };
@@ -94,7 +101,7 @@ const main = async (command) => {
       process.exit(0);
     }
   } else if (['healthcheck', 'basicget', 'connectivity'].includes(command)) {
-    const { serviceItem } = await getAdapterConfig();
+    const { serviceItem } = await utils.getAdapterConfig();
     if (serviceItem) {
       const adapter = serviceItem;
       const a = basicGet.getAdapterInstance(adapter);
@@ -154,7 +161,6 @@ program.parse(process.argv);
 if (process.argv.length < 3) {
   main();
 }
-
 const allowedParams = ['install', 'healthcheck', 'basicget', 'connectivity'];
 if (process.argv.length === 3 && !allowedParams.includes(process.argv[2])) {
   console.log(`unknown parameter ${process.argv[2]}`);

package/utils/tbUtils.js

@@ -100,8 +100,8 @@ module.exports = {
    *
    * @function decryptProperties
    */
-  decryptProperties: (props, dirname, discovery) => {
-    const propertyEncryptionClassPath = path.join(dirname, '../../../@itential/pronghorn-core/core/PropertyEncryption.js');
+  decryptProperties: (props, iapDir, discovery) => {
+    const propertyEncryptionClassPath = path.join(iapDir, 'node_modules/@itential/pronghorn-core/core/PropertyEncryption.js');
     const isEncrypted = props.pathProps.encrypted;
     const PropertyEncryption = discovery.require(propertyEncryptionClassPath, isEncrypted);
     const propertyEncryption = new PropertyEncryption({
@@ -177,12 +177,12 @@ module.exports = {
   verifyInstallationDir: (dirname, name) => {
     const pathArray = dirname.split(path.sep);
     const expectedPath = `node_modules/${name}`;
-    const currentPath = pathArray.slice(pathArray.length - 4, pathArray.length - 1).join('/');
-    if (expectedPath !== currentPath) {
-      throw new Error(`adapter should be installed under ${expectedPath}`);
+    const currentPath = pathArray.slice(pathArray.length - 3, pathArray.length).join('/');
+    if (currentPath.trim() !== expectedPath.trim()) {
+      throw new Error(`adapter should be installed under ${expectedPath} but is installed under ${currentPath}`);
     }
 
-    const serverFile = path.join(dirname, '../../../..', 'server.js');
+    const serverFile = path.join(dirname, '../../../', 'server.js');
     if (!fs.existsSync(serverFile)) {
       throw new Error(`adapter should be installed under IAP/${expectedPath}`);
     }
@@ -304,23 +304,72 @@ module.exports = {
    * @param {Object} adapterPronghorn - ./pronghorn.json in adapter dir
    * @param {Object} sampleProperties - './sampleProperties.json' in adapter dir
    */
-  createAdapter: (pronghornProps, profileItem, sampleProperties, adapterPronghorn) => {
-    const adapter = {
-      mongoProps: pronghornProps.mongoProps,
-      isEncrypted: pronghornProps.pathProps.encrypted,
-      model: adapterPronghorn.id,
-      name: sampleProperties.id,
-      type: adapterPronghorn.type,
-      properties: sampleProperties,
-      redisProps: profileItem.redisProps,
-      loggerProps: profileItem.loggerProps,
-      rabbitmq: profileItem.rabbitmq
-    };
+  createAdapter: function createAdapter(pronghornProps, profileItem, sampleProperties, adapterPronghorn) {
+    const dirname = this.getDirname();
+    const packagePath = `${dirname.split('node_modules')[0]}package.json`;
+    const info = JSON.parse(fs.readFileSync(packagePath));
+    const version = parseInt(info.version.split('.')[0], 10);
+
+    let adapter = {};
+    if (version >= 2020) {
+      adapter = {
+        isEncrypted: pronghornProps.pathProps.encrypted,
+        model: adapterPronghorn.id,
+        name: sampleProperties.id,
+        type: adapterPronghorn.type,
+        properties: sampleProperties,
+        loggerProps: profileItem.loggerProps
+      };
+    } else {
+      adapter = {
+        mongoProps: pronghornProps.mongoProps,
+        isEncrypted: pronghornProps.pathProps.encrypted,
+        model: adapterPronghorn.id,
+        name: sampleProperties.id,
+        type: adapterPronghorn.type,
+        properties: sampleProperties,
+        redisProps: profileItem.redisProps,
+        loggerProps: profileItem.loggerProps,
+        rabbitmq: profileItem.rabbitmq
+      };
+      adapter.mongoProps.pdb = true;
+    }
+
     adapter.loggerProps.log_filename = `adapter-${adapter.name}.log`;
-    adapter.mongoProps.pdb = true;
     return adapter;
   },
 
+  getPronghornProps: function getPronghornProps(iapDir) {
+    console.log('Retrieving properties.json file...');
+    const rawProps = require(path.join(iapDir, 'properties.json'));
+    console.log('Decrypting properties...');
+    const { Discovery } = require(path.join(iapDir, 'node_modules/@itential/itential-utils'));
+    const discovery = new Discovery();
+    const pronghornProps = this.decryptProperties(rawProps, iapDir, discovery);
+    console.log('Found properties.\n');
+    return pronghornProps;
+  },
+
+  // get database connection and existing adapter config
+  getAdapterConfig: async function getAdapterConfig() {
+    const newDirname = this.getDirname();
+    let iapDir;
+    if (this.withinIAP(newDirname)) { // when this script is called from IAP
+      iapDir = newDirname;
+    } else {
+      iapDir = path.join(this.getDirname(), 'utils', '../../../../');
+    }
+    const pronghornProps = this.getPronghornProps(iapDir);
+    console.log('Connecting to Database...');
+    const database = await this.connect(iapDir, pronghornProps);
+    console.log('Connection established.');
+    const { name } = require(path.join(__dirname, '..', 'package.json'));
+    const serviceItem = await database.collection(this.SERVICE_CONFIGS_COLLECTION).findOne(
+      { model: name }
+    );
+    return { database, serviceItem, pronghornProps };
+  },
+
   /**
    * @summary return async healthcheck result as a Promise
    *
@@ -368,5 +417,35 @@ module.exports = {
     } catch (error) {
       return false;
     }
+  },
+
+  /**
+   * @summary Used to determine the proper dirname to return in case adapter reference is
+   * symlinked withink IAP
+   * @returns the symlinked path (using pwd command) of the adapter in case properties.json
+   * is not found in the original path
+   * @function getDirname
+   */
+  getDirname: function getDirname() {
+    if (this.withinIAP(path.join(__dirname, '../../../../'))) {
+      return __dirname;
+    }
+    const { stdout } = this.systemSync('pwd', true);
+    return stdout.trim();
+  },
+
+  /**
+   * @summary connect to mongodb
+   *
+   * @function connect
+   * @param {Object} properties - pronghornProps
+   */
+  connect: async function connect(iapDir, properties) {
+    // Connect to Mongo
+    const { MongoDBConnection } = require(path.join(iapDir, 'node_modules/@itential/database'));
+    const connection = new MongoDBConnection(properties.mongoProps);
+    const database = await connection.connect(true);
+    return database;
   }
+
 };