@rockcarver/frodo-cli 2.0.0-51 → 2.0.0-52

package/esm/ops/JourneyOps.js

@@ -1,6 +1,6 @@
-import { frodo, state } from '@rockcarver/frodo-lib';
+import { frodo, FrodoError, state } from '@rockcarver/frodo-lib';
 import fs from 'fs';
-import { createProgressIndicator, createTable, debugMessage, printMessage, stopProgressIndicator, updateProgressIndicator } from '../utils/Console';
+import { createProgressIndicator, createTable, debugMessage, printError, printMessage, stopProgressIndicator, updateProgressIndicator } from '../utils/Console';
 import * as CirclesOfTrust from './CirclesOfTrustOps';
 import * as EmailTemplate from './EmailTemplateOps';
 import * as Idp from './IdpOps';
@@ -29,14 +29,16 @@ const {
   onlineTreeExportResolver,
   getJourneyClassification: _getJourneyClassification,
   disableJourney: _disableJourney,
-  enableJourney: _enableJourney
+  enableJourney: _enableJourney,
+  deleteJourney: _deleteJourney,
+  deleteJourneys: _deleteJourneys
 } = frodo.authn.journey;
 
 /**
  * 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
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function listJourneys(long = false, analyze = false) {
   let journeys = [];
@@ -46,6 +48,7 @@ export async function listJourneys(long = false, analyze = false) {
       for (const journeyStub of journeys) {
         printMessage(`${journeyStub['_id']}`, 'data');
       }
+      return true;
     } else {
       if (!analyze) {
         const table = createTable(['Name', 'Status', 'Tags']);
@@ -54,6 +57,7 @@ export async function listJourneys(long = false, analyze = false) {
           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');
+        return true;
       } else {
         const spinnerId = createProgressIndicator('indeterminate', 0, `Retrieving details of all journeys...`);
         const exportPromises = [];
@@ -73,17 +77,17 @@ export async function listJourneys(long = false, analyze = false) {
             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');
+          return true;
         } catch (error) {
           stopProgressIndicator(spinnerId, 'Error retrieving details of all journeys.', 'fail');
-          printMessage(error.response.data, 'error');
+          printError(error);
         }
       }
     }
   } catch (error) {
-    var _error$response;
-    printMessage((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data, 'error');
+    printError(error);
   }
-  return journeys;
+  return false;
 }
 
 /**
@@ -92,6 +96,7 @@ export async function listJourneys(long = false, analyze = false) {
  * @param {string} file optional export file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  * @param {TreeExportOptions} options export options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function exportJourneyToFile(journeyId, file, includeMeta = true, options = {
   deps: false,
@@ -111,10 +116,13 @@ export async function exportJourneyToFile(journeyId, file, includeMeta = true, o
     if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `${journeyId}`);
     saveJsonToFile(fileData, filePath, includeMeta);
     stopProgressIndicator(spinnerId, `Exported ${journeyId['brightCyan']} to ${filePath['brightCyan']}.`, 'success');
+    return true;
   } catch (error) {
     if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `${journeyId}`);
     stopProgressIndicator(spinnerId, `Error exporting journey ${journeyId}: ${error}`, 'fail');
+    printError(error);
   }
+  return false;
 }
 
 /**
@@ -122,44 +130,57 @@ export async function exportJourneyToFile(journeyId, file, includeMeta = true, o
  * @param {string} file optional export file name
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  * @param {TreeExportOptions} options export options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function exportJourneysToFile(file, includeMeta = true, options = {
   deps: false,
   useStringArrays: false,
   coords: true
 }) {
-  if (!file) {
-    file = getTypedFilename(`all${getRealmString()}Journeys`, 'journey');
+  try {
+    if (!file) {
+      file = getTypedFilename(`all${getRealmString()}Journeys`, 'journey');
+    }
+    const filePath = getFilePath(file, true);
+    const fileData = await exportJourneys(options);
+    saveJsonToFile(fileData, filePath, includeMeta);
+    return true;
+  } catch (error) {
+    printError(error);
   }
-  const filePath = getFilePath(file, true);
-  const fileData = await exportJourneys(options);
-  saveJsonToFile(fileData, filePath, includeMeta);
 }
 
 /**
  * Export all journeys to separate files
  * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  * @param {TreeExportOptions} options export options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function exportJourneysToFiles(includeMeta = true, options = {
   deps: false,
   useStringArrays: false,
   coords: true
 }) {
-  const journeysExport = await exportJourneys(options);
-  const trees = Object.entries(journeysExport.trees);
-  for (const [treeId, treeValue] of trees) {
-    const indicatorId = createProgressIndicator('determinate', 1, `Saving ${treeId}...`);
-    const file = getFilePath(getTypedFilename(`${treeId}`, 'journey'), true);
-    treeValue['meta'] = journeysExport.meta;
-    try {
-      updateProgressIndicator(indicatorId, `Saving ${treeId} to ${file}`);
-      saveJsonToFile(treeValue, file, includeMeta);
-      stopProgressIndicator(indicatorId, `${treeId} saved to ${file}`);
-    } catch (error) {
-      stopProgressIndicator(indicatorId, `Error saving ${treeId} to ${file}`);
+  try {
+    const journeysExport = await exportJourneys(options);
+    const trees = Object.entries(journeysExport.trees);
+    for (const [treeId, treeValue] of trees) {
+      const indicatorId = createProgressIndicator('determinate', 1, `Saving ${treeId}...`);
+      const file = getFilePath(getTypedFilename(`${treeId}`, 'journey'), true);
+      treeValue['meta'] = journeysExport.meta;
+      try {
+        updateProgressIndicator(indicatorId, `Saving ${treeId} to ${file}`);
+        saveJsonToFile(treeValue, file, includeMeta);
+        stopProgressIndicator(indicatorId, `${treeId} saved to ${file}`);
+      } catch (error) {
+        stopProgressIndicator(indicatorId, `Error saving ${treeId} to ${file}`);
+      }
     }
+    return true;
+  } catch (error) {
+    printError(error);
   }
+  return false;
 }
 
 /**
@@ -167,6 +188,7 @@ export async function exportJourneysToFiles(includeMeta = true, options = {
  * @param {string} journeyId journey id/name
  * @param {string} file import file name
  * @param {TreeImportOptions} options import options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function importJourneyFromFile(journeyId, file, options) {
   const verbose = state.getVerbose();
@@ -198,6 +220,7 @@ export async function importJourneyFromFile(journeyId, file, options) {
           await importJourney(journeyData, options);
           if (verbose) indicatorId2 = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
           stopProgressIndicator(indicatorId2, `Imported ${journeyId}.`, 'success');
+          return true;
         } catch (importError) {
           if (verbose) indicatorId2 = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
           stopProgressIndicator(indicatorId2, `${importError}`, 'fail');
@@ -214,14 +237,16 @@ export async function importJourneyFromFile(journeyId, file, options) {
       stopProgressIndicator(indicatorId3, `${journeyId} not found!`, 'fail');
     }
   } catch (error) {
-    printMessage(`Error importing journey ${journeyId}: ${error}`, 'error');
+    printError(error);
   }
+  return false;
 }
 
 /**
  * Import first journey from file
  * @param {string} file import file name
  * @param {TreeImportOptions} options import options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function importFirstJourneyFromFile(file, options) {
   const verbose = state.getVerbose();
@@ -262,6 +287,7 @@ export async function importFirstJourneyFromFile(file, options) {
           await importJourney(journeyData, options);
           if (verbose) importSpinnerId = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
           stopProgressIndicator(importSpinnerId, `Imported ${journeyId}.`, 'success');
+          return true;
         } catch (importError) {
           if (verbose) importSpinnerId = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
           stopProgressIndicator(importSpinnerId, `${importError}`, 'fail');
@@ -278,59 +304,51 @@ export async function importFirstJourneyFromFile(file, options) {
     }
     // end dependency resolution for single tree import
   } catch (error) {
-    printMessage(`Error importing first journey: ${error}`, 'error');
+    printError(error);
   }
+  return false;
 }
 
 /**
  * Import all journeys from file
  * @param {string} file import file name
  * @param {TreeImportOptions} options import options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function importJourneysFromFile(file, options) {
   try {
     const data = fs.readFileSync(getFilePath(file), 'utf8');
-    try {
-      const fileData = JSON.parse(data);
-      await importJourneys(fileData, options);
-    } catch (error) {
-      if (error.name === 'UnresolvedDependenciesError') {
-        for (const journey of Object.keys(error.unresolvedJourneys)) {
-          printMessage({
-            message: `  - ${journey} requires ${error.unresolvedJourneys[journey]}`,
-            type: 'info',
-            state
-          });
-        }
-      } else {
-        printMessage(`${error.message}`, 'error');
-      }
-    }
+    const fileData = JSON.parse(data);
+    await importJourneys(fileData, options);
+    return true;
   } catch (error) {
-    printMessage(`Error importing journeys: ${error}`, 'error');
+    printError(error);
   }
+  return false;
 }
 
 /**
  * Import all journeys from separate files
  * @param {TreeImportOptions} options import options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function importJourneysFromFiles(options) {
-  const names = fs.readdirSync(getWorkingDirectory());
-  const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.journey.json')).map(name => getFilePath(name));
-  const allJourneysData = {
-    trees: {}
-  };
-  for (const file of jsonFiles) {
-    const journeyData = JSON.parse(fs.readFileSync(file, 'utf8'));
-    allJourneysData.trees[journeyData.tree._id] = journeyData;
-  }
   try {
+    const names = fs.readdirSync(getWorkingDirectory());
+    const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.journey.json')).map(name => getFilePath(name));
+    const allJourneysData = {
+      trees: {}
+    };
+    for (const file of jsonFiles) {
+      const journeyData = JSON.parse(fs.readFileSync(file, 'utf8'));
+      allJourneysData.trees[journeyData.tree._id] = journeyData;
+    }
     await importJourneys(allJourneysData, options);
+    return true;
   } catch (error) {
-    var _error$response2;
-    printMessage(`${((_error$response2 = error.response) === null || _error$response2 === void 0 || (_error$response2 = _error$response2.data) === null || _error$response2 === void 0 ? void 0 : _error$response2.message) || error.message}`, 'error');
+    printError(error);
   }
+  return false;
 }
 
 /**
@@ -450,122 +468,132 @@ function describeTreeDescendentsMd(descendents, depth = 0) {
  * - SAML2 circles of trust
  * @param {SingleTreeExportInterface} journeyData journey export object
  * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function describeJourney(journeyData, resolveTreeExport = onlineTreeExportResolver) {
-  var _journeyData$meta, _journeyData$tree$uiC, _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;
+  const errors = [];
+  try {
+    var _journeyData$meta, _journeyData$tree$uiC, _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;
+      }
     }
-  }
 
-  // initialize AM version from file
-  if (!state.getAmVersion() && (_journeyData$meta = journeyData.meta) !== null && _journeyData$meta !== void 0 && _journeyData$meta.originAmVersion) {
-    state.setAmVersion(journeyData.meta.originAmVersion);
-  }
+    // initialize AM version from file
+    if (!state.getAmVersion() && (_journeyData$meta = journeyData.meta) !== null && _journeyData$meta !== void 0 && _journeyData$meta.originAmVersion) {
+      state.setAmVersion(journeyData.meta.originAmVersion);
+    }
 
-  // Journey Name
-  printMessage(`${getOneLineDescription(journeyData.tree)}`, 'data');
-  printMessage(Array(`[${journeyData.tree._id}]`['length']).fill('=').join(''));
+    // Journey Name
+    printMessage(`${getOneLineDescription(journeyData.tree)}`, 'data');
+    printMessage(Array(`[${journeyData.tree._id}]`['length']).fill('=').join(''));
 
-  // Description
-  if (journeyData.tree.description) {
-    printMessage(`\n${journeyData.tree.description}`, 'data');
-  }
+    // Description
+    if (journeyData.tree.description) {
+      printMessage(`\n${journeyData.tree.description}`, 'data');
+    }
 
-  // Status
-  printMessage(`\nStatus\n${journeyData.tree.enabled === false ? 'disabled'['brightRed'] : 'enabled'['brightGreen']}`);
+    // Status
+    printMessage(`\nStatus\n${journeyData.tree.enabled === false ? 'disabled'['brightRed'] : 'enabled'['brightGreen']}`);
 
-  // Classification
-  if (state.getAmVersion()) {
-    printMessage(`\nClassification\n${getJourneyClassification(journeyData).join(', ')}`, 'data');
-  }
+    // Classification
+    if (state.getAmVersion()) {
+      printMessage(`\nClassification\n${getJourneyClassification(journeyData).join(', ')}`, 'data');
+    }
 
-  // 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');
-  }
+    // 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
-  try {
-    const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
-    describeTreeDescendents(descendents);
-  } catch (error) {
-    printMessage(`Error resolving inner tree dependencies:`, 'error');
-    printMessage(error.stack, 'error');
-  }
+    // Dependency Tree
+    try {
+      const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
+      describeTreeDescendents(descendents);
+    } catch (error) {
+      errors.push(error);
+    }
 
-  // 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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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 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
-  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');
+    // 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');
+      }
+    }
+    if (errors.length > 0) {
+      throw new FrodoError(`Error describing journey`, errors);
     }
+    return true;
+  } catch (error) {
+    printError(error);
   }
+  return false;
 }
 
 /**
@@ -582,138 +610,205 @@ export async function describeJourney(journeyData, resolveTreeExport = onlineTre
  * - SAML2 circles of trust
  * @param {SingleTreeExportInterface} journeyData journey export object
  * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
  */
 export async function describeJourneyMd(journeyData, resolveTreeExport = onlineTreeExportResolver) {
-  var _journeyData$meta2, _journeyData$tree$uiC2, _journeyData$themes2;
-  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;
+  const errors = [];
+  try {
+    var _journeyData$meta2, _journeyData$tree$uiC2, _journeyData$themes2;
+    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
-  if (!state.getAmVersion() && (_journeyData$meta2 = journeyData.meta) !== null && _journeyData$meta2 !== void 0 && _journeyData$meta2.originAmVersion) {
-    state.setAmVersion(journeyData.meta.originAmVersion);
-  }
 
-  // Journey Name
-  printMessage(`# ${getOneLineDescriptionMd(journeyData.tree)} - ${journeyData.tree.enabled === false ? ':o: `disabled`' : ':white_check_mark: `enabled`'}, ${getJourneyClassificationMd(journeyData).join(', ')}`, 'data');
+    // initialize AM version from file
+    if (!state.getAmVersion() && (_journeyData$meta2 = journeyData.meta) !== null && _journeyData$meta2 !== void 0 && _journeyData$meta2.originAmVersion) {
+      state.setAmVersion(journeyData.meta.originAmVersion);
+    }
 
-  // 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');
-  }
+    // Journey Name
+    printMessage(`# ${getOneLineDescriptionMd(journeyData.tree)} - ${journeyData.tree.enabled === false ? ':o: `disabled`' : ':white_check_mark: `enabled`'}, ${getJourneyClassificationMd(journeyData).join(', ')}`, 'data');
 
-  // Description
-  if (journeyData.tree.description) {
-    printMessage(`\n${journeyData.tree.description}`, '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');
+    }
 
-  // Journey image
-  printMessage(`\n[![](./${journeyData.tree._id}.png)]()\n`, 'data');
+    // Description
+    if (journeyData.tree.description) {
+      printMessage(`\n${journeyData.tree.description}`, 'data');
+    }
 
-  // Dependency Tree
-  const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
-  printMessage(describeTreeDescendentsMd(descendents), 'data');
+    // Journey image
+    printMessage(`\n[![](./${journeyData.tree._id}.png)]()\n`, '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');
+    // Dependency Tree
+    const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
+    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
-  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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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');
+    // 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
-  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 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
-  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');
+    // 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');
+      }
+    }
+    if (errors.length > 0) {
+      throw new FrodoError(`Error describing journey`, errors);
     }
+    return true;
+  } catch (error) {
+    printError(error);
   }
+  return false;
 }
+
+/**
+ * Enable a journey
+ * @param {string} journeyId id/name of journey
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
+ */
 export async function enableJourney(journeyId) {
   const indicatorId = createProgressIndicator('indeterminate', 0, `Enabling journey ${journeyId}...`);
-  if (_enableJourney(journeyId)) {
+  try {
+    await _enableJourney(journeyId);
     stopProgressIndicator(indicatorId, `Enabled journey ${journeyId}.`, 'success');
     return true;
-  } else {
+  } catch (error) {
     stopProgressIndicator(indicatorId, `Error enabling journey ${journeyId}`, 'fail');
-    return false;
+    printError(error);
   }
+  return false;
 }
+
+/**
+ * Disable a journey
+ * @param {string} journeyId id/name of journey
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
+ */
 export async function disableJourney(journeyId) {
   const indicatorId = createProgressIndicator('indeterminate', 0, `Disabling journey ${journeyId}...`);
-  if (_disableJourney(journeyId)) {
+  try {
+    await _disableJourney(journeyId);
     stopProgressIndicator(indicatorId, `Disabled journey ${journeyId}.`, 'success');
     return true;
-  } else {
+  } catch (error) {
     stopProgressIndicator(indicatorId, `Error disabling journey ${journeyId}`, 'fail');
-    return false;
   }
+  return false;
+}
+
+/**
+ * Delete a journey
+ * @param {string} journeyId id/name of journey
+ * @param {{ deep: boolean; verbose: boolean }} [options] delete journey options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
+ */
+export async function deleteJourney(journeyId, options = {
+  deep: true,
+  verbose: false,
+  progress: true
+}) {
+  try {
+    await _deleteJourney(journeyId, options);
+    return true;
+  } catch (error) {
+    printError(error);
+  }
+  return false;
+}
+
+/**
+ * Delete all journeys
+ * @param {{ deep: boolean; verbose: boolean }} [options] delete journey options
+ * @returns {Promise<boolean>} a promise resolving to true if successful, false otherwise
+ */
+export async function deleteJourneys(options = {
+  deep: true,
+  verbose: false
+}) {
+  const indicatorId = createProgressIndicator('indeterminate', null, `Deleting journeys...`);
+  try {
+    const status = await _deleteJourneys(options);
+    stopProgressIndicator(indicatorId, `Deleted ${Object.keys(status).length} journeys`);
+    return true;
+  } catch (error) {
+    stopProgressIndicator(indicatorId, `Error deleting journeys`);
+    printError(error);
+  }
+  return false;
 }
 //# sourceMappingURL=JourneyOps.js.map