@itentialopensource/adapter-f5_bigiq 0.5.7 → 0.6.0

package/utils/troubleshootingAdapter.js

@@ -6,10 +6,8 @@
 
 const path = require('path');
 const rls = require('readline-sync');
-const fs = require('fs-extra');
 
-const utils = require(path.join(__dirname, 'tbUtils'));
-const basicGet = require(path.join(__dirname, 'basicGet'));
+const tbUtils = require(path.join(__dirname, 'tbUtils'));
 const { name } = require(path.join(__dirname, '..', 'package.json'));
 const sampleProperties = require(path.join(__dirname, '..', 'sampleProperties.json'));
 
@@ -21,7 +19,7 @@ const collectAnswersSync = (questions, props) => {
     const answer = rls.question(q);
     answers.push(answer);
   });
-  return utils.getNewProps(answers, props);
+  return tbUtils.getNewProps(answers, props);
 };
 
 // change object into array of questions
@@ -33,7 +31,7 @@ const confirm = (props) => {
 // allow user to change auth_method
 const confirmAuthOptions = (authentication) => {
   const authOptions = ['basic user_password', 'request_token', 'static_token', 'no_authentication'];
-  const displayAuthOptions = utils.getDisplayAuthOptions(authentication.auth_method, authOptions);
+  const displayAuthOptions = tbUtils.getDisplayAuthOptions(authentication.auth_method, authOptions);
   const index = rls.keyInSelect(displayAuthOptions, 'Which authentication?');
   if (index === -1) {
     return authentication.auth_method;
@@ -45,7 +43,7 @@ const confirmAuthOptions = (authentication) => {
 // helper function to update auth properties
 const confirmAndUpdate = (auth, config) => {
   const newAuth = confirm(auth);
-  return utils.updateAuth(newAuth, auth, config);
+  return tbUtils.updateAuth(newAuth, auth, config);
 };
 
 // extract basic auth properties
@@ -69,34 +67,40 @@ const updateStaticAuth = (config, authentication) => {
 
 // troubleshooting connection and healthcheck endpoint setting of adapter
 const VerifyHealthCheckEndpoint = (serviceItem, props, scriptFlag) => {
-  // Updates connectivity params and runs connectivity
   let connConfig;
   const result = {};
+
   if (scriptFlag) {
-    const connection = utils.getConnection(serviceItem.properties);
+    const connection = tbUtils.getConnection(serviceItem.properties);
     const newConnection = confirm(connection);
-    utils.runConnectivity(newConnection.host, scriptFlag);
-    connConfig = utils.updateNewConnection(serviceItem, newConnection);
+    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) {
-      connConfig = utils.updateNewConnection(serviceItem, props.connProps);
       host = connConfig.properties.properties.host;
-    } else {
-      connConfig = serviceItem;
     }
-    result.connectivity = utils.runConnectivity(host, scriptFlag);
+
+    result.connectivity = tbUtils.runConnectivity(host, scriptFlag);
   }
-  // Updates the healthcheck endpoing
-  const healthcheck = require('../entities/.system/action.json');
-  const healthCheckEndpoint = utils.getHealthCheckEndpoint(healthcheck);
+
+  // 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);
-    utils.getHealthCheckEndpointURL(newHealthCheckEndpoint, connConfig);
+    tbUtils.getHealthCheckEndpointURL(newHealthCheckEndpoint, connConfig);
   } else if (props.healthCheckEndpoint) {
     newHealthCheckEndpoint = props.healthCheckEndpoint;
   }
+
   // Updates the authorization params
   const { authentication } = connConfig.properties.properties;
   let updatedAdapter = connConfig;
@@ -110,84 +114,64 @@ const VerifyHealthCheckEndpoint = (serviceItem, props, scriptFlag) => {
       console.log('current troubleshooting script does not support updating request_token authentication');
     }
   } else if (props.auth) {
-    updatedAdapter = utils.updateAuth(props.auth, authentication, connConfig);
+    updatedAdapter = tbUtils.updateAuth(props.auth, authentication, connConfig);
   }
-  // Writes the new healthcheck endpoint into action.json
-  utils.updateHealthCheckEndpoint(newHealthCheckEndpoint, healthCheckEndpoint, healthcheck);
   return { result, updatedAdapter };
 };
 
-const offline = async () => {
-  console.log('Start offline troubleshooting');
-  const { updatedAdapter } = VerifyHealthCheckEndpoint({ properties: sampleProperties }, {}, true);
-  const a = basicGet.getAdapterInstance(updatedAdapter);
-  const res = await utils.healthCheck(a);
-  if (!res) {
-    console.log('run `npm run troubleshoot` again to update settings');
-    process.exit(0);
-  }
-  console.log('Save changes to sampleProperties.json');
-  await fs.writeFile('sampleProperties.json', JSON.stringify(updatedAdapter.properties, null, 2));
-  if (rls.keyInYN('Test with more GET request')) {
-    await utils.runBasicGet(true);
-  }
-};
-
-const troubleshoot = async (props, scriptFlag, persistFlag, adapter) => {
+const troubleshoot = async (props, scriptFlag, adapter) => {
   let serviceItem;
+
   if (adapter && adapter.allProps) {
     serviceItem = { properties: { properties: adapter.allProps } };
-  }
-  if (adapter && adapter.properties && adapter.properties.properties) {
+  } 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 (serviceItem) {
-    if (!scriptFlag || rls.keyInYN(`Start verifying the connection and authentication properties for ${name}?`)) {
-      const { result, updatedAdapter } = VerifyHealthCheckEndpoint(serviceItem, props, scriptFlag);
-      let a;
-      if (scriptFlag) {
-        a = basicGet.getAdapterInstance(updatedAdapter);
-      } else {
-        a = adapter;
-      }
-      const healthRes = await utils.healthCheck(a);
-      result.healthCheck = healthRes;
-      if (scriptFlag && !healthRes) {
-        console.log('run `npm run troubleshoot` again to update settings');
-        process.exit(0);
-      }
-
-      if (persistFlag && healthRes) {
-        const { database } = await utils.getIAPDatabaseConnection();
-        const update = { $set: { properties: updatedAdapter.properties } };
-        await database.collection(utils.SERVICE_CONFIGS_COLLECTION).updateOne({ model: name }, update);
-        if (scriptFlag) {
-          console.log(`${name} updated.`);
-        }
-      }
-      if (scriptFlag) {
-        if (rls.keyInYN('Test with more GET request')) {
-          await utils.runBasicGet(scriptFlag);
-          process.exit(0);
-        } else {
-          console.log('Exiting');
-          process.exit(0);
-        }
-      } else {
-        result.basicGet = await utils.runBasicGet(scriptFlag);
-        return result;
-      }
+
+  if (scriptFlag) {
+    if (rls.keyInYN('Test with more GET request')) {
+      await tbUtils.runBasicGet(serviceItem.properties.properties, true);
     } else {
-      console.log('You can update healthCheckEndpoint in ./entities/.system/action.json');
-      console.log('You can update authentication credientials under Settings/Services');
       console.log('Exiting');
-      process.exit(0);
     }
-  } else {
-    console.log(`${name} not installed`);
-    console.log('run `npm run install:adapter` to install current adapter to IAP first. Exiting...');
+    process.exit(0);
   }
-  return null;
+
+  result.basicGet = await tbUtils.runBasicGet(serviceItem.properties.properties, false);
+
+  return result;
 };
 
-module.exports = { troubleshoot, offline };
+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 };

package/utils/addAuth.js

@@ -1,94 +0,0 @@
-/* eslint-disable no-plusplus */
-/* eslint global-require: warn */
-/* eslint import/no-dynamic-require: warn */
-
-const path = require('path');
-const fs = require('fs');
-const rls = require('readline-sync');
-
-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/artifactize.js

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-/* @copyright Itential, LLC 2019 */
-
-const path = require('path');
-const fs = require('fs-extra');
-
-async function createBundle(adapterOldDir) {
-  // set directories
-  const artifactDir = path.join(adapterOldDir, '../artifactTemp');
-  const workflowsDir = path.join(adapterOldDir, 'workflows');
-
-  // read adapter's package and set names
-  const adapterPackage = fs.readJSONSync(path.join(adapterOldDir, 'package.json'));
-  const originalName = adapterPackage.name.substring(adapterPackage.name.lastIndexOf('/') + 1);
-  const shortenedName = originalName.replace('adapter-', '');
-  const artifactName = originalName.replace('adapter', 'bundled-adapter');
-
-  const adapterNewDir = path.join(artifactDir, 'bundles', 'adapters', originalName);
-  fs.ensureDirSync(adapterNewDir);
-
-  const ops = [];
-
-  // copy old adapterDir to bundled hierarchy location
-  ops.push(() => fs.copySync(adapterOldDir, adapterNewDir));
-
-  // copy readme
-  ops.push(() => fs.copySync(path.join(adapterOldDir, 'README.md'), path.join(artifactDir, 'README.md')));
-
-  // copy changelog
-  if (fs.existsSync(path.join(adapterOldDir, 'CHANGELOG.md'))) {
-    ops.push(() => fs.copySync(path.join(adapterOldDir, 'CHANGELOG.md'), path.join(artifactDir, 'CHANGELOG.md')));
-  }
-
-  // copy license
-  if (fs.existsSync(path.join(adapterOldDir, 'LICENSE'))) {
-    ops.push(() => fs.copySync(path.join(adapterOldDir, 'LICENSE'), path.join(artifactDir, 'LICENSE')));
-  }
-
-  // create package
-  const artifactPackage = {
-    name: artifactName,
-    version: adapterPackage.version,
-    description: `A bundled version of the ${originalName} to be used in adapter-artifacts for easy installation`,
-    scripts: {
-      test: 'echo "Error: no test specified" && exit 1',
-      deploy: 'npm publish --registry=http://registry.npmjs.org'
-    },
-    keywords: [
-      'IAP',
-      'artifacts',
-      'Itential',
-      'Pronghorn',
-      'Adapter',
-      'Adapter-Artifacts',
-      shortenedName
-    ],
-    author: 'Itential Artifacts',
-    license: 'Apache-2.0',
-    repository: adapterPackage.repository,
-    private: false,
-    devDependencies: {
-      r2: '^2.0.1',
-      ajv: '6.10.0',
-      'better-ajv-errors': '^0.6.1',
-      'fs-extra': '^7.0.1'
-    }
-  };
-
-  ops.push(() => fs.writeJSONSync(path.join(artifactDir, 'package.json'), artifactPackage, { spaces: 2 }));
-
-  // create manifest
-  const manifest = {
-    bundleName: originalName,
-    version: adapterPackage.version,
-    fingerprint: 'Some verifiable token',
-    createdEpoch: '1554836984020',
-    artifacts: [
-      {
-        id: `${shortenedName}-adapter`,
-        name: `${shortenedName}-adapter`,
-        type: 'adapter',
-        location: `/bundles/adapters/${originalName}`,
-        description: artifactPackage.description,
-        properties: {
-          entryPoint: false
-        }
-      }
-    ]
-  };
-
-  // add workflows into artifact
-  if (fs.existsSync(workflowsDir)) {
-    const workflowFileNames = fs.readdirSync(workflowsDir);
-
-    // if folder isnt empty and only file is not readme
-    if (workflowFileNames.length !== 0 && (!(workflowFileNames.length === 1 && workflowFileNames[0].split('.')[1] === 'md'))) {
-      // add workflows to correct location in bundle
-      ops.push(() => fs.copySync(workflowsDir, path.join(artifactDir, 'bundles', 'workflows')));
-
-      // add workflows to manifest
-      workflowFileNames.forEach((filename) => {
-        const [filenameNoExt, ext] = filename.split('.');
-        if (ext === 'json') {
-          manifest.artifacts.push({
-            id: `workflow-${filenameNoExt}`,
-            name: filenameNoExt,
-            type: 'workflow',
-            location: `/bundles/workflows/${filename}`,
-            description: 'Main entry point to artifact',
-            properties: {
-              entryPoint: false
-            }
-          });
-        }
-      });
-    }
-  }
-
-  ops.push(() => fs.writeJSONSync(path.join(artifactDir, 'manifest.json'), manifest, { spaces: 2 }));
-
-  // Run the commands in parallel
-  try {
-    await Promise.all(ops.map(async (op) => op()));
-  } catch (e) {
-    throw new Error(e);
-  }
-
-  const pathObj = {
-    bundlePath: artifactDir,
-    bundledAdapterPath: path.join(artifactDir, 'bundles', 'adapters', originalName)
-  };
-  return pathObj;
-}
-
-async function artifactize(entryPathToAdapter) {
-  const truePath = path.resolve(entryPathToAdapter);
-  const packagePath = path.join(truePath, 'package');
-  // remove adapter from package and move bundle in
-  const pathObj = await createBundle(packagePath);
-  const { bundlePath } = pathObj;
-  fs.removeSync(packagePath);
-  fs.moveSync(bundlePath, packagePath);
-  return 'Bundle successfully created and old folder system removed';
-}
-
-module.exports = { createBundle, artifactize };

package/utils/basicGet.js

@@ -1,50 +0,0 @@
-/* @copyright Itential, LLC 2020 */
-
-/* eslint object-shorthand: warn */
-/* 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');
-
-const logLevel = 'none';
-const myCustomLevels = {
-  levels: {
-    spam: 6,
-    trace: 5,
-    debug: 4,
-    info: 3,
-    warn: 2,
-    error: 1,
-    none: 0
-  }
-};
-
-const basicGet = {
-  /**
-   * @summary create Adapter instance
-   *
-   * @function getAdapterInstance
-   * @param {Object} adapter - adaper configuration object required by IAP
-   */
-  getAdapterInstance: (adapter) => {
-    const Adapter = require('../adapter');
-    const adapterProps = JSON.parse(JSON.stringify(adapter.properties.properties));
-    adapterProps.stub = false;
-    // need to set global logging
-    global.log = winston.createLogger({
-      level: logLevel,
-      levels: myCustomLevels.levels,
-      transports: [
-        new winston.transports.Console()
-      ]
-    });
-    return new Adapter(
-      adapter.id,
-      adapterProps
-    );
-  }
-};
-
-module.exports = basicGet;