@rockcarver/frodo-lib 0.12.1 → 0.12.2-0

package/esm/ops/JourneyOps.mjs

@@ -1,12 +1,11 @@
-/* eslint-disable no-param-reassign */
 import fs from 'fs';
-import yesno from 'yesno';
 import { v4 as uuidv4 } from 'uuid';
 import _ from 'lodash';
 import { convertBase64TextToArray, getTypedFilename, saveJsonToFile, getRealmString, convertTextArrayToBase64, convertTextArrayToBase64Url } from './utils/ExportImportUtils';
 import { getRealmManagedUser, replaceAll } from './utils/OpsUtils';
 import storage from '../storage/SessionStorage';
-import { getNode, putNode, deleteNode, getTrees, getTree, putTree, getNodeTypes, getNodesByType, deleteTree } from '../api/TreeApi';
+import { getNode, putNode, deleteNode, getNodeTypes, getNodesByType } from '../api/NodeApi';
+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';
@@ -21,9 +20,10 @@ import { createOrUpdateScript } from './ScriptOps';
 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
+const emptyScriptPlaceholder = '[Empty]';
 
-function getSingleTreeFileDataTemplate() {
+// use a function vs a template variable to avoid problems in loops
+function createSingleTreeExportTemplate() {
   return {
     meta: {},
     innerNodes: {},
@@ -36,10 +36,10 @@ function getSingleTreeFileDataTemplate() {
     circlesOfTrust: {},
     tree: {}
   };
-} // use a function vs a template variable to avoid problems in loops
-
+}
 
-function getMultipleTreesFileDataTemplate() {
+// use a function vs a template variable to avoid problems in loops
+function createMultipleTreesExportTemplate() {
   return {
     meta: {},
     trees: {}
@@ -113,18 +113,39 @@ 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;
+// }
+
 /**
- * Helper method to create export data for a tree with all its
- * dependencies. The export data can be written to a file as is
- * (but it doesn't contain meta data).
- * @param {Object} treeObject tree object
- * @param {Object} exportData export data
- * @param {Object} options options object
+ * Export options
  */
 
 
-async function exportTree(treeObject, exportData, options) {
+/**
+ * Create export data for a tree 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<SingleTreeExportTemplate>} a promise that resolves to an object containing the tree and all its nodes and dependencies
+ */
+export async function exportTree(treeId, options = {
+  useStringArrays: true,
+  deps: true,
+  verbose: false
+}) {
+  const treeObject = await getTree(treeId);
+  const exportData = createSingleTreeExportTemplate();
   const {
     useStringArrays,
     deps,
@@ -151,7 +172,7 @@ async function exportTree(treeObject, exportData, options) {
   const themes = []; // get all the nodes
 
   for (const [nodeId, nodeInfo] of Object.entries(treeObject.nodes)) {
-    nodePromises.push(getNode(nodeId, nodeInfo['nodeType']).then(response => response.data));
+    nodePromises.push(getNode(nodeId, nodeInfo['nodeType']));
   }
 
   if (verbose && nodePromises.length > 0) printMessage('  - Nodes:');
@@ -216,7 +237,7 @@ async function exportTree(treeObject, exportData, options) {
 
     if (containerNodes.includes(nodeType)) {
       for (const innerNode of nodeObject.nodes) {
-        innerNodePromises.push(getNode(innerNode._id, innerNode.nodeType).then(response => response.data));
+        innerNodePromises.push(getNode(innerNode._id, innerNode.nodeType));
       } // frodo supports themes in platform deployments
 
 
@@ -375,15 +396,16 @@ async function exportTree(treeObject, exportData, options) {
       });
     });
   }
+
+  return exportData;
 }
 /**
  * Export journey by id/name to file
- * @param {String} journeyId journey id/name
- * @param {String} file optional export file name
- * @param {Object} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output, deps:boolean: include dependencies
+ * @param {string} journeyId journey id/name
+ * @param {string} file optional export file name
+ * @param {ExportOptions} options export options
  */
 
-
 export async function exportJourneyToFile(journeyId, file, options) {
   const {
     verbose
@@ -395,26 +417,21 @@ export async function exportJourneyToFile(journeyId, file, options) {
   }
 
   if (!verbose) createProgressIndicator(undefined, `${journeyId}`, 'indeterminate');
-  await getTree(journeyId).then(async response => {
-    const treeData = response.data;
-    const fileData = getSingleTreeFileDataTemplate();
 
-    try {
-      await exportTree(treeData, fileData, options);
-      if (verbose) createProgressIndicator(undefined, `${journeyId}`, 'indeterminate');
-      saveJsonToFile(fileData, fileName);
-      stopProgressIndicator(`Exported ${journeyId.brightCyan} to ${fileName.brightCyan}.`, 'success');
-    } catch (error) {
-      if (verbose) createProgressIndicator(undefined, `${journeyId}`, 'indeterminate');
-      stopProgressIndicator(`Error exporting journey ${journeyId}: ${error}`, 'fail');
-    }
-  }).catch(err => {
-    stopProgressIndicator(err.message, 'fail');
-  });
+  try {
+    const fileData = await exportTree(journeyId, options);
+    if (verbose) createProgressIndicator(undefined, `${journeyId}`, 'indeterminate');
+    saveJsonToFile(fileData, fileName);
+    stopProgressIndicator(`Exported ${journeyId['brightCyan']} to ${fileName['brightCyan']}.`, 'success');
+  } catch (error) {
+    if (verbose) createProgressIndicator(undefined, `${journeyId}`, 'indeterminate');
+    stopProgressIndicator(`Error exporting journey ${journeyId}: ${error}`, 'fail');
+  }
 }
 /**
  * Export all journeys to file
- * @param {String} file optional export file name
+ * @param {string} file optional export file name
+ * @param {ExportOptions} options export options
  */
 
 export async function exportJourneysToFile(file, options) {
@@ -424,20 +441,16 @@ export async function exportJourneysToFile(file, options) {
     fileName = getTypedFilename(`all${getRealmString()}Journeys`, 'journeys');
   }
 
-  const trees = (await getTrees()).data.result;
-  const fileData = getMultipleTreesFileDataTemplate();
+  const trees = await getTrees();
+  const fileData = createMultipleTreesExportTemplate();
   createProgressIndicator(trees.length, 'Exporting journeys...');
 
   for (const tree of trees) {
     updateProgressIndicator(`${tree._id}`);
 
     try {
-      // eslint-disable-next-line no-await-in-loop
-      const treeData = (await getTree(tree._id)).data;
-      const exportData = getSingleTreeFileDataTemplate();
-      delete exportData.meta; // eslint-disable-next-line no-await-in-loop
-
-      await exportTree(treeData, exportData, options);
+      const exportData = await exportTree(tree._id, options);
+      delete exportData.meta;
       fileData.trees[tree._id] = exportData;
     } catch (error) {
       printMessage(`Error exporting journey ${tree._id}: ${error}`, 'error');
@@ -449,59 +462,39 @@ export async function exportJourneysToFile(file, options) {
 }
 /**
  * Export all journeys to separate files
+ * @param {ExportOptions} options export options
  */
 
 export async function exportJourneysToFiles(options) {
-  const trees = (await getTrees()).data.result;
+  const trees = await getTrees();
   createProgressIndicator(trees.length, 'Exporting journeys...');
 
   for (const tree of trees) {
     updateProgressIndicator(`${tree._id}`);
-    const fileName = getTypedFilename(`${tree._id}`, 'journey'); // eslint-disable-next-line no-await-in-loop
+    const fileName = getTypedFilename(`${tree._id}`, 'journey');
 
-    const treeData = (await getTree(tree._id)).data;
-    const exportData = getSingleTreeFileDataTemplate(); // eslint-disable-next-line no-await-in-loop
-
-    await exportTree(treeData, exportData, options);
-    saveJsonToFile(exportData, fileName);
+    try {
+      const exportData = await exportTree(tree._id, options);
+      saveJsonToFile(exportData, fileName);
+    } catch (error) {// do we need to report status here?
+    }
   }
 
   stopProgressIndicator('Done');
 }
 /**
- * Get data for journey by id/name
- * @param {String} journeyId journey id/name
- * @returns {Object} object containing all journey data
+ * Import options
  */
 
-export async function getJourneyData(journeyId) {
-  createProgressIndicator(undefined, `${journeyId}`, 'indeterminate');
-  const journeyData = getSingleTreeFileDataTemplate();
-  const treeData = (await getTree(journeyId).catch(err => {
-    stopProgressIndicator(null, 'success');
-    printMessage(err, 'error');
-  }))['data'];
-  updateProgressIndicator();
-  await exportTree(treeData, journeyData, {
-    useStringArrays: true
-  });
-  stopProgressIndicator(null, 'success');
-  return journeyData;
-}
 /**
  * Helper to import a tree with all dependencies from an import data object (typically read from a file)
- * @param {Object} treeObject tree object containing tree and all its dependencies
- * @param {Object} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output
+ * @param {SingleTreeExportTemplate} treeObject tree object containing tree and all its dependencies
+ * @param {ImportOptions} options import options
  */
-
-async function importTree(treeObject, options) {
-  const {
-    reUuid
-  } = options;
-  const {
-    deps
-  } = options;
+export async function importTree(treeObject, options) {
   const {
+    reUuid,
+    deps,
     verbose
   } = options;
   if (verbose) printMessage(`\n- ${treeObject.tree._id}\n`, 'info', false);
@@ -555,8 +548,8 @@ async function importTree(treeObject, options) {
     const themes = {};
 
     for (const theme of treeObject.themes) {
-      if (verbose) printMessage(`    - ${theme._id} (${theme.name})`, 'info');
-      themes[theme._id] = theme;
+      if (verbose) printMessage(`    - ${theme['_id']} (${theme['name']})`, 'info');
+      themes[theme['_id']] = theme;
     }
 
     try {
@@ -775,7 +768,7 @@ async function importTree(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')) {
     treeObject.tree.identityResource = `managed/${getRealmManagedUser()}`;
     if (verbose) printMessage(`    - identityResource: ${treeObject.tree.identityResource}`, 'info', false);
   }
@@ -820,7 +813,6 @@ async function importTree(treeObject, options) {
  * @param {int} index Depth of recursion
  */
 
-
 async function resolveDependencies(installedJorneys, journeyMap, unresolvedJourneys, resolvedJourneys, index = -1) {
   let before = -1;
   let after = index;
@@ -877,9 +869,9 @@ async function resolveDependencies(installedJorneys, journeyMap, unresolvedJourn
 }
 /**
  * Import a journey from file
- * @param {String} journeyId journey id/name
- * @param {String} file import file name
- * @param {boolean} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output
+ * @param {string} journeyId journey id/name
+ * @param {string} file import file name
+ * @param {ImportOptions} options import options
  */
 
 
@@ -900,7 +892,7 @@ export async function importJourneyFromFile(journeyId, file, options) {
 
     if (journeyData && journeyId === journeyData.tree._id) {
       // attempt dependency resolution for single tree import
-      const installedJourneys = (await getTrees()).data.result.map(x => x._id);
+      const installedJourneys = (await getTrees()).map(x => x._id);
       const unresolvedJourneys = {};
       const resolvedJourneys = [];
       createProgressIndicator(undefined, 'Resolving dependencies', 'indeterminate');
@@ -934,8 +926,8 @@ export async function importJourneyFromFile(journeyId, file, options) {
 }
 /**
  * Import first journey from file
- * @param {String} file import file name
- * @param {boolean} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output
+ * @param {string} file import file name
+ * @param {ImportOptions} options import options
  */
 
 export async function importFirstJourneyFromFile(file, options) {
@@ -965,7 +957,7 @@ export async function importFirstJourneyFromFile(file, options) {
 
     if (journeyData && journeyId) {
       // attempt dependency resolution for single tree import
-      const installedJourneys = (await getTrees()).data.result.map(x => x._id);
+      const installedJourneys = (await getTrees()).map(x => x._id);
       const unresolvedJourneys = {};
       const resolvedJourneys = [];
       createProgressIndicator(undefined, 'Resolving dependencies', 'indeterminate');
@@ -1000,11 +992,11 @@ export async function importFirstJourneyFromFile(file, options) {
 /**
  * Helper to import multiple trees from a tree map
  * @param {Object} treesMap map of trees object
- * @param {boolean} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output
+ * @param {ImportOptions} options import options
  */
 
 async function importAllTrees(treesMap, options) {
-  const installedJourneys = (await getTrees()).data.result.map(x => x._id);
+  const installedJourneys = (await getTrees()).map(x => x._id);
   const unresolvedJourneys = {};
   const resolvedJourneys = [];
   createProgressIndicator(undefined, 'Resolving dependencies', 'indeterminate');
@@ -1036,8 +1028,8 @@ async function importAllTrees(treesMap, options) {
 }
 /**
  * Import all journeys from file
- * @param {*} file import file name
- * @param {boolean} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output
+ * @param {string} file import file name
+ * @param {ImportOptions} options import options
  */
 
 
@@ -1050,7 +1042,7 @@ export async function importJourneysFromFile(file, options) {
 }
 /**
  * Import all journeys from separate files
- * @param {boolean} options reUuid:boolean: re-uuid all node objects, verbose:boolean: verbose output
+ * @param {ImportOptions} options import options
  */
 
 export async function importJourneysFromFiles(options) {
@@ -1107,23 +1099,50 @@ export function describeTree(treeData) {
   treeMap['nodeTypes'] = nodeTypeMap;
   treeMap['scripts'] = scriptsMap;
   treeMap['emailTemplates'] = emailTemplatesMap;
+  printMessage(`\nJourney: ${treeMap['treeName']}`, 'data');
+  printMessage('========');
+  printMessage('\nNodes:', 'data');
+
+  if (Object.entries(treeMap['nodeTypes']).length) {
+    for (const [name, count] of Object.entries(treeMap['nodeTypes'])) {
+      printMessage(`- ${name}: ${count}`, 'data');
+    }
+  }
+
+  if (Object.entries(treeMap['scripts']).length) {
+    printMessage('\nScripts:', 'data');
+
+    for (const [name, desc] of Object.entries(treeMap['scripts'])) {
+      printMessage(`- ${name}: ${desc}`, 'data');
+    }
+  }
+
+  if (Object.entries(treeMap['emailTemplates']).length) {
+    printMessage('\nEmail Templates:', 'data');
+
+    for (const [id] of Object.entries(treeMap['emailTemplates'])) {
+      printMessage(`- ${id}`, 'data');
+    }
+  }
+
   return treeMap;
 }
 /**
  * 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
  */
 
-async function findOrphanedNodes() {
+export async function findOrphanedNodes() {
   const allNodes = [];
   const orphanedNodes = [];
   let types = [];
-  const allJourneys = (await getTrees()).data.result;
+  const allJourneys = await getTrees();
   let errorMessage = '';
   const errorTypes = [];
   createProgressIndicator(undefined, `Counting total nodes...`, 'indeterminate');
 
   try {
-    types = (await getNodeTypes()).data.result;
+    types = await getNodeTypes();
   } catch (error) {
     printMessage('Error retrieving all available node types:', 'error');
     printMessage(error.response.data, 'error');
@@ -1133,7 +1152,7 @@ async function findOrphanedNodes() {
   for (const type of types) {
     try {
       // eslint-disable-next-line no-await-in-loop, no-loop-func
-      (await getNodesByType(type._id)).data.result.forEach(node => {
+      (await getNodesByType(type._id)).forEach(node => {
         allNodes.push(node);
         updateProgressIndicator(`${allNodes.length} total nodes${errorMessage}`);
       });
@@ -1162,7 +1181,7 @@ async function findOrphanedNodes() {
 
         if (containerNodes.includes(node.nodeType)) {
           // eslint-disable-next-line no-await-in-loop
-          const containerNode = (await getNode(nodeId, node.nodeType)).data;
+          const containerNode = await getNode(nodeId, node.nodeType);
           containerNode.nodes.forEach(n => {
             activeNodes.push(n._id);
             updateProgressIndicator(`${activeNodes.length} active nodes`);
@@ -1182,41 +1201,27 @@ async function findOrphanedNodes() {
 /**
  * Remove orphaned nodes
  * @param {[Object]} orphanedNodes Pass in an array of orphaned node configuration objects to remove
+ * @returns {Promise<unknown[]>} a promise that resolves to an array nodes that encountered errors deleting
  */
 
-
-async function removeOrphanedNodes(orphanedNodes) {
+export async function removeOrphanedNodes(orphanedNodes) {
+  const errorNodes = [];
   createProgressIndicator(orphanedNodes.length, 'Removing orphaned nodes...');
 
   for (const node of orphanedNodes) {
-    updateProgressIndicator(`Removing ${node._id}...`); // eslint-disable-next-line no-await-in-loop
+    updateProgressIndicator(`Removing ${node['_id']}...`);
 
-    await deleteNode(node._id, node._type._id).catch(deleteError => {
-      printMessage(`${deleteError}`, 'error');
-    });
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      await deleteNode(node['_id'], node['_type']['_id']);
+    } catch (deleteError) {
+      errorNodes.push(node);
+      printMessage(` ${deleteError}`, 'error');
+    }
   }
 
   stopProgressIndicator(`Removed ${orphanedNodes.length} orphaned nodes.`);
-}
-/**
- * Prune orphaned nodes
- */
-
-
-export async function prune() {
-  const orphanedNodes = await findOrphanedNodes();
-
-  if (orphanedNodes.length > 0) {
-    const ok = await yesno({
-      question: 'Prune (permanently delete) orphaned nodes? (y|n):'
-    });
-
-    if (ok) {
-      await removeOrphanedNodes(orphanedNodes);
-    }
-  } else {
-    printMessage('No orphaned nodes found.');
-  }
+  return errorNodes;
 }
 const OOTB_NODE_TYPES_7 = ['AcceptTermsAndConditionsNode', 'AccountActiveDecisionNode', 'AccountLockoutNode', 'AgentDataStoreDecisionNode', 'AnonymousSessionUpgradeNode', 'AnonymousUserNode', 'AttributeCollectorNode', 'AttributePresentDecisionNode', 'AttributeValueDecisionNode', 'AuthLevelDecisionNode', 'ChoiceCollectorNode', 'ConsentNode', 'CookiePresenceDecisionNode', 'CreateObjectNode', 'CreatePasswordNode', 'DataStoreDecisionNode', 'DeviceGeoFencingNode', 'DeviceLocationMatchNode', 'DeviceMatchNode', 'DeviceProfileCollectorNode', 'DeviceSaveNode', 'DeviceTamperingVerificationNode', 'DisplayUserNameNode', 'EmailSuspendNode', 'EmailTemplateNode', 'IdentifyExistingUserNode', 'IncrementLoginCountNode', 'InnerTreeEvaluatorNode', 'IotAuthenticationNode', 'IotRegistrationNode', 'KbaCreateNode', 'KbaDecisionNode', 'KbaVerifyNode', 'LdapDecisionNode', 'LoginCountDecisionNode', 'MessageNode', 'MetadataNode', 'MeterNode', 'ModifyAuthLevelNode', 'OneTimePasswordCollectorDecisionNode', 'OneTimePasswordGeneratorNode', 'OneTimePasswordSmsSenderNode', 'OneTimePasswordSmtpSenderNode', 'PageNode', 'PasswordCollectorNode', 'PatchObjectNode', 'PersistentCookieDecisionNode', 'PollingWaitNode', 'ProfileCompletenessDecisionNode', 'ProvisionDynamicAccountNode', 'ProvisionIdmAccountNode', 'PushAuthenticationSenderNode', 'PushResultVerifierNode', 'QueryFilterDecisionNode', 'RecoveryCodeCollectorDecisionNode', 'RecoveryCodeDisplayNode', 'RegisterLogoutWebhookNode', 'RemoveSessionPropertiesNode', 'RequiredAttributesDecisionNode', 'RetryLimitDecisionNode', 'ScriptedDecisionNode', 'SelectIdPNode', 'SessionDataNode', 'SetFailureUrlNode', 'SetPersistentCookieNode', 'SetSessionPropertiesNode', 'SetSuccessUrlNode', 'SocialFacebookNode', 'SocialGoogleNode', 'SocialNode', 'SocialOAuthIgnoreProfileNode', 'SocialOpenIdConnectNode', 'SocialProviderHandlerNode', 'TermsAndConditionsDecisionNode', 'TimeSinceDecisionNode', 'TimerStartNode', 'TimerStopNode', 'UsernameCollectorNode', 'ValidatedPasswordNode', 'ValidatedUsernameNode', 'WebAuthnAuthenticationNode', 'WebAuthnDeviceStorageNode', 'WebAuthnRegistrationNode', 'ZeroPageLoginNode', 'product-CertificateCollectorNode', 'product-CertificateUserExtractorNode', 'product-CertificateValidationNode', 'product-KerberosNode', 'product-ReCaptchaNode', 'product-Saml2Node', 'product-WriteFederationInformationNode'];
 const OOTB_NODE_TYPES_7_1 = ['PushRegistrationNode', 'GetAuthenticatorAppNode', 'MultiFactorRegistrationOptionsNode', 'OptOutMultiFactorAuthenticationNode'].concat(OOTB_NODE_TYPES_7);
@@ -1229,10 +1234,9 @@ const OOTB_NODE_TYPES_6 = ['AbstractSocialAuthLoginNode', 'AccountLockoutNode',
  * @returns {boolean} True if the journey/tree contains any custom nodes, false otherwise.
  */
 
-async function isCustom(journey) {
+export async function isCustom(journey) {
   let ootbNodeTypes = [];
-  const nodeList = journey.nodes; // console.log(nodeList);
-  // console.log(storage.session.getAmVersion());
+  const nodeList = journey.nodes;
 
   switch (storage.session.getAmVersion()) {
     case '7.1.0':
@@ -1240,7 +1244,6 @@ async function isCustom(journey) {
       break;
 
     case '7.2.0':
-      // console.log("here");
       ootbNodeTypes = OOTB_NODE_TYPES_7_2.slice(0);
       break;
 
@@ -1286,7 +1289,7 @@ async function isCustom(journey) {
 
       if (containerNodes.includes(nodeList[node].nodeType)) {
         results.push( // eslint-disable-next-line no-await-in-loop
-        (await getNode(node, nodeList[node].nodeType))['data']);
+        await getNode(node, nodeList[node].nodeType));
       }
     }
   }
@@ -1313,12 +1316,11 @@ async function isCustom(journey) {
  * @param {boolean} analyze Analyze journeys/trees for custom nodes (expensive)
  */
 
-
 export async function listJourneys(long = false, analyze = false) {
   let journeys = [];
 
   try {
-    journeys = (await getTrees()).data.result;
+    journeys = await getTrees();
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
@@ -1351,11 +1353,11 @@ export async function listJourneys(long = false, analyze = false) {
 }
 /**
  * Delete a journey
- * @param {String} journeyId journey id/name
+ * @param {string} journeyId journey id/name
  * @param {Object} options deep=true also delete all the nodes and inner nodes, verbose=true print verbose info
  */
 
-export async function deleteJourney(journeyId, options, spinner = true) {
+export async function deleteJourney(journeyId, options, progress = true) {
   const {
     deep
   } = options;
@@ -1365,29 +1367,29 @@ export async function deleteJourney(journeyId, options, spinner = true) {
   const status = {
     nodes: {}
   };
-  if (spinner) createProgressIndicator(undefined, `Deleting ${journeyId}...`, 'indeterminate');
-  if (spinner && verbose) stopProgressIndicator();
+  if (progress) createProgressIndicator(undefined, `Deleting ${journeyId}...`, 'indeterminate');
+  if (progress && verbose) stopProgressIndicator();
   return deleteTree(journeyId).then(async deleteTreeResponse => {
     status['status'] = 'success';
     const nodePromises = [];
     if (verbose) printMessage(`Deleted ${journeyId} (tree)`, 'info');
 
     if (deep) {
-      for (const [nodeId, nodeObject] of Object.entries(deleteTreeResponse.data.nodes)) {
+      for (const [nodeId, nodeObject] of Object.entries(deleteTreeResponse.nodes)) {
         // delete inner nodes (nodes inside container nodes)
         if (containerNodes.includes(nodeObject['nodeType'])) {
           try {
             // eslint-disable-next-line no-await-in-loop
-            const pageNode = (await getNode(nodeId, nodeObject['nodeType'])).data;
+            const containerNode = await getNode(nodeId, nodeObject['nodeType']);
             if (verbose) printMessage(`Read ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`, 'info');
 
-            for (const innerNodeObject of pageNode.nodes) {
+            for (const innerNodeObject of containerNode.nodes) {
               nodePromises.push(deleteNode(innerNodeObject._id, innerNodeObject.nodeType).then(response2 => {
                 status.nodes[innerNodeObject._id] = {
                   status: 'success'
                 };
                 if (verbose) printMessage(`Deleted ${innerNodeObject._id} (${innerNodeObject.nodeType}) from ${journeyId}`, 'info');
-                return response2.data;
+                return response2;
               }).catch(error => {
                 status.nodes[innerNodeObject._id] = {
                   status: 'error',
@@ -1398,18 +1400,27 @@ export async function deleteJourney(journeyId, options, spinner = true) {
             } // finally delete the container node
 
 
-            nodePromises.push(deleteNode(nodeId, nodeObject['nodeType']).then(response2 => {
-              status.nodes[nodeId] = {
+            nodePromises.push(deleteNode(containerNode._id, containerNode['_type']['_id']).then(response2 => {
+              status.nodes[containerNode._id] = {
                 status: 'success'
               };
-              if (verbose) printMessage(`Deleted ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`, 'info');
-              return response2.data;
+              if (verbose) printMessage(`Deleted ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}`, 'info');
+              return response2;
             }).catch(error => {
-              status.nodes[nodeId] = {
-                status: 'error',
-                error
-              };
-              if (verbose) printMessage(`Error deleting container node ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}: ${error}`, 'error');
+              var _error$response, _error$response$data;
+
+              if ((error === null || error === void 0 ? void 0 : (_error$response = error.response) === null || _error$response === void 0 ? void 0 : (_error$response$data = _error$response.data) === null || _error$response$data === void 0 ? void 0 : _error$response$data.code) === 500 && error.response.data.message === 'Unable to read SMS config: Node did not exist') {
+                status.nodes[containerNode._id] = {
+                  status: 'success'
+                };
+                if (verbose) printMessage(`Deleted ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}`, 'info');
+              } else {
+                status.nodes[containerNode._id] = {
+                  status: 'error',
+                  error
+                };
+                if (verbose) printMessage(`Error deleting container node ${containerNode._id} (${containerNode['_type']['_id']}) from ${journeyId}: ${error.response.data.message}`, 'error');
+              }
             }));
           } catch (error) {
             if (verbose) printMessage(`Error getting container node ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}: ${error}`, 'error');
@@ -1421,7 +1432,7 @@ export async function deleteJourney(journeyId, options, spinner = true) {
               status: 'success'
             };
             if (verbose) printMessage(`Deleted ${nodeId} (${nodeObject['nodeType']}) from ${journeyId}`, 'info');
-            return response.data;
+            return response;
           }).catch(error => {
             status.nodes[nodeId] = {
               status: 'error',
@@ -1436,7 +1447,7 @@ export async function deleteJourney(journeyId, options, spinner = true) {
 
     await Promise.allSettled(nodePromises); // report status
 
-    if (spinner) {
+    if (progress) {
       let nodeCount = 0;
       let errorCount = 0;
 
@@ -1471,7 +1482,7 @@ export async function deleteJourneys(options) {
     verbose
   } = options;
   const status = {};
-  const trees = (await getTrees()).data.result;
+  const trees = await getTrees();
   createProgressIndicator(trees.length, 'Deleting journeys...');
 
   for (const tree of trees) {