@rockcarver/frodo-cli 0.13.3 → 0.14.0

package/src/cli/theme/theme-delete.e2e.test_.ts

@@ -0,0 +1,178 @@
+// import { jest } from '@jest/globals';
+import { spawn, spawnSync } from 'child_process';
+
+const ansiEscapeCodes =
+  // eslint-disable-next-line no-control-regex
+  /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+/**
+ * Run once before running the suites in this file
+ */
+beforeAll(async () => {});
+
+/**
+ * Run before every test in every suite in this file
+ */
+beforeEach(async () => {
+  // delete all themes
+  const deleteThemesCmd = spawnSync('frodo', [
+    'theme',
+    'delete',
+    '--all',
+    'frodo-dev',
+  ]);
+  if (deleteThemesCmd.status > 0) {
+    console.error(deleteThemesCmd.stderr.toString());
+    console.log(deleteThemesCmd.stdout.toString());
+  }
+
+  // import test themes
+  const importTestThemesCmd = spawnSync(
+    'frodo',
+    ['theme', 'import', '--all-separate', 'frodo-dev'],
+    {
+      cwd: `test/e2e/theme/baseline`,
+    }
+  );
+  if (importTestThemesCmd.status > 0) {
+    console.error(importTestThemesCmd.stderr.toString());
+    console.log(importTestThemesCmd.stdout.toString());
+  }
+});
+
+describe('frodo theme delete', () => {
+  it('"frodo theme delete -n Zardoz": should delete the Zardoz theme', (done) => {
+    const deleteThemeCmd = spawn('frodo', [
+      'theme',
+      'delete',
+      '-n',
+      'Zardoz',
+      'frodo-dev',
+    ]);
+    const expected = ['✔ Deleted Zardoz.', ''].join('\n');
+    const chunks = [];
+    deleteThemeCmd.stderr.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    deleteThemeCmd.stderr.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toContain(expected);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it('"frodo theme delete -n DoesNotExist": should report an error that the theme does not exist', (done) => {
+    const deleteThemeCmd = spawn('frodo', [
+      'theme',
+      'delete',
+      '-n',
+      'DoesNotExist',
+      'frodo-dev',
+    ]);
+    const expected = ['✖ Error: DoesNotExist not found', ''].join('\n');
+    const chunks = [];
+    deleteThemeCmd.stderr.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    deleteThemeCmd.stderr.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toContain(expected);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it('"frodo theme delete -i 4ded6d91-ceea-400a-ae3f-42209f1b0e06": should delete the 4ded6d91-ceea-400a-ae3f-42209f1b0e06 (Zardoz) theme', (done) => {
+    const deleteThemeCmd = spawn('frodo', [
+      'theme',
+      'delete',
+      '-i',
+      '4ded6d91-ceea-400a-ae3f-42209f1b0e06',
+      'frodo-dev',
+    ]);
+    const expected = [
+      '✔ Deleted 4ded6d91-ceea-400a-ae3f-42209f1b0e06.',
+      '',
+    ].join('\n');
+    const chunks = [];
+    deleteThemeCmd.stderr.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    deleteThemeCmd.stderr.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toContain(expected);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it('"frodo theme delete -i 4ded6d91-ceea-400a-ae3f-42209f1b0e07": should report an error that the theme does not exist', (done) => {
+    const deleteThemeCmd = spawn('frodo', [
+      'theme',
+      'delete',
+      '-i',
+      '4ded6d91-ceea-400a-ae3f-42209f1b0e07',
+      'frodo-dev',
+    ]);
+    const expected = [
+      '✖ Error: 4ded6d91-ceea-400a-ae3f-42209f1b0e07 not found',
+      '',
+    ].join('\n');
+    const chunks = [];
+    deleteThemeCmd.stderr.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    deleteThemeCmd.stderr.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toContain(expected);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it('"frodo theme delete -a": should delete all themes', (done) => {
+    const deleteThemeCmd = spawn('frodo', [
+      'theme',
+      'delete',
+      '-a',
+      'frodo-dev',
+    ]);
+    const expected = ['✔ Deleted all realm themes.', ''].join('\n');
+    const chunks = [];
+    deleteThemeCmd.stderr.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+    deleteThemeCmd.stderr.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toContain(expected);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+});

package/src/cli/theme/theme-list.e2e.test_.ts

@@ -0,0 +1,119 @@
+// import { jest } from '@jest/globals';
+import { spawn, spawnSync } from 'child_process';
+
+const ansiEscapeCodes =
+  // eslint-disable-next-line no-control-regex
+  /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+/**
+ * delete all themes and import baseline and additional test themes
+ */
+beforeAll(async () => {
+  // delete all themes
+  const deleteThemesCmd = spawnSync('frodo', [
+    'theme',
+    'delete',
+    '--all',
+    'frodo-dev',
+  ]);
+  if (deleteThemesCmd.status > 0) {
+    console.error(deleteThemesCmd.stderr.toString());
+    console.log(deleteThemesCmd.stdout.toString());
+  }
+
+  // import baseline themes
+  const importBaselineThemesCmd = spawnSync(
+    'frodo',
+    ['theme', 'import', '--all-separate', 'frodo-dev'],
+    {
+      cwd: `test/e2e/theme/baseline`,
+    }
+  );
+  if (importBaselineThemesCmd.status > 0) {
+    console.error(importBaselineThemesCmd.stderr.toString());
+    console.log(importBaselineThemesCmd.stdout.toString());
+  }
+});
+
+describe('frodo theme list', () => {
+  it('"frodo theme list": should list the names of the default themes', (done) => {
+    const themeList = spawn('frodo', ['theme', 'list', 'frodo-dev']);
+    const expected = [
+      'Contrast',
+      'Highlander',
+      'Robroy',
+      'Starter Theme',
+      'Zardoz',
+      '',
+    ].join('\n');
+
+    const chunks = [];
+    themeList.stdout.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+
+    themeList.stdout.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toBe(expected);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  const expectedLong = [
+    'Name         │Id                                  │Default',
+    'Contrast     │cd6c93e2-52e2-4340-9770-66a588343841│       ',
+    'Highlander   │00203891-dde0-4114-b27a-219ae0b43a61│       ',
+    'Robroy       │b82755e8-fe9a-4d27-b66b-45e37ae12345│       ',
+    'Starter Theme│86ce2f64-586d-44fe-8593-b12a85aac68d│Yes    ',
+    'Zardoz       │4ded6d91-ceea-400a-ae3f-42209f1b0e06│       ',
+    '',
+  ].join('\n');
+
+  it('"frodo theme list -l": should list the names, ids, and default flag of the baseline themes', (done) => {
+    const themeList = spawn('frodo', ['theme', 'list', '-l', 'frodo-dev']);
+
+    const chunks = [];
+    themeList.stdout.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+
+    themeList.stdout.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toBe(expectedLong);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+
+  it('"frodo theme list --long": should list the names, status, and default flag of the baseline themes', (done) => {
+    const themeList = spawn('frodo', ['theme', 'list', '--long', 'frodo-dev']);
+
+    const chunks = [];
+    themeList.stdout.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+
+    themeList.stdout.on('end', () => {
+      const output = Buffer.concat(chunks)
+        .toString()
+        .replace(ansiEscapeCodes, '');
+      try {
+        expect(output).toBe(expectedLong);
+        done();
+      } catch (error) {
+        done(error);
+      }
+    });
+  });
+});

package/src/ops/CirclesOfTrustOps.ts

@@ -0,0 +1,12 @@
+// import { CircleOfTrustSkeleton } from "@rockcarver/frodo-lib/types/api/ApiTypes";
+import { TypesRaw } from '@rockcarver/frodo-lib';
+
+/**
+ * Get a one-line description of the circle of trust object
+ * @param {CircleOfTrustSkeleton} cotObj circle of trust object to describe
+ * @returns {string} a one-line description
+ */
+export function getOneLineDescription(cotObj: TypesRaw.CircleOfTrustSkeleton): string {
+  const description = `[${cotObj._id['brightCyan']}]`;
+  return description;
+}

package/src/ops/EmailTemplateOps.ts

@@ -0,0 +1,19 @@
+import { EmailTemplateSkeleton } from '@rockcarver/frodo-lib/types/api/ApiTypes';
+
+/**
+ * Get a one-line description of the email template
+ * @param {EmailTemplateSkeleton} templateObj email template object to describe
+ * @returns {string} a one-line description
+ */
+export function getOneLineDescription(
+  templateObj: EmailTemplateSkeleton
+): string {
+  const description = `[${templateObj._id.split('/')[1]['brightCyan']}] ${
+    templateObj.displayName ? templateObj.displayName : ''
+  } - ${
+    templateObj.defaultLocale
+      ? templateObj.subject[templateObj.defaultLocale]
+      : Object.values(templateObj.subject)[0]
+  }`;
+  return description;
+}

package/src/ops/IdpOps.ts

@@ -0,0 +1,11 @@
+import { SocialIdpSkeleton } from "@rockcarver/frodo-lib/types/api/ApiTypes";
+
+/**
+ * Get a one-line description of the social idp object
+ * @param {SocialIdpSkeleton} socialIdpObj social idp object to describe
+ * @returns {string} a one-line description
+ */
+export function getOneLineDescription(socialIdpObj: SocialIdpSkeleton): string {
+  const description = `[${socialIdpObj._id['brightCyan']}] ${socialIdpObj._type._id}`;
+  return description;
+}

package/src/ops/JourneyOps.ts

@@ -0,0 +1,278 @@
+import {
+  NodeSkeleton,
+  TreeSkeleton,
+} from '@rockcarver/frodo-lib/types/api/ApiTypes';
+import {
+  SingleTreeExportInterface,
+  TreeDependencyMapInterface,
+  TreeExportResolverInterface,
+} from '@rockcarver/frodo-lib/types/ops/OpsTypes';
+import { printMessage } from '../utils/Console';
+import { Journey, Types, state } from '@rockcarver/frodo-lib';
+import * as CirclesOfTrust from './CirclesOfTrustOps';
+import * as EmailTemplate from './EmailTemplateOps';
+import * as Idp from './IdpOps';
+import * as Node from './NodeOps';
+import * as Saml2 from './Saml2Ops';
+import * as Script from './ScriptOps';
+import * as Theme from './ThemeOps';
+
+const {
+  onlineTreeExportResolver,
+  getTreeDescendents,
+  getNodeRef,
+} = Journey;
+
+/**
+ * Get journey classification
+ * @param {SingleTreeExportInterface} journey journey export
+ * @returns {stringp[]} Colored string array of classifications
+ */
+export function getJourneyClassification(journey: SingleTreeExportInterface): string[] {
+  return Journey.getJourneyClassification(journey).map((it) => {
+    switch (it) {
+      case Types.JourneyClassification.STANDARD:
+        return it.toString()['brightGreen'];
+
+      case Types.JourneyClassification.CLOUD:
+        return it.toString()['brightMagenta'];
+
+      case Types.JourneyClassification.CUSTOM:
+        return it.toString()['brightRed'];
+
+      case Types.JourneyClassification.PREMIUM:
+        return it.toString()['brightYellow'];
+    }
+  });
+}
+
+/**
+ * Get a one-line description of the tree object
+ * @param {TreeSkeleton} treeObj circle of trust object to describe
+ * @returns {string} a one-line description
+ */
+export function getOneLineDescription(treeObj: TreeSkeleton): string {
+  const description = `[${treeObj._id['brightCyan']}]`;
+  return description;
+}
+
+/**
+ * Helper function to render a nested list of dependent trees
+ * @param {TreeDependencyMapInterface} descendents tree dependency map
+ * @param {number} depth level of nesting
+ */
+function describeTreeDescendents(
+  descendents: TreeDependencyMapInterface,
+  depth = 0
+) {
+  if (depth || Object.values(descendents)[0].length) {
+    // heading
+    if (depth === 0) {
+      printMessage(
+        `\nInner Tree Dependencies (${Object.values(descendents)[0].length}):`,
+        'data'
+      );
+    }
+    const indent = Array(depth * 2)
+      .fill(' ')
+      .join('');
+    const [tree] = Object.keys(descendents);
+    printMessage(`${indent}- ${tree['brightCyan']}`, 'data');
+    for (const descendent of descendents[tree]) {
+      describeTreeDescendents(descendent, depth + 1);
+    }
+  }
+}
+
+/**
+ * Describe a journey:
+ * - Properties, tags, description, name, metadata
+ * - Inner tree dependency tree
+ * - Node type summary
+ * - Nodes
+ * - Themes
+ * - Scripts
+ * - Email templates
+ * - Social identity providers
+ * - SAML2 entity providers
+ * - SAML2 circles of trust
+ * @param {SingleTreeExportInterface} journeyData journey export object
+ * @param {TreeExportResolverInterface} resolveTreeExport tree export resolver callback function
+ */
+export async function describeJourney(
+  journeyData: SingleTreeExportInterface,
+  resolveTreeExport: TreeExportResolverInterface = onlineTreeExportResolver
+): Promise<void> {
+  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;
+    }
+  }
+
+  // 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');
+  }
+
+  // Status
+  printMessage(
+    `\nStatus\n${
+      journeyData.tree.enabled === false
+        ? 'disabled'['brightRed']
+        : 'enabled'['brightGreen']
+    }`
+  );
+
+  // Classification
+  if (
+    !state.default.session.getAmVersion() &&
+    journeyData.meta?.originAmVersion
+  ) {
+    state.default.session.setAmVersion(journeyData.meta.originAmVersion);
+  }
+  if (state.default.session.getAmVersion()) {
+    printMessage(
+      `\nClassification\n${getJourneyClassification(journeyData).join(', ')}`,
+      'data'
+    );
+  }
+
+  // Categories/Tags
+  if (journeyData.tree.uiConfig?.categories && journeyData.tree.uiConfig.categories != '[]') {
+    printMessage('\nCategories/Tags', 'data');
+    printMessage(
+      `${
+        JSON.parse(journeyData.tree.uiConfig.categories).join(', ')
+      }`,
+      'data'
+    );
+  }
+
+  // Dependency Tree
+  const descendents = await getTreeDescendents(journeyData, resolveTreeExport);
+  describeTreeDescendents(descendents);
+
+  // Node Types
+  if (Object.entries(nodeTypeMap).length) {
+    printMessage(
+      `\nNode Types (${Object.entries(nodeTypeMap).length}):`,
+      'data'
+    );
+    for (const [nodeType, count] of Object.entries(nodeTypeMap)) {
+      printMessage(
+        `- ${String(count)} [${
+          nodeType['brightCyan']
+        }] (${Node.getNodeClassification(nodeType).join(', ')})`,
+        'data'
+      );
+    }
+  }
+
+  // Nodes
+  if (Object.entries(allNodes).length) {
+    printMessage(`\nNodes (${Object.entries(allNodes).length}):`, 'data');
+    for (const nodeObj of Object.values<NodeSkeleton>(allNodes)) {
+      printMessage(
+        `- ${Node.getOneLineDescription(
+          nodeObj,
+          getNodeRef(nodeObj, journeyData)
+        )}`,
+        'data'
+      );
+    }
+  }
+
+  // Themes
+  if (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');
+    }
+  }
+
+  // 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');
+    }
+  }
+
+  // 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'
+      );
+    }
+  }
+}

package/src/ops/NodeOps.ts

@@ -0,0 +1,47 @@
+import {
+  InnerNodeRefSkeletonInterface,
+  NodeRefSkeletonInterface,
+  NodeSkeleton,
+} from '@rockcarver/frodo-lib/types/api/ApiTypes';
+import { Node, Types } from '@rockcarver/frodo-lib';
+
+/**
+ * Get node classification
+ * @param {string} nodeType node type
+ * @returns {stringp[]} Colored string array of classifications
+ */
+export function getNodeClassification(nodeType: string): string[] {
+  return Node.getNodeClassification(nodeType).map((it) => {
+    switch (it) {
+      case Types.NodeClassification.STANDARD:
+        return it.toString()['brightGreen'];
+
+      case Types.NodeClassification.CLOUD:
+        return it.toString()['brightMagenta'];
+
+      case Types.NodeClassification.CUSTOM:
+        return it.toString()['brightRed'];
+
+      case Types.NodeClassification.PREMIUM:
+        return it.toString()['brightYellow'];
+    }
+  });
+}
+
+/**
+ * Get a one-line description of the node
+ * @param {NodeSkeleton} nodeObj node object to describe
+ * @param {NodeRefSkeletonInterface | InnerNodeRefSkeletonInterface} nodeRef node reference object
+ * @returns {string} a one-line description
+ */
+export function getOneLineDescription(
+  nodeObj: NodeSkeleton,
+  nodeRef?: NodeRefSkeletonInterface | InnerNodeRefSkeletonInterface
+): string {
+  const description = `[${nodeObj._id['brightCyan']}] (${getNodeClassification(
+    nodeObj._type._id
+  ).join(', ')}) ${nodeObj._type._id}${
+    nodeRef ? ' - ' + nodeRef?.displayName : ''
+  }`;
+  return description;
+}