@rockcarver/frodo-cli 0.18.2-7 → 0.18.2-9

package/esm/ops/JourneyOps.js

@@ -26,19 +26,17 @@ const {
   saveJsonToFile,
   getRealmString
 } = ExportImportUtils;
+
 /**
  * List all the journeys/trees
  * @param {boolean} long Long version, all the fields
  * @param {boolean} analyze Analyze journeys/trees for custom nodes (expensive)
  * @returns {Promise<TreeSkeleton[]>} a promise that resolves to an array journey objects
  */
-
 export async function listJourneys(long = false, analyze = false) {
   let journeys = [];
-
   try {
     journeys = await getJourneys();
-
     if (!long && !analyze) {
       for (const journeyStub of journeys) {
         printMessage(`${journeyStub['_id']}`, 'data');
@@ -46,18 +44,14 @@ export async function listJourneys(long = false, analyze = false) {
     } else {
       if (!analyze) {
         const table = createTable(['Name', 'Status', 'Tags']);
-
         for (const journeyStub of journeys) {
           var _journeyStub$uiConfig;
-
           table.push([`${journeyStub._id}`, journeyStub.enabled === false ? 'disabled'['brightRed'] : 'enabled'['brightGreen'], (_journeyStub$uiConfig = journeyStub.uiConfig) !== null && _journeyStub$uiConfig !== void 0 && _journeyStub$uiConfig.categories ? wordwrap(JSON.parse(journeyStub.uiConfig.categories).join(', '), 60) : '']);
         }
-
         printMessage(table.toString(), 'data');
       } else {
         showSpinner('Retrieving details of all journeys...');
         const exportPromises = [];
-
         try {
           for (const journeyStub of journeys) {
             exportPromises.push(exportJourney(journeyStub['_id'], {
@@ -65,17 +59,13 @@ export async function listJourneys(long = false, analyze = false) {
               deps: false
             }));
           }
-
           const journeyExports = await Promise.all(exportPromises);
           succeedSpinner('Retrieved details of all journeys.');
           const table = createTable(['Name', 'Status', 'Classification', 'Tags']);
-
           for (const journeyExport of journeyExports) {
             var _journeyExport$tree$u;
-
             table.push([`${journeyExport.tree._id}`, journeyExport.tree.enabled === false ? 'disabled'['brightRed'] : 'enabled'['brightGreen'], getJourneyClassification(journeyExport).join(', '), (_journeyExport$tree$u = journeyExport.tree.uiConfig) !== null && _journeyExport$tree$u !== void 0 && _journeyExport$tree$u.categories ? wordwrap(JSON.parse(journeyExport.tree.uiConfig.categories).join(', '), 60) : '']);
           }
-
           printMessage(table.toString(), 'data');
         } catch (error) {
           failSpinner('Error retrieving details of all journeys.');
@@ -86,29 +76,26 @@ export async function listJourneys(long = false, analyze = false) {
   } catch (error) {
     printMessage(error.response.data, 'error');
   }
-
   return journeys;
 }
+
 /**
  * Export journey by id/name to file
  * @param {string} journeyId journey id/name
  * @param {string} file optional export file name
  * @param {TreeExportOptions} options export options
  */
-
 export async function exportJourneyToFile(journeyId, file, options) {
   debugMessage(`exportJourneyToFile: start`);
   const verbose = state.default.session.getDebug();
-
   if (!file) {
     file = getTypedFilename(journeyId, 'journey');
   }
-
   if (state.default.session.getDirectory()) {
     const dir = state.default.session.getDirectory().replace(/\/$/, '');
     debugMessage(`exportJourneyToFile: directory='${dir}'`);
-    file = `${dir}/${file}`; // create directory if it doesn't exist
-
+    file = `${dir}/${file}`;
+    // create directory if it doesn't exist
     if (!fs.existsSync(dir)) {
       debugMessage(`exportJourneyToFile: creating directory '${dir}'`);
       fs.mkdirSync(dir, {
@@ -116,9 +103,7 @@ export async function exportJourneyToFile(journeyId, file, options) {
       });
     }
   }
-
   if (!verbose) showSpinner(`${journeyId}`);
-
   try {
     const fileData = await exportJourney(journeyId, options);
     if (verbose) showSpinner(`${journeyId}`);
@@ -129,29 +114,25 @@ export async function exportJourneyToFile(journeyId, file, options) {
     failSpinner(`Error exporting journey ${journeyId}: ${error}`);
   }
 }
+
 /**
  * Export all journeys to file
  * @param {string} file optional export file name
  * @param {TreeExportOptions} options export options
  */
-
 export async function exportJourneysToFile(file, options = {
   deps: false,
   useStringArrays: false
 }) {
   let fileName = file;
-
   if (!fileName) {
     fileName = getTypedFilename(`all${getRealmString()}Journeys`, 'journeys');
   }
-
   const trees = await getJourneys();
   const fileData = createMultiTreeExportTemplate();
   createProgressBar(trees.length, 'Exporting journeys...');
-
   for (const tree of trees) {
     updateProgressBar(`${tree._id}`);
-
     try {
       const exportData = await exportJourney(tree._id, options);
       delete exportData.meta;
@@ -160,52 +141,49 @@ export async function exportJourneysToFile(file, options = {
       printMessage(`Error exporting journey ${tree._id}: ${error}`, 'error');
     }
   }
-
   saveJsonToFile(fileData, fileName);
   stopProgressBar(`Exported to ${fileName}`);
 }
+
 /**
  * Export all journeys to separate files
  * @param {TreeExportOptions} options export options
  */
-
 export async function exportJourneysToFiles(options) {
   const trees = await getJourneys();
   createProgressBar(trees.length, 'Exporting journeys...');
-
   for (const tree of trees) {
     updateProgressBar(`${tree._id}`);
     const fileName = getTypedFilename(`${tree._id}`, 'journey');
-
     try {
       const exportData = await exportJourney(tree._id, options);
       saveJsonToFile(exportData, fileName);
-    } catch (error) {// do we need to report status here?
+    } catch (error) {
+      // do we need to report status here?
     }
   }
-
   stopProgressBar('Done');
 }
+
 /**
  * Import a journey from file
  * @param {string} journeyId journey id/name
  * @param {string} file import file name
  * @param {TreeImportOptions} options import options
  */
-
 export async function importJourneyFromFile(journeyId, file, options) {
   const verbose = state.default.session.getDebug();
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
-    let journeyData = JSON.parse(data); // check if this is a file with multiple trees and get journey by id
-
+    let journeyData = JSON.parse(data);
+    // check if this is a file with multiple trees and get journey by id
     if (journeyData.trees && journeyData.trees[journeyId]) {
       journeyData = journeyData.trees[journeyId];
     } else if (journeyData.trees) {
       journeyData = null;
-    } // if a journeyId was specified, only import the matching journey
-
+    }
 
+    // if a journeyId was specified, only import the matching journey
     if (journeyData && journeyId === journeyData.tree._id) {
       // attempt dependency resolution for single tree import
       const installedJourneys = (await getJourneys()).map(x => x._id);
@@ -215,7 +193,6 @@ export async function importJourneyFromFile(journeyId, file, options) {
       await resolveDependencies(installedJourneys, {
         [journeyId]: journeyData
       }, unresolvedJourneys, resolvedJourneys);
-
       if (Object.keys(unresolvedJourneys).length === 0) {
         succeedSpinner(`Resolved all dependencies.`);
         if (!verbose) showSpinner(`Importing ${journeyId}...`);
@@ -228,36 +205,34 @@ export async function importJourneyFromFile(journeyId, file, options) {
         });
       } else {
         failSpinner(`Unresolved dependencies:`);
-
         for (const journey of Object.keys(unresolvedJourneys)) {
           printMessage(`  ${journey} requires ${unresolvedJourneys[journey]}`, 'error');
         }
-      } // end dependency resolution for single tree import
-
+      }
+      // end dependency resolution for single tree import
     } else {
       showSpinner(`Importing ${journeyId}...`);
       failSpinner(`${journeyId} not found!`);
     }
   });
 }
+
 /**
  * Import first journey from file
  * @param {string} file import file name
  * @param {TreeImportOptions} options import options
  */
-
 export async function importFirstJourneyFromFile(file, options) {
   const verbose = state.default.session.getDebug();
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
-
     let journeyData = _.cloneDeep(JSON.parse(data));
-
-    let journeyId = null; // single tree
-
+    let journeyId = null;
+    // single tree
     if (journeyData.tree) {
       journeyId = _.cloneDeep(journeyData.tree._id);
-    } // multiple trees, so get the first tree
+    }
+    // multiple trees, so get the first tree
     else if (journeyData.trees) {
       for (const treeId in journeyData.trees) {
         if (Object.hasOwnProperty.call(journeyData.trees, treeId)) {
@@ -266,9 +241,9 @@ export async function importFirstJourneyFromFile(file, options) {
           break;
         }
       }
-    } // if a journeyId was specified, only import the matching journey
-
+    }
 
+    // if a journeyId was specified, only import the matching journey
     if (journeyData && journeyId) {
       // attempt dependency resolution for single tree import
       const installedJourneys = (await getJourneys()).map(x => x._id);
@@ -278,7 +253,6 @@ export async function importFirstJourneyFromFile(file, options) {
       await resolveDependencies(installedJourneys, {
         [journeyId]: journeyData
       }, unresolvedJourneys, resolvedJourneys);
-
       if (Object.keys(unresolvedJourneys).length === 0) {
         succeedSpinner(`Resolved all dependencies.`);
         if (!verbose) showSpinner(`Importing ${journeyId}...`);
@@ -291,7 +265,6 @@ export async function importFirstJourneyFromFile(file, options) {
         });
       } else {
         failSpinner(`Unresolved dependencies:`);
-
         for (const journey of Object.keys(unresolvedJourneys)) {
           printMessage(`  ${journey} requires ${unresolvedJourneys[journey]}`, 'error');
         }
@@ -299,16 +272,16 @@ export async function importFirstJourneyFromFile(file, options) {
     } else {
       showSpinner(`Importing...`);
       failSpinner(`No journeys found!`);
-    } // end dependency resolution for single tree import
-
+    }
+    // end dependency resolution for single tree import
   });
 }
+
 /**
  * Import all journeys from file
  * @param {string} file import file name
  * @param {TreeImportOptions} options import options
  */
-
 export async function importJourneysFromFile(file, options) {
   fs.readFile(file, 'utf8', (err, data) => {
     if (err) throw err;
@@ -316,142 +289,127 @@ export async function importJourneysFromFile(file, options) {
     importAllJourneys(fileData.trees, options);
   });
 }
+
 /**
  * Import all journeys from separate files
  * @param {TreeImportOptions} options import options
  */
-
 export async function importJourneysFromFiles(options) {
   const names = fs.readdirSync('.');
   const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.journey.json'));
   const allJourneysData = {
     trees: {}
   };
-
   for (const file of jsonFiles) {
     const journeyData = JSON.parse(fs.readFileSync(file, 'utf8'));
     allJourneysData.trees[journeyData.tree._id] = journeyData;
   }
-
   importAllJourneys(allJourneysData.trees, options);
 }
+
 /**
  * Get journey classification
  * @param {SingleTreeExportInterface} journey journey export
  * @returns {string[]} Colored string array of classifications
  */
-
 export function getJourneyClassification(journey) {
   return Journey.getJourneyClassification(journey).map(it => {
     switch (it) {
       case Types.JourneyClassification.STANDARD:
         return it.toString()['brightGreen'];
-
       case Types.JourneyClassification.CLOUD:
         return it.toString()['brightMagenta'];
-
       case Types.JourneyClassification.CUSTOM:
         return it.toString()['brightRed'];
-
       case Types.JourneyClassification.PREMIUM:
         return it.toString()['brightYellow'];
     }
   });
 }
+
 /**
  * Get journey classification in markdown
  * @param {SingleTreeExportInterface} journey journey export
  * @returns {string[]} Colored string array of classifications
  */
-
 export function getJourneyClassificationMd(journey) {
   return Journey.getJourneyClassification(journey).map(it => {
     switch (it) {
       case Types.JourneyClassification.STANDARD:
         return `:green_circle: \`${it.toString()}\``;
-
       case Types.JourneyClassification.CLOUD:
         return `:purple_circle: \`${it.toString()}\``;
-
       case Types.JourneyClassification.CUSTOM:
         return `:red_circle: \`${it.toString()}\``;
-
       case Types.JourneyClassification.PREMIUM:
         return `:yellow_circle: \`${it.toString()}\``;
     }
   });
 }
+
 /**
  * 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;
 }
+
 /**
  * Get a one-line description of the tree object in markdown
  * @param {TreeSkeleton} treeObj circle of trust object to describe
  * @returns {string} a one-line description
  */
-
 export function getOneLineDescriptionMd(treeObj) {
   const description = `${treeObj._id}`;
   return description;
 }
+
 /**
  * Helper function to render a nested list of dependent trees
  * @param {TreeDependencyMapInterface} descendents tree dependency map
  * @param {number} depth level of nesting
  */
-
 function describeTreeDescendents(descendents, depth = 0) {
   if (depth || Object.values(descendents)[0].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['brightCyan']}`, 'data');
-
     for (const descendent of descendents[tree]) {
       describeTreeDescendents(descendent, depth + 1);
     }
   }
 }
+
 /**
  * Helper function to render a nested list of dependent trees in markdown
  * @param {TreeDependencyMapInterface} descendents tree dependency map
  * @param {number} depth level of nesting
  */
-
-
 function describeTreeDescendentsMd(descendents, depth = 0) {
   let markdown = '';
-
   if (depth || Object.values(descendents)[0].length) {
     // heading
     if (depth === 0) {
       markdown += `## Inner Tree Dependencies (${Object.values(descendents)[0].length})\n`;
     }
-
     const indent = Array(depth * 2).fill(' ').join('');
     const [tree] = Object.keys(descendents);
     markdown += `${indent}- ${tree}\n`;
-
     for (const descendent of descendents[tree]) {
       markdown += describeTreeDescendentsMd(descendent, depth + 1);
     }
-
     return markdown;
   }
-
   return markdown;
 }
+
 /**
  * Describe a journey:
  * - Properties, tags, description, name, metadata
@@ -467,125 +425,118 @@ function describeTreeDescendentsMd(descendents, depth = 0) {
  * @param {SingleTreeExportInterface} journeyData journey export object
  * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
  */
-
-
 export async function describeJourney(journeyData, resolveTreeExport = onlineTreeExportResolver) {
   var _journeyData$meta, _journeyData$tree$uiC, _journeyData$themes;
-
-  const allNodes = { ...journeyData.nodes,
+  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;
     }
-  } // initialize AM version from file
-
+  }
 
+  // initialize AM version from file
   if (!state.default.session.getAmVersion() && (_journeyData$meta = journeyData.meta) !== null && _journeyData$meta !== void 0 && _journeyData$meta.originAmVersion) {
     state.default.session.setAmVersion(journeyData.meta.originAmVersion);
-  } // Journey Name
-
+  }
 
+  // Journey Name
   printMessage(`${getOneLineDescription(journeyData.tree)}`, 'data');
-  printMessage(Array(`[${journeyData.tree._id}]`['length']).fill('=').join('')); // Description
+  printMessage(Array(`[${journeyData.tree._id}]`['length']).fill('=').join(''));
 
+  // Description
   if (journeyData.tree.description) {
     printMessage(`\n${journeyData.tree.description}`, 'data');
-  } // Status
-
+  }
 
-  printMessage(`\nStatus\n${journeyData.tree.enabled === false ? 'disabled'['brightRed'] : 'enabled'['brightGreen']}`); // Classification
+  // Status
+  printMessage(`\nStatus\n${journeyData.tree.enabled === false ? 'disabled'['brightRed'] : 'enabled'['brightGreen']}`);
 
+  // Classification
   if (state.default.session.getAmVersion()) {
     printMessage(`\nClassification\n${getJourneyClassification(journeyData).join(', ')}`, 'data');
-  } // Categories/Tags
-
+  }
 
+  // Categories/Tags
   if ((_journeyData$tree$uiC = journeyData.tree.uiConfig) !== null && _journeyData$tree$uiC !== void 0 && _journeyData$tree$uiC.categories && journeyData.tree.uiConfig.categories != '[]') {
     printMessage('\nCategories/Tags', 'data');
     printMessage(`${JSON.parse(journeyData.tree.uiConfig.categories).join(', ')}`, 'data');
-  } // Dependency Tree
-
+  }
 
+  // Dependency Tree
   const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
-  describeTreeDescendents(descendents); // Node Types
+  describeTreeDescendents(descendents);
 
+  // Node Types
   if (Object.entries(nodeTypeMap).length) {
     printMessage(`\nNode Types (${Object.entries(nodeTypeMap).length}):`, 'data');
-
     for (const [nodeType, count] of Object.entries(nodeTypeMap)) {
       printMessage(`- ${String(count)} [${nodeType['brightCyan']}] (${Node.getNodeClassification(nodeType).join(', ')})`, 'data');
     }
-  } // Nodes
-
+  }
 
+  // Nodes
   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');
     }
-  } // Themes
-
+  }
 
+  // Themes
   if ((_journeyData$themes = journeyData.themes) !== null && _journeyData$themes !== void 0 && _journeyData$themes.length) {
     printMessage(`\nThemes (${journeyData.themes.length}):`, 'data');
-
     for (const themeData of journeyData.themes) {
       printMessage(`- ${Theme.getOneLineDescription(themeData)}`, 'data');
     }
-  } // Scripts
-
+  }
 
+  // Scripts
   if (Object.entries(journeyData.scripts).length) {
     printMessage(`\nScripts (${Object.entries(journeyData.scripts).length}):`, 'data');
-
     for (const scriptData of Object.values(journeyData.scripts)) {
       printMessage(`- ${Script.getOneLineDescription(scriptData)}`, 'data');
     }
-  } // Email Templates
-
+  }
 
+  // Email Templates
   if (Object.entries(journeyData.emailTemplates).length) {
     printMessage(`\nEmail Templates (${Object.entries(journeyData.emailTemplates).length}):`, 'data');
-
     for (const templateData of Object.values(journeyData.emailTemplates)) {
       printMessage(`- ${EmailTemplate.getOneLineDescription(templateData)}`, 'data');
     }
-  } // Social Identity Providers
-
+  }
 
+  // Social Identity Providers
   if (Object.entries(journeyData.socialIdentityProviders).length) {
     printMessage(`\nSocial Identity Providers (${Object.entries(journeyData.socialIdentityProviders).length}):`, 'data');
-
     for (const socialIdpData of Object.values(journeyData.socialIdentityProviders)) {
       printMessage(`- ${Idp.getOneLineDescription(socialIdpData)}`, 'data');
     }
-  } // SAML2 Entity Providers
-
+  }
 
+  // SAML2 Entity Providers
   if (Object.entries(journeyData.saml2Entities).length) {
     printMessage(`\nSAML2 Entity Providers (${Object.entries(journeyData.saml2Entities).length}):`, 'data');
-
     for (const entityProviderData of Object.values(journeyData.saml2Entities)) {
       printMessage(`- ${Saml2.getOneLineDescription(entityProviderData)}`, 'data');
     }
-  } // SAML2 Circles Of Trust
-
+  }
 
+  // SAML2 Circles Of Trust
   if (Object.entries(journeyData.circlesOfTrust).length) {
     printMessage(`\nSAML2 Circles Of Trust (${Object.entries(journeyData.circlesOfTrust).length}):`, 'data');
-
     for (const cotData of Object.values(journeyData.circlesOfTrust)) {
       printMessage(`- ${CirclesOfTrust.getOneLineDescription(cotData)}`, 'data');
     }
   }
 }
+
 /**
  * Describe a journey in markdown:
  * - Properties, tags, description, name, metadata
@@ -601,121 +552,114 @@ export async function describeJourney(journeyData, resolveTreeExport = onlineTre
  * @param {SingleTreeExportInterface} journeyData journey export object
  * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
  */
-
 export async function describeJourneyMd(journeyData, resolveTreeExport = onlineTreeExportResolver) {
   var _journeyData$meta2, _journeyData$tree$uiC2, _journeyData$themes2;
-
-  const allNodes = { ...journeyData.nodes,
+  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;
     }
-  } // initialize AM version from file
-
+  }
 
+  // initialize AM version from file
   if (!state.default.session.getAmVersion() && (_journeyData$meta2 = journeyData.meta) !== null && _journeyData$meta2 !== void 0 && _journeyData$meta2.originAmVersion) {
     state.default.session.setAmVersion(journeyData.meta.originAmVersion);
-  } // Journey Name
-
+  }
 
-  printMessage(`# ${getOneLineDescriptionMd(journeyData.tree)} - ${journeyData.tree.enabled === false ? ':o: `disabled`' : ':white_check_mark: `enabled`'}, ${getJourneyClassificationMd(journeyData).join(', ')}`, 'data'); // Categories/Tags
+  // Journey Name
+  printMessage(`# ${getOneLineDescriptionMd(journeyData.tree)} - ${journeyData.tree.enabled === false ? ':o: `disabled`' : ':white_check_mark: `enabled`'}, ${getJourneyClassificationMd(journeyData).join(', ')}`, 'data');
 
+  // Categories/Tags
   if ((_journeyData$tree$uiC2 = journeyData.tree.uiConfig) !== null && _journeyData$tree$uiC2 !== void 0 && _journeyData$tree$uiC2.categories && journeyData.tree.uiConfig.categories != '[]') {
     printMessage(`\`${JSON.parse(journeyData.tree.uiConfig.categories).join('`, `')}\``, 'data');
-  } // Description
-
+  }
 
+  // Description
   if (journeyData.tree.description) {
     printMessage(`\n${journeyData.tree.description}`, 'data');
-  } // Journey image
-
+  }
 
-  printMessage(`\n[![](./${journeyData.tree._id}.png)]()\n`, 'data'); // Dependency Tree
+  // Journey image
+  printMessage(`\n[![](./${journeyData.tree._id}.png)]()\n`, 'data');
 
+  // Dependency Tree
   const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
-  printMessage(describeTreeDescendentsMd(descendents), 'data'); // Node Types
+  printMessage(describeTreeDescendentsMd(descendents), 'data');
 
+  // Node Types
   if (Object.entries(nodeTypeMap).length) {
     printMessage(`## Node Types (${Object.entries(nodeTypeMap).length})`, 'data');
     printMessage('| Count | Type | Classification |', 'data');
     printMessage('| -----:| ---- | -------------- |', 'data');
-
     for (const [nodeType, count] of Object.entries(nodeTypeMap)) {
       printMessage(`| ${String(count)} | ${nodeType} | ${Node.getNodeClassificationMd(nodeType).join('<br>')} |`, 'data');
     }
-  } // Nodes
-
+  }
 
+  // Nodes
   if (Object.entries(allNodes).length) {
     printMessage(`## Nodes (${Object.entries(allNodes).length})`, 'data');
     printMessage(Node.getTableHeaderMd(), 'data');
-
     for (const nodeObj of Object.values(allNodes)) {
       printMessage(`${Node.getTableRowMd(nodeObj, getNodeRef(nodeObj, journeyData))}`, 'data');
     }
-  } // Themes
-
+  }
 
+  // Themes
   if ((_journeyData$themes2 = journeyData.themes) !== null && _journeyData$themes2 !== void 0 && _journeyData$themes2.length) {
     printMessage(`## Themes (${journeyData.themes.length})`, 'data');
     printMessage(Theme.getTableHeaderMd(), 'data');
-
     for (const themeData of journeyData.themes) {
       printMessage(`${Theme.getTableRowMd(themeData)}`, 'data');
     }
-  } // Scripts
-
+  }
 
+  // Scripts
   if (Object.entries(journeyData.scripts).length) {
     printMessage(`## Scripts (${Object.entries(journeyData.scripts).length})`, 'data');
     printMessage(Script.getTableHeaderMd(), 'data');
-
     for (const scriptData of Object.values(journeyData.scripts)) {
       printMessage(`${Script.getTableRowMd(scriptData)}`, 'data');
     }
-  } // Email Templates
-
+  }
 
+  // Email Templates
   if (Object.entries(journeyData.emailTemplates).length) {
     printMessage(`## Email Templates (${Object.entries(journeyData.emailTemplates).length})`, 'data');
     printMessage(EmailTemplate.getTableHeaderMd(), 'data');
-
     for (const templateData of Object.values(journeyData.emailTemplates)) {
       printMessage(`${EmailTemplate.getTableRowMd(templateData)}`, 'data');
     }
-  } // Social Identity Providers
-
+  }
 
+  // Social Identity Providers
   if (Object.entries(journeyData.socialIdentityProviders).length) {
     printMessage(`## Social Identity Providers (${Object.entries(journeyData.socialIdentityProviders).length})`, 'data');
     printMessage(Idp.getTableHeaderMd(), 'data');
-
     for (const socialIdpData of Object.values(journeyData.socialIdentityProviders)) {
       printMessage(`${Idp.getTableRowMd(socialIdpData)}`, 'data');
     }
-  } // SAML2 Entity Providers
-
+  }
 
+  // SAML2 Entity Providers
   if (Object.entries(journeyData.saml2Entities).length) {
     printMessage(`## SAML2 Entity Providers (${Object.entries(journeyData.saml2Entities).length})`, 'data');
     printMessage(Saml2.getTableHeaderMd(), 'data');
-
     for (const entityProviderData of Object.values(journeyData.saml2Entities)) {
       printMessage(`${Saml2.getTableRowMd(entityProviderData)}`, 'data');
     }
-  } // SAML2 Circles Of Trust
-
+  }
 
+  // SAML2 Circles Of Trust
   if (Object.entries(journeyData.circlesOfTrust).length) {
     printMessage(`## SAML2 Circles Of Trust (${Object.entries(journeyData.circlesOfTrust).length})`, 'data');
     printMessage(CirclesOfTrust.getTableHeaderMd(), 'data');
-
     for (const cotData of Object.values(journeyData.circlesOfTrust)) {
       printMessage(`${CirclesOfTrust.getTableRowMd(cotData)}`, 'data');
     }