@itentialopensource/adapter-generic 0.1.8 → 0.2.0

package/utils/argParser.js

@@ -0,0 +1,44 @@
+const customLevels = {
+  spam: 6,
+  trace: 5,
+  debug: 4,
+  info: 3,
+  warn: 2,
+  error: 1,
+  none: 0
+};
+
+function parseArgs(argv = process.argv) {
+  let properties = null;
+  let logLevel = 'none';
+  let maxCalls = 5;
+  let host = null;
+
+  argv.forEach((val) => {
+    if (val.startsWith('--PROPS=')) {
+      // get the properties
+      const inputVal = val.split('=')[1];
+      properties = JSON.parse(inputVal);
+    } else if (val.startsWith('--LOG=')) {
+      // get the desired log level
+      const level = val.split('=')[1];
+      // validate the log level is supported, if so set it
+      if (Object.hasOwnProperty.call(customLevels, level)) {
+        logLevel = level;
+      }
+    } else if (val.startsWith('--MAXCALLS=')) {
+      const override = parseInt(val.split('=')[1], 10);
+      if (!Number.isNaN(override) && override > 0) {
+        maxCalls = override;
+      }
+    } else if (val.startsWith('--HOST=')) {
+      [, host] = val.split('=');
+    }
+  });
+
+  return {
+    properties, logLevel, maxCalls, host
+  };
+}
+
+module.exports = { parseArgs };

package/utils/checkMigrate.js

@@ -1,63 +1,102 @@
+/* @copyright Itential, LLC 2025 */
+
+/**
+ * This script will determine if the adapter needs to be upgraded, a migration is needed or
+ * a remediation is needed. This is self contained and depends on accessing GitLab repos as well as
+ * finding files within the adapter to gather and compare information.
+ *
+ * This utility is executed from a script in the package.json by `npm run adapter:checkMigrate`. As a result,
+ * this utility is exposed and available to customers but exclusively through the CLI.
+ */
+
 const { execSync } = require('child_process');
-const fs = require('fs');
 const semver = require('semver');
-const axios = require('axios');
 const packageJson = require('../package.json');
+const { get } = require('./tbUtils');
 
+const localAdaptVer = packageJson.version;
 const localEngineVer = packageJson.engineVersion;
 const localUtils = execSync('npm list @itentialopensource/adapter-utils', { encoding: 'utf-8' });
 const localUtilsVer = localUtils.split('@').pop().replace(/(\r\n|\n|\r| )/gm, '');
 
 /**
- * @summary Makes a GET call using axios
+ * @summary Checks if adapter is the latest version
  *
- * @function get
- * @param {String} url - url to make the call to
+ * @function updateNeeded
  */
-function get(url) {
-  const config = {
-    method: 'get',
-    url
-  };
-  return axios(config);
+async function updateNeeded() {
+  const adapterUrl = `https://registry.npmjs.org/${packageJson.name}`;
+  const latestAdapterVer = (await get(adapterUrl)).data['dist-tags'].latest;
+  console.log('\n[Upgrade Check]');
+  console.log(`Local Adapter Version : ${localAdaptVer}`);
+  console.log(`Latest Adapter Version: ${latestAdapterVer}`);
+  return semver.lt(localAdaptVer, latestAdapterVer);
 }
 
 /**
- * @summary Checks if adapter can be migrated using migration package
+ * @summary Checks if adapter is up-to-date or if migration is needed
  *
- * @function migratePossible
+ * @function migrateNeeded
  */
-function migratePossible() {
-  const adapterTestUnit = fs.readFileSync('./test/unit/adapterTestUnit.js', { encoding: 'utf-8' });
-  const readme = fs.readFileSync('./README.md', { encoding: 'utf-8' });
-  return packageJson.keywords !== null && adapterTestUnit.indexOf('DO NOT REMOVE THIS COMMENT BLOCK') !== -1
-  && readme.indexOf('available at ') !== -1 && readme.indexOf('You will need to change the credentials and possibly the host information below.') !== -1;
+async function migrateNeeded() {
+  const engineUrl = 'https://adapters.itential.io/engineVersion';
+  const latestEngineVer = (await get(engineUrl)).data;
+  console.log('\n[Migration Check]');
+  console.log(`Local Engine Version : ${localEngineVer}`);
+  console.log(`Latest Engine Version: ${latestEngineVer}`);
+  return semver.lt(localEngineVer, latestEngineVer);
 }
 
 /**
- * @summary Checks if adapter is up-to-date or if migration is needed
+ * @summary Checks if adapter is up-to-date or if remediation is needed
  *
- * @function migrateNeeded
+ * @function remediationNeeded
  */
-async function migrateNeeded() {
-  const engineUrl = 'https://adapters.itential.io/engineVersion';
+async function remediationNeeded() {
   const utilsUrl = 'https://registry.npmjs.org/@itentialopensource/adapter-utils';
-  const latestEngineVer = (await get(engineUrl)).data;
   const latestUtilsVer = (await get(utilsUrl)).data['dist-tags'].latest;
-  return semver.lt(localEngineVer, latestEngineVer) || semver.lt(localUtilsVer, latestUtilsVer);
+  console.log('\n[Remediation Check]');
+  console.log(`Local Utils Version : ${localUtilsVer}`);
+  console.log(`Latest Utils Version: ${latestUtilsVer}`);
+  return semver.lt(localUtilsVer, latestUtilsVer);
 }
 
-// Main Script
-if (migratePossible()) {
-  migrateNeeded().then((needed) => {
-    if (needed) {
-      console.log('Migration is needed and possible -- go to dev site to download migration package');
-    } else {
-      console.log('Migration is possible but not needed at the current time.');
-    }
-  }).catch((error) => {
-    console.log('Could not get latest engine or utils version.', error.message);
-  });
-} else {
-  console.log('Migration is not possible. Please contact Itential support for assistance');
-}
+/**
+ * @summary Main Script (rest of file)
+ *
+ * Input - None
+ * Process - gets the adapter version from the package.json and compares it to the latest version of the adapter,
+ *      then get the engine version from the package.json and compare it to the adapter engine version in the repo.
+ *      then get the local adapter-utils version and compare that to the latest version of adapter-utils.
+ * Output - console logs providing state and path forward
+ *
+ */
+updateNeeded().then((needed) => {
+  if (needed) {
+    console.log('You should update the adapter to the latest available version -- git pull');
+  } else {
+    console.log('Update is not needed at the current time.');
+  }
+}).catch((error) => {
+  console.log('Could not get latest adapter version. Confirm the adapter is an open source adapter.', error.message);
+});
+
+migrateNeeded().then((needed) => {
+  if (needed) {
+    console.log('Migration is needed -- if open source, request Itential migrate the adapter');
+  } else {
+    console.log('Migration is not needed at the current time.');
+  }
+}).catch((error) => {
+  console.log('Could not get latest engine version. Confirm the adapter was built by the Itential Adapter Builder.', error.message);
+});
+
+remediationNeeded().then((needed) => {
+  if (needed) {
+    console.log('Remediation is needed -- update the version of adapter-utils in the package.json, remove node modules and package-lock and run npm install');
+  } else {
+    console.log('Remediation is not needed at the current time.');
+  }
+}).catch((error) => {
+  console.log('Could not get latest utils version. Confirm the adapter utilizes the Itential adapter foundation.', error.message);
+});

package/utils/entitiesToDB.js

@@ -16,18 +16,19 @@
 
 const fs = require('fs');
 const path = require('path');
-const utils = require('./tbUtils');
-
-// 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;
+const tbUtils = require('./tbUtils');
+const mongoUtils = require('./mongoUtils');
+
+/**
+ * Function to load sample properties from the file system
+ */
+const loadSampleProperties = async () => {
+  const samplePath = path.join(__dirname, '../sampleProperties.json');
+  if (fs.existsSync(samplePath)) {
+    const fullProps = JSON.parse(fs.readFileSync(samplePath, 'utf-8'));
+    return fullProps.properties.mongo;
+  }
+  throw new Error('sampleProperties.json not found');
 };
 
 /**
@@ -77,22 +78,23 @@ const buildDoc = (pathstring) => {
 /**
  *  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);
+const optionsHandler = async (options) => {
+  try {
+    // Try mongo properties from service config first
+    const mongoPronghornProps = options?.pronghornProps?.mongo;
+    const validatedPronghornProps = mongoPronghornProps ? mongoUtils.getAndValidateMongoProps(mongoPronghornProps) : undefined;
+    if (validatedPronghornProps) return validatedPronghornProps;
+
+    // Fallback to sample properties
+    const sampleProps = await loadSampleProperties();
+    const validatedSampleProps = mongoUtils.getAndValidateMongoProps(sampleProps);
+    if (validatedSampleProps) return validatedSampleProps;
+
+    throw new Error('No mongo properties provided! Need either a complete URL or both host and database');
+  } catch (error) {
+    log.error('Error in optionsHandler:', error.message);
+    throw error;
   }
-
-  // if nothing was provided, error
-  return new Promise((resolve, reject) => reject(new Error('Neither pronghornProps nor iapDir defined in options!')));
 };
 
 /**
@@ -102,6 +104,7 @@ const moveEntitiesToDB = async (targetPath, options) => {
   // set local variables
   let myOpts = options;
   let myPath = targetPath;
+  let mongoConnection = null;
 
   // if we got a string parse into a JSON object
   if (typeof myOpts === 'string') {
@@ -118,15 +121,17 @@ const moveEntitiesToDB = async (targetPath, options) => {
     throw new Error('Adapter ID required!');
   }
 
-  // get the pronghorn database properties
-  return optionsHandler(options).then(async (currentProps) => {
-    // 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);
-    }
+  // 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);
+  }
+
+  try {
+    // get the database properties from adapter service instance configs
+    const currentProps = await optionsHandler(options);
 
     // verify set the entity path
     const entitiesPath = `${myPath}/entities`;
@@ -165,15 +170,21 @@ const moveEntitiesToDB = async (targetPath, options) => {
     });
 
     // Upload documents to db collection
-    const db = await utils.connect(currentProps).catch((err) => { console.error(err); throw err; });
-    if (!db) {
-      console.error('Error occured when connectiong to database', currentProps);
+    mongoConnection = await tbUtils.connect(currentProps).catch((err) => { log.error(err); throw err; });
+    if (!mongoConnection) {
+      log.error('Error occurred when connecting to database', currentProps);
       throw new Error('Database not found');
     }
-    const collection = db.collection(myOpts.targetCollection);
-    const res = await collection.insertMany(docs, { checkKeys: false }).catch((err) => { console.error(err); throw err; });
+
+    const collection = mongoConnection.db.collection(myOpts.targetCollection);
+    const res = await collection.insertMany(docs, { checkKeys: false }).catch((err) => { log.error(err); throw err; });
     return res;
-  });
+  } finally {
+    // Ensure connection is closed even if an error occurs
+    if (mongoConnection) {
+      await tbUtils.closeConnection(mongoConnection);
+    }
+  }
 };
 
 module.exports = { moveEntitiesToDB };

package/utils/logger.js

@@ -0,0 +1,26 @@
+// utils/logger.js
+const winston = require('winston');
+const { parseArgs } = require('./argParser');
+
+const customLevels = {
+  spam: 6,
+  trace: 5,
+  debug: 4,
+  info: 3,
+  warn: 2,
+  error: 1,
+  none: 0
+};
+
+// Only set global logger if it doesn't already exist (i.e., not provided by app)
+if (!global.log) {
+  const { logLevel = 'info' } = parseArgs();
+
+  global.log = winston.createLogger({
+    level: logLevel,
+    levels: customLevels,
+    transports: [new winston.transports.Console()]
+  });
+}
+
+module.exports = global.log;

package/utils/modify.js

@@ -1,29 +1,7 @@
 const { execSync } = require('child_process');
 const fs = require('fs-extra');
-const Ajv = require('ajv');
 const rls = require('readline-sync');
 const { existsSync } = require('fs-extra');
-const { getAdapterConfig } = require('./tbUtils');
-const { name } = require('../package.json');
-const propertiesSchema = require('../propertiesSchema.json');
-
-const flags = process.argv[2];
-
-/**
- * @summary Updates database instance with new adapter properties
- *
- * @function updateServiceItem
- */
-async function updateServiceItem() {
-  const { database, serviceItem } = await getAdapterConfig();
-  const currentProps = serviceItem.properties.properties;
-  const ajv = new Ajv({ allErrors: true, useDefaults: true });
-  const validate = ajv.compile(propertiesSchema);
-  validate(currentProps);
-  console.log('Updating Properties...');
-  await database.collection('service_configs').updateOne({ model: name }, { $set: serviceItem });
-  console.log('Properties Updated');
-}
 
 /**
  * @summary Creates a backup zip file of current adapter
@@ -70,21 +48,20 @@ function revertMod() {
       fs.removeSync(file);
     }
   });
-  // // unzip previousVersion, reinstall dependencies and delete zipfile
+  // unzip previousVersion, reinstall dependencies and delete zipfile
   execSync('unzip -o previousVersion.zip && rm -rf node_modules && rm package-lock.json && npm install', { maxBuffer: 1024 * 1024 * 2 });
   execSync('rm previousVersion.zip');
   console.log('Changes have been reverted');
 }
 
-// Main Script
-
-// Migrate
-if (flags === '-m') {
-  if (!fs.existsSync('migrationPackage.zip')) {
-    console.log('Migration Package not found. Download and place migrationPackage in the adapter root directory');
-    process.exit();
+/**
+ * @summary Handle migration logic
+ */
+function handleMigration() {
+  if (!existsSync('migrationPackage.zip')) {
+    throw new Error('Migration Package not found. Download and place migrationPackage in the adapter root directory');
   }
-  // Backup current adapter
+
   backup();
   console.log('Migrating adapter and running tests...');
   const migrateCmd = 'unzip -o migrationPackage.zip'
@@ -92,61 +69,85 @@ if (flags === '-m') {
     + ' && node migrate';
   const migrateOutput = execSync(migrateCmd, { encoding: 'utf-8' });
   console.log(migrateOutput);
-  if (migrateOutput.indexOf('Lint exited with code 1') >= 0
-    || migrateOutput.indexOf('Tests exited with code 1') >= 0) {
+
+  if (migrateOutput.includes('Lint exited with code 1') || migrateOutput.includes('Tests exited with code 1')) {
     if (rls.keyInYN('Adapter failed tests or lint after migrating. Would you like to revert the changes?')) {
       console.log('Reverting changes...');
       revertMod();
-      process.exit();
+      throw new Error('Adapter failed tests or lint after migrating. Changes reverted');
     }
     console.log('Adapter Migration will continue. If you want to revert the changes, run the command npm run adapter:revert');
   }
+
   console.log('Installing new dependencies..');
   const updatePackageCmd = 'rm -rf node_modules && rm package-lock.json && npm install';
   const updatePackageOutput = execSync(updatePackageCmd, { encoding: 'utf-8' });
   console.log(updatePackageOutput);
   console.log('New dependencies installed');
-  console.log('Updating adapter properties..');
-  updateServiceItem().then(() => {
-    console.log('Adapter Successfully Migrated. Restart adapter in IAP to apply the changes');
-    archiveMod('MIG');
-    process.exit();
-  });
+  archiveMod('MIG');
 }
 
-// Update
-if (flags === '-u') {
-  if (!fs.existsSync('updatePackage.zip')) {
-    console.log('Update Package not found. Download and place updateAdapter.zip in the adapter root directory');
-    process.exit();
+/**
+ * @summary Handle update logic
+ */
+function handleUpdate() {
+  if (!existsSync('updatePackage.zip')) {
+    throw new Error('Update Package not found. Download and place updateAdapter.zip in the adapter root directory');
   }
-  // Backup current adapter
+
   backup();
   const updateCmd = 'unzip -o updatePackage.zip'
     + ' && cd adapter_modifications'
     + ' && node update.js updateFiles';
   execSync(updateCmd, { encoding: 'utf-8' });
   const updateOutput = execSync(updateCmd, { encoding: 'utf-8' });
-  if (updateOutput.indexOf('Lint exited with code 1') >= 0
-    || updateOutput.indexOf('Tests exited with code 1') >= 0) {
+
+  if (updateOutput.includes('Lint exited with code 1') || updateOutput.includes('Tests exited with code 1')) {
     if (rls.keyInYN('Adapter failed tests or lint after updating. Would you like to revert the changes?')) {
       console.log('Reverting changes...');
       revertMod();
-      process.exit();
+      throw new Error('Adapter failed tests or lint after updating. Changes reverted');
     }
     console.log('Adapter Update will continue. If you want to revert the changes, run the command npm run adapter:revert');
   }
+
   console.log(updateOutput);
   console.log('Adapter Successfully Updated. Restart adapter in IAP to apply the changes');
   archiveMod('UPD');
-  process.exit();
 }
 
-// Revert
-if (flags === '-r') {
-  if (!fs.existsSync('previousVersion.zip')) {
-    console.log('Previous adapter version not found. There are no changes to revert');
-    process.exit();
+/**
+ * @summary Handle revert logic
+ */
+function handleRevert() {
+  if (!existsSync('previousVersion.zip')) {
+    throw new Error('Previous adapter version not found. There are no changes to revert');
   }
   revertMod();
 }
+
+/**
+ * @summary Entrypoint for the script
+ */
+function main() {
+  const flags = process.argv[2];
+
+  switch (flags) {
+    case '-m':
+      return handleMigration();
+    case '-u':
+      return handleUpdate();
+    case '-r':
+      return handleRevert();
+    default:
+      throw new Error('Invalid flag. Use -m for migrate, -u for update, or -r for revert.');
+  }
+}
+
+try {
+  main();
+  process.exit(0);
+} catch (error) {
+  console.error(error.message || error);
+  process.exit(1);
+}

package/utils/mongoDbConnection.js

@@ -0,0 +1,79 @@
+// Set globals
+/* global log */
+
+const { MongoClient } = require('mongodb');
+const MongoUtils = require('./mongoUtils');
+
+class MongoDBConnection {
+  constructor(properties) {
+    this.properties = properties;
+    this.initialize(properties);
+  }
+
+  initialize(properties) {
+    const {
+      url, database, maxPoolSize, appname
+    } = properties;
+
+    // Handle URL first - if provided, it takes precedence
+    if (url) {
+      const urlObj = new URL(url);
+      const urlDbName = urlObj.pathname.slice(1);
+      this.dbName = database || urlDbName;
+
+      // Update URL if database name is different
+      if (this.dbName !== urlDbName) {
+        urlObj.pathname = `${this.dbName}`;
+      }
+
+      this.url = urlObj.toString();
+    } else {
+      const connectionObj = MongoUtils.generateConnectionObj(properties);
+      this.url = MongoUtils.generateConnectionString(connectionObj);
+      this.dbName = database;
+    }
+
+    // Set options using generateTlsSettings
+    this.options = MongoUtils.generateTlsSettings(properties);
+
+    // Add maxPoolSize if configured
+    if (maxPoolSize > 0 && maxPoolSize <= 65535) {
+      this.options.maxPoolSize = maxPoolSize;
+    }
+
+    // Add application name if provided
+    if (appname) {
+      this.options.appname = appname;
+    }
+  }
+
+  async closeConnection() {
+    if (this.connection && this.connection.close) {
+      try {
+        await this.connection.close();
+      } catch (err) {
+        log.error(`Failed to close MongoDB connection - ${err.message}`);
+      }
+    }
+  }
+
+  async connect() {
+    const client = new MongoClient(this.url, this.options);
+
+    client.on('serverHeartbeatSucceeded', (msg) => log.info(`Connection established and heartbeat succeeded - ${JSON.stringify(msg)}`));
+    client.on('connectionClosed', (msg) => log.info(`Connection closed - ${JSON.stringify(msg)}`));
+    client.on('error', (msg) => log.error(`Connection error - ${JSON.stringify(msg)}`));
+    client.on('commandFailed', (msg) => log.error(`Command failed - ${JSON.stringify(msg)}`));
+    client.on('serverHeartbeatFailed', (msg) => log.error(`Connection timeout - ${JSON.stringify(msg)}`));
+
+    await client.connect().catch((error) => {
+      throw new Error(MongoUtils.resolveMongoError(error));
+    });
+
+    this.db = client.db(this.dbName);
+    this.connection = client;
+    return this;
+  }
+}
+
+module.exports = MongoDBConnection;