@itentialopensource/adapter-gcp_compute 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,4 +1,12 @@
 
+## 1.0.1 [12-21-2021]
+
+* Don't call readPropsKeyFile in the constructor - if already have a key
+
+See merge request itentialopensource/adapters/cloud/adapter-gcp_compute!4
+
+---
+
 ## 1.0.0 [07-28-2021]
 
 * add Firewall Policies calls

package/adapter.js

@@ -34,7 +34,7 @@ class GcpCompute extends AdapterBaseCl {
 
     // for gtoken documentation see https://googleapis.dev/nodejs/gtoken/latest/index.html
     this.configureGtokenFromProps();
-    this.keyObj = this.readPropsKeyFile();
+    // this.keyObj = this.readPropsKeyFile(); // jorrok 2021-12-20 this method shoud not be called if we have a key; but as it stands, healthCheck depends on keyObj :-(
     // log.debug(`constructor keyObj is ${JSON.stringify(this.keyObj)}`)
 
     // const restFunctionNames = this.getWorkflowFunctions();
@@ -128,7 +128,8 @@ class GcpCompute extends AdapterBaseCl {
       'refreshAccessTokenPromise',
       'refreshAuthorizationHeader',
       'refreshAuthorizationAndIdentifyRequest',
-      'getToken'
+      'getToken',
+      'generateKeyObjFromProps'
     ];
     if (!inIgnore && Array.isArray(inIgnore)) {
       myIgnore = inIgnore;
@@ -602,12 +603,35 @@ class GcpCompute extends AdapterBaseCl {
     return args.reduce((subObj, level) => subObj && subObj[level], obj);
   }
 
-  readPropsKeyFile() {
+  generateKeyObjFromProps(someProps) {
+    // the blank object comes from https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating
+    // the only properties you should be supplying (at most) are the ones with hyphenated dummy values
+    // ie: project_id, private_key_id, private_key, client_email, client_id, client_x509_cert_url
+    // of which as of ADAPT-1898 only project_id is used (for the adapter's own healthCheck)
+    const blank = {
+      type: 'service_account',
+      project_id: 'project-id',
+      private_key_id: 'key-id',
+      private_key: '-----BEGIN PRIVATE KEY-----\nprivate-key\n-----END PRIVATE KEY-----\n',
+      client_email: 'service-account-email',
+      client_id: 'client-id',
+      auth_uri: 'https://accounts.google.com/o/oauth2/auth',
+      token_uri: 'https://accounts.google.com/o/oauth2/token',
+      auth_provider_x509_cert_url: 'https://www.googleapis.com/oauth2/v1/certs',
+      client_x509_cert_url: 'https://www.googleapis.com/robot/v1/metadata/x509/service-account-email'
+    };
+    this.keyObj = Object.keys(blank).reduce((gen, key) => ({
+      ...gen,
+      [key]: someProps.hasOwnProperty(key) ? someProps[key] : blank[key] // eslint-disable-line no-prototype-builtins
+    }), {});
+  }
+
+  readPropsKeyFile(keyFile) {
     const meth = 'adapter-readPropsKeyFile';
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
     try {
-      const keyFile = this.getNested(this, 'allProps', 'authentication', 'configureGtoken', 'keyFile') || process.env.GOOGLE_APPLICATION_CREDENTIALS;
+      // const keyFile = this.getNested(this, 'allProps', 'authentication', 'configureGtoken', 'keyFile') || process.env.GOOGLE_APPLICATION_CREDENTIALS;
       // log.debug(`readPropsKeyFile keyFile is ${keyFile}`)
       if (!keyFile) {
         throw new Error('No keyFile specified in Service Config or GOOGLE_APPLICATION_CREDENTIALS');
@@ -633,7 +657,10 @@ class GcpCompute extends AdapterBaseCl {
       const configureGtoken = this.getNested(this, 'allProps', 'authentication', 'configureGtoken') || {};
       if (!configureGtoken.key) {
         configureGtoken.keyFile = configureGtoken.keyFile || process.env.GOOGLE_APPLICATION_CREDENTIALS || null;
+        this.keyObj = this.readPropsKeyFile(configureGtoken.keyFile);
       } else {
+        const { project_id } = configureGtoken; // eslint-disable-line camelcase
+        this.generateKeyObjFromProps({ project_id }); // eslint-disable-line camelcase
         delete configureGtoken.keyFile;
       }
       if (configureGtoken.key || configureGtoken.keyFile) {
@@ -738,6 +765,7 @@ class GcpCompute extends AdapterBaseCl {
         if (kfc && kfc.private_key) {
           keyFile = null; // eslint-disable-line no-param-reassign
           key = kfc.private_key; // eslint-disable-line no-param-reassign
+          this.keyObj = kfc;
         } else {
           throw new Error('Did not obtain private_key from keyFileContents');
         }
@@ -760,6 +788,7 @@ class GcpCompute extends AdapterBaseCl {
       log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
       return callback(null, errorObj);
     }
+    if (keyFile) this.keyObj = this.readPropsKeyFile(keyFile);
 
     // build the options for GoogleToken and call it
     const gOptions = Array.from(arguments).reduce((r, v, i) => { // eslint-disable-line prefer-rest-params

package/adapterBase.js

@@ -22,6 +22,7 @@ const AjvCl = require('ajv');
 const PropUtilCl = require('@itentialopensource/adapter-utils').PropertyUtility;
 const RequestHandlerCl = require('@itentialopensource/adapter-utils').RequestHandler;
 
+const entitiesToDB = require(path.join(__dirname, 'utils/entitiesToDB'));
 const troubleshootingAdapter = require(path.join(__dirname, 'utils/troubleshootingAdapter'));
 const tbUtils = require(path.join(__dirname, 'utils/tbUtils'));
 
@@ -1001,6 +1002,27 @@ class AdapterBase extends EventEmitterCl {
       return [];
     }
   }
+
+  /**
+   * @summary moves entities to mongo database
+   *
+   * @function moveEntitiesToDB
+   *
+   * @return {Callback} - containing the response from the mongo transaction
+   */
+  moveEntitiesToDB(callback) {
+    const meth = 'adapterBase-moveEntitiesToDB';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return callback(entitiesToDB.moveEntitiesToDB(__dirname, { pronghornProps: this.allProps, id: this.id }), null);
+    } catch (err) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, err);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
 }
 
 module.exports = AdapterBase;

package/entities/.generic/action.json

@@ -4,7 +4,7 @@
       "name": "getGenerics",
       "protocol": "REST",
       "method": "GET",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -25,7 +25,7 @@
       "name": "createGeneric",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -46,7 +46,7 @@
       "name": "updateGeneric",
       "protocol": "REST",
       "method": "PUT",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -67,7 +67,7 @@
       "name": "patchGeneric",
       "protocol": "REST",
       "method": "PATCH",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -88,7 +88,7 @@
       "name": "deleteGeneric",
       "protocol": "REST",
       "method": "DELETE",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@itentialopensource/adapter-gcp_compute",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "This adapter integrates with system described as: computeEngineApi.",
   "main": "adapter.js",
-  "wizardVersion": "2.44.0",
-  "engineVersion": "1.59.28",
+  "wizardVersion": "2.44.7",
+  "engineVersion": "1.59.50",
   "adapterType": "http",
   "scripts": {
     "artifactize": "npm i && node utils/packModificationScript.js",
-    "preinstall": "node utils/setup.js",
+    "preinstall": "node utils/setup.js && npm install --package-lock-only --ignore-scripts && npx npm-force-resolutions",
     "lint": "node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js",
     "lint:errors": "node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js --quiet",
     "test:baseunit": "mocha test/unit/adapterBaseTestUnit.js --LOG=error",
@@ -16,7 +16,7 @@
     "test:integration": "mocha test/integration/adapterTestIntegration.js --LOG=error",
     "test:cover": "nyc --reporter html --reporter text mocha --reporter dot test/*",
     "test": "npm run test:baseunit && npm run test:unit && npm run test:integration",
-    "adapter:install": "node utils/tbScript.js install",
+    "adapter:install": "npm i && node utils/tbScript.js install",
     "adapter:checkMigrate": "node utils/checkMigrate.js",
     "adapter:findPath": "node utils/findPath.js",
     "adapter:migrate": "node utils/modify.js -m",
@@ -26,7 +26,7 @@
     "healthcheck": "node utils/tbScript.js healthcheck",
     "basicget": "node utils/tbScript.js basicget",
     "connectivity": "node utils/tbScript.js connectivity",
-    "deploy": "npm publish --registry=http://registry.npmjs.org --access=public",
+    "deploy": "npm publish --registry=https://registry.npmjs.org --access=public",
     "build": "npm run deploy"
   },
   "keywords": [
@@ -54,7 +54,7 @@
   "author": "Itential",
   "homepage": "https://gitlab.com/itentialopensource/adapters/cloud/adapter-gcp_compute#readme",
   "dependencies": {
-    "@itentialopensource/adapter-utils": "^4.44.0",
+    "@itentialopensource/adapter-utils": "^4.44.11",
     "ajv": "^6.12.0",
     "axios": "^0.21.0",
     "commander": "^2.20.0",
@@ -62,6 +62,7 @@
     "gtoken": "^5.2.1",
     "mocha": "^9.0.1",
     "mocha-param": "^2.0.1",
+    "mongodb": "^4.1.0",
     "network-diagnostics": "^0.5.3",
     "nyc": "^15.1.0",
     "readline-sync": "^1.4.10",
@@ -77,5 +78,8 @@
     "package-json-validator": "^0.6.3",
     "testdouble": "^3.16.1"
   },
+  "resolutions": {
+    "minimist": "^1.2.5"
+  },
   "private": false
 }

package/test/unit/adapterBaseTestUnit.js

@@ -317,7 +317,7 @@ describe('[unit] Adapter Base Test', () => {
       });
       it('should return a list of functions', (done) => {
         const returnedFunctions = ['addEntityCache', 'capabilityResults', 'checkActionFiles', 'checkProperties', 'connect', 'encryptProperty',
-          'entityInList', 'findPath', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck',
+          'entityInList', 'findPath', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck', 'moveEntitiesToDB',
           'refreshProperties', 'runBasicGet', 'runConnectivity', 'runHealthcheck', 'suspend', 'troubleshoot', 'unsuspend', 'updateAdapterConfiguration', 'addListener',
           'emit', 'eventNames', 'getMaxListeners', 'listenerCount', 'listeners', 'off', 'on', 'once', 'prependListener',
           'prependOnceListener', 'rawListeners', 'removeAllListeners', 'removeListener', 'setMaxListeners'];

package/test/unit/adapterTestUnit.js

@@ -362,7 +362,7 @@ describe('[unit] GcpCompute Adapter Test', () => {
           assert.notEqual(undefined, packageDotJson.scripts);
           assert.notEqual(null, packageDotJson.scripts);
           assert.notEqual('', packageDotJson.scripts);
-          assert.equal('node utils/setup.js', packageDotJson.scripts.preinstall);
+          assert.equal('node utils/setup.js && npm install --package-lock-only --ignore-scripts && npx npm-force-resolutions', packageDotJson.scripts.preinstall);
           assert.equal('node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js', packageDotJson.scripts.lint);
           assert.equal('node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js --quiet', packageDotJson.scripts['lint:errors']);
           assert.equal('mocha test/unit/adapterBaseTestUnit.js --LOG=error', packageDotJson.scripts['test:baseunit']);
@@ -370,7 +370,7 @@ describe('[unit] GcpCompute Adapter Test', () => {
           assert.equal('mocha test/integration/adapterTestIntegration.js --LOG=error', packageDotJson.scripts['test:integration']);
           assert.equal('nyc --reporter html --reporter text mocha --reporter dot test/*', packageDotJson.scripts['test:cover']);
           assert.equal('npm run test:baseunit && npm run test:unit && npm run test:integration', packageDotJson.scripts.test);
-          assert.equal('npm publish --registry=http://registry.npmjs.org --access=public', packageDotJson.scripts.deploy);
+          assert.equal('npm publish --registry=https://registry.npmjs.org --access=public', packageDotJson.scripts.deploy);
           assert.equal('npm run deploy', packageDotJson.scripts.build);
           done();
         } catch (error) {

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/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

@@ -178,7 +178,7 @@ module.exports = {
     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) {
+    if (currentPath.trim() !== expectedPath.trim()) {
       throw new Error(`adapter should be installed under ${expectedPath}`);
     }
 
@@ -304,8 +304,9 @@ module.exports = {
    * @param {Object} adapterPronghorn - ./pronghorn.json in adapter dir
    * @param {Object} sampleProperties - './sampleProperties.json' in adapter dir
    */
-  createAdapter: (pronghornProps, profileItem, sampleProperties, adapterPronghorn) => {
-    const packagePath = `${__dirname.split('node_modules')[0]}package.json`;
+  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);
 
@@ -338,6 +339,31 @@ module.exports = {
     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, this.getDirname(), discovery);
+    console.log('Found properties.\n');
+    return pronghornProps;
+  },
+
+  // get database connection and existing adapter config
+  getAdapterConfig: async function getAdapterConfig() {
+    const iapDir = path.join(this.getDirname(), '../../../../');
+    const pronghornProps = this.getPronghornProps(iapDir);
+    console.log('Connecting to Database...');
+    const database = await this.connect(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
    *
@@ -385,5 +411,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 path.join(stdout, 'utils');
+  },
+
+  /**
+   * @summary connect to mongodb
+   *
+   * @function connect
+   * @param {Object} properties - pronghornProps
+   */
+  connect: async function connect(properties) {
+    // Connect to Mongo
+    const { MongoDBConnection } = require(path.join(this.getDirname(), '../../../', '@itential/database'));
+    const connection = new MongoDBConnection(properties.mongoProps);
+    const database = await connection.connect(true);
+    return database;
   }
+
 };

package/utils/troubleshootingAdapter.js

@@ -117,30 +117,6 @@ const VerifyHealthCheckEndpoint = (serviceItem, props, scriptFlag) => {
   return { result, updatedAdapter };
 };
 
-const getPronghornProps = (iapDir) => {
-  console.log('Retrieving properties.json file...');
-  const rawProps = require(path.join(iapDir, 'properties.json'));
-  console.log('Decrypting properties...');
-  const { Discovery } = require('@itential/itential-utils');
-  const discovery = new Discovery();
-  const pronghornProps = utils.decryptProperties(rawProps, __dirname, discovery);
-  console.log('Found properties.\n');
-  return pronghornProps;
-};
-
-// get database connection and existing adapter config
-const getAdapterConfig = async () => {
-  const iapDir = path.join(__dirname, '../../../../');
-  const pronghornProps = getPronghornProps(iapDir);
-  console.log('Connecting to Database...');
-  const database = await basicGet.connect(pronghornProps);
-  console.log('Connection established.');
-  const serviceItem = await database.collection(utils.SERVICE_CONFIGS_COLLECTION).findOne(
-    { model: name }
-  );
-  return { database, serviceItem, pronghornProps };
-};
-
 const offline = async () => {
   console.log('Start offline troubleshooting');
   const { updatedAdapter } = VerifyHealthCheckEndpoint({ properties: sampleProperties }, {}, true);
@@ -159,7 +135,7 @@ const offline = async () => {
 
 const troubleshoot = async (props, scriptFlag, persistFlag, adapter) => {
   // get database connection and existing adapter config
-  const { database, serviceItem } = await getAdapterConfig();
+  const { database, serviceItem } = await utils.getAdapterConfig();
   // where troubleshoot should start
   if (serviceItem) {
     if (!scriptFlag || rls.keyInYN(`Start verifying the connection and authentication properties for ${name}?`)) {
@@ -211,4 +187,4 @@ const troubleshoot = async (props, scriptFlag, persistFlag, adapter) => {
   return null;
 };
 
-module.exports = { troubleshoot, getAdapterConfig, offline };
+module.exports = { troubleshoot, offline };