@rockcarver/frodo-lib 0.12.5 → 0.12.6

package/esm/ops/JourneyOps.mjs

@@ -6,11 +6,18 @@ import { getRealmManagedUser, replaceAll } from './utils/OpsUtils';
 import storage from '../storage/SessionStorage';
 import { getNode, putNode, deleteNode, getNodeTypes, getNodesByType } from '../api/NodeApi';
 import { isCloudOnlyNode, isCustomNode, isPremiumNode } from './NodeOps';
+import * as Node from './NodeOps';
+import * as EmailTemplate from './EmailTemplateOps';
+import * as Script from './ScriptOps';
+import * as Theme from './ThemeOps';
+import * as Idp from './IdpOps';
+import * as Saml2 from './Saml2Ops';
+import * as CirclesOfTrust from './CirclesOfTrustOps';
 import { getTrees, getTree, putTree, deleteTree } from '../api/TreeApi';
 import { getEmailTemplate, putEmailTemplate } from '../api/EmailTemplateApi';
 import { getScript } from '../api/ScriptApi';
 import * as global from '../storage/StaticStorage';
-import { printMessage, createProgressIndicator, updateProgressIndicator, stopProgressIndicator, createTable } from './utils/Console';
+import { printMessage, createProgressIndicator, updateProgressIndicator, stopProgressIndicator, createTable, debugMessage } from './utils/Console';
 import wordwrap from './utils/Wordwrap';
 import { getProviderByLocationAndId, getProviders, getProviderMetadata, createProvider, findProviders, updateProvider } from '../api/Saml2Api';
 import { createCircleOfTrust, getCirclesOfTrust, updateCircleOfTrust } from '../api/CirclesOfTrustApi';
@@ -22,8 +29,22 @@ const containerNodes = ['PageNode', 'CustomPageNode'];
 const scriptedNodes = ['ConfigProviderNode', 'ScriptedDecisionNode', 'ClientScriptNode', 'SocialProviderHandlerNode', 'CustomScriptNode'];
 const emailTemplateNodes = ['EmailSuspendNode', 'EmailTemplateNode'];
 const emptyScriptPlaceholder = '[Empty]';
-// use a function vs a template variable to avoid problems in loops
-export function createSingleJourneyExportTemplate() {
+/**
+ * Get a one-line description of the tree object
+ * @param {TreeSkeleton} treeObj circle of trust object to describe
+ * @returns {string} a one-line description
+ */
+
+export function getOneLineDescription(treeObj) {
+  const description = `[${treeObj._id['brightCyan']}]`;
+  return description;
+}
+/**
+ * Create an empty single tree export template
+ * @returns {SingleTreeExportInterface} an empty single tree export template
+ */
+
+export function createSingleTreeExportTemplate() {
   return {
     meta: {},
     innerNodes: {},
@@ -37,8 +58,12 @@ export function createSingleJourneyExportTemplate() {
     tree: {}
   };
 }
-// use a function vs a template variable to avoid problems in loops
-export function createMultiJourneyExportTemplate() {
+/**
+ * Create an empty multi tree export template
+ * @returns {MultiTreeExportInterface} an empty multi tree export template
+ */
+
+export function createMultiTreeExportTemplate() {
   return {
     meta: {},
     trees: {}
@@ -126,39 +151,22 @@ async function getSaml2NodeDependencies(nodeObject, allProviders, allCirclesOfTr
     };
     return saml2NodeDependencies;
   }
-} // export async function getTreeNodes(treeObject) {
-//   const nodeList = Object.entries(treeObject.nodes);
-//   const results = await Promise.allSettled(
-//     nodeList.map(
-//       async ([nodeId, nodeInfo]) => await getNode(nodeId, nodeInfo['nodeType'])
-//     )
-//   );
-//   const nodes = results.filter((r) => r.status === 'fulfilled');
-//   nodes.map((f) => {
-//     return f.status;
-//   });
-//   const failedList = results.filter((r) => r.status === 'rejected');
-//   return nodes;
-// }
-
-/**
- * Export options
- */
-
-
+}
 /**
  * Create export data for a tree/journey with all its nodes and dependencies. The export data can be written to a file as is.
  * @param {string} treeId tree id/name
- * @param {ExportOptions} options export options
- * @returns {Promise<SingleJourneyExportTemplate>} a promise that resolves to an object containing the tree and all its nodes and dependencies
+ * @param {TreeExportOptions} options export options
+ * @returns {Promise<SingleTreeExportInterface>} a promise that resolves to an object containing the tree and all its nodes and dependencies
  */
+
+
 export async function exportJourney(treeId, options = {
   useStringArrays: true,
   deps: true,
   verbose: false
 }) {
   const treeObject = await getTree(treeId);
-  const exportData = createSingleJourneyExportTemplate();
+  const exportData = createSingleTreeExportTemplate();
   const {
     useStringArrays,
     deps,
@@ -456,7 +464,7 @@ export async function getJourneys() {
  * Export journey by id/name to file
  * @param {string} journeyId journey id/name
  * @param {string} file optional export file name
- * @param {ExportOptions} options export options
+ * @param {TreeExportOptions} options export options
  */
 
 export async function exportJourneyToFile(journeyId, file, options) {
@@ -484,10 +492,14 @@ export async function exportJourneyToFile(journeyId, file, options) {
 /**
  * Export all journeys to file
  * @param {string} file optional export file name
- * @param {ExportOptions} options export options
+ * @param {TreeExportOptions} options export options
  */
 
-export async function exportJourneysToFile(file, options) {
+export async function exportJourneysToFile(file, options = {
+  deps: false,
+  useStringArrays: false,
+  verbose: false
+}) {
   let fileName = file;
 
   if (!fileName) {
@@ -495,7 +507,7 @@ export async function exportJourneysToFile(file, options) {
   }
 
   const trees = (await getTrees()).result;
-  const fileData = createMultiJourneyExportTemplate();
+  const fileData = createMultiTreeExportTemplate();
   createProgressIndicator(trees.length, 'Exporting journeys...');
 
   for (const tree of trees) {
@@ -515,7 +527,7 @@ export async function exportJourneysToFile(file, options) {
 }
 /**
  * Export all journeys to separate files
- * @param {ExportOptions} options export options
+ * @param {TreeExportOptions} options export options
  */
 
 export async function exportJourneysToFiles(options) {
@@ -535,15 +547,12 @@ export async function exportJourneysToFiles(options) {
 
   stopProgressIndicator('Done');
 }
-/**
- * Import options
- */
-
 /**
  * Helper to import a tree with all dependencies from an import data object (typically read from a file)
- * @param {SingleJourneyExportTemplate} treeObject tree object containing tree and all its dependencies
- * @param {ImportOptions} options import options
+ * @param {SingleTreeExportInterface} treeObject tree object containing tree and all its dependencies
+ * @param {TreeImportOptions} options import options
  */
+
 export async function importJourney(treeObject, options) {
   const {
     reUuid,
@@ -795,7 +804,7 @@ export async function importJourney(treeObject, options) {
       // and the node's identityResource is the same as the tree's identityResource
       // change it to the current realm managed user identityResource otherwise leave it alone.
 
-      if (nodeData['identityResource'] && nodeData['identityResource'].endsWith('user') && nodeData['identityResource'] === treeObject.tree.identityResource) {
+      if (nodeData.identityResource && nodeData.identityResource.endsWith('user') && nodeData.identityResource === treeObject.tree.identityResource) {
         nodeData['identityResource'] = `managed/${getRealmManagedUser()}`;
         if (verbose) printMessage(`\n      - identityResource: ${nodeData['identityResource']}`, 'info', false);
       }
@@ -868,7 +877,7 @@ export async function importJourney(treeObject, options) {
       var _importError$response9, _importError$response10;
 
       printMessage(((_importError$response9 = importError.response) === null || _importError$response9 === void 0 ? void 0 : _importError$response9.data) || importError, 'error');
-      console.dir(((_importError$response10 = importError.response) === null || _importError$response10 === void 0 ? void 0 : _importError$response10.data) || importError);
+      debugMessage(((_importError$response10 = importError.response) === null || _importError$response10 === void 0 ? void 0 : _importError$response10.data) || importError);
       throw new Error(`\nError importing journey flow ${treeId}`);
     }
   }
@@ -940,7 +949,7 @@ async function resolveDependencies(installedJorneys, journeyMap, unresolvedJourn
  * Import a journey from file
  * @param {string} journeyId journey id/name
  * @param {string} file import file name
- * @param {ImportOptions} options import options
+ * @param {TreeImportOptions} options import options
  */
 
 
@@ -996,7 +1005,7 @@ export async function importJourneyFromFile(journeyId, file, options) {
 /**
  * Import first journey from file
  * @param {string} file import file name
- * @param {ImportOptions} options import options
+ * @param {TreeImportOptions} options import options
  */
 
 export async function importFirstJourneyFromFile(file, options) {
@@ -1061,7 +1070,7 @@ export async function importFirstJourneyFromFile(file, options) {
 /**
  * Helper to import multiple trees from a tree map
  * @param {Object} treesMap map of trees object
- * @param {ImportOptions} options import options
+ * @param {TreeImportOptions} options import options
  */
 
 async function importAllJourneys(treesMap, options) {
@@ -1098,7 +1107,7 @@ async function importAllJourneys(treesMap, options) {
 /**
  * Import all journeys from file
  * @param {string} file import file name
- * @param {ImportOptions} options import options
+ * @param {TreeImportOptions} options import options
  */
 
 
@@ -1111,7 +1120,7 @@ export async function importJourneysFromFile(file, options) {
 }
 /**
  * Import all journeys from separate files
- * @param {ImportOptions} options import options
+ * @param {TreeImportOptions} options import options
  */
 
 export async function importJourneysFromFiles(options) {
@@ -1129,92 +1138,270 @@ export async function importJourneysFromFiles(options) {
   importAllJourneys(allJourneysData.trees, options);
 }
 /**
- * Describe a journey
- * @param {SingleJourneyExportTemplate} journeyData journey export object
+ * Get the node reference obbject for a node object. Node reference objects
+ * are used in a tree flow definition and within page nodes to reference
+ * nodes. Among other things, node references contain all the non-configuration
+ * meta data that exists for readaility, like the x/y coordinates of the node
+ * and the display name chosen by the tree designer. The dislay name is the
+ * only intuitive link between the graphical representation of the tree and
+ * the node configurations that make up the tree.
+ * @param nodeObj node object to retrieve the node reference object for
+ * @param singleTreeExport tree export with or without dependencies
+ * @returns {NodeRefSkeletonInterface | InnerNodeRefSkeletonInterface} node reference object
  */
 
-export function describeJourney(journeyData) {
-  var _journeyData$themes;
+export function getNodeRef(nodeObj, singleTreeExport) {
+  if (singleTreeExport.tree.nodes[nodeObj._id]) {
+    return singleTreeExport.tree.nodes[nodeObj._id];
+  } else {
+    for (const node of Object.values(singleTreeExport.nodes)) {
+      if (containerNodes.includes(node._type._id)) {
+        for (const nodeRef of node.nodes) {
+          if (nodeRef._id === nodeObj._id) {
+            return nodeRef;
+          }
+        }
+      }
+    }
+  }
 
-  const nodeTypeMap = {};
+  return undefined;
+}
+/**
+ * Default tree export resolver used to resolve a tree id/name to a full export
+ * w/o dependencies of that tree from a platform instance.
+ * @param {string} treeId id/name of the tree to resolve
+ * @returns {TreeExportResolverInterface} tree export
+ */
 
-  for (const nodeData of Object.values(journeyData.nodes)) {
-    if (nodeTypeMap[nodeData['_type']['_id']]) {
-      nodeTypeMap[nodeData['_type']['_id']] += 1;
-    } else {
-      nodeTypeMap[nodeData['_type']['_id']] = 1;
+export const onlineTreeExportResolver = async function (treeId) {
+  debugMessage(`onlineTreeExportResolver(${treeId})`);
+  return await exportJourney(treeId, {
+    deps: false,
+    useStringArrays: false,
+    verbose: false
+  });
+};
+/**
+ * Tree export resolver used to resolve a tree id/name to a full export
+ * of that tree from individual `treename.journey.json` export files.
+ * @param {string} treeId id/name of the tree to resolve
+ * @returns {TreeExportResolverInterface} tree export
+ */
+
+export const fileByIdTreeExportResolver = async function (treeId) {
+  debugMessage(`fileByIdTreeExportResolver(${treeId})`);
+  let treeExport = createSingleTreeExportTemplate();
+  const file = getTypedFilename(`${treeId}`, 'journey');
+  debugMessage(`fileByIdTreeExportResolver: resolving '${treeId}' to ${file}`);
+
+  try {
+    var _jsonData$tree;
+
+    const jsonData = JSON.parse(fs.readFileSync(file, 'utf8')); // did we resolve the tree we were asked to resolved?
+
+    if (((_jsonData$tree = jsonData.tree) === null || _jsonData$tree === void 0 ? void 0 : _jsonData$tree._id) === treeId) {
+      treeExport = jsonData;
+    } // check if this is a file with multiple trees and get journey by id
+    else if (jsonData.trees && jsonData.trees[treeId]) {
+      treeExport = jsonData.trees[treeId];
+    }
+  } catch (error) {//
+  }
+
+  return treeExport;
+};
+/**
+ * Factory that creates a tree export resolver used to resolve a tree id
+ * to a full export of that tree from a multi-tree export file.
+ * @param {string} file multi-tree export file
+ * @returns {TreeExportResolverInterface} tree export resolver
+ */
+
+export function createFileParamTreeExportResolver(file) {
+  const fileParamTreeExportResolver = async function (treeId) {
+    debugMessage(`fileParamTreeExportResolver(${treeId})`);
+    let treeExport = createSingleTreeExportTemplate();
+
+    try {
+      var _jsonData$tree2;
+
+      const jsonData = JSON.parse(fs.readFileSync(file, 'utf8')); // did we resolve the tree we were asked to resolved?
+
+      if (((_jsonData$tree2 = jsonData.tree) === null || _jsonData$tree2 === void 0 ? void 0 : _jsonData$tree2._id) === treeId) {
+        treeExport = jsonData;
+      } // check if this is a file with multiple trees and get journey by id
+      else if (jsonData.trees && jsonData.trees[treeId]) {
+        treeExport = jsonData.trees[treeId];
+      } // fall back to fileByIdTreeExportResolver
+      else {
+        treeExport = await fileByIdTreeExportResolver(treeId);
+      }
+    } catch (error) {//
+    }
+
+    return treeExport;
+  };
+
+  debugMessage('fileParamTreeExportResolver:');
+  debugMessage(fileParamTreeExportResolver);
+  return fileParamTreeExportResolver;
+}
+/**
+ * Get tree dependencies (all descendent inner trees)
+ * @param {SingleTreeExportInterface} treeExport single tree export
+ * @param {string[]} resolvedTreeIds list of tree ids wich have already been resolved
+ * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
+ * @returns {Promise<TreeDependencyMapInterface>} a promise that resolves to a tree dependency map
+ */
+
+export async function getTreeDescendents(treeExport, resolveTreeExport = onlineTreeExportResolver, resolvedTreeIds = []) {
+  debugMessage(`getTreeDependencies(${treeExport.tree._id}, [${resolvedTreeIds.join(', ')}])`);
+
+  if (!resolvedTreeIds.includes(treeExport.tree._id)) {
+    resolvedTreeIds.push(treeExport.tree._id);
+  }
+
+  const treeDependencyMap = {
+    [treeExport.tree._id]: []
+  };
+  const dependencies = [];
+
+  for (const [nodeId, node] of Object.entries(treeExport.tree.nodes)) {
+    const innerTreeId = treeExport.nodes[nodeId].tree;
+
+    if (node.nodeType === 'InnerTreeEvaluatorNode' && !resolvedTreeIds.includes(innerTreeId)) {
+      const innerTreeExport = await resolveTreeExport(innerTreeId);
+      debugMessage(`resolved inner tree: ${innerTreeExport.tree._id}`); // resolvedTreeIds.push(innerTreeId);
+
+      dependencies.push(await getTreeDescendents(innerTreeExport, resolveTreeExport, resolvedTreeIds));
     }
   }
 
-  for (const nodeData of Object.values(journeyData.innerNodes)) {
-    if (nodeTypeMap[nodeData['_type']['_id']]) {
-      nodeTypeMap[nodeData['_type']['_id']] += 1;
+  treeDependencyMap[treeExport.tree._id] = dependencies;
+  return treeDependencyMap;
+}
+
+function describeTreeDescendents(descendents, depth = 0) {
+  if ([Object.values(descendents)].length) {
+    // heading
+    if (depth === 0) {
+      printMessage(`\nInner Tree Dependencies (${Object.values(descendents)[0].length}):`, 'data');
+    }
+
+    const indent = Array(depth * 2).fill(' ').join('');
+    const [tree] = Object.keys(descendents);
+    printMessage(`${indent}- ${tree}`, 'data');
+
+    for (const descendent of descendents[tree]) {
+      describeTreeDescendents(descendent, depth + 1);
+    }
+  }
+}
+/**
+ * Describe a journey:
+ * - Properties, tags, description, name, metadata
+ * - Inner tree dependency tree
+ * - Node type summary
+ * - Nodes
+ * - Themes
+ * - Scripts
+ * - Email templates
+ * - Social identity providers
+ * - SAML2 entity providers
+ * - SAML2 circles of trust
+ * @param {SingleTreeExportInterface} journeyData journey export object
+ * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
+ */
+
+
+export async function describeJourney(journeyData, resolveTreeExport = onlineTreeExportResolver) {
+  var _journeyData$themes;
+
+  const allNodes = { ...journeyData.nodes,
+    ...journeyData.innerNodes
+  };
+  const nodeTypeMap = {};
+
+  for (const nodeData of Object.values(allNodes)) {
+    if (nodeTypeMap[nodeData._type._id]) {
+      nodeTypeMap[nodeData._type._id] += 1;
     } else {
-      nodeTypeMap[nodeData['_type']['_id']] = 1;
+      nodeTypeMap[nodeData._type._id] = 1;
     }
   }
 
-  printMessage(`\n${journeyData.tree._id}`, 'data');
-  const line = Array(journeyData.tree._id['length']).fill('=').join('');
-  printMessage(line);
+  printMessage(`${getOneLineDescription(journeyData.tree)}`, 'data');
+  printMessage(Array(`[${journeyData.tree._id}]`['length']).fill('=').join(''));
 
   if (journeyData.tree.description) {
-    printMessage(`\n${journeyData.tree.description}\n`, 'data');
+    printMessage(`\n${journeyData.tree.description['brightYellow']}`, 'data');
   }
 
-  printMessage('\nNodes:', 'data');
+  const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
+  describeTreeDescendents(descendents);
 
   if (Object.entries(nodeTypeMap).length) {
+    printMessage(`\nNode Types (${Object.entries(nodeTypeMap).length}):`, 'data');
+
     for (const [name, count] of Object.entries(nodeTypeMap)) {
-      printMessage(`- [${String(count)['brightCyan']}] ${name}`, 'data');
+      printMessage(`- ${String(count)} [${name['brightCyan']}]`, 'data');
+    }
+  }
+
+  if (Object.entries(allNodes).length) {
+    printMessage(`\nNodes (${Object.entries(allNodes).length}):`, 'data');
+
+    for (const nodeObj of Object.values(allNodes)) {
+      printMessage(`- ${Node.getOneLineDescription(nodeObj, getNodeRef(nodeObj, journeyData))}`, 'data');
     }
   }
 
   if ((_journeyData$themes = journeyData.themes) !== null && _journeyData$themes !== void 0 && _journeyData$themes.length) {
-    printMessage('\nThemes:', 'data');
+    printMessage(`\nThemes (${journeyData.themes.length}):`, 'data');
 
     for (const themeData of journeyData.themes) {
-      printMessage(`- [${themeData['_id']['brightCyan']}] ${themeData['name']}`, 'data');
+      printMessage(`- ${Theme.getOneLineDescription(themeData)}`, 'data');
     }
   }
 
   if (Object.entries(journeyData.scripts).length) {
-    printMessage('\nScripts:', 'data');
+    printMessage(`\nScripts (${Object.entries(journeyData.scripts).length}):`, 'data');
 
     for (const scriptData of Object.values(journeyData.scripts)) {
-      printMessage(`- [${scriptData['_id'].brightCyan}] ${scriptData['name']}`, 'data');
+      printMessage(`- ${Script.getOneLineDescription(scriptData)}`, 'data');
     }
   }
 
   if (Object.entries(journeyData.emailTemplates).length) {
-    printMessage('\nEmail Templates:', 'data');
+    printMessage(`\nEmail Templates (${Object.entries(journeyData.emailTemplates).length}):`, 'data');
 
     for (const templateData of Object.values(journeyData.emailTemplates)) {
-      printMessage(`- ${templateData['_id'].split('/')[1]}`, 'data');
+      printMessage(`- ${EmailTemplate.getOneLineDescription(templateData)}`, 'data');
     }
   }
 
   if (Object.entries(journeyData.socialIdentityProviders).length) {
-    printMessage('\nSocial Identity Providers:', 'data');
+    printMessage(`\nSocial Identity Providers (${Object.entries(journeyData.socialIdentityProviders).length}):`, 'data');
 
     for (const socialIdpData of Object.values(journeyData.socialIdentityProviders)) {
-      printMessage(`- ${socialIdpData['_id']} [${socialIdpData['_type']['_id'].brightCyan}]`, 'data');
+      printMessage(`- ${Idp.getOneLineDescription(socialIdpData)}`, 'data');
     }
   }
 
   if (Object.entries(journeyData.saml2Entities).length) {
-    printMessage('\nSAML2 Entity Providers:', 'data');
+    printMessage(`\nSAML2 Entity Providers (${Object.entries(journeyData.saml2Entities).length}):`, 'data');
 
     for (const entityProviderData of Object.values(journeyData.saml2Entities)) {
-      printMessage(`- ${entityProviderData['entityId']}`, 'data');
+      printMessage(`- ${Saml2.getOneLineDescription(entityProviderData)}`, 'data');
     }
   }
 
   if (Object.entries(journeyData.circlesOfTrust).length) {
-    printMessage('\nSAML2 Circles Of Trust:', 'data');
+    printMessage(`\nSAML2 Circles Of Trust (${Object.entries(journeyData.circlesOfTrust).length}):`, 'data');
 
     for (const cotData of Object.values(journeyData.circlesOfTrust)) {
-      printMessage(`- ${cotData['_id']}`, 'data');
+      printMessage(`- ${CirclesOfTrust.getOneLineDescription(cotData)}`, 'data');
     }
   }
 }
@@ -1322,7 +1509,7 @@ export async function removeOrphanedNodes(orphanedNodes) {
 }
 /**
  * Analyze if a journey contains any custom nodes considering the detected or the overridden version.
- * @param {SingleJourneyExportTemplate} journey Journey/tree configuration object
+ * @param {SingleTreeExportInterface} journey Journey/tree configuration object
  * @returns {boolean} True if the journey/tree contains any custom nodes, false otherwise.
  */
 
@@ -1339,7 +1526,7 @@ export function isCustomJourney(journey) {
 }
 /**
  * Analyze if a journey contains any premium nodes considering the detected or the overridden version.
- * @param {SingleJourneyExportTemplate} journey Journey/tree configuration object
+ * @param {SingleTreeExportInterface} journey Journey/tree configuration object
  * @returns {boolean} True if the journey/tree contains any custom nodes, false otherwise.
  */
 
@@ -1356,7 +1543,7 @@ export function isPremiumJourney(journey) {
 }
 /**
  * Analyze if a journey contains any cloud-only nodes considering the detected or the overridden version.
- * @param {SingleJourneyExportTemplate} journey Journey/tree configuration object
+ * @param {SingleTreeExportInterface} journey Journey/tree configuration object
  * @returns {boolean} True if the journey/tree contains any cloud-only nodes, false otherwise.
  */
 
@@ -1376,7 +1563,7 @@ export function isCloudOnlyJourney(journey) {
  * - standard: can run on any instance of a ForgeRock platform
  * - cloud: utilize nodes, which are exclusively available in the ForgeRock Identity Cloud
  * - premium: utilizes nodes, which come at a premium
- * @param {SingleJourneyExportTemplate} journey journey export data
+ * @param {SingleTreeExportInterface} journey journey export data
  * @returns {string[]} an array of one or multiple classifications
  */
 

package/esm/ops/NodeOps.mjs

@@ -9,6 +9,17 @@ const containerNodes = ['PageNode', 'CustomPageNode'];
 const scriptedNodes = ['ConfigProviderNode', 'ScriptedDecisionNode', 'ClientScriptNode', 'SocialProviderHandlerNode', 'CustomScriptNode'];
 const emailTemplateNodes = ['EmailSuspendNode', 'EmailTemplateNode'];
 const emptyScriptPlaceholder = '[Empty]';
+/**
+ * Get a one-line description of the node
+ * @param {NodeSkeleton} nodeObj node object to describe
+ * @param {NodeRefSkeletonInterface | InnerNodeRefSkeletonInterface} nodeRef node reference object
+ * @returns {string} a one-line description
+ */
+
+export function getOneLineDescription(nodeObj, nodeRef) {
+  const description = `[${nodeObj._id['brightCyan']}] ${nodeObj._type._id}${nodeRef ? ' - ' + (nodeRef === null || nodeRef === void 0 ? void 0 : nodeRef.displayName['brightYellow']) : ''}`;
+  return description;
+}
 /**
  * Helper to get all SAML2 dependencies for a given node object
  * @param {Object} nodeObject node object

package/esm/ops/OpsTypes.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OpsTypes.js.map

package/esm/ops/Saml2Ops.mjs

@@ -6,12 +6,30 @@ import { getProviders, findProviders, getProviderByLocationAndId, getProviderMet
 import { getScript } from '../api/ScriptApi';
 import { convertBase64TextToArray, convertBase64UrlTextToArray, convertTextArrayToBase64, convertTextArrayToBase64Url, getRealmString, getTypedFilename, saveJsonToFile, saveTextToFile, validateImport } from './utils/ExportImportUtils';
 import { createOrUpdateScript } from './ScriptOps';
-const roleMap = {
+export const roleMap = {
   identityProvider: 'IDP',
   serviceProvider: 'SP',
   attributeQueryProvider: 'AttrQuery',
   xacmlPolicyEnforcementPoint: 'XACML PEP'
-}; // use a function vs a template variable to avoid problems in loops
+};
+/**
+ * Get a one-line description of the saml2 provider object
+ * @param {Saml2ProviderSkeleton} saml2ProviderObj saml2 provider object to describe
+ * @returns {string} a one-line description
+ */
+
+export function getOneLineDescription(saml2ProviderObj) {
+  const roles = [];
+
+  for (const [key, value] of Object.entries(roleMap)) {
+    if (saml2ProviderObj[key]) {
+      roles.push(value);
+    }
+  }
+
+  const description = `[${saml2ProviderObj.entityId['brightCyan']}]${' (' + saml2ProviderObj.entityLocation}${roles.length ? ' ' + roles.join(', ') + ')' : ')'}`;
+  return description;
+} // use a function vs a template variable to avoid problems in loops
 
 function getFileDataTemplate() {
   return {

package/esm/ops/ScriptOps.mjs

@@ -6,6 +6,16 @@ import { getScriptByName, getScripts, putScript } from '../api/ScriptApi';
 import wordwrap from './utils/Wordwrap';
 import { convertBase64TextToArray, convertTextArrayToBase64, getTypedFilename, saveToFile, titleCase, validateImport } from './utils/ExportImportUtils';
 import storage from '../storage/SessionStorage';
+
+/**
+ * Get a one-line description of the script object
+ * @param {ScriptSkeleton} scriptObj script object to describe
+ * @returns {string} a one-line description
+ */
+export function getOneLineDescription(scriptObj) {
+  const description = `[${scriptObj._id['brightCyan']}] ${scriptObj.context} - ${scriptObj.name['brightYellow']}`;
+  return description;
+}
 /**
  * List scripts
  */

package/esm/ops/ThemeOps.mjs

@@ -2,6 +2,16 @@ import fs from 'fs';
 import { deleteTheme, deleteThemeByName, deleteThemes, getTheme, getThemeByName, getThemes, putTheme, putThemeByName, putThemes } from '../api/ThemeApi';
 import { createProgressIndicator, createTable, printMessage, stopProgressIndicator, updateProgressIndicator } from './utils/Console';
 import { getRealmString, getTypedFilename, saveToFile, validateImport } from './utils/ExportImportUtils';
+/**
+ * Get a one-line description of the theme
+ * @param {ThemeSkeleton} themeObj theme object to describe
+ * @returns {string} a one-line description
+ */
+
+export function getOneLineDescription(themeObj) {
+  const description = `[${themeObj._id['brightCyan']}] ${themeObj.name['brightYellow']}${themeObj.linkedTrees ? ' (' + themeObj.linkedTrees.join(', ')['brightCyan'] + ')' : ''}`;
+  return description;
+}
 /**
  * List all the themes
  * @param {boolean} long Long version, more fields