@rockcarver/frodo-lib 0.12.5 → 0.12.7

package/esm/ops/JourneyOps.mjs

@@ -10,7 +10,7 @@ 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';
@@ -18,12 +18,17 @@ import { decode, encode, encodeBase64Url, isBase64Encoded } from '../api/utils/B
 import { getSocialIdentityProviders, putProviderByTypeAndId } from '../api/SocialIdentityProvidersApi';
 import { getThemes, putThemes } from '../api/ThemeApi';
 import { createOrUpdateScript } from './ScriptOps';
+import { JourneyClassification } from './OpsTypes';
 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() {
+/**
+ * Create an empty single tree export template
+ * @returns {SingleTreeExportInterface} an empty single tree export template
+ */
+
+export function createSingleTreeExportTemplate() {
   return {
     meta: {},
     innerNodes: {},
@@ -37,8 +42,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 +135,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 +448,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 +476,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 +491,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 +511,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 +531,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,
@@ -754,8 +747,29 @@ export async function importJourney(treeObject, options) {
       try {
         await putNode(newUuid, nodeType, innerNodeData);
       } catch (nodeImportError) {
+        var _nodeImportError$resp, _nodeImportError$resp2, _nodeImportError$resp3;
+
         if (nodeImportError.response.status === 400 && nodeImportError.response.data.message === 'Data validation failed for the attribute, Script') {
           throw new Error(`Missing script ${innerNodeData['script']} referenced by inner node ${innerNodeId}${innerNodeId === newUuid ? '' : ` [${newUuid}]`} (${innerNodeData['_type']['_id']}) in journey ${treeId}.`);
+        } else if (((_nodeImportError$resp = nodeImportError.response) === null || _nodeImportError$resp === void 0 ? void 0 : _nodeImportError$resp.status) === 400 && ((_nodeImportError$resp2 = nodeImportError.response) === null || _nodeImportError$resp2 === void 0 ? void 0 : (_nodeImportError$resp3 = _nodeImportError$resp2.data) === null || _nodeImportError$resp3 === void 0 ? void 0 : _nodeImportError$resp3.message) === 'Invalid attribute specified.') {
+          const {
+            validAttributes
+          } = nodeImportError.response.data.detail;
+          validAttributes.push('_id');
+
+          for (const attribute of Object.keys(innerNodeData)) {
+            if (!validAttributes.includes(attribute)) {
+              if (verbose) printMessage(`\n      - Removing invalid attribute: ${attribute}`, 'warn', false);
+              delete innerNodeData[attribute];
+            }
+          }
+
+          try {
+            await putNode(newUuid, nodeType, innerNodeData);
+          } catch (nodeImportError2) {
+            printMessage(nodeImportError2.response.data, 'error');
+            throw new Error(`Error importing node ${innerNodeId}${innerNodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
+          }
         } else {
           printMessage(nodeImportError.response.data, 'error');
           throw new Error(`Error importing inner node ${innerNodeId}${innerNodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
@@ -795,7 +809,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);
       }
@@ -803,8 +817,29 @@ export async function importJourney(treeObject, options) {
       try {
         await putNode(newUuid, nodeType, nodeData);
       } catch (nodeImportError) {
+        var _nodeImportError$resp4, _nodeImportError$resp5, _nodeImportError$resp6;
+
         if (nodeImportError.response.status === 400 && nodeImportError.response.data.message === 'Data validation failed for the attribute, Script') {
           throw new Error(`Missing script ${nodeData['script']} referenced by node ${nodeId}${nodeId === newUuid ? '' : ` [${newUuid}]`} (${nodeData['_type']['_id']}) in journey ${treeId}.`);
+        } else if (((_nodeImportError$resp4 = nodeImportError.response) === null || _nodeImportError$resp4 === void 0 ? void 0 : _nodeImportError$resp4.status) === 400 && ((_nodeImportError$resp5 = nodeImportError.response) === null || _nodeImportError$resp5 === void 0 ? void 0 : (_nodeImportError$resp6 = _nodeImportError$resp5.data) === null || _nodeImportError$resp6 === void 0 ? void 0 : _nodeImportError$resp6.message) === 'Invalid attribute specified.') {
+          const {
+            validAttributes
+          } = nodeImportError.response.data.detail;
+          validAttributes.push('_id');
+
+          for (const attribute of Object.keys(nodeData)) {
+            if (!validAttributes.includes(attribute)) {
+              if (verbose) printMessage(`\n      - Removing invalid attribute: ${attribute}`, 'warn', false);
+              delete nodeData[attribute];
+            }
+          }
+
+          try {
+            await putNode(newUuid, nodeType, nodeData);
+          } catch (nodeImportError2) {
+            printMessage(nodeImportError2.response.data, 'error');
+            throw new Error(`Error importing node ${nodeId}${nodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
+          }
         } else {
           printMessage(nodeImportError.response.data, 'error');
           throw new Error(`Error importing node ${nodeId}${nodeId === newUuid ? '' : ` [${newUuid}]`} in journey ${treeId}`);
@@ -831,7 +866,7 @@ export async function importJourney(treeObject, options) {
   // Set the identityResource for the tree to the selected resource.
 
 
-  if (treeObject.tree.identityResource && treeObject.tree['identityResource'].endsWith('user')) {
+  if (treeObject.tree.identityResource && treeObject.tree['identityResource'].endsWith('user') || storage.session.getDeploymentType() === global.CLOUD_DEPLOYMENT_TYPE_KEY || storage.session.getDeploymentType() === global.FORGEOPS_DEPLOYMENT_TYPE_KEY) {
     treeObject.tree.identityResource = `managed/${getRealmManagedUser()}`;
     if (verbose) printMessage(`    - identityResource: ${treeObject.tree.identityResource}`, 'info', false);
   }
@@ -852,7 +887,7 @@ export async function importJourney(treeObject, options) {
 
       for (const attribute of Object.keys(treeObject.tree)) {
         if (!validAttributes.includes(attribute)) {
-          if (verbose) printMessage(`\n    - Removing invalid attribute: ${attribute}`, 'info', false);
+          if (verbose) printMessage(`\n    - Removing invalid attribute: ${attribute}`, 'warn', false);
           delete treeObject.tree[attribute];
         }
       }
@@ -868,7 +903,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 +975,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 +1031,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 +1096,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 +1133,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 +1146,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,94 +1164,148 @@ 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;
-
-  const nodeTypeMap = {};
-
-  for (const nodeData of Object.values(journeyData.nodes)) {
-    if (nodeTypeMap[nodeData['_type']['_id']]) {
-      nodeTypeMap[nodeData['_type']['_id']] += 1;
-    } else {
-      nodeTypeMap[nodeData['_type']['_id']] = 1;
-    }
-  }
-
-  for (const nodeData of Object.values(journeyData.innerNodes)) {
-    if (nodeTypeMap[nodeData['_type']['_id']]) {
-      nodeTypeMap[nodeData['_type']['_id']] += 1;
-    } else {
-      nodeTypeMap[nodeData['_type']['_id']] = 1;
+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;
+          }
+        }
+      }
     }
   }
 
-  printMessage(`\n${journeyData.tree._id}`, 'data');
-  const line = Array(journeyData.tree._id['length']).fill('=').join('');
-  printMessage(line);
+  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
+ */
 
-  if (journeyData.tree.description) {
-    printMessage(`\n${journeyData.tree.description}\n`, 'data');
-  }
+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
+ */
 
-  printMessage('\nNodes:', 'data');
+export const fileByIdTreeExportResolver = async function (treeId) {
+  debugMessage(`fileByIdTreeExportResolver(${treeId})`);
+  let treeExport = createSingleTreeExportTemplate();
+  const file = getTypedFilename(`${treeId}`, 'journey');
+  debugMessage(`fileByIdTreeExportResolver: resolving '${treeId}' to ${file}`);
 
-  if (Object.entries(nodeTypeMap).length) {
-    for (const [name, count] of Object.entries(nodeTypeMap)) {
-      printMessage(`- [${String(count)['brightCyan']}] ${name}`, 'data');
-    }
-  }
+  try {
+    var _jsonData$tree;
 
-  if ((_journeyData$themes = journeyData.themes) !== null && _journeyData$themes !== void 0 && _journeyData$themes.length) {
-    printMessage('\nThemes:', 'data');
+    const jsonData = JSON.parse(fs.readFileSync(file, 'utf8')); // did we resolve the tree we were asked to resolved?
 
-    for (const themeData of journeyData.themes) {
-      printMessage(`- [${themeData['_id']['brightCyan']}] ${themeData['name']}`, 'data');
+    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) {//
   }
 
-  if (Object.entries(journeyData.scripts).length) {
-    printMessage('\nScripts:', 'data');
+  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();
 
-    for (const scriptData of Object.values(journeyData.scripts)) {
-      printMessage(`- [${scriptData['_id'].brightCyan}] ${scriptData['name']}`, 'data');
+    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) {//
     }
-  }
 
-  if (Object.entries(journeyData.emailTemplates).length) {
-    printMessage('\nEmail Templates:', 'data');
+    return treeExport;
+  };
 
-    for (const templateData of Object.values(journeyData.emailTemplates)) {
-      printMessage(`- ${templateData['_id'].split('/')[1]}`, 'data');
-    }
-  }
+  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
+ */
 
-  if (Object.entries(journeyData.socialIdentityProviders).length) {
-    printMessage('\nSocial Identity Providers:', 'data');
+export async function getTreeDescendents(treeExport, resolveTreeExport = onlineTreeExportResolver, resolvedTreeIds = []) {
+  debugMessage(`getTreeDependencies(${treeExport.tree._id}, [${resolvedTreeIds.join(', ')}])`);
 
-    for (const socialIdpData of Object.values(journeyData.socialIdentityProviders)) {
-      printMessage(`- ${socialIdpData['_id']} [${socialIdpData['_type']['_id'].brightCyan}]`, 'data');
-    }
+  if (!resolvedTreeIds.includes(treeExport.tree._id)) {
+    resolvedTreeIds.push(treeExport.tree._id);
   }
 
-  if (Object.entries(journeyData.saml2Entities).length) {
-    printMessage('\nSAML2 Entity Providers:', 'data');
+  const treeDependencyMap = {
+    [treeExport.tree._id]: []
+  };
+  const dependencies = [];
 
-    for (const entityProviderData of Object.values(journeyData.saml2Entities)) {
-      printMessage(`- ${entityProviderData['entityId']}`, 'data');
-    }
-  }
+  for (const [nodeId, node] of Object.entries(treeExport.tree.nodes)) {
+    const innerTreeId = treeExport.nodes[nodeId].tree;
 
-  if (Object.entries(journeyData.circlesOfTrust).length) {
-    printMessage('\nSAML2 Circles Of Trust:', 'data');
+    if (node.nodeType === 'InnerTreeEvaluatorNode' && !resolvedTreeIds.includes(innerTreeId)) {
+      const innerTreeExport = await resolveTreeExport(innerTreeId);
+      debugMessage(`resolved inner tree: ${innerTreeExport.tree._id}`); // resolvedTreeIds.push(innerTreeId);
 
-    for (const cotData of Object.values(journeyData.circlesOfTrust)) {
-      printMessage(`- ${cotData['_id']}`, 'data');
+      dependencies.push(await getTreeDescendents(innerTreeExport, resolveTreeExport, resolvedTreeIds));
     }
   }
+
+  treeDependencyMap[treeExport.tree._id] = dependencies;
+  return treeDependencyMap;
 }
 /**
  * Find all node configuration objects that are no longer referenced by any tree
@@ -1322,7 +1411,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 +1428,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 +1445,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,8 +1465,8 @@ 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
- * @returns {string[]} an array of one or multiple classifications
+ * @param {SingleTreeExportInterface} journey journey export data
+ * @returns {JourneyClassification[]} an array of one or multiple classifications
  */
 
 export function getJourneyClassification(journey) {
@@ -1387,14 +1476,14 @@ export function getJourneyClassification(journey) {
   const cloud = isCloudOnlyJourney(journey);
 
   if (custom) {
-    classifications.push('custom');
+    classifications.push(JourneyClassification.CUSTOM);
   } else if (cloud) {
-    classifications.push('cloud');
+    classifications.push(JourneyClassification.CLOUD);
   } else {
-    classifications.push('standard');
+    classifications.push(JourneyClassification.STANDARD);
   }
 
-  if (premium) classifications.push('premium');
+  if (premium) classifications.push(JourneyClassification.PREMIUM);
   return classifications;
 }
 /**

package/esm/ops/NodeOps.mjs

@@ -5,6 +5,7 @@ import { getTrees } from '../api/TreeApi';
 import { printMessage, createProgressIndicator, updateProgressIndicator, stopProgressIndicator } from './utils/Console';
 import { getProviderByLocationAndId, getProviderMetadata } from '../api/Saml2Api';
 import { encodeBase64Url } from '../api/utils/Base64';
+import { NodeClassification } from './OpsTypes';
 const containerNodes = ['PageNode', 'CustomPageNode'];
 const scriptedNodes = ['ConfigProviderNode', 'ScriptedDecisionNode', 'ClientScriptNode', 'SocialProviderHandlerNode', 'CustomScriptNode'];
 const emailTemplateNodes = ['EmailSuspendNode', 'EmailTemplateNode'];
@@ -91,21 +92,7 @@ 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;
-// }
-
+}
 /**
  * Find all node configuration objects that are no longer referenced by any tree
  * @returns {Promise<unknown[]>} a promise that resolves to an array of orphaned nodes
@@ -291,4 +278,30 @@ export function isCustomNode(nodeType) {
 
   return !ootbNodeTypes.includes(nodeType) && !isPremiumNode(nodeType) && !isCloudOnlyNode(nodeType);
 }
+/**
+ * Get a node's classifications, which can be one or multiple of:
+ * - 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 {string} nodeType Node type
+ * @returns {NodeClassification[]} an array of one or multiple classifications
+ */
+
+export function getNodeClassification(nodeType) {
+  const classifications = [];
+  const premium = isPremiumNode(nodeType);
+  const custom = isCustomNode(nodeType);
+  const cloud = isCloudOnlyNode(nodeType);
+
+  if (custom) {
+    classifications.push(NodeClassification.CUSTOM);
+  } else if (cloud) {
+    classifications.push(NodeClassification.CLOUD);
+  } else {
+    classifications.push(NodeClassification.STANDARD);
+  }
+
+  if (premium) classifications.push(NodeClassification.PREMIUM);
+  return classifications;
+}
 //# sourceMappingURL=NodeOps.js.map

package/esm/ops/OpsTypes.mjs

@@ -0,0 +1,25 @@
+/**
+ * Tree export options
+ */
+
+/**
+ * Tree import options
+ */
+export let NodeClassification;
+
+(function (NodeClassification) {
+  NodeClassification["STANDARD"] = "standard";
+  NodeClassification["CUSTOM"] = "custom";
+  NodeClassification["CLOUD"] = "cloud";
+  NodeClassification["PREMIUM"] = "premium";
+})(NodeClassification || (NodeClassification = {}));
+
+export let JourneyClassification;
+
+(function (JourneyClassification) {
+  JourneyClassification["STANDARD"] = "standard";
+  JourneyClassification["CUSTOM"] = "custom";
+  JourneyClassification["CLOUD"] = "cloud";
+  JourneyClassification["PREMIUM"] = "premium";
+})(JourneyClassification || (JourneyClassification = {}));
+//# sourceMappingURL=OpsTypes.js.map

package/esm/ops/Saml2Ops.mjs

@@ -6,7 +6,7 @@ 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',