@itentialopensource/adapter-aws_lambda 0.1.1

package/utils/troubleshootingAdapter.js

@@ -0,0 +1,177 @@
+/* @copyright Itential, LLC 2020 */
+/* eslint global-require: warn */
+/* eslint no-console: warn */
+/* eslint import/no-unresolved: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const path = require('path');
+const rls = require('readline-sync');
+
+const tbUtils = require(path.join(__dirname, 'tbUtils'));
+const { name } = require(path.join(__dirname, '..', 'package.json'));
+const sampleProperties = require(path.join(__dirname, '..', 'sampleProperties.json'));
+
+// send interactive questions and collection answers
+// return updated connection object
+const collectAnswersSync = (questions, props) => {
+  const answers = [];
+  questions.forEach((q) => {
+    const answer = rls.question(q);
+    answers.push(answer);
+  });
+  return tbUtils.getNewProps(answers, props);
+};
+
+// change object into array of questions
+const confirm = (props) => {
+  const questions = Object.keys(props).map((key) => `${key}: (${props[key]}) `);
+  return collectAnswersSync(questions, props);
+};
+
+// allow user to change auth_method
+const confirmAuthOptions = (authentication) => {
+  const authOptions = ['basic user_password', 'request_token', 'static_token', 'no_authentication'];
+  const displayAuthOptions = tbUtils.getDisplayAuthOptions(authentication.auth_method, authOptions);
+  const index = rls.keyInSelect(displayAuthOptions, 'Which authentication?');
+  if (index === -1) {
+    return authentication.auth_method;
+  }
+  console.log(`${authOptions[index]} is selected.`);
+  return authOptions[index];
+};
+
+// helper function to update auth properties
+const confirmAndUpdate = (auth, config) => {
+  const newAuth = confirm(auth);
+  return tbUtils.updateAuth(newAuth, auth, config);
+};
+
+// extract basic auth properties
+const updateBasicAuth = (config, authentication) => {
+  const auth = {
+    username: authentication.username,
+    password: authentication.password
+  };
+  return confirmAndUpdate(auth, config);
+};
+
+// extract static auth properties
+const updateStaticAuth = (config, authentication) => {
+  const auth = {
+    token: authentication.token,
+    auth_field: authentication.auth_field,
+    auth_field_format: authentication.auth_field_format
+  };
+  return confirmAndUpdate(auth, config);
+};
+
+// troubleshooting connection and healthcheck endpoint setting of adapter
+const VerifyHealthCheckEndpoint = (serviceItem, props, scriptFlag) => {
+  let connConfig;
+  const result = {};
+
+  if (scriptFlag) {
+    const connection = tbUtils.getConnection(serviceItem.properties);
+    const newConnection = confirm(connection);
+    tbUtils.runConnectivity(newConnection.host, scriptFlag);
+    connConfig = tbUtils.updateNewConnection(serviceItem, newConnection);
+  } else {
+    let { properties: { properties: { host } } } = serviceItem;
+
+    connConfig = props.connProps
+      ? tbUtils.updateNewConnection(serviceItem, props.connProps)
+      : serviceItem;
+
+    if (props.connProps) {
+      host = connConfig.properties.properties.host;
+    }
+
+    result.connectivity = tbUtils.runConnectivity(host, scriptFlag);
+  }
+
+  // Updates the healthcheck endpoint
+  const healthcheck = require(path.resolve(__dirname, '../entities/.system/action.json'));
+  const healthCheckEndpoint = tbUtils.getHealthCheckEndpoint(healthcheck);
+  let newHealthCheckEndpoint = healthCheckEndpoint;
+
+  if (scriptFlag) {
+    newHealthCheckEndpoint = confirm(healthCheckEndpoint);
+    tbUtils.getHealthCheckEndpointURL(newHealthCheckEndpoint, connConfig);
+  } else if (props.healthCheckEndpoint) {
+    newHealthCheckEndpoint = props.healthCheckEndpoint;
+  }
+
+  // Updates the authorization params
+  const { authentication } = connConfig.properties.properties;
+  let updatedAdapter = connConfig;
+  if (scriptFlag) {
+    authentication.auth_method = confirmAuthOptions(authentication);
+    if (authentication.auth_method === 'basic user_password') {
+      updatedAdapter = updateBasicAuth(connConfig, authentication);
+    } else if (authentication.auth_method === 'static_token') {
+      updatedAdapter = updateStaticAuth(connConfig, authentication);
+    } else if (authentication.auth_method === 'request_token') {
+      console.log('current troubleshooting script does not support updating request_token authentication');
+    }
+  } else if (props.auth) {
+    updatedAdapter = tbUtils.updateAuth(props.auth, authentication, connConfig);
+  }
+  return { result, updatedAdapter };
+};
+
+const troubleshoot = async (props, scriptFlag, adapter) => {
+  let serviceItem;
+
+  if (adapter && adapter.allProps) {
+    serviceItem = { properties: { properties: adapter.allProps } };
+  } else if (adapter && adapter.properties && adapter.properties.properties) {
+    serviceItem = adapter.properties;
+  } else {
+    serviceItem = { properties: sampleProperties };
+  }
+
+  if (!serviceItem) {
+    console.log(`${name} not installed`);
+    console.log('run `npm run install:adapter` to install current adapter to IAP first. Exiting...');
+    if (scriptFlag) {
+      process.exit(1);
+    }
+    return null;
+  }
+
+  const shouldRun = !scriptFlag || rls.keyInYN(`Start verifying the connection and authentication properties for ${name}?`);
+  if (!shouldRun) {
+    console.log('You can update healthCheckEndpoint in ./entities/.system/action.json');
+    console.log('You can update authentication credientials under Settings/Services');
+    if (scriptFlag) {
+      process.exit(0);
+    }
+    return null;
+  }
+
+  const { result, updatedAdapter } = VerifyHealthCheckEndpoint(serviceItem, props, scriptFlag);
+  const a = scriptFlag ? tbUtils.getAdapterInstance(updatedAdapter) : adapter;
+
+  const healthRes = await tbUtils.healthCheck(a);
+  result.healthCheck = healthRes;
+
+  if (scriptFlag && !healthRes) {
+    console.log('run `npm run troubleshoot` again to update settings');
+    process.exit(1);
+  }
+
+  if (scriptFlag) {
+    if (rls.keyInYN('Test with more GET request')) {
+      await tbUtils.runBasicGet(serviceItem.properties.properties, true);
+    } else {
+      console.log('Exiting');
+    }
+    process.exit(0);
+  }
+
+  result.basicGet = await tbUtils.runBasicGet(serviceItem.properties.properties, false);
+
+  return result;
+};
+
+module.exports = { troubleshoot };

package/utils/updateAdapterConfig.js

@@ -0,0 +1,158 @@
+/* @copyright Itential, LLC 2025 */
+
+// Set globals
+/* global log */
+
+const fs = require('fs');
+const path = require('path');
+const PropUtilCl = require('@itentialopensource/adapter-utils').PropertyUtility;
+const MongoDBConnection = require('./mongoDbConnection');
+
+const propUtil = new PropUtilCl();
+
+/**
+ * Updates action configuration in the document
+ * @param {Object} doc - Document to update
+ * @param {string} action - Action name
+ * @param {Object} changes - Changes to apply
+ * @returns {Object} Updated document
+ */
+function updateActionConfig(doc, action, changes) {
+  const updateDoc = { ...doc };
+  if (!updateDoc.actions) updateDoc.actions = [];
+  const actionIndex = updateDoc.actions.findIndex((a) => a.name === action);
+  if (actionIndex >= 0) {
+    updateDoc.actions[actionIndex] = propUtil.mergeProperties(changes, updateDoc.actions[actionIndex]);
+  } else {
+    updateDoc.actions.push({ name: action, ...changes });
+  }
+  return updateDoc;
+}
+
+/**
+ * Updates schema configuration in the document
+ * @param {Object} doc - Document to update
+ * @param {string} configFile - Configuration file name
+ * @param {Object} changes - Changes to apply
+ * @returns {Object} Updated document
+ */
+function updateSchemaConfig(doc, configFile, changes) {
+  const updateDoc = { ...doc };
+  if (!updateDoc.schema) updateDoc.schema = [];
+  const schemaIndex = updateDoc.schema.findIndex((s) => s.name === configFile);
+  if (schemaIndex >= 0) {
+    updateDoc.schema[schemaIndex].schema = propUtil.mergeProperties(changes, updateDoc.schema[schemaIndex].schema);
+  } else {
+    updateDoc.schema.push({ name: configFile, schema: changes });
+  }
+  return updateDoc;
+}
+
+/**
+ * Updates mock data configuration in the document
+ * @param {Object} doc - Document to update
+ * @param {string} configFile - Configuration file name
+ * @param {Object} changes - Changes to apply
+ * @param {boolean} replace - Whether to replace or merge
+ * @returns {Object} Updated document
+ */
+function updateMockConfig(doc, configFile, changes, replace) {
+  const updateDoc = { ...doc };
+  if (!updateDoc.mockdatafiles) updateDoc.mockdatafiles = {};
+  updateDoc.mockdatafiles[configFile] = replace ? changes : propUtil.mergeProperties(changes, updateDoc.mockdatafiles[configFile] || {});
+  return updateDoc;
+}
+
+/**
+ * Configuration update strategies for different types
+ */
+const updateStrategies = {
+  action: (doc, configFile, changes, action) => (!action ? doc : updateActionConfig(doc, action, changes)),
+  schema: (doc, configFile, changes) => updateSchemaConfig(doc, configFile, changes),
+  mock: (doc, configFile, changes, replace) => updateMockConfig(doc, configFile, changes, replace)
+};
+
+/**
+ * Updates MongoDB configuration for an adapter entity
+ * @param {Object} options - Configuration options
+ * @param {string} options.id - Adapter ID
+ * @param {Object} options.mongoProps - MongoDB connection properties
+ * @param {string} options.entity - Entity name
+ * @param {string} options.type - Update type (action/schema/mock)
+ * @param {string} options.configFile - Configuration file name
+ * @param {Object} options.changes - Changes to apply
+ * @param {string} options.action - Action name (for action type updates)
+ * @param {boolean} options.replace - Whether to replace or merge (for mock type updates)
+ * @returns {Promise<void>}
+ */
+async function updateMongoDBConfig(options) {
+  const {
+    id,
+    mongoProps,
+    entity,
+    type,
+    configFile,
+    changes,
+    action,
+    replace
+  } = options;
+
+  if (!mongoProps) {
+    log.error('MongoDB properties not found');
+    return;
+  }
+
+  let mongoConnection = null;
+  try {
+    // Get adapter type from pronghorn.json
+    const pronghornPath = path.join(__dirname, '../pronghorn.json');
+    const pronghornData = JSON.parse(fs.readFileSync(pronghornPath, 'utf8'));
+    const adapterType = pronghornData.id;
+
+    mongoConnection = new MongoDBConnection(mongoProps);
+    await mongoConnection.connect();
+
+    const collection = mongoConnection.db.collection('adapter_configs');
+    const query = {
+      id,
+      type: adapterType,
+      entity
+    };
+
+    const existingConfig = await collection.findOne(query);
+    if (!existingConfig) {
+      log.debug(`No existing configuration found for entity ${entity}`);
+      return;
+    }
+
+    // Update the configuration based on type
+    const updateStrategy = updateStrategies[type];
+    if (!updateStrategy) {
+      log.error(`Unsupported update type: ${type}`);
+      return;
+    }
+
+    const updatedDoc = updateStrategy(existingConfig, configFile, changes, action || replace);
+
+    // Remove _id from updateDoc as it can't be modified
+    const { _id, ...updateDocWithoutId } = updatedDoc;
+    const updateResult = await collection.updateOne(
+      { id, type: adapterType, entity },
+      { $set: updateDocWithoutId }
+    );
+
+    if (updateResult.modifiedCount === 0) {
+      log.warn(`No documents were modified for entity ${entity}`);
+    }
+    log.info(`Successfully updated MongoDB configuration for entity ${entity}`);
+  } catch (error) {
+    log.error(`Error updating MongoDB configuration: ${error.message}`);
+    throw error;
+  } finally {
+    if (mongoConnection) {
+      await mongoConnection.closeConnection();
+    }
+  }
+}
+
+module.exports = { updateMongoDBConfig };