@rockcarver/frodo-cli 0.10.4 → 0.11.1-2

package/src/cli/idm/idm-export.js

@@ -1,13 +1,13 @@
 import { Command, Option } from 'commander';
+import { Authenticate, Idm, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import {
+
+const { getTokens } = Authenticate;
+const {
   exportAllConfigEntities,
   exportAllRawConfigEntities,
   exportConfigEntity,
-} from '../../ops/IdmOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+} = Idm;
 
 const program = new Command('frodo idm export');
 
@@ -61,19 +61,19 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
         // export by id/name
         if (options.idmName) {
-          printMessage(
+          console.log(
             `Exporting object "${
               options.idmName
-            }" from realm "${storage.session.getRealm()}"...`
+            }" from realm "${state.default.session.getRealm()}"...`
           );
           exportConfigEntity(options.idmName, options.file);
         }
@@ -84,7 +84,7 @@ program
           options.entitiesFile &&
           options.envFile
         ) {
-          printMessage(
+          console.log(
             `Exporting IDM configuration objects specified in ${options.entitiesFile} into separate files in ${options.directory} using ${options.envFile} for variable replacement...`
           );
           exportAllConfigEntities(
@@ -95,14 +95,14 @@ program
         }
         // --all-separate -A without variable replacement
         else if (options.allSeparate && options.directory) {
-          printMessage(
+          console.log(
             `Exporting all IDM configuration objects into separate files in ${options.directory}...`
           );
           exportAllRawConfigEntities(options.directory);
         }
         // unrecognized combination of options or no options
         else {
-          printMessage(
+          console.log(
             'Unrecognized combination of options or no options...',
             'error'
           );

package/src/cli/idm/idm-list.js

@@ -1,9 +1,9 @@
 import { Command } from 'commander';
+import { Authenticate, Idm, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { listAllConfigEntities } from '../../ops/IdmOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
+
+const { getTokens } = Authenticate;
+const { listAllConfigEntities } = Idm;
 
 const program = new Command('frodo idm list');
 
@@ -23,14 +23,14 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
-        printMessage('Listing all IDM configuration objects...');
+        console.log('Listing all IDM configuration objects...');
         listAllConfigEntities();
       }
     }

package/src/cli/idp/idp-export.js

@@ -1,13 +1,9 @@
 import { Command, Option } from 'commander';
+import { Authenticate, Idp, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import {
-  exportProvider,
-  exportProvidersToFile,
-  exportProvidersToFiles,
-} from '../../ops/IdpOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+
+const { getTokens } = Authenticate;
+const { exportProvider, exportProvidersToFile, exportProvidersToFiles } = Idp;
 
 const program = new Command('frodo idp export');
 
@@ -48,35 +44,35 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
         // export by id/name
         if (options.idpId) {
-          printMessage(
+          console.log(
             `Exporting provider "${
               options.idpId
-            }" from realm "${storage.session.getRealm()}"...`
+            }" from realm "${state.default.session.getRealm()}"...`
           );
           exportProvider(options.idpId, options.file);
         }
         // --all -a
         else if (options.all) {
-          printMessage('Exporting all providers to a single file...');
+          console.log('Exporting all providers to a single file...');
           exportProvidersToFile(options.file);
         }
         // --all-separate -A
         else if (options.allSeparate) {
-          printMessage('Exporting all providers to separate files...');
+          console.log('Exporting all providers to separate files...');
           exportProvidersToFiles();
         }
         // unrecognized combination of options or no options
         else {
-          printMessage(
+          console.log(
             'Unrecognized combination of options or no options...',
             'error'
           );

package/src/cli/idp/idp-import.js

@@ -1,14 +1,14 @@
 import { Command, Option } from 'commander';
+import { Authenticate, Idp, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import {
+
+const { getTokens } = Authenticate;
+const {
   importProviderById,
   importFirstProvider,
   importProvidersFromFile,
   importProvidersFromFiles,
-} from '../../ops/IdpOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+} = Idp;
 
 const program = new Command('frodo idp import');
 
@@ -49,48 +49,48 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
         // import by id
         if (options.file && options.idpId) {
-          printMessage(
+          console.log(
             `Importing provider "${
               options.idpId
-            }" into realm "${storage.session.getRealm()}"...`
+            }" into realm "${state.default.session.getRealm()}"...`
           );
           importProviderById(options.idpId, options.file);
         }
         // --all -a
         else if (options.all && options.file) {
-          printMessage(
+          console.log(
             `Importing all providers from a single file (${options.file})...`
           );
           importProvidersFromFile(options.file);
         }
         // --all-separate -A
         else if (options.allSeparate && !options.file) {
-          printMessage(
+          console.log(
             'Importing all providers from separate files in current directory...'
           );
           importProvidersFromFiles();
         }
         // import first provider from file
         else if (options.file) {
-          printMessage(
+          console.log(
             `Importing first provider from file "${
               options.file
-            }" into realm "${storage.session.getRealm()}"...`
+            }" into realm "${state.default.session.getRealm()}"...`
           );
           importFirstProvider(options.file);
         }
         // unrecognized combination of options or no options
         else {
-          printMessage('Unrecognized combination of options or no options...');
+          console.log('Unrecognized combination of options or no options...');
           program.help();
         }
       }

package/src/cli/idp/idp-list.js

@@ -1,9 +1,9 @@
 import { Command } from 'commander';
+import { Authenticate, Idp, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import { listProviders } from '../../ops/IdpOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+
+const { getTokens } = Authenticate;
+const { listProviders } = Idp;
 
 const program = new Command('frodo idp list');
 
@@ -23,15 +23,15 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
-        printMessage(
-          `Listing providers in realm "${storage.session.getRealm()}"...`
+        console.log(
+          `Listing providers in realm "${state.default.session.getRealm()}"...`
         );
         listProviders();
       }

package/src/cli/info/info.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
+import { Authenticate, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+
+const { getTokens } = Authenticate;
 
 export default function setup() {
   const info = new Command('info');
@@ -16,32 +16,36 @@ export default function setup() {
     .addOption(common.scriptFriendlyOption)
     .description('Print versions and tokens.')
     .action(async (host, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
-      storage.session.setItem('scriptFriendly', options.scriptFriendly);
+      state.default.session.setTenant(host);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setItem('scriptFriendly', options.scriptFriendly);
       if (!options.scriptFriendly) {
-        printMessage('Printing versions and tokens...');
+        console.log('Printing versions and tokens...');
         if (await getTokens()) {
-          printMessage(`Cookie name: ${storage.session.getCookieName()}`);
-          printMessage(`Session token: ${storage.session.getCookieValue()}`);
-          if (storage.session.getBearerToken()) {
-            printMessage(`Bearer token: ${storage.session.getBearerToken()}`);
+          console.log(`Cookie name: ${state.default.session.getCookieName()}`);
+          console.log(
+            `Session token: ${state.default.session.getCookieValue()}`
+          );
+          if (state.default.session.getBearerToken()) {
+            console.log(
+              `Bearer token: ${state.default.session.getBearerToken()}`
+            );
           }
         } else {
           process.exitCode = 1;
         }
       } else if (await getTokens()) {
         const output = {
-          cookieName: storage.session.getCookieName(),
-          sessionToken: storage.session.getCookieValue(),
+          cookieName: state.default.session.getCookieName(),
+          sessionToken: state.default.session.getCookieValue(),
         };
-        if (storage.session.getBearerToken()) {
-          output.bearerToken = storage.session.getBearerToken();
+        if (state.default.session.getBearerToken()) {
+          output.bearerToken = state.default.session.getBearerToken();
         }
-        printMessage(JSON.stringify(output, null, 2), 'data');
+        console.log(JSON.stringify(output, null, 2), 'data');
       } else {
         process.exitCode = 1;
       }

package/src/cli/journey/journey-delete.js

@@ -1,9 +1,9 @@
 import { Command, Option } from 'commander';
+import { Authenticate, Journey, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import { deleteJourney, deleteJourneys } from '../../ops/JourneyOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+
+const { getTokens } = Authenticate;
+const { deleteJourney, deleteJourneys } = Journey;
 
 const program = new Command('frodo journey delete');
 
@@ -44,30 +44,30 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
         // delete by id
         if (options.journeyId) {
-          printMessage(
+          console.log(
             `Deleting journey ${
               options.journeyId
-            } in realm "${storage.session.getRealm()}"...`
+            } in realm "${state.default.session.getRealm()}"...`
           );
           deleteJourney(options.journeyId, options);
         }
         // --all -a
         else if (options.all) {
-          printMessage('Deleting all journeys...');
+          console.log('Deleting all journeys...');
           deleteJourneys(options);
         }
         // unrecognized combination of options or no options
         else {
-          printMessage('Unrecognized combination of options or no options...');
+          console.log('Unrecognized combination of options or no options...');
           program.help();
         }
       }

package/src/cli/journey/journey-describe.js

@@ -1,19 +1,10 @@
 import fs from 'fs';
 import { Command, Option } from 'commander';
+import { Authenticate, Journey, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import {
-  listJourneys,
-  getJourneyData,
-  describeTree,
-} from '../../ops/JourneyOps.js';
-import storage from '../../storage/SessionStorage.js';
-import {
-  printMessage,
-  createProgressBar,
-  updateProgressBar,
-  stopProgressBar,
-} from '../../ops/utils/Console.js';
+
+const { getTokens } = Authenticate;
+const { listJourneys, getJourneyData, describeTree } = Journey;
 
 const program = new Command('frodo journey describe');
 
@@ -50,68 +41,68 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       const treeDescription = [];
       // TODO: review checks for arguments
       if (typeof host === 'undefined' || typeof options.file !== 'undefined') {
         if (typeof options.file === 'undefined') {
-          printMessage(
+          console.log(
             'You either need <host> or -f when using describe',
             'error'
           );
           return;
         }
-        printMessage(`Describing local journey file ${options.file}...`);
+        console.log(`Describing local journey file ${options.file}...`);
         try {
           const data = fs.readFileSync(options.file, 'utf8');
           const journeyData = JSON.parse(data);
           treeDescription.push(describeTree(journeyData));
         } catch (err) {
-          printMessage(err, 'error');
+          console.log(err, 'error');
         }
       } else if (await getTokens()) {
-        printMessage(
-          `Describing journey(s) in realm "${storage.session.getRealm()}"...`
+        console.log(
+          `Describing journey(s) in realm "${state.default.session.getRealm()}"...`
         );
         if (typeof options.journeyId === 'undefined') {
           const journeyList = await listJourneys(false);
-          createProgressBar(journeyList.length, '');
+          // createProgressBar(journeyList.length, '');
           for (const item of journeyList) {
             // eslint-disable-next-line no-await-in-loop
             const journeyData = await getJourneyData(item.name);
             treeDescription.push(describeTree(journeyData));
-            updateProgressBar(`Analyzing journey - ${item.name}`);
+            // updateProgressBar(`Analyzing journey - ${item.name}`);
           }
-          stopProgressBar('Done');
+          // stopProgressBar('Done');
         } else {
           const journeyData = await getJourneyData(options.journeyId);
           treeDescription.push(describeTree(journeyData));
         }
       }
       for (const item of treeDescription) {
-        printMessage(`\nJourney: ${item.treeName}`, 'info');
-        printMessage('========');
-        printMessage('\nNodes:', 'info');
+        console.log(`\nJourney: ${item.treeName}`, 'info');
+        console.log('========');
+        console.log('\nNodes:', 'info');
         if (Object.entries(item.nodeTypes).length) {
           for (const [name, count] of Object.entries(item.nodeTypes)) {
-            printMessage(`- ${name}: ${count}`, 'info');
+            console.log(`- ${name}: ${count}`, 'info');
           }
         }
         if (Object.entries(item.scripts).length) {
-          printMessage('\nScripts:', 'info');
+          console.log('\nScripts:', 'info');
           for (const [name, desc] of Object.entries(item.scripts)) {
-            printMessage(`- ${name}: ${desc}`, 'info');
+            console.log(`- ${name}: ${desc}`, 'info');
           }
         }
         if (Object.entries(item.emailTemplates).length) {
-          printMessage('\nEmail Templates:', 'info');
+          console.log('\nEmail Templates:', 'info');
           for (const [id] of Object.entries(item.emailTemplates)) {
-            printMessage(`- ${id}`, 'info');
+            console.log(`- ${id}`, 'info');
           }
         }
       }

package/src/cli/journey/journey-export.js

@@ -1,13 +1,10 @@
 import { Command, Option } from 'commander';
+import { Authenticate, Journey, state } from '@rockcarver/frodo-lib';
 import * as common from '../cmd_common.js';
-import { getTokens } from '../../ops/AuthenticateOps.js';
-import {
-  exportJourneyToFile,
-  exportJourneysToFile,
-  exportJourneysToFiles,
-} from '../../ops/JourneyOps.js';
-import storage from '../../storage/SessionStorage.js';
-import { printMessage } from '../../ops/utils/Console.js';
+
+const { getTokens } = Authenticate;
+const { exportJourneyToFile, exportJourneysToFile, exportJourneysToFiles } =
+  Journey;
 
 const program = new Command('frodo journey export');
 
@@ -66,17 +63,17 @@ program
   .action(
     // implement command logic inside action handler
     async (host, realm, user, password, options) => {
-      storage.session.setTenant(host);
-      storage.session.setRealm(realm);
-      storage.session.setUsername(user);
-      storage.session.setPassword(password);
-      storage.session.setDeploymentType(options.type);
-      storage.session.setAllowInsecureConnection(options.insecure);
+      state.default.session.setTenant(host);
+      state.default.session.setRealm(realm);
+      state.default.session.setUsername(user);
+      state.default.session.setPassword(password);
+      state.default.session.setDeploymentType(options.type);
+      state.default.session.setAllowInsecureConnection(options.insecure);
       if (await getTokens()) {
         // export
         if (options.journeyId) {
-          printMessage('Exporting journey...');
-          exportJourneyToFile(options.journeyId, options.file, {
+          console.log('Exporting journey...');
+          await exportJourneyToFile(options.journeyId, options.file, {
             useStringArrays: options.useStringArrays,
             deps: options.deps,
             verbose: options.verbose,
@@ -84,8 +81,8 @@ program
         }
         // --all -a
         else if (options.all) {
-          printMessage('Exporting all journeys to a single file...');
-          exportJourneysToFile(options.file, {
+          console.log('Exporting all journeys to a single file...');
+          await exportJourneysToFile(options.file, {
             useStringArrays: options.useStringArrays,
             deps: options.deps,
             verbose: options.verbose,
@@ -93,8 +90,8 @@ program
         }
         // --all-separate -A
         else if (options.allSeparate) {
-          printMessage('Exporting all journeys to separate files...');
-          exportJourneysToFiles({
+          console.log('Exporting all journeys to separate files...');
+          await exportJourneysToFiles({
             useStringArrays: options.useStringArrays,
             deps: options.deps,
             verbose: options.verbose,
@@ -102,7 +99,7 @@ program
         }
         // unrecognized combination of options or no options
         else {
-          printMessage('Unrecognized combination of options or no options...');
+          console.log('Unrecognized combination of options or no options...');
           program.help();
         }
       }