@itentialopensource/adapter-aruba_central 0.1.1

package/adapter_modifications/update.js

@@ -0,0 +1,532 @@
+/* eslint-disable */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const folder = process.argv[2];
+
+/**
+ *
+ * This is the file to run in order to update your existing adapter.
+ * Make sure the zip is in the adapter's top level directory, then navigate there in the terminal and run 'node update'.
+ */
+
+ /**
+  * @summary the main function to be run in this file.
+  * @function run
+  */
+function run() {
+
+  // To ensure that the names of each group are brought in.
+  console.log('Updating...\n');
+  const names = JSON.parse(fs.readFileSync(path.join(__dirname, `./${folder}/components/methods.json`), 'utf8'));
+  const toDeleteNames = names.toDelByName.map(d => d.fnName);
+  const toAppendNames = names.toAppByName.map(d => d.fnName);
+  const toAppByName = names.toAppByName.map(d => ({name: d.name, fnName: d.fnName, parameters: d.func.parameters}));
+  const toUpdateNames = [];
+  toDeleteNames.forEach((n) => {
+    toAppendNames.forEach((a) => {
+      if (n === a && !toUpdateNames.includes(n)) {
+        toUpdateNames.push(n);
+      }
+    });
+  });
+
+  // Creating copy of this object to be used later.
+  const curAppByName = JSON.parse(JSON.stringify(toAppByName));
+
+  // This object will contain any methods we attempt to add but already exist in the adapter, marking them for versioning.
+  const reAddingMethods = {};
+  const reAddingEmitMethods = {};
+
+  const adapterName = __dirname.split('/')[__dirname.split('/').length - 2].split('-')[1];
+  // Note that this assumes that the adapter name starts with 'adapter-'; if it does not, this will have to be edited.
+
+  // Filtering out and adding functions to the pronghorn.
+  if (fs.existsSync(path.join(__dirname, '../pronghorn.json'))) {
+    let pFile = JSON.parse(fs.readFileSync(path.join(__dirname, '../pronghorn.json'), 'utf8'));
+    pFile.methods = pFile.methods.filter(m => !toDeleteNames.includes(m.name));
+    //console.log(pFile.methods);
+    const methsToAdd = JSON.parse(fs.readFileSync(path.join(__dirname, `./${folder}/components/pronghorn.json`)));
+    methsToAdd.forEach((m) => {
+      //console.log(m.input);
+      if (toUpdateNames.includes(m.name)) {
+        pFile.methods.push(m);
+      } 
+      // loop through methods and check signatures for versioning
+      let version = false;
+      let alreadyExists = false;
+      pFile.methods.forEach((pm) => {
+        if (pm.name === m.name) {
+          alreadyExists = true;
+          if (pm.input.length !== m.input.length) {
+            version = true;
+          } else {
+            for (let x = 0; x < m.input.length; x++) {
+              if (pm.input[x].name !== m.input[x].name || pm.input[x].required !== m.input[x].required || pm.input[x].type !== m.input[x].type) {
+                version = true;
+              }
+            }
+          }
+        }
+      });
+      if (version) {
+        // add for versioning
+        reAddingMethods[m.name] = {};
+        reAddingEmitMethods[m.name] = {};
+        reAddingMethods[m.name].pronghorn = m;
+      } else if (toAppendNames.includes(m.name) && !alreadyExists && !version) {
+        pFile.methods.push(m);
+      }
+    });
+    fs.writeFileSync(path.join(__dirname, '../pronghorn.json'), JSON.stringify(pFile, null, 2));
+  } else {
+    console.log('Your pronghorn.json file is missing; are you sure your adapter works?');
+    return;
+  }
+  if (fs.existsSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'))) {
+    let uFile = fs.readFileSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'), 'utf8');
+    const last = uFile.split('\n').slice(uFile.split('\n').length - 3).join('\n');
+    let list = uFile.split('\n').slice(0, uFile.split('\n').length - 3).join('\n').split(/(?=\n {4}describe\()/g).filter((u) => {
+      let remain = true;
+      toDeleteNames.forEach((n) => {
+        if (u.indexOf('#'.concat(n, ' - ')) >= 0 || u.indexOf('#'.concat(n, 'Emit - ')) >= 0) {
+          remain = false;
+        }
+      });
+      return remain;
+    });
+    list = list.join('');
+    let uChanges = fs.readFileSync(path.join(__dirname, `./${folder}/components/test/unit/adapterTestUnit.js`), 'utf8');
+    const units = uChanges.split(/(?=\n {4}describe\()/g);
+    if (units.length > 0) {
+      list = list.concat('\n');
+    }
+    units.forEach((un) => {
+      const u = un.replace(/Test-append-adapter/g, `Test-${adapterName}-adapter`); // See above about adapter name starting with 'adapter-'.
+      let remain = true;
+      toAppendNames.forEach((n) => {
+        if (list.includes('#'.concat(n, ' - ')) && u.includes('#'.concat(n, ' - '))) {
+          remain = false;
+          if (reAddingMethods[n] && !reAddingMethods[n].unit) {
+            reAddingMethods[n].unit = u;
+          }
+        } else if (list.includes('#'.concat(n, 'Emit - ')) && u.includes('#'.concat(n, 'Emit - '))) {
+          remain = false;
+          if (reAddingEmitMethods[n] && !reAddingEmitMethods[n].unit) {
+            reAddingEmitMethods[n].unit = u;
+          }
+        }
+      });
+      if (remain) {
+        list = list.concat(u);
+      }
+    });
+    list = list.replace('\n\n\n    ', '\n\n    ').concat(last);
+    fs.writeFileSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'), list);
+  } else {
+    console.log('Your unit test file does not exist, will not delete or add any tests.');
+  }
+
+  if (fs.existsSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'))) {
+    let iFile = fs.readFileSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'), 'utf8');
+    const last = iFile.split('\n').slice(iFile.split('\n').length - 3).join('\n');
+    let list = iFile.split('\n').slice(0, iFile.split('\n').length - 3).join('\n').split(/(?=\n {4}describe\()|(?=\n {4}const [a-zA-Z]+)/g).filter((i) => {
+      let remain = true;
+      toDeleteNames.forEach((n) => {
+        if (i.indexOf('#'.concat(n, ' - ')) >= 0 || i.indexOf('#'.concat(n, 'Emit - ')) >= 0) {
+          remain = false;
+        }
+      });
+      return remain;
+    });
+    list = list.join('');
+
+    let iChanges = fs.readFileSync(path.join(__dirname, `./${folder}/components/test/integration/adapterTestIntegration.js`), 'utf8');
+    const integrations = iChanges.split(/(?=\n {4}describe\()|(?=\n {4}const [a-zA-Z]+)/g);
+    if (integrations.length > 0) {
+      list = list.concat('\n');
+    }
+    integrations.forEach((integ) => {
+      const i = integ.replace(/Test-append/g, `Test-${adapterName}`);
+      let remain = true;
+      // This portion determines if this part is a body parameter or test. Note that both body parameters and tests are both versioned if necessary.
+      let bodyParamMatch = i.match(/const [a-zA-Z]+BodyParam/g);
+      if (bodyParamMatch && list.match(bodyParamMatch[0])) {
+        if (reAddingMethods && !reAddingMethods.bodyParams) {
+          reAddingMethods.bodyParams = [];
+        }
+        reAddingMethods.bodyParams.push(i);
+        return;
+      }
+      toAppendNames.forEach((n) => {
+        if (list.includes('#'.concat(n, ' - ')) && i.includes('#'.concat(n, ' - '))) {
+          remain = false;
+          if (reAddingMethods[n] && !reAddingMethods[n].integration) {
+            reAddingMethods[n].integration = i;
+          }
+        } else if (list.includes('#'.concat(n, 'Emit - ')) && i.includes('#'.concat(n, 'Emit - '))) {
+          remain = false;
+          if (reAddingEmitMethods[n] && !reAddingEmitMethods[n].integration) {
+            reAddingEmitMethods[n].integration = i;
+          }
+        }
+      });
+      if (remain) {
+        list = list.concat(i);
+      }
+    });
+    list = list.replace('\n\n\n    ', '\n\n    ').concat(last);
+    fs.writeFileSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'), list);
+  } else {
+    console.log('Your integration test file does not exist, will not delete or add any tests.');
+  }
+
+  const uEntitiesDir = path.join(__dirname, `./${folder}/components/entities/`);
+  const uEntities = fs.readdirSync(uEntitiesDir, { withFileTypes: true })
+      .filter(files => files.isDirectory())
+      .map(files => files.name);
+
+  const entitiesDir = path.join(__dirname, '../entities');
+  const entities = fs.readdirSync(entitiesDir, { withFileTypes: true })
+      .filter(files => files.isDirectory())
+      .map(files => files.name);
+  const filtered = [];
+  entities.forEach((e) => {
+    if (!filtered.includes(e)) {
+      filtered.push(e);
+    }
+  });
+  if (!fs.existsSync(path.join(__dirname, '../entities'))) {
+    fs.mkdirSync(path.join(__dirname, '../entities'));
+  }
+  
+  uEntities.forEach((e) => {
+    // If an entity that may attempt to have an action removed from it does not exist, it will be created with no actions in it. If it remains that way, a user can go and delete it later.
+    if (!fs.existsSync(path.join(__dirname, `../entities/${e}`))) {
+      fs.mkdirSync(path.join(__dirname, `../entities/${e}`));
+      fs.writeFileSync(path.join(__dirname, `../entities/${e}/action.json`), "{\n  \"actions\": [\n  ]\n}\n");
+      fs.writeFileSync(path.join(__dirname, `../entities/${e}/schema.json`), "{\n  \"$id\": \"schema.json\",\n  \"type\": \"object\",\n  \"schema\": \"http://json-schema.org/draft-07/schema#\",\n  \"translate\": false,\n  \"dynamicfields\": true,\n  \"properties\": {\n    \"ph_request_type\": {\n      \"type\": \"string\",\n      \"description\": \"type of request (internal to adapter)\",\n      \"default\": \"\",\n      \"enum\": [\n      ],\n      \"external_name\": \"ph_request_type\"\n    }\n  },\n  \"definitions\": {}\n}\n");
+    }
+    if (!fs.existsSync(path.join(__dirname, `../entities/${e}/action.json`))) {
+      fs.writeFileSync(path.join(__dirname, `../entities/${e}/action.json`), "{\n  \"actions\": [\n  ]\n}\n");
+    }
+    if (!fs.existsSync(path.join(__dirname, `../entities/${e}/schema.json`))) {
+      fs.writeFileSync(path.join(__dirname, `../entities/${e}/schema.json`), "{\n  \"$id\": \"schema.json\",\n  \"type\": \"object\",\n  \"schema\": \"http://json-schema.org/draft-07/schema#\",\n  \"translate\": false,\n  \"dynamicfields\": true,\n  \"properties\": {\n    \"ph_request_type\": {\n      \"type\": \"string\",\n      \"description\": \"type of request (internal to adapter)\",\n      \"default\": \"\",\n      \"enum\": [\n      ],\n      \"external_name\": \"ph_request_type\"\n    }\n  },\n  \"definitions\": {}\n}\n");
+    }
+    // The entities that will have functions deleted from them.
+    const thisEntityNames = names.toDelByName.filter(n => n.name === e).map(n => n.fnName);
+
+    // The entities that will have functions appended to them.
+    const thisMethodEntity = curAppByName.filter(n => n.name === e).map(n => n.fnName);
+
+    let aFile = JSON.parse(fs.readFileSync(path.join(__dirname, `../entities/${e}/action.json`), 'utf8'));
+    const aCopy = JSON.parse(JSON.stringify(aFile));
+    aFile.actions = aFile.actions.filter(a => !thisEntityNames.includes(a.name));
+
+    if (fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${e}/action.json`), 'utf8') !== '[]') {
+      let acts = JSON.parse(fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${e}/action.json`), 'utf8'));
+      acts.forEach((a) => {
+        if (reAddingMethods && Object.keys(reAddingMethods).includes(a.name)) {
+          reAddingMethods[a.name].action = a;
+        } else if (thisMethodEntity.includes(a.name) && !aFile.actions.map(ac => ac.name).includes(a.name)) {
+          aFile.actions.push(a);
+        }
+      });
+      fs.writeFileSync(path.join(__dirname, `../entities/${e}/action.json`), JSON.stringify(aFile, null, 2));
+    }
+
+    let sFile = JSON.parse(fs.readFileSync(path.join(__dirname, `../entities/${e}/schema.json`), 'utf8'));
+    sFile.properties.ph_request_type.enum = sFile.properties.ph_request_type.enum.filter(p => !thisEntityNames.includes(p));
+    if (fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${e}/schema.json`), 'utf8') !== '[]') {
+      let sches = JSON.parse(fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${e}/schema.json`), 'utf8')).properties.ph_request_type.enum;
+      sches.forEach((s) => {
+        if (reAddingMethods && Object.keys(reAddingMethods).includes(s)) {
+          reAddingMethods[s].schema = s;
+        } else if (thisMethodEntity.includes(s) && !sFile.properties.ph_request_type.enum.includes(s)) {
+          sFile.properties.ph_request_type.enum.push(s);
+        }
+      });
+      fs.writeFileSync(path.join(__dirname, `../entities/${e}/schema.json`), JSON.stringify(sFile, null, 2));
+    }
+
+    if (!fs.existsSync(path.join(__dirname, `../entities/${e}/mockdatafiles`))) {
+      fs.mkdirSync(path.join(__dirname, `../entities/${e}/mockdatafiles`));
+    }
+    const mock =  JSON.parse(fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${e}/mockdatafiles/mockdata.json`), 'utf8'));
+    mock.forEach((m) => {
+      if (m.entity === e) {
+        // Currently do not have a .id field in the mock data (will always end in -default); future improvement.
+        const fileName = m.name || m.function.concat(m.id || '-default.json');
+        if (!fs.existsSync(path.join(__dirname, `../entities/${e}/mockdatafiles/${fileName}`)) || toUpdateNames.includes(m.function) || !aCopy.actions.map(ac => ac.name).includes(m.function)) {
+          fs.writeFileSync(path.join(__dirname, `../entities/${e}/mockdatafiles/${fileName}`), JSON.stringify(m.contents, null, 2));
+        }
+      }
+    });
+    // thisEntityNames.forEach((n) => {
+    //   console.log(`We are not currently deleting existing mock data. path entities/${e}/mockdatafiles/${n}-default.json is intact if it exists.`);
+    // });
+  });
+
+  if (fs.existsSync(path.join(__dirname, '../adapter.js'))) {
+    let adFile = fs.readFileSync(path.join(__dirname, '../adapter.js'), 'utf8');
+    let splitArray = adFile.split('}\n\nmodule');
+    //if (splitArray[1] === undefined) {
+      //splitArray = adFile.split('}\nmodule');
+    //}
+
+    // const last = adFile.split('\n').slice(adFile.split('\n').length - 4).join('\n');
+    let list = adFile.split('\n').slice(0, adFile.split('\n').length - 4).join('\n').split(/(?=\n {2}\/\*\*\n {3}\* @summary)/g).filter((u) => {
+      let remain = true;
+      toDeleteNames.forEach((n) => {
+        if (u.indexOf('\n  '.concat(n, '(')) >= 0) {
+          remain = false;
+        } else if (reAddingMethods && Object.keys(reAddingMethods).includes(n)) {
+          remain = false;
+          reAddingMethods[n].adapter = u;
+        }
+      });
+      return remain;
+    }).join('');
+    let adChanges = fs.readFileSync(path.join(__dirname, `./${folder}/components/adapter.js`), 'utf8');
+    const adMethods = adChanges.split(/(?=\n {2}\/\*\*\n {3}\* @function)/g);
+    if (adMethods.length > 0) {
+      list = list.concat('\n');
+    }
+    adMethods.forEach((a) => {
+      let remain = true;
+      //console.log(toAppendNames);
+
+      toAppendNames.forEach((n) => {
+        if (list.includes(n.concat('(')) && a.includes(n.concat('('))) {
+          let checkPrefix = a.split('@function ');
+          checkPrefix = checkPrefix[1].split('\n');
+          checkPrefix = checkPrefix[0];
+          if (checkPrefix === n) {
+            remain = false;
+            if (reAddingMethods[n] && !reAddingMethods[n].adapter) {
+              reAddingMethods[n].adapter = a;
+            }
+          }
+        }
+      });
+      /** 
+      toAppendNames.forEach((n) => {
+        if (list.includes(n.concat('(')) && a.includes(n.concat('('))) {
+          remain = false;
+          if (reAddingMethods[n] && !reAddingMethods[n].adapter) {
+            reAddingMethods[n].adapter = a;
+          }
+        }
+      });
+      **/
+      if (remain) {
+        list = list.concat(a);
+      }
+    });
+    list = list.concat('}\n\nmodule', splitArray[1]);
+    fs.writeFileSync(path.join(__dirname, '../adapter.js'), list);
+  }
+
+  // This is the object to be used in determining what version to assign methods that already exist.
+  let versionList = {};
+  if (fs.existsSync(path.join(__dirname, '../versions.json'))) {
+    versionList = JSON.parse(fs.readFileSync(path.join(__dirname, '../versions.json'), 'utf8'));
+  }
+
+  const newAdapter = fs.readFileSync(path.join(__dirname, '../adapter.js'), 'utf8');
+  const methods = newAdapter.match(/\n {2}[a-zA-Z]+\(/g).map(s => s.substr(3, s.length - 4));
+  let aRet = fs.readFileSync(path.join(__dirname, '../adapter.js'), 'utf8');
+  let versionedAdapters = "";
+  methods.forEach((m) => {
+    if (['constructor', 'hasEntity', 'verifyCapability', 'updateEntityCache'].includes(m)) {
+      versionList[m] = -1;
+      return;
+      // Those are the default methods: should not ever change unless by user directly or itential update.
+    } else if (!Object.keys(versionList).includes(m)) {
+      versionList[m] = 0;
+      // This method does not yet exist, it will be added as the original (version 0).
+    } 
+   // console.log(reAddingMethods['uploadFile']);
+    if (typeof reAddingMethods[m] !== 'undefined') {
+      versionList[m] += 1;
+      const newMethodName = `${m}__v${versionList[m]}`;  // The old name, double underscore then v(version#)
+      //console.log(newMethodName);
+      // The below code replaces all existences of the previous name with the new one in the relevant files, then performs an append as it would if this were a unique method.
+      const ph = JSON.parse(fs.readFileSync(path.join(__dirname, '../pronghorn.json'), 'utf8'));
+      reAddingMethods[m].pronghorn.name = newMethodName;
+      reAddingMethods[m].pronghorn.route.path = `\/${newMethodName}`;
+      ph.methods.push(reAddingMethods[m].pronghorn);
+      fs.writeFileSync(path.join(__dirname, '../pronghorn.json'), JSON.stringify(ph, null, 2));
+
+      const uFile = fs.readFileSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'), 'utf8');
+      const uLast = uFile.split('\n').slice(uFile.split('\n').length - 3).join('\n');
+
+      if (typeof reAddingMethods[m].unit !== 'undefined') {
+        reAddingMethods[m].unit = reAddingMethods[m].unit.replace(`#${m} `, `#${newMethodName} `).replace(`\.${m} `, `\.${newMethodName} `).replace(` ${m} `, ` ${newMethodName} `);
+        const re = new RegExp(`\\.${m}\\(`, 'g');
+        const re1 = new RegExp(`-${m}\\'`, 'g');
+        reAddingMethods[m].unit = reAddingMethods[m].unit.replace(re, `\.${newMethodName}\(`);
+        reAddingMethods[m].unit = reAddingMethods[m].unit.replace(re1, `-${newMethodName}\'`);
+        const uRet = uFile.split('\n').slice(0, uFile.split('\n').length - 3).join('\n').concat('\n', reAddingMethods[m].unit, uLast);
+        fs.writeFileSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'), uRet);
+      }
+
+      const iFile = fs.readFileSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'), 'utf8');
+      const iLast = iFile.split('\n').slice(iFile.split('\n').length - 3).join('\n');
+
+      if (typeof reAddingMethods[m].integration !== 'undefined') {
+        reAddingMethods[m].integration = reAddingMethods[m].integration.replace(`#${m} - `, `#${newMethodName} - `).replace(`\.${m}\(`, `\.${newMethodName}\(`).replace(`\'${m}\'`, `\'${newMethodName}\'`).concat(reAddingMethods[m].integration.endsWith('\n') ? '' : '\n');
+      
+        // check for typeof undefined
+        if (typeof reAddingMethods.bodyParams !== 'undefined') {
+          reAddingMethods.bodyParams.forEach((b) => {
+            const varName = b.split(' = ')[0].substring(10);
+            if (reAddingMethods[m].integration.match(new RegExp(varName.concat(',')))) {
+              const nb = b.replace(varName, `${varName}__v${versionList[m]}`);
+              reAddingMethods[m].integration = nb.concat(reAddingMethods[m].integration);
+              reAddingMethods[m].integration = reAddingMethods[m].integration.replace(new RegExp(varName.concat(','), 'g'), varName.concat(`__v${versionList[m]},`));
+            }
+          });
+        }
+      
+        const iRet = iFile.split('\n').slice(0, iFile.split('\n').length - 3).join('\n').concat('\n', reAddingMethods[m].integration, iLast);
+        fs.writeFileSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'), iRet);
+      }
+
+      const thisMethodEntity = curAppByName.filter(a => a.fnName === m)[0].name;
+      const action = JSON.parse(fs.readFileSync(path.join(__dirname, `../entities/${thisMethodEntity}/action.json`)));
+      
+      if (typeof reAddingMethods[m].action !== 'undefined') {
+        reAddingMethods[m].action.name = newMethodName;
+        reAddingMethods[m].action.responseObjects.forEach((r) => {
+          r.mockFile = r.mockFile.replace(m, newMethodName);
+        });
+        action.actions.push(reAddingMethods[m].action);
+        fs.writeFileSync(path.join(__dirname, `../entities/${thisMethodEntity}/action.json`), JSON.stringify(action, null, 2));
+      }
+      if (fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${thisMethodEntity}/schema.json`), 'utf8') !== '[]') {
+        const schema = JSON.parse(fs.readFileSync(path.join(__dirname, `../entities/${thisMethodEntity}/schema.json`)));
+        reAddingMethods[m].schema = newMethodName;
+        schema.properties.ph_request_type.enum.push(reAddingMethods[m].schema);
+        fs.writeFileSync(path.join(__dirname, `../entities/${thisMethodEntity}/schema.json`), JSON.stringify(schema, null, 2));
+      }
+
+      const mock = JSON.parse(fs.readFileSync(path.join(__dirname, `./${folder}/components/entities/${thisMethodEntity}/mockdatafiles/mockdata.json`), 'utf8'));
+      mock.forEach((mo) => {
+        const moc = mo;
+        if (moc.function === m && thisMethodEntity === moc.entity) {
+          moc.name = moc.name.replace(m, newMethodName);
+          moc.function = newMethodName;
+          fs.writeFileSync(path.join(__dirname, `../entities/${thisMethodEntity}/mockdatafiles/${moc.name}`), JSON.stringify(moc.contents, null, 2));
+        }
+      });
+
+      if (typeof reAddingMethods[m].adapter !== 'undefined') {
+        reAddingMethods[m].adapter = reAddingMethods[m].adapter.replace(`\n  ${m}(`, `\n  ${newMethodName}(`).replace(`\@function ${m}`, `\@function ${newMethodName}`).replace(`adapter-${m}\'`, `adapter-${newMethodName}\'`).replace(new RegExp(`\'${m}\'`, 'g'), `\'${newMethodName}\'`);
+        versionedAdapters = versionedAdapters.concat('\n', reAddingMethods[m].adapter).replace(/\n{2,}/, '\n');
+      }
+    }
+
+    if (reAddingEmitMethods[m]) {
+      const newMethodName = `${m}__v${versionList[m]}`;
+      const newEmitMethodName = `${m}Emit__v${versionList[m]}`;  // The old name, double underscore then v(version#)
+
+      const uFile = fs.readFileSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'), 'utf8');
+      const uLast = uFile.split('\n').slice(uFile.split('\n').length - 3).join('\n');
+
+      if (typeof reAddingEmitMethods[m].unit !== 'undefined') {
+        reAddingEmitMethods[m].unit = reAddingEmitMethods[m].unit.replace(`#${m}Emit `, `#${newEmitMethodName} `).replace(`\.${m}Emit `, `\.${newEmitMethodName} `).replace(` ${m}Emit `, ` ${newEmitMethodName} `).replace(`\.${m}Emit\(`, `\.${newEmitMethodName}\(`).replace(`-${m}\'`, `-${newMethodName}\'`);
+        const uRet = uFile.split('\n').slice(0, uFile.split('\n').length - 3).join('\n').concat(reAddingEmitMethods[m].unit, uLast);
+        fs.writeFileSync(path.join(__dirname, '../test/unit/adapterTestUnit.js'), uRet);
+      }
+
+      const iFile = fs.readFileSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'), 'utf8');
+      const iLast = iFile.split('\n').slice(iFile.split('\n').length - 3).join('\n');
+
+      if (typeof reAddingEmitMethods[m].integration !== 'undefined') {
+        reAddingEmitMethods[m].integration = reAddingEmitMethods[m].integration.replace(`#${m}Emit - `, `#${newEmitMethodName} - `).replace(`\.${m}Emit\(`, `\.${newEmitMethodName}\(`).replace(`\'${m}Emit\'`, `\'${newEmitMethodName}\'`).concat(reAddingEmitMethods[m].integration.endsWith('\n') ? '' : '\n');
+      
+        // check for typeof undefined
+        if (typeof reAddingEmitMethods.bodyParams !== 'undefined') {
+          reAddingEmitMethods.bodyParams.forEach((b) => {
+            const varName = b.split(' = ')[0].substring(10);
+            if (reAddingEmitMethods[m].integration.match(new RegExp(varName.concat(',')))) {
+              const nb = b.replace(varName, `${varName}__v${versionList[m]}`);
+              reAddingEmitMethods[m].integration = nb.concat(reAddingEmitMethods[m].integration);
+              reAddingEmitMethods[m].integration = reAddingEmitMethods[m].integration.replace(new RegExp(varName.concat(','), 'g'), varName.concat(`__v${versionList[m]},`));
+            }
+          });
+        }
+
+        const iRet = iFile.split('\n').slice(0, iFile.split('\n').length - 3).join('\n').concat('\n', reAddingEmitMethods[m].integration, iLast);
+        fs.writeFileSync(path.join(__dirname, '../test/integration/adapterTestIntegration.js'), iRet);
+      }
+    }
+  });
+
+  
+  // Read in the adapter.js file and add the versioned adapters to the end. String manipulation to add correct brackets & export
+  if (versionedAdapters != "") {
+    let finalAdapter = fs.readFileSync(path.join(__dirname, '../adapter.js'), 'utf8');
+    const splitArray = finalAdapter.split('}\n\nmodule');
+    // const aFinal = finalAdapter.split('\n').slice(finalAdapter.split('\n').length - 4).join('\n')
+    // finalAdapter = finalAdapter.replace(aFinal, "");
+    // const adapterNameCaps = adapterName.charAt(0).toUpperCase() + adapterName.slice(1);
+    finalAdapter = splitArray[0].concat(versionedAdapters, '}\n\nmodule', splitArray[1]);
+   
+    // write the new adapter.js and updated versions.json
+    fs.writeFileSync(path.join(__dirname, '../adapter.js'), finalAdapter);
+
+  }
+
+  fs.writeFileSync(path.join(__dirname, '../versions.json'), JSON.stringify(versionList, null, 2));
+
+  // Here, the lint, unit, and integration tests are run to ensure the operations succeeded. If not, the user may have to go and fix things.
+  console.log('Update Done\n')
+  console.log('Linting...\n');
+  const lint = spawn('npm', ['run', 'lint'], {
+    cwd: path.join(__dirname, '..')
+  });
+  let testLintErr = '';
+  lint.stderr.on('data', (err) => {
+    testLintErr = testLintErr.concat(err);
+  });
+  let testLintOut = '';
+  lint.stdout.on('data', (out) => {
+    testLintOut = testLintOut.concat(out);
+  });
+  lint.on('close', (code) => {
+    console.log(`Lint exited with code ${code}`);
+    if (code == 0) {
+      console.log('Lint test passed with no errors');
+      console.log('\n\nRunning unit and integration tests...\n\n');
+    } else {
+      console.log(testLintErr);
+      console.log('\n\nRunning unit and integration tests...\n\n')
+    }
+  }); 
+  
+  const tests = spawn('npm', ['run', 'test'], {
+    cwd: path.join(__dirname, '..')
+  });
+  let testErr = '';
+  tests.stderr.on('data', (err) => {
+    testErr = testErr.concat(err);
+  });
+  let testOut = '';
+  tests.stdout.on('data', (out) => {
+    testOut = testOut.concat(out);
+  });
+  tests.on('close', (code) => {
+    console.log(`Tests exited with code ${code}`);
+    if (code === 0) {
+      console.log(testOut);
+    } else {
+      console.log(testErr);
+    }
+  });
+}
+
+run();