@rockcarver/frodo-lib 0.16.2-9 → 0.17.1

package/esm/ops/utils/ExportImportUtils.mjs

@@ -3,44 +3,40 @@ import { lstat, readdir } from 'fs/promises';
 import { join } from 'path';
 import slugify from 'slugify';
 import { decode, decodeBase64Url, encode, encodeBase64Url } from '../../api/utils/Base64';
-import storage from '../../storage/SessionStorage';
+import * as state from '../../shared/State';
 import { FRODO_METADATA_ID } from '../../storage/StaticStorage';
 import { debugMessage, printMessage } from './Console';
 export function getCurrentTimestamp() {
   const ts = new Date();
   return ts.toISOString();
 }
-
-function getMetadata() {
+export function getMetadata() {
   const metadata = {
-    origin: storage.session.getTenant(),
-    originAmVersion: storage.session.getAmVersion(),
-    exportedBy: storage.session.getUsername(),
+    origin: state.getHost(),
+    originAmVersion: state.getAmVersion(),
+    exportedBy: state.getUsername(),
     exportDate: getCurrentTimestamp(),
     exportTool: FRODO_METADATA_ID,
-    exportToolVersion: storage.session.getFrodoVersion()
+    exportToolVersion: state.getFrodoVersion()
   };
   return metadata;
 }
+
 /*
  * Output str in title case
  *
  * e.g.: 'ALL UPPERCASE AND all lowercase' = 'All Uppercase And All Lowercase'
  */
-
-
 export function titleCase(input) {
   const str = input.toString();
   const splitStr = str.toLowerCase().split(' ');
-
   for (let i = 0; i < splitStr.length; i += 1) {
     splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].slice(1);
   }
-
   return splitStr.join(' ');
 }
 export function getRealmString() {
-  const realm = storage.session.getRealm();
+  const realm = state.getRealm();
   return realm.split('/').reduce((result, item) => `${result}${titleCase(item)}`, '');
 }
 export function convertBase64TextToArray(b64text) {
@@ -66,8 +62,9 @@ export function convertTextArrayToBase64Url(textArray) {
   const joinedText = textArray.join('\n');
   const b64encodedScript = encodeBase64Url(joinedText);
   return b64encodedScript;
-} // eslint-disable-next-line no-unused-vars
+}
 
+// eslint-disable-next-line no-unused-vars
 export function validateImport(metadata) {
   return metadata || true;
 }
@@ -77,10 +74,9 @@ export function getTypedFilename(name, type, suffix = 'json') {
 }
 export function getWorkingDirectory() {
   let wd = '.';
-
-  if (storage.session.getDirectory()) {
-    wd = storage.session.getDirectory().replace(/\/$/, ''); // create directory if it doesn't exist
-
+  if (state.getDirectory()) {
+    wd = state.getDirectory().replace(/\/$/, '');
+    // create directory if it doesn't exist
     if (!fs.existsSync(wd)) {
       debugMessage(`ExportImportUtils.getWorkingDirectory: creating directory '${wd}'`);
       fs.mkdirSync(wd, {
@@ -88,14 +84,12 @@ export function getWorkingDirectory() {
       });
     }
   }
-
   return wd;
 }
 export function saveToFile(type, data, identifier, filename) {
   const exportData = {};
   exportData['meta'] = getMetadata();
   exportData[type] = {};
-
   if (Array.isArray(data)) {
     data.forEach(element => {
       exportData[type][element[identifier]] = element;
@@ -103,54 +97,52 @@ export function saveToFile(type, data, identifier, filename) {
   } else {
     exportData[type][data[identifier]] = data;
   }
-
   fs.writeFile(filename, JSON.stringify(exportData, null, 2), err => {
     if (err) {
       return printMessage(`ERROR - can't save ${type} to file`, 'error');
     }
-
     return '';
   });
 }
+
 /**
  * Save JSON object to file
  * @param {Object} data data object
  * @param {String} filename file name
+ * @return {boolean} true if successful, false otherwise
  */
-
-export function saveJsonToFile(data, filename) {
+export function saveJsonToFile(data, filename, includeMeta = true) {
   const exportData = data;
-  exportData.meta = getMetadata();
-  fs.writeFile(filename, JSON.stringify(exportData, null, 2), err => {
-    if (err) {
-      return printMessage(`ERROR - can't save ${filename}`, 'error');
-    }
-
-    return '';
-  });
+  if (includeMeta) exportData.meta = getMetadata();
+  try {
+    fs.writeFileSync(filename, JSON.stringify(exportData, null, 2));
+    return true;
+  } catch (err) {
+    printMessage(`ERROR - can't save ${filename}`, 'error');
+    return false;
+  }
 }
+
 /**
  * Save text data to file
  * @param {String} data text data
  * @param {String} filename file name
  */
-
 export function saveTextToFile(data, filename) {
   fs.writeFile(filename, data, err => {
     if (err) {
       printMessage(`ERROR - can't save ${filename}`, 'error');
       return false;
     }
-
     return true;
   });
 }
+
 /**
  * Append text data to file
  * @param {String} data text data
  * @param {String} filename file name
  */
-
 export function appendTextToFile(data, filename) {
   try {
     fs.appendFileSync(filename, data);
@@ -158,6 +150,7 @@ export function appendTextToFile(data, filename) {
     printMessage(`${error.message}`, 'error');
   }
 }
+
 /**
  * Find files by name
  * @param {string} fileName file name to search for
@@ -165,40 +158,38 @@ export function appendTextToFile(data, filename) {
  * @param {string} path path to directory where to start the search
  * @returns {string[]} array of found file paths relative to starting directory
  */
-
 export function findFilesByName(fileName, fast = true, path = './') {
   const entries = fs.readdirSync(path, {
     encoding: 'utf8',
     withFileTypes: true
-  }); // Get files within the current directory and add a path key to the file objects
+  });
 
-  const files = entries.filter(entry => !entry.isDirectory()).filter(file => file.name === fileName) // .map((file) => ({ ...file, path: path + file.name }));
+  // Get files within the current directory and add a path key to the file objects
+  const files = entries.filter(entry => !entry.isDirectory()).filter(file => file.name === fileName)
+  // .map((file) => ({ ...file, path: path + file.name }));
   .map(file => path + file.name);
-  if (fast && files.length > 0) return files; // search sub-folders
+  if (fast && files.length > 0) return files;
 
+  // search sub-folders
   const folders = entries.filter(entry => entry.isDirectory());
-
   for (const folder of folders) files.push(...findFilesByName(fileName, fast, `${path}${folder.name}/`));
-
   return files;
 }
+
 /**
  * find all (nested) files in a directory
  *
  * @param directory directory to search
  * @returns list of files
  */
-
 export async function readFilesRecursive(directory) {
   const items = await readdir(directory);
   const filePathsNested = await Promise.all(items.map(async entity => {
     const path = join(directory, entity);
     const isDirectory = (await lstat(path)).isDirectory();
-
     if (isDirectory) {
       return readFilesRecursive(path);
     }
-
     return path;
   }));
   return filePathsNested.flat();

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

@@ -1,6 +1,7 @@
 import { resolve } from 'path';
 import { rmSync, existsSync, readFileSync } from 'fs';
-import { convertTextArrayToBase64, convertBase64TextToArray, saveToFile, validateImport } from './ExportImportUtils'; // Warning! implimentation file contains non determinisitc functions which are either; not reasonable to test or imposible
+import { convertTextArrayToBase64, convertBase64TextToArray, saveToFile, validateImport } from './ExportImportUtils';
+// Warning! implimentation file contains non determinisitc functions which are either; not reasonable to test or imposible
 // Cause: date based non overidable functions
 // Not tested: getCurrentTimestamp
 
@@ -13,10 +14,10 @@ test('convertBase64TextToArray returns an array of text lines in base64 encoding
       return 'ring to mt doom';
     }
   `;
-  const base64Script = Buffer.from(originalScript).toString('base64'); // Act
-
-  const result = convertBase64TextToArray(base64Script); // Assert
-
+  const base64Script = Buffer.from(originalScript).toString('base64');
+  // Act
+  const result = convertBase64TextToArray(base64Script);
+  // Assert
   expect(result).toEqual(originalScript.split('\n'));
 });
 test('convertTextArrayToBase64', () => {
@@ -26,16 +27,17 @@ test('convertTextArrayToBase64', () => {
       return 'ring to mt doom';
     }
   `;
-  const expected = Buffer.from(originalArrayOfScriptLines).toString('base64'); // Act
-
-  const result = convertTextArrayToBase64(originalArrayOfScriptLines.split('\n')); // Assert
-
+  const expected = Buffer.from(originalArrayOfScriptLines).toString('base64');
+  // Act
+  const result = convertTextArrayToBase64(originalArrayOfScriptLines.split('\n'));
+  // Assert
   expect(result).toEqual(expected);
 });
 test('validateImport should always return true', () => {
   expect(validateImport(null)).not.toBe(false);
-}); // This function has no way to determine when its asnyc task is complete, suggest using callback or promises to allow for testing
+});
 
+// This function has no way to determine when its asnyc task is complete, suggest using callback or promises to allow for testing
 describe.skip('file system based tests', () => {
   afterAll(() => {
     if (existsSync(PATH_TO_ARTIFACT)) {
@@ -60,11 +62,11 @@ describe.skip('file system based tests', () => {
           words: 1064
         }
       }
-    }; // Act
-
+    };
+    // Act
     saveToFile('lotr', data, 'id', PATH_TO_ARTIFACT);
-    const resultingJSON = JSON.parse(readFileSync(PATH_TO_ARTIFACT, 'utf8')); // Assert
-
+    const resultingJSON = JSON.parse(readFileSync(PATH_TO_ARTIFACT, 'utf8'));
+    // Assert
     expect(resultingJSON.lotr).toEqual(expected.lotr);
   });
   test('saveToFile should save a file with metadata', async () => {
@@ -75,11 +77,11 @@ describe.skip('file system based tests', () => {
       location: 'The Shire',
       character: 'Gandalf',
       words: 1064
-    }]; // Act
-
+    }];
+    // Act
     saveToFile('lotr', data, 'id', PATH_TO_ARTIFACT);
-    const resultingJSON = JSON.parse(readFileSync(PATH_TO_ARTIFACT, 'utf8')); // Assert
-
+    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,50 +1,49 @@
-import storage from '../../storage/SessionStorage';
-import * as global from '../../storage/StaticStorage';
+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';
 import { join } from 'path';
-import replaceall from 'replaceall'; // TODO: do we really need this? if yes: document
+import replaceall from 'replaceall';
 
+// TODO: do we really need this? if yes: document
 export function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-} // TODO: do we really need this? if yes: document
+}
 
+// TODO: do we really need this? if yes: document
 export function replaceAll(str, find, replace) {
   return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
 }
+
 /**
  * Get new name when names collide
  * @param {String} name to apply policy to
  * @returns {String} new name according to policy
  */
-
 export function applyNameCollisionPolicy(name) {
   const capturingRegex = /(.* - imported) \(([0-9]+)\)/;
   const found = name.match(capturingRegex);
-
   if (found && found.length > 0 && found.length === 3) {
     // already renamed one or more times
     // return the next number
     return `${found[1]} (${parseInt(found[2], 10) + 1})`;
-  } // first time
-
-
+  }
+  // first time
   return `${name} - imported (1)`;
 }
+
 /**
  * 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() {
   let realmManagedUser = 'user';
-
-  if (storage.session.getDeploymentType() === global.CLOUD_DEPLOYMENT_TYPE_KEY) {
+  if (state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY) {
     realmManagedUser = `${getCurrentRealmName()}_user`;
   }
-
   return realmManagedUser;
 }
+
 /**
  * Compare two json objects
  * @param {Object} obj1 object 1
@@ -52,15 +51,12 @@ export function getRealmManagedUser() {
  * @param {[String]} ignoreKeys array of keys to ignore in comparison
  * @returns {boolean} true if the two json objects have the same length and all the properties have the same value
  */
-
 export function isEqualJson(obj1, obj2, ignoreKeys = []) {
   const obj1Keys = Object.keys(obj1).filter(key => !ignoreKeys.includes(key));
   const obj2Keys = Object.keys(obj2).filter(key => !ignoreKeys.includes(key));
-
   if (obj1Keys.length !== obj2Keys.length) {
     return false;
   }
-
   for (const objKey of obj1Keys) {
     if (obj1[objKey] !== obj2[objKey]) {
       if (typeof obj1[objKey] === 'object' && typeof obj2[objKey] === 'object') {
@@ -72,18 +68,18 @@ export function isEqualJson(obj1, obj2, ignoreKeys = []) {
       }
     }
   }
-
   return true;
 }
+
 /**
  * Get current realm name
  * @param {String} realm realm
  * @returns {String} name of the realm. /alpha -> alpha
  */
-
 export function getRealmName(realm) {
   return _getRealmName(realm);
 }
+
 /**
  * find all (nested) files in a directory
  *
@@ -91,7 +87,6 @@ export function getRealmName(realm) {
  * @param childDirectory subdirectory to search
  * @returns list of files
  */
-
 export async function readFiles(baseDirectory, childDirectory = '') {
   const targetDirectory = join(baseDirectory, childDirectory);
   const directoryItems = await readdir(targetDirectory);
@@ -99,11 +94,9 @@ export async function readFiles(baseDirectory, childDirectory = '') {
   const filePathsNested = await Promise.all(childPaths.map(async childPath => {
     const path = join(baseDirectory, childPath);
     const isDirectory = (await lstat(path)).isDirectory();
-
     if (isDirectory) {
       return readFiles(baseDirectory, childPath);
     }
-
     return {
       path: childPath,
       content: await readFile(path, 'utf8')
@@ -123,4 +116,17 @@ export function unSubstituteEnvParams(input, reader) {
   });
   return input;
 }
+
+/**
+ * Check if a string is a valid URL
+ * @param {string} urlString input string to be evaluated
+ * @returns {boolean} true if a valid URL, false otherwise
+ */
+export function isValidUrl(urlString) {
+  try {
+    return Boolean(new URL(urlString));
+  } catch (error) {
+    return false;
+  }
+}
 //# sourceMappingURL=OpsUtils.js.map

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

@@ -1,50 +1,178 @@
-import { getRealmManagedUser } from './OpsUtils';
-import sessionStorage from '../../storage/SessionStorage';
+import * as OpsUtils from './OpsUtils';
+import * as state from '../../shared/State';
 import { CLOUD_DEPLOYMENT_TYPE_KEY, FORGEOPS_DEPLOYMENT_TYPE_KEY, CLASSIC_DEPLOYMENT_TYPE_KEY } from '../../storage/StaticStorage';
-describe('OpsUtils', () => {
-  test('getRealmManagedUser should prepend realm to managed user type in identity cloud', () => {
+describe('OpsUtils - getRealmManagedUser()', () => {
+  test('getRealmManagedUser() 0: Method is implemented', async () => {
+    expect(OpsUtils.getRealmManagedUser).toBeDefined();
+  });
+  test('getRealmManagedUser() 1: should prepend realm to managed user type in identity cloud', () => {
     // Arrange
     const REALM = 'alpha';
     const DEPLOYMENT_TYPE = CLOUD_DEPLOYMENT_TYPE_KEY;
-    sessionStorage.session.setRealm(REALM);
-    sessionStorage.session.setDeploymentType(DEPLOYMENT_TYPE); // Act
-
-    const testString = getRealmManagedUser(); // Assert
-
+    state.setRealm(REALM);
+    state.setDeploymentType(DEPLOYMENT_TYPE);
+    // Act
+    const testString = OpsUtils.getRealmManagedUser();
+    // Assert
     expect(testString).toBe('alpha_user');
   });
-  test('getCurrentRealmPath should prepend realm without leading slash to managed user type in identity cloud', () => {
+  test('getRealmManagedUser() 2: should prepend realm without leading slash to managed user type in identity cloud', () => {
     // Arrange
     const REALM = '/alpha';
     const DEPLOYMENT_TYPE = CLOUD_DEPLOYMENT_TYPE_KEY;
-    sessionStorage.session.setRealm(REALM);
-    sessionStorage.session.setDeploymentType(DEPLOYMENT_TYPE); // Act
-
-    const testString = getRealmManagedUser(); // Assert
-
+    state.setRealm(REALM);
+    state.setDeploymentType(DEPLOYMENT_TYPE);
+    // Act
+    const testString = OpsUtils.getRealmManagedUser();
+    // Assert
     expect(testString).toBe('alpha_user');
   });
-  test('getRealmManagedUser should not prepend realm to managed user type in forgeops deployments', () => {
+  test('getRealmManagedUser() 3: should not prepend realm to managed user type in forgeops deployments', () => {
     // Arrange
     const REALM = 'alpha';
     const DEPLOYMENT_TYPE = FORGEOPS_DEPLOYMENT_TYPE_KEY;
-    sessionStorage.session.setRealm(REALM);
-    sessionStorage.session.setDeploymentType(DEPLOYMENT_TYPE); // Act
-
-    const testString = getRealmManagedUser(); // Assert
-
+    state.setRealm(REALM);
+    state.setDeploymentType(DEPLOYMENT_TYPE);
+    // Act
+    const testString = OpsUtils.getRealmManagedUser();
+    // Assert
     expect(testString).toBe('user');
   });
-  test('getRealmManagedUser should not prepend realm to managed user type in classic deployments', () => {
+  test('getRealmManagedUser() 4: should not prepend realm to managed user type in classic deployments', () => {
     // Arrange
     const REALM = 'alpha';
     const DEPLOYMENT_TYPE = CLASSIC_DEPLOYMENT_TYPE_KEY;
-    sessionStorage.session.setRealm(REALM);
-    sessionStorage.session.setDeploymentType(DEPLOYMENT_TYPE); // Act
-
-    const testString = getRealmManagedUser(); // Assert
-
+    state.setRealm(REALM);
+    state.setDeploymentType(DEPLOYMENT_TYPE);
+    // Act
+    const testString = OpsUtils.getRealmManagedUser();
+    // Assert
     expect(testString).toBe('user');
   });
 });
+describe('OpsUtils - isEqualJson()', () => {
+  test('isEqualJson() 0: Method is implemented', async () => {
+    expect(OpsUtils.isEqualJson).toBeDefined();
+  });
+  test('isEqualJson() 1: two empty objects should be equal', () => {
+    const obj1 = {};
+    const obj2 = {};
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeTruthy();
+  });
+  test('isEqualJson() 2: two objects with single and equal entry should be equal', () => {
+    const obj1 = {
+      key: 'value'
+    };
+    const obj2 = {
+      key: 'value'
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeTruthy();
+  });
+  test('isEqualJson() 3: two objects with equal key but different value should not be equal', () => {
+    const obj1 = {
+      key: 'value1'
+    };
+    const obj2 = {
+      key: 'value2'
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeFalsy();
+  });
+  test('isEqualJson() 4: two objects with differing keys but equal values should not be equal', () => {
+    const obj1 = {
+      key1: 'value'
+    };
+    const obj2 = {
+      key2: 'value'
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeFalsy();
+  });
+  test('isEqualJson() 5: two objects with unequal amounts of entries should not be equal', () => {
+    const obj1 = {
+      key1: 'value'
+    };
+    const obj2 = {
+      key1: 'value',
+      key2: 'value2'
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeFalsy();
+  });
+  test('isEqualJson() 6: two objects with equal but nested keys should be equal', () => {
+    const obj1 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3'
+      }
+    };
+    const obj2 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3'
+      }
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeTruthy();
+  });
+  test('isEqualJson() 7: two objects with equal but multi-nested keys should be equal', () => {
+    const obj1 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3',
+        key4: {
+          key5: 'value5'
+        }
+      }
+    };
+    const obj2 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3',
+        key4: {
+          key5: 'value5'
+        }
+      }
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeTruthy();
+  });
+  test('isEqualJson() 8: two objects with equal multi-nested keys but unequal values should not be equal', () => {
+    const obj1 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3',
+        key4: {
+          key5: 'value5'
+        }
+      }
+    };
+    const obj2 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3',
+        key4: {
+          key5: 'value'
+        }
+      }
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2)).toBeFalsy();
+  });
+  test('isEqualJson() 9: two objects with equal multi-nested keys but unequal values with the offending key excluded should be equal', () => {
+    const obj1 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3',
+        key4: {
+          key5: 'value5'
+        }
+      }
+    };
+    const obj2 = {
+      key1: 'value1',
+      key2: {
+        key3: 'value3',
+        key4: {
+          key5: 'value'
+        }
+      }
+    };
+    expect(OpsUtils.isEqualJson(obj1, obj2, ['key5'])).toBeTruthy();
+  });
+});
 //# sourceMappingURL=OpsUtils.test.js.map

package/esm/ops/utils/ValidationUtils.mjs

@@ -2,42 +2,33 @@ import { parseScript } from 'esprima';
 import { printMessage } from './Console';
 export function validateScriptHooks(jsonData) {
   const scriptHooks = findAllScriptHooks(jsonData);
-
   for (const scriptHook of scriptHooks) {
     if (!('source' in scriptHook)) {
       continue;
     }
-
     if (!isValidJs(scriptHook.source)) {
       return false;
     }
   }
-
   return true;
 }
-
 function findAllScriptHooks(jsonData, scriptHooksArray = []) {
   if (typeof jsonData !== 'object' || jsonData === null) {
     return scriptHooksArray;
   }
-
   for (const key in jsonData) {
     const item = jsonData[key];
-
     if (typeof item !== 'object' || item === null) {
       continue;
     }
-
     if ('type' in item && item.type === 'text/javascript') {
       scriptHooksArray.push(item);
     } else {
       findAllScriptHooks(item, scriptHooksArray);
     }
   }
-
   return scriptHooksArray;
 }
-
 function isValidJs(javascriptSource) {
   try {
     parseScript(javascriptSource);