@rockcarver/frodo-lib 1.0.0 → 2.0.0-2

package/esm/ops/cloud/VariablesOps.mjs

@@ -1,134 +1,72 @@
-import { createKeyValueTable, createProgressIndicator, createTable, printMessage, stopProgressIndicator, updateProgressIndicator } from '../utils/Console';
 import { deleteVariable, getVariable, getVariables, putVariable, setVariableDescription } from '../../api/cloud/VariablesApi';
-import wordwrap from '../utils/Wordwrap';
-import { resolveUserName } from '../ManagedObjectOps';
-import { decode } from '../../api/utils/Base64';
-
-/**
- * List variables
- * @param {boolean} long Long version, all the fields
- */
-export async function listVariables(long) {
-  let variables = [];
-  try {
-    variables = (await getVariables()).result;
-    variables.sort((a, b) => a._id.localeCompare(b._id));
-  } catch (error) {
-    printMessage(`${error.message}`, 'error');
-    printMessage(error.response.data, 'error');
-  }
-  if (long) {
-    const table = createTable(['Id'['brightCyan'], 'Value'['brightCyan'], 'Status'['brightCyan'], 'Description'['brightCyan'], 'Modifier'['brightCyan'], 'Modified'['brightCyan']]);
-    for (const variable of variables) {
-      table.push([variable._id, wordwrap(decode(variable.valueBase64), 40), variable.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], wordwrap(variable.description, 40),
-      // eslint-disable-next-line no-await-in-loop
-      await resolveUserName('teammember', variable.lastChangedBy), new Date(variable.lastChangeDate).toLocaleString()]);
-    }
-    printMessage(table.toString(), 'data');
-  } else {
-    variables.forEach(secret => {
-      printMessage(secret._id, 'data');
-    });
+export default class VariablesOps {
+  constructor(state) {
+    this.state = state;
   }
-}
 
-/**
- * Create variable
- * @param {String} variableId variable id
- * @param {String} value variable value
- * @param {String} description variable description
- */
-export async function createVariable(variableId, value, description) {
-  createProgressIndicator(undefined, `Creating variable ${variableId}...`, 'indeterminate');
-  try {
-    await putVariable(variableId, value, description);
-    stopProgressIndicator(`Created variable ${variableId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Delete variable by id/name
+   * @param {string} variableId variable id/name
+   * @returns {Promise<unknown>} a promise that resolves to a variable object
+   */
+  deleteVariable(variableId) {
+    return deleteVariable({
+      variableId,
+      state: this.state
+    });
   }
-}
 
-/**
- * Update variable
- * @param {String} variableId variable id
- * @param {String} value variable value
- * @param {String} description variable description
- */
-export async function updateVariable(variableId, value, description) {
-  createProgressIndicator(undefined, `Updating variable ${variableId}...`, 'indeterminate');
-  try {
-    await putVariable(variableId, value, description);
-    stopProgressIndicator(`Updated variable ${variableId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Get variable by id/name
+   * @param {string} variableId variable id/name
+   * @returns {Promise<unknown>} a promise that resolves to a variable object
+   */
+  getVariable(variableId) {
+    return getVariable({
+      variableId,
+      state: this.state
+    });
   }
-}
 
-/**
- * Set description of variable
- * @param {String} variableId variable id
- * @param {String} description variable description
- */
-export async function setDescriptionOfVariable(variableId, description) {
-  createProgressIndicator(undefined, `Setting description of variable ${variableId}...`, 'indeterminate');
-  try {
-    await setVariableDescription(variableId, description);
-    stopProgressIndicator(`Set description of variable ${variableId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Get all variables
+   * @returns {Promise<unknown[]>} a promise that resolves to an array of variable objects
+   */
+  getVariables() {
+    return getVariables({
+      state: this.state
+    });
   }
-}
 
-/**
- * Delete a variable
- * @param {String} variableId variable id
- */
-export async function deleteVariableCmd(variableId) {
-  createProgressIndicator(undefined, `Deleting variable ${variableId}...`, 'indeterminate');
-  try {
-    await deleteVariable(variableId);
-    stopProgressIndicator(`Deleted variable ${variableId}`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
+  /**
+   * Put variable by id/name
+   * @param {string} variableId variable id/name
+   * @param {string} value variable value
+   * @param {string} description variable description
+   * @returns {Promise<unknown>} a promise that resolves to a variable object
+   */
+  putVariable(variableId, value, description) {
+    return putVariable({
+      variableId,
+      value,
+      description,
+      state: this.state
+    });
   }
-}
 
-/**
- * Delete all variables
- */
-export async function deleteVariablesCmd() {
-  try {
-    const variables = (await getVariables()).result;
-    createProgressIndicator(variables.length, `Deleting variable...`);
-    for (const variable of variables) {
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        await deleteVariable(variable._id);
-        updateProgressIndicator(`Deleted variable ${variable._id}`);
-      } catch (error) {
-        printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
-      }
-    }
-    stopProgressIndicator(`Variables deleted.`);
-  } catch (error) {
-    printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
+  /**
+   * Set variable description
+   * @param {string} variableId variable id/name
+   * @param {string} description variable description
+   * @returns {Promise<unknown>} a promise that resolves to a status object
+   */
+  setVariableDescription(variableId, description) {
+    return setVariableDescription({
+      variableId,
+      description,
+      state: this.state
+    });
   }
 }
-
-/**
- * Describe a variable
- * @param {String} variableId variable id
- */
-export async function describeVariable(variableId) {
-  const variable = await getVariable(variableId);
-  const table = createKeyValueTable();
-  table.push(['Name'['brightCyan'], variable._id]);
-  table.push(['Value'['brightCyan'], wordwrap(decode(variable.valueBase64), 40)]);
-  table.push(['Status'['brightCyan'], variable.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed']]);
-  table.push(['Description'['brightCyan'], wordwrap(variable.description, 60)]);
-  table.push(['Modified'['brightCyan'], new Date(variable.lastChangeDate).toLocaleString()]);
-  table.push(['Modifier'['brightCyan'], await resolveUserName('teammember', variable.lastChangedBy)]);
-  table.push(['Modifier UUID'['brightCyan'], variable.lastChangedBy]);
-  printMessage(table.toString());
-}
+export { deleteVariable, getVariable, getVariables, putVariable, setVariableDescription };
 //# sourceMappingURL=VariablesOps.js.map

package/esm/ops/utils/Console.mjs

@@ -1,5 +1,5 @@
 import Table from 'cli-table3';
-import * as state from '../../shared/State';
+import { state } from '../../lib/FrodoLib';
 
 /**
  * Handles data / messages output. The caller decides and implements how
@@ -51,6 +51,7 @@ export function debugMessage(message) {
 /**
  * Helper function to mask password header in curl command
  * @param curlCommand curl command to mask
+ * @param {State} state library state
  * @returns masked curl command
  */
 function maskPasswordHeader(curlCommand) {

package/esm/ops/utils/DataProtection.mjs

@@ -14,7 +14,6 @@ import crypto from 'crypto';
 import { homedir } from 'os';
 import { promisify } from 'util';
 import { printMessage } from './Console';
-import * as state from '../../shared/State';
 import { FRODO_MASTER_KEY_PATH_KEY, FRODO_MASTER_KEY_KEY } from '../../storage/StaticStorage';
 const scrypt = promisify(crypto.scrypt);
 // using WeakMaps for added security since  it gets garbage collected
@@ -24,8 +23,8 @@ const _salt = new WeakMap();
 const _key = new WeakMap();
 const _encrypt = new WeakMap();
 class DataProtection {
-  constructor() {
-    const masterKeyPath = () => state.getMasterKeyPath() || process.env[FRODO_MASTER_KEY_PATH_KEY] || `${homedir()}/.frodo/masterkey.key`;
+  constructor(pathToMasterKey = null) {
+    const masterKeyPath = () => pathToMasterKey || process.env[FRODO_MASTER_KEY_PATH_KEY] || `${homedir()}/.frodo/masterkey.key`;
     // Generates a master key in base64 format. This master key will be used to derive the key for encryption. this key should be protected by an HSM or KMS
     _masterKey.set(this, async () => {
       try {

package/esm/ops/utils/ExportImportUtils.mjs

@@ -3,10 +3,112 @@ import { lstat, readdir } from 'fs/promises';
 import { join } from 'path';
 import slugify from 'slugify';
 import { decode, decodeBase64Url, encode, encodeBase64Url } from '../../api/utils/Base64';
-import * as state from '../../shared/State';
 import { FRODO_METADATA_ID } from '../../storage/StaticStorage';
 import { debugMessage, printMessage } from './Console';
-export function getMetadata() {
+export default class ExportImportUtils {
+  constructor(state) {
+    this.state = state;
+  }
+  getMetadata() {
+    return getMetadata({
+      state: this.state
+    });
+  }
+
+  /*
+   * Output str in title case
+   *
+   * e.g.: 'ALL UPPERCASE AND all lowercase' = 'All Uppercase And All Lowercase'
+   */
+  titleCase(input) {
+    return titleCase(input);
+  }
+  getRealmString() {
+    return getRealmString({
+      state: this.state
+    });
+  }
+  convertBase64TextToArray(b64text) {
+    return convertBase64TextToArray(b64text);
+  }
+  convertBase64UrlTextToArray(b64UTF8Text) {
+    return convertBase64UrlTextToArray(b64UTF8Text);
+  }
+  convertTextArrayToBase64(textArray) {
+    return convertTextArrayToBase64(textArray);
+  }
+  convertTextArrayToBase64Url(textArray) {
+    return convertTextArrayToBase64Url(textArray);
+  }
+  validateImport(metadata) {
+    return validateImport(metadata);
+  }
+  getTypedFilename(name, type, suffix = 'json') {
+    return getTypedFilename(name, type, suffix);
+  }
+  getWorkingDirectory() {
+    return getWorkingDirectory({
+      state: this.state
+    });
+  }
+  saveToFile(type, data, identifier, filename) {
+    return saveToFile({
+      type,
+      data,
+      identifier,
+      filename,
+      state: this.state
+    });
+  }
+
+  /**
+   * Save JSON object to file
+   * @param {Object} data data object
+   * @param {String} filename file name
+   * @return {boolean} true if successful, false otherwise
+   */
+  saveJsonToFile(data, filename, includeMeta = true) {
+    return saveJsonToFile({
+      data,
+      filename,
+      includeMeta,
+      state: this.state
+    });
+  }
+
+  /**
+   * Append text data to file
+   * @param {String} data text data
+   * @param {String} filename file name
+   */
+  appendTextToFile(data, filename) {
+    return appendTextToFile(data, filename);
+  }
+
+  /**
+   * Find files by name
+   * @param {string} fileName file name to search for
+   * @param {boolean} fast return first result and stop search
+   * @param {string} path path to directory where to start the search
+   * @returns {string[]} array of found file paths relative to starting directory
+   */
+  findFilesByName(fileName, fast = true, path = './') {
+    return findFilesByName(fileName, fast, path);
+  }
+
+  /**
+   * find all (nested) files in a directory
+   *
+   * @param directory directory to search
+   * @returns list of files
+   */
+  async readFilesRecursive(directory) {
+    return readFilesRecursive(directory);
+  }
+}
+export function getMetadata({
+  state
+}) {
   const metadata = {
     origin: state.getHost(),
     originAmVersion: state.getAmVersion(),
@@ -31,7 +133,9 @@ export function titleCase(input) {
   }
   return splitStr.join(' ');
 }
-export function getRealmString() {
+export function getRealmString({
+  state
+}) {
   const realm = state.getRealm();
   return realm.split('/').reduce((result, item) => `${result}${titleCase(item)}`, '');
 }
@@ -68,7 +172,9 @@ export function getTypedFilename(name, type, suffix = 'json') {
   const slug = slugify(name.replace(/^http(s?):\/\//, ''));
   return `${slug}.${type}.${suffix}`;
 }
-export function getWorkingDirectory() {
+export function getWorkingDirectory({
+  state
+}) {
   let wd = '.';
   if (state.getDirectory()) {
     wd = state.getDirectory().replace(/\/$/, '');
@@ -82,9 +188,17 @@ export function getWorkingDirectory() {
   }
   return wd;
 }
-export function saveToFile(type, data, identifier, filename) {
+export function saveToFile({
+  type,
+  data,
+  identifier,
+  filename,
+  state
+}) {
   const exportData = {};
-  exportData['meta'] = getMetadata();
+  exportData['meta'] = getMetadata({
+    state
+  });
   exportData[type] = {};
   if (Array.isArray(data)) {
     data.forEach(element => {
@@ -107,9 +221,16 @@ export function saveToFile(type, data, identifier, filename) {
  * @param {String} filename file name
  * @return {boolean} true if successful, false otherwise
  */
-export function saveJsonToFile(data, filename, includeMeta = true) {
+export function saveJsonToFile({
+  data,
+  filename,
+  includeMeta = true,
+  state
+}) {
   const exportData = data;
-  if (includeMeta) exportData.meta = getMetadata();
+  if (includeMeta) exportData['meta'] = getMetadata({
+    state
+  });
   try {
     fs.writeFileSync(filename, JSON.stringify(exportData, null, 2));
     return true;

package/esm/ops/utils/ExportImportUtils.test.mjs

@@ -1,3 +1,4 @@
+import { state } from '../../index';
 import { resolve } from 'path';
 import { rmSync, existsSync, readFileSync } from 'fs';
 import { convertTextArrayToBase64, convertBase64TextToArray, saveToFile, validateImport } from './ExportImportUtils';
@@ -64,7 +65,13 @@ describe.skip('file system based tests', () => {
       }
     };
     // Act
-    saveToFile('lotr', data, 'id', PATH_TO_ARTIFACT);
+    saveToFile({
+      type: 'lotr',
+      data,
+      identifier: 'id',
+      filename: PATH_TO_ARTIFACT,
+      state
+    });
     const resultingJSON = JSON.parse(readFileSync(PATH_TO_ARTIFACT, 'utf8'));
     // Assert
     expect(resultingJSON.lotr).toEqual(expected.lotr);
@@ -79,7 +86,13 @@ describe.skip('file system based tests', () => {
       words: 1064
     }];
     // Act
-    saveToFile('lotr', data, 'id', PATH_TO_ARTIFACT);
+    saveToFile({
+      type: 'lotr',
+      data,
+      identifier: 'id',
+      filename: PATH_TO_ARTIFACT,
+      state
+    });
     const resultingJSON = JSON.parse(readFileSync(PATH_TO_ARTIFACT, 'utf8'));
     // Assert
     expect(Object.keys(resultingJSON.meta)).toEqual(['origin', 'exportedBy', 'exportDate', 'exportTool', 'exportToolVersion']);

package/esm/ops/utils/OpsUtils.mjs

@@ -1,4 +1,3 @@
-import * as state from '../../shared/State';
 import * as globalConfig from '../../storage/StaticStorage';
 import { getCurrentRealmName, getRealmName as _getRealmName } from '../../api/utils/ApiUtils';
 import { lstat, readdir, readFile } from 'fs/promises';
@@ -36,10 +35,12 @@ export function applyNameCollisionPolicy(name) {
  * Get the name of the managed user object for the current realm
  * @returns {String} the name of the managed user object for the current realm
  */
-export function getRealmManagedUser() {
+export function getRealmManagedUser({
+  state
+}) {
   let realmManagedUser = 'user';
   if (state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY) {
-    realmManagedUser = `${getCurrentRealmName()}_user`;
+    realmManagedUser = `${getCurrentRealmName(state)}_user`;
   }
   return realmManagedUser;
 }

package/esm/ops/utils/OpsUtils.test.mjs

@@ -1,5 +1,13 @@
+/**
+ * Run tests
+ *
+ *        npm run test:only OpsUtils
+ *
+ * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
+ * in case things don't function as expected
+ */
 import * as OpsUtils from './OpsUtils';
-import * as state from '../../shared/State';
+import { state } from '../../index';
 import { CLOUD_DEPLOYMENT_TYPE_KEY, FORGEOPS_DEPLOYMENT_TYPE_KEY, CLASSIC_DEPLOYMENT_TYPE_KEY } from '../../storage/StaticStorage';
 describe('OpsUtils - getRealmManagedUser()', () => {
   test('getRealmManagedUser() 0: Method is implemented', async () => {
@@ -12,7 +20,9 @@ describe('OpsUtils - getRealmManagedUser()', () => {
     state.setRealm(REALM);
     state.setDeploymentType(DEPLOYMENT_TYPE);
     // Act
-    const testString = OpsUtils.getRealmManagedUser();
+    const testString = OpsUtils.getRealmManagedUser({
+      state
+    });
     // Assert
     expect(testString).toBe('alpha_user');
   });
@@ -23,7 +33,9 @@ describe('OpsUtils - getRealmManagedUser()', () => {
     state.setRealm(REALM);
     state.setDeploymentType(DEPLOYMENT_TYPE);
     // Act
-    const testString = OpsUtils.getRealmManagedUser();
+    const testString = OpsUtils.getRealmManagedUser({
+      state
+    });
     // Assert
     expect(testString).toBe('alpha_user');
   });
@@ -34,7 +46,9 @@ describe('OpsUtils - getRealmManagedUser()', () => {
     state.setRealm(REALM);
     state.setDeploymentType(DEPLOYMENT_TYPE);
     // Act
-    const testString = OpsUtils.getRealmManagedUser();
+    const testString = OpsUtils.getRealmManagedUser({
+      state
+    });
     // Assert
     expect(testString).toBe('user');
   });
@@ -45,7 +59,9 @@ describe('OpsUtils - getRealmManagedUser()', () => {
     state.setRealm(REALM);
     state.setDeploymentType(DEPLOYMENT_TYPE);
     // Act
-    const testString = OpsUtils.getRealmManagedUser();
+    const testString = OpsUtils.getRealmManagedUser({
+      state
+    });
     // Assert
     expect(testString).toBe('user');
   });

package/esm/ops/utils/{ValidationUtils.mjs → ScriptValidationUtils.mjs}

@@ -56,4 +56,4 @@ export function isValidJs(javascriptSource) {
     return false;
   }
 }
-//# sourceMappingURL=ValidationUtils.js.map
+//# sourceMappingURL=ScriptValidationUtils.js.map

package/esm/ops/utils/{ValidationUtils.test.mjs → ScriptValidationUtils.test.mjs}

@@ -1,4 +1,4 @@
-import { validateScriptHooks } from './ValidationUtils';
+import { validateScriptHooks } from './ScriptValidationUtils';
 describe('validateScriptHooks', () => {
   it('should return false when there is an invalid script', () => {
     const jsonData = {
@@ -27,4 +27,4 @@ describe('validateScriptHooks', () => {
     expect(validateScriptHooks(jsonData)).toBe(true);
   });
 });
-//# sourceMappingURL=ValidationUtils.test.js.map
+//# sourceMappingURL=ScriptValidationUtils.test.js.map

package/esm/ops/utils/Version.mjs

@@ -2,17 +2,40 @@ import fs from 'fs';
 import path from 'path';
 import { generateReleaseApi } from '../../api/BaseApi';
 import { fileURLToPath } from 'url';
+export default class Version {
+  constructor(state) {
+    this.state = state;
+  }
+  getVersion() {
+    return getVersion({
+      state: this.state
+    });
+  }
+  async getAllVersions(endpoints) {
+    return getAllVersions({
+      endpoints,
+      state: this.state
+    });
+  }
+}
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../../package.json'), 'utf8'));
-// const userAgent = `${pkg.name}/${pkg.version}`;
-
-export function getVersion() {
-  return `${pkg.version}`;
+export function getVersion({
+  state
+}) {
+  // must initialize state to avoid library initialization issues
+  if (state) return `${pkg.version}`;
 }
-export async function getAllVersions(endpoints) {
+export async function getAllVersions({
+  endpoints,
+  state
+}) {
   const reqPromises = [];
   endpoints.forEach(item => {
-    reqPromises.push(generateReleaseApi(item.base).get(item.path));
+    reqPromises.push(generateReleaseApi({
+      baseUrl: item.base,
+      state
+    }).get(item.path));
   });
   const result = await Promise.allSettled(reqPromises);
   return result;

package/esm/ops/utils/Version.test.mjs

@@ -1,3 +1,4 @@
+import { state } from '../../index';
 import fs from 'fs';
 import path from 'path';
 import { getVersion } from './Version';
@@ -6,7 +7,9 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../../package.json'), 'utf8'));
 describe('index', () => {
   test('get library version', () => {
-    const result = getVersion();
+    const result = getVersion({
+      state
+    });
     expect(result).toEqual(`${pkg.version}`);
   });
 });