@rockcarver/frodo-cli 2.0.0-4 → 2.0.0-41

package/esm/ops/JourneyOps.js

@@ -1,6 +1,6 @@
 import { frodo, state } from '@rockcarver/frodo-lib';
 import fs from 'fs';
-import { printMessage, createProgressBar, updateProgressBar, stopProgressBar, showSpinner, succeedSpinner, failSpinner, createTable, debugMessage } from '../utils/Console';
+import { createProgressIndicator, createTable, debugMessage, printMessage, stopProgressIndicator, updateProgressIndicator } from '../utils/Console';
 import * as CirclesOfTrust from './CirclesOfTrustOps';
 import * as EmailTemplate from './EmailTemplateOps';
 import * as Idp from './IdpOps';
@@ -8,8 +8,29 @@ import * as Node from './NodeOps';
 import * as Saml2 from './Saml2Ops';
 import * as Script from './ScriptOps';
 import * as Theme from './ThemeOps';
-import wordwrap from './utils/Wordwrap';
 import { cloneDeep } from './utils/OpsUtils';
+import wordwrap from './utils/Wordwrap';
+const {
+  getTypedFilename,
+  saveJsonToFile,
+  getRealmString,
+  getFilePath,
+  getWorkingDirectory
+} = frodo.utils;
+const {
+  readJourneys,
+  exportJourney,
+  exportJourneys,
+  resolveDependencies,
+  importJourneys,
+  importJourney,
+  getTreeDescendents,
+  getNodeRef,
+  onlineTreeExportResolver,
+  getJourneyClassification: _getJourneyClassification,
+  disableJourney: _disableJourney,
+  enableJourney: _enableJourney
+} = frodo.authn.journey;
 
 /**
  * List all the journeys/trees
@@ -20,7 +41,7 @@ import { cloneDeep } from './utils/OpsUtils';
 export async function listJourneys(long = false, analyze = false) {
   let journeys = [];
   try {
-    journeys = await frodo.authn.journey.getJourneys();
+    journeys = await readJourneys();
     if (!long && !analyze) {
       for (const journeyStub of journeys) {
         printMessage(`${journeyStub['_id']}`, 'data');
@@ -34,17 +55,17 @@ export async function listJourneys(long = false, analyze = false) {
         }
         printMessage(table.toString(), 'data');
       } else {
-        showSpinner('Retrieving details of all journeys...');
+        const spinnerId = createProgressIndicator('indeterminate', 0, `Retrieving details of all journeys...`);
         const exportPromises = [];
         try {
           for (const journeyStub of journeys) {
-            exportPromises.push(frodo.authn.journey.exportJourney(journeyStub['_id'], {
+            exportPromises.push(exportJourney(journeyStub['_id'], {
               useStringArrays: false,
               deps: false
             }));
           }
           const journeyExports = await Promise.all(exportPromises);
-          succeedSpinner('Retrieved details of all journeys.');
+          stopProgressIndicator(spinnerId, 'Retrieved details of all journeys.', 'success');
           const table = createTable(['Name', 'Status', 'Classification', 'Tags']);
           for (const journeyExport of journeyExports) {
             var _journeyExport$tree$u;
@@ -52,7 +73,7 @@ export async function listJourneys(long = false, analyze = false) {
           }
           printMessage(table.toString(), 'data');
         } catch (error) {
-          failSpinner('Error retrieving details of all journeys.');
+          stopProgressIndicator(spinnerId, 'Error retrieving details of all journeys.', 'fail');
           printMessage(error.response.data, 'error');
         }
       }
@@ -68,86 +89,73 @@ export async function listJourneys(long = false, analyze = false) {
  * Export journey by id/name to file
  * @param {string} journeyId journey id/name
  * @param {string} file optional export file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  * @param {TreeExportOptions} options export options
  */
-export async function exportJourneyToFile(journeyId, file, options) {
+export async function exportJourneyToFile(journeyId, file, includeMeta = true, options = {
+  deps: false,
+  useStringArrays: false
+}) {
   debugMessage(`exportJourneyToFile: start`);
-  const verbose = state.getDebug();
+  const verbose = state.getVerbose();
   if (!file) {
-    file = frodo.utils.impex.getTypedFilename(journeyId, 'journey');
-  }
-  if (state.getDirectory()) {
-    const dir = state.getDirectory().replace(/\/$/, '');
-    debugMessage(`exportJourneyToFile: directory='${dir}'`);
-    file = `${dir}/${file}`;
-    // create directory if it doesn't exist
-    if (!fs.existsSync(dir)) {
-      debugMessage(`exportJourneyToFile: creating directory '${dir}'`);
-      fs.mkdirSync(dir, {
-        recursive: true
-      });
-    }
+    file = getTypedFilename(journeyId, 'journey');
   }
-  if (!verbose) showSpinner(`${journeyId}`);
+  const filePath = getFilePath(file, true);
+  let spinnerId;
+  if (!verbose) spinnerId = createProgressIndicator('indeterminate', 0, `${journeyId}`);
   try {
-    const fileData = await frodo.authn.journey.exportJourney(journeyId, options);
-    if (verbose) showSpinner(`${journeyId}`);
-    frodo.utils.impex.saveJsonToFile(fileData, file);
-    succeedSpinner(`Exported ${journeyId['brightCyan']} to ${file['brightCyan']}.`);
+    const fileData = await exportJourney(journeyId, options);
+    if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `${journeyId}`);
+    saveJsonToFile(fileData, filePath, includeMeta);
+    stopProgressIndicator(spinnerId, `Exported ${journeyId['brightCyan']} to ${filePath['brightCyan']}.`, 'success');
   } catch (error) {
-    if (verbose) showSpinner(`${journeyId}`);
-    failSpinner(`Error exporting journey ${journeyId}: ${error}`);
+    if (verbose) spinnerId = createProgressIndicator('indeterminate', 0, `${journeyId}`);
+    stopProgressIndicator(spinnerId, `Error exporting journey ${journeyId}: ${error}`, 'fail');
   }
 }
 
 /**
  * Export all journeys to file
  * @param {string} file optional export file name
+ * @param {boolean} includeMeta true to include metadata, false otherwise. Default: true
  * @param {TreeExportOptions} options export options
  */
-export async function exportJourneysToFile(file, options = {
+export async function exportJourneysToFile(file, includeMeta = true, options = {
   deps: false,
   useStringArrays: false
 }) {
-  let fileName = file;
-  if (!fileName) {
-    fileName = frodo.utils.impex.getTypedFilename(`all${frodo.utils.impex.getRealmString()}Journeys`, 'journeys');
-  }
-  const trees = await frodo.authn.journey.getJourneys();
-  const fileData = frodo.authn.journey.createMultiTreeExportTemplate();
-  createProgressBar(trees.length, 'Exporting journeys...');
-  for (const tree of trees) {
-    updateProgressBar(`${tree._id}`);
-    try {
-      const exportData = await frodo.authn.journey.exportJourney(tree._id, options);
-      delete exportData.meta;
-      fileData.trees[tree._id] = exportData;
-    } catch (error) {
-      printMessage(`Error exporting journey ${tree._id}: ${error}`, 'error');
-    }
+  if (!file) {
+    file = getTypedFilename(`all${getRealmString()}Journeys`, 'journey');
   }
-  frodo.utils.impex.saveJsonToFile(fileData, fileName);
-  stopProgressBar(`Exported to ${fileName}`);
+  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
  */
-export async function exportJourneysToFiles(options) {
-  const trees = await frodo.authn.journey.getJourneys();
-  createProgressBar(trees.length, 'Exporting journeys...');
-  for (const tree of trees) {
-    updateProgressBar(`${tree._id}`);
-    const fileName = frodo.utils.impex.getTypedFilename(`${tree._id}`, 'journey');
+export async function exportJourneysToFiles(includeMeta = true, options = {
+  deps: false,
+  useStringArrays: false
+}) {
+  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 {
-      const exportData = await frodo.authn.journey.exportJourney(tree._id, options);
-      frodo.utils.impex.saveJsonToFile(exportData, fileName);
+      updateProgressIndicator(indicatorId, `Saving ${treeId} to ${file}`);
+      saveJsonToFile(treeValue, file, includeMeta);
+      stopProgressIndicator(indicatorId, `${treeId} saved to ${file}`);
     } catch (error) {
-      // do we need to report status here?
+      stopProgressIndicator(indicatorId, `Error saving ${treeId} to ${file}`);
     }
   }
-  stopProgressBar('Done');
 }
 
 /**
@@ -157,9 +165,9 @@ export async function exportJourneysToFiles(options) {
  * @param {TreeImportOptions} options import options
  */
 export async function importJourneyFromFile(journeyId, file, options) {
-  const verbose = state.getDebug();
-  fs.readFile(file, 'utf8', async (err, data) => {
-    if (err) throw err;
+  const verbose = state.getVerbose();
+  try {
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     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]) {
@@ -171,35 +179,39 @@ export async function importJourneyFromFile(journeyId, file, options) {
     // 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 frodo.authn.journey.getJourneys()).map(x => x._id);
+      const installedJourneys = (await readJourneys()).map(x => x._id);
       const unresolvedJourneys = {};
       const resolvedJourneys = [];
-      showSpinner('Resolving dependencies');
-      await frodo.authn.journey.resolveDependencies(installedJourneys, {
+      const indicatorId1 = createProgressIndicator('indeterminate', 0, 'Resolving dependencies');
+      await resolveDependencies(installedJourneys, {
         [journeyId]: journeyData
       }, unresolvedJourneys, resolvedJourneys);
       if (Object.keys(unresolvedJourneys).length === 0) {
-        succeedSpinner(`Resolved all dependencies.`);
-        if (!verbose) showSpinner(`Importing ${journeyId}...`);
-        frodo.authn.journey.importJourney(journeyData, options).then(() => {
-          if (verbose) showSpinner(`Importing ${journeyId}...`);
-          succeedSpinner(`Imported ${journeyId}.`);
-        }).catch(importError => {
-          if (verbose) showSpinner(`Importing ${journeyId}...`);
-          failSpinner(`${importError}`);
-        });
+        stopProgressIndicator(indicatorId1, `Resolved all dependencies.`, 'success');
+        let indicatorId2;
+        if (!verbose) indicatorId2 = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+        try {
+          await importJourney(journeyData, options);
+          if (verbose) indicatorId2 = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+          stopProgressIndicator(indicatorId2, `Imported ${journeyId}.`, 'success');
+        } catch (importError) {
+          if (verbose) indicatorId2 = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+          stopProgressIndicator(indicatorId2, `${importError}`, 'fail');
+        }
       } else {
-        failSpinner(`Unresolved dependencies:`);
+        stopProgressIndicator(indicatorId1, `Unresolved dependencies:`, 'fail');
         for (const journey of Object.keys(unresolvedJourneys)) {
           printMessage(`  ${journey} requires ${unresolvedJourneys[journey]}`, 'error');
         }
       }
       // end dependency resolution for single tree import
     } else {
-      showSpinner(`Importing ${journeyId}...`);
-      failSpinner(`${journeyId} not found!`);
+      const indicatorId3 = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+      stopProgressIndicator(indicatorId3, `${journeyId} not found!`, 'fail');
     }
-  });
+  } catch (error) {
+    printMessage(`Error importing journey ${journeyId}: ${error}`, 'error');
+  }
 }
 
 /**
@@ -208,9 +220,9 @@ export async function importJourneyFromFile(journeyId, file, options) {
  * @param {TreeImportOptions} options import options
  */
 export async function importFirstJourneyFromFile(file, options) {
-  const verbose = state.getDebug();
-  fs.readFile(file, 'utf8', async (err, data) => {
-    if (err) throw err;
+  const verbose = state.getVerbose();
+  try {
+    const data = fs.readFileSync(getFilePath(file), 'utf8');
     let journeyData = cloneDeep(JSON.parse(data));
     let journeyId = null;
     // single tree
@@ -231,35 +243,39 @@ export async function importFirstJourneyFromFile(file, options) {
     // if a journeyId was specified, only import the matching journey
     if (journeyData && journeyId) {
       // attempt dependency resolution for single tree import
-      const installedJourneys = (await frodo.authn.journey.getJourneys()).map(x => x._id);
+      const installedJourneys = (await readJourneys()).map(x => x._id);
       const unresolvedJourneys = {};
       const resolvedJourneys = [];
-      showSpinner('Resolving dependencies');
-      await frodo.authn.journey.resolveDependencies(installedJourneys, {
+      const depSpinnerId = createProgressIndicator('indeterminate', 0, 'Resolving dependencies');
+      await resolveDependencies(installedJourneys, {
         [journeyId]: journeyData
       }, unresolvedJourneys, resolvedJourneys);
       if (Object.keys(unresolvedJourneys).length === 0) {
-        succeedSpinner(`Resolved all dependencies.`);
-        if (!verbose) showSpinner(`Importing ${journeyId}...`);
-        frodo.authn.journey.importJourney(journeyData, options).then(() => {
-          if (verbose) showSpinner(`Importing ${journeyId}...`);
-          succeedSpinner(`Imported ${journeyId}.`);
-        }).catch(importError => {
-          if (verbose) showSpinner(`Importing ${journeyId}...`);
-          failSpinner(`${importError}`);
-        });
+        stopProgressIndicator(depSpinnerId, `Resolved all dependencies.`, 'success');
+        let importSpinnerId;
+        if (!verbose) importSpinnerId = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+        try {
+          await importJourney(journeyData, options);
+          if (verbose) importSpinnerId = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+          stopProgressIndicator(importSpinnerId, `Imported ${journeyId}.`, 'success');
+        } catch (importError) {
+          if (verbose) importSpinnerId = createProgressIndicator('indeterminate', 0, `Importing ${journeyId}...`);
+          stopProgressIndicator(importSpinnerId, `${importError}`, 'fail');
+        }
       } else {
-        failSpinner(`Unresolved dependencies:`);
+        stopProgressIndicator(depSpinnerId, `Unresolved dependencies:`, 'fail');
         for (const journey of Object.keys(unresolvedJourneys)) {
           printMessage(`  ${journey} requires ${unresolvedJourneys[journey]}`, 'error');
         }
       }
     } else {
-      showSpinner(`Importing...`);
-      failSpinner(`No journeys found!`);
+      const importSpinnerId = createProgressIndicator('indeterminate', 0, `Importing...`);
+      stopProgressIndicator(importSpinnerId, `No journeys found!`, 'fail');
     }
     // end dependency resolution for single tree import
-  });
+  } catch (error) {
+    printMessage(`Error importing first journey: ${error}`, 'error');
+  }
 }
 
 /**
@@ -268,11 +284,27 @@ export async function importFirstJourneyFromFile(file, options) {
  * @param {TreeImportOptions} options import options
  */
 export async function importJourneysFromFile(file, options) {
-  fs.readFile(file, 'utf8', (err, data) => {
-    if (err) throw err;
-    const fileData = JSON.parse(data);
-    frodo.authn.journey.importAllJourneys(fileData.trees, 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');
+      }
+    }
+  } catch (error) {
+    printMessage(`Error importing journeys: ${error}`, 'error');
+  }
 }
 
 /**
@@ -280,8 +312,8 @@ export async function importJourneysFromFile(file, options) {
  * @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 names = fs.readdirSync(getWorkingDirectory());
+  const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.journey.json')).map(name => getFilePath(name));
   const allJourneysData = {
     trees: {}
   };
@@ -289,7 +321,12 @@ export async function importJourneysFromFiles(options) {
     const journeyData = JSON.parse(fs.readFileSync(file, 'utf8'));
     allJourneysData.trees[journeyData.tree._id] = journeyData;
   }
-  frodo.authn.journey.importAllJourneys(allJourneysData.trees, options);
+  try {
+    await importJourneys(allJourneysData, options);
+  } 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');
+  }
 }
 
 /**
@@ -298,7 +335,7 @@ export async function importJourneysFromFiles(options) {
  * @returns {string[]} Colored string array of classifications
  */
 export function getJourneyClassification(journey) {
-  return frodo.authn.journey.getJourneyClassification(journey).map(it => {
+  return _getJourneyClassification(journey).map(it => {
     switch (it) {
       case 'standard':
         return it['brightGreen'];
@@ -318,7 +355,7 @@ export function getJourneyClassification(journey) {
  * @returns {string[]} Colored string array of classifications
  */
 export function getJourneyClassificationMd(journey) {
-  return frodo.authn.journey.getJourneyClassification(journey).map(it => {
+  return _getJourneyClassification(journey).map(it => {
     switch (it) {
       case 'standard':
         return `:green_circle: \`${it}\``;
@@ -410,7 +447,7 @@ 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 = frodo.authn.journey.onlineTreeExportResolver) {
+export async function describeJourney(journeyData, resolveTreeExport = onlineTreeExportResolver) {
   var _journeyData$meta, _journeyData$tree$uiC, _journeyData$themes;
   const allNodes = {
     ...journeyData.nodes,
@@ -454,8 +491,13 @@ export async function describeJourney(journeyData, resolveTreeExport = frodo.aut
   }
 
   // Dependency Tree
-  const descendents = await frodo.authn.journey.getTreeDescendents(journeyData, resolveTreeExport);
-  describeTreeDescendents(descendents);
+  try {
+    const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
+    describeTreeDescendents(descendents);
+  } catch (error) {
+    printMessage(`Error resolving inner tree dependencies:`, 'error');
+    printMessage(error.stack, 'error');
+  }
 
   // Node Types
   if (Object.entries(nodeTypeMap).length) {
@@ -469,7 +511,7 @@ export async function describeJourney(journeyData, resolveTreeExport = frodo.aut
   if (Object.entries(allNodes).length) {
     printMessage(`\nNodes (${Object.entries(allNodes).length}):`, 'data');
     for (const nodeObj of Object.values(allNodes)) {
-      printMessage(`- ${Node.getOneLineDescription(nodeObj, frodo.authn.journey.getNodeRef(nodeObj, journeyData))}`, 'data');
+      printMessage(`- ${Node.getOneLineDescription(nodeObj, getNodeRef(nodeObj, journeyData))}`, 'data');
     }
   }
 
@@ -537,7 +579,7 @@ export async function describeJourney(journeyData, resolveTreeExport = frodo.aut
  * @param {SingleTreeExportInterface} journeyData journey export object
  * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
  */
-export async function describeJourneyMd(journeyData, resolveTreeExport = frodo.authn.journey.onlineTreeExportResolver) {
+export async function describeJourneyMd(journeyData, resolveTreeExport = onlineTreeExportResolver) {
   var _journeyData$meta2, _journeyData$tree$uiC2, _journeyData$themes2;
   const allNodes = {
     ...journeyData.nodes,
@@ -574,7 +616,7 @@ export async function describeJourneyMd(journeyData, resolveTreeExport = frodo.a
   printMessage(`\n[![](./${journeyData.tree._id}.png)]()\n`, 'data');
 
   // Dependency Tree
-  const descendents = await frodo.authn.journey.getTreeDescendents(journeyData, resolveTreeExport);
+  const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
   printMessage(describeTreeDescendentsMd(descendents), 'data');
 
   // Node Types
@@ -592,7 +634,7 @@ export async function describeJourneyMd(journeyData, resolveTreeExport = frodo.a
     printMessage(`## Nodes (${Object.entries(allNodes).length})`, 'data');
     printMessage(Node.getTableHeaderMd(), 'data');
     for (const nodeObj of Object.values(allNodes)) {
-      printMessage(`${Node.getTableRowMd(nodeObj, frodo.authn.journey.getNodeRef(nodeObj, journeyData))}`, 'data');
+      printMessage(`${Node.getTableRowMd(nodeObj, getNodeRef(nodeObj, journeyData))}`, 'data');
     }
   }
 
@@ -650,4 +692,24 @@ export async function describeJourneyMd(journeyData, resolveTreeExport = frodo.a
     }
   }
 }
-//# sourceMappingURL=JourneyOps.js.map
+export async function enableJourney(journeyId) {
+  const indicatorId = createProgressIndicator('indeterminate', 0, `Enabling journey ${journeyId}...`);
+  if (_enableJourney(journeyId)) {
+    stopProgressIndicator(indicatorId, `Enabled journey ${journeyId}.`, 'success');
+    return true;
+  } else {
+    stopProgressIndicator(indicatorId, `Error enabling journey ${journeyId}`, 'fail');
+    return false;
+  }
+}
+export async function disableJourney(journeyId) {
+  const indicatorId = createProgressIndicator('indeterminate', 0, `Disabling journey ${journeyId}...`);
+  if (_disableJourney(journeyId)) {
+    stopProgressIndicator(indicatorId, `Disabled journey ${journeyId}.`, 'success');
+    return true;
+  } else {
+    stopProgressIndicator(indicatorId, `Error disabling journey ${journeyId}`, 'fail');
+    return false;
+  }
+}
+//# sourceMappingURL=JourneyOps.js.map