@contrail/cli 1.0.39 → 1.0.41

package/src/apps/install-app/app-installer.ts

@@ -1,8 +1,10 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { Entities } from '@contrail/sdk';
-import {authUser} from '../../auth/login';
-import { deleteAppOrg, getAvailableApps, getInstalledApps, installAppToOrg } from '../app-api';
+import { authUser } from '../../auth/login';
+import { deleteAppOrg, getAvailableApps, getInstalledApps, getWorkflowTemplateDefinitionsForApp, installAppToOrg } from '../../api/apps';
+import { App } from '../../interfaces';
+import { WorkflowTemplateDefinitionDeployer } from '../../workflow-template-definitions/workflow-template-definition-deployer';
 
 async function getConfigProperties(app) {
   const config = {};
@@ -30,14 +32,14 @@ export async function uninstallApp() {
     message: 'Which app would you like to uninstall?',
     choices: installedApps.map(x => x.app.identifier)
   }]);
-  const appToDelete = installedApps.find(x=> x.app.identifier === answers.appIdentifier);
+  const appToDelete = installedApps.find(x => x.app.identifier === answers.appIdentifier);
   console.log('%s Uninstalling app', chalk.green.bold('APP INSTALLATION'));
   await deleteAppOrg(appToDelete.id);
   // eslint-disable-next-line no-constant-condition
   while (true) {
     await delay(1000);
-    try{
-      const appStillDeleting = await new Entities().get({entityName: 'app-org', id: appToDelete.id});
+    try {
+      const appStillDeleting = await new Entities().get({ entityName: 'app-org', id: appToDelete.id });
       if (!appStillDeleting) {
         break;
       }
@@ -52,7 +54,7 @@ export async function uninstallApp() {
 
 export async function installApp() {
   await authUser();
-  const apps = await getAvailableApps();
+  const apps: App[] = await getAvailableApps();
   if (!apps.length) {
     throw new Error('No apps are available to install...');
   }
@@ -70,7 +72,7 @@ export async function installApp() {
     message: 'Which app would you like to install?',
     choices: installableApps.map(x => x.identifier)
   });
-  const answers = await inquirer.prompt(questions);
+  let answers = await inquirer.prompt(questions);
   const app = installableApps.find(x => x.identifier === answers.appIdentifier);
   let configProperties: any;
   if (app.configProperties) {
@@ -82,24 +84,43 @@ export async function installApp() {
   // eslint-disable-next-line no-constant-condition
   while (true) {
     await delay(1000);
-    try{
-      const installingApp = await new Entities().get({entityName: 'app-org', id: appOrg.id});
+    try {
+      const installingApp = await new Entities().get({ entityName: 'app-org', id: appOrg.id });
       if (installingApp.status === 'READY') {
         console.log('%s App installed', chalk.green.bold('APP INSTALLATION'));
-        return;
+        break;
       }
-      if(installingApp.status === 'FAILED_INSTALLING') {
+      if (installingApp.status === 'FAILED_INSTALLING') {
         console.log('%s App installation failed', chalk.red.bold('APP INSTALLATION'));
         return;
       }
       process.stdout.write('.');
     } catch (e) {
+      console.log('%s App installation failed', chalk.red.bold('APP INSTALLATION'));
       console.log('Error is:', e);
-      break;
+      return;
     }
   }
+
+  const workflowTemplateDefinitions = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
+  if (!workflowTemplateDefinitions.length) {
+    return;
+  }
+  answers = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'shouldInstallWorkflows',
+    message: 'Would you like to install the Workflows associated with this app?',
+    default: false
+  }]);
+
+  if (!answers.shouldInstallWorkflows) {
+    console.log('%s Not installing associated app workflows', chalk.yellow.bold('APP INSTALLATION'));
+    return;
+  }
+
+  new WorkflowTemplateDefinitionDeployer().installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
 }
 
 function delay(ms: number) {
-  return new Promise( resolve => setTimeout(resolve, ms) );
+  return new Promise(resolve => setTimeout(resolve, ms));
 }

package/src/apps/upgrade-app/app-upgrader.ts

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { Entities } from '@contrail/sdk';
 import { authUser } from '../../auth/login';
-import { deleteAppOrg, getAppVersions, getAvailableApps, getInstalledApps, installAppToOrg, upgradeAppVersion } from '../app-api';
+import { deleteAppOrg, getAppVersions, getAvailableApps, getInstalledApps, installAppToOrg, upgradeAppVersion } from '../../api/apps';
 
 async function getConfigProperties(app) {
   const config = {};

package/src/cli.ts

@@ -7,12 +7,13 @@ import { UploadOptionSets } from './types/option-set-uploader';
 import { ParseOptionSetsLocalFiles } from './types/option-set-parser';
 import { MergeOptionSets } from './types/option-set-merger';
 import { MergeTypeProperties } from './types/types-properties-merger';
-import { ParseTypesFromFiles, ParseTypesFromLocalFiles, ParseTypesFromTemplateFromLocalFiles } from './types/parse-types';
+import { ParseTypesFromFiles, ParseTypesFromLocalFiles, ParseTypesFromTemplateFromLocalFiles, ParseTypesFromTemplateAndDataFromLocalFiles } from './types/parse-types';
 import { loadColors, deleteColors } from './colors/color-loader';
-import { listConfig, removeConfig } from './config/configCommands';
-import { deleteWorkflowTemplate, deployWorkflowTemplate, listWorkflowTemplate } from './workflows/workflowCommands';
+import { listConfig, removeConfig, setConfig } from './config/configCommands';
+import { deleteWorkflowTemplates, localDeployWorkflowTemplate, listWorkflowTemplate } from './workflow-templates/workflow-template-commands';
 import { installApp, uninstallApp } from './apps/install-app/app-installer';
 import { upgradeApp } from './apps/upgrade-app/app-upgrader';
+import { cliInstallWorkflowTemplateDefinitions, listWorkflowTemplateDefinitions } from './workflow-template-definitions/workflow-template-definition-commands';
 const cliUsage = require('command-line-usage');
 
 /**
@@ -22,8 +23,6 @@ const cliUsage = require('command-line-usage');
 
 export async function cli(args) {
   const fullCommand = args[2];
-  let domain;
-  let command;
   if (!fullCommand) {
     printIllegalCommand();
     return;
@@ -35,13 +34,18 @@ export async function cli(args) {
     return;
   }
 
-  if (commandParts?.length < 2 && commandParts[0].toLowerCase() !== 'help' && commandParts[0].toLowerCase() !== '-help' && commandParts[0].toLowerCase() !== '--help') {
+  if (
+    commandParts?.length < 2 &&
+    commandParts[0].toLowerCase() !== 'help' &&
+    commandParts[0].toLowerCase() !== '-help' &&
+    commandParts[0].toLowerCase() !== '--help'
+  ) {
     printIllegalCommand();
     return;
   }
 
-  domain = commandParts[0];
-  command = commandParts[1];
+  const domain = commandParts[0];
+  const command = commandParts[1];
 
   switch (domain) {
   case 'app': {
@@ -102,6 +106,10 @@ export async function cli(args) {
       ParseTypesFromTemplateFromLocalFiles(args);
       break;
     }
+    case 'parseTypesFromTemplateAndDataFromLocalFiles': {
+      ParseTypesFromTemplateAndDataFromLocalFiles(args);
+      break;
+    }
     case 'parseTypesFromFiles': {
       ParseTypesFromFiles(args);
       break;
@@ -140,11 +148,11 @@ export async function cli(args) {
   case 'workflow-templates': {
     switch (command) {
     case 'load': {
-      await deployWorkflowTemplate();
+      await localDeployWorkflowTemplate();
       break;
     }
     case 'delete': {
-      await deleteWorkflowTemplate();
+      await deleteWorkflowTemplates();
       break;
     }
     case 'list': {
@@ -157,12 +165,32 @@ export async function cli(args) {
     }
     break;
   }
+  case 'workflow-template-definitions': {
+    switch (command) {
+    case 'install': {
+      await cliInstallWorkflowTemplateDefinitions();
+      break;
+    }
+    case 'list': {
+      await listWorkflowTemplateDefinitions();
+      break;
+    }
+    default: {
+      printIllegalCommand();
+    }
+    }
+    break;
+  }
   case 'config': {
     switch (command) {
     case 'list': {
       await listConfig();
       break;
     }
+    case 'set': {
+      await setConfig(args);
+      break;
+    }
     case 'remove': {
       await removeConfig(args);
       break;
@@ -218,55 +246,105 @@ const helpSections = [
   {
     header: 'App Commands - Domain: app',
     content: [
-      'create                       Create a new app workspace.',
-      'deploy                       Deploy your app.',
-      'deploy [OPTIONS]             --template-only deploy event workflow as',
-      '.                            a template directly to the org',
-      'deploy                       Deploy your app.',
-      'remove                       Remove your app.',
-      'install                      Install an app to your org.',
-      'uninstall                    Uninstall an app from your org.',
+      {
+        name: 'create',
+        summary: 'Create a new app workspace.'
+      },
+      {
+        name: 'deploy [--template-only]',
+        summary: 'Deploy your app. --template-only can be used to deploy event workflow as a template directly to the org'
+      },
+      {
+        name: 'remove',
+        summary: 'Remove your app.'
+      },
+      {
+        name: 'install',
+        summary: 'Install an app to your org.'
+      },
+      {
+        name: 'uninstall',
+        summary: 'Uninstall an app from your org.'
+      },
     ],
   },
   {
     header: 'Colors Commands - Domain: colors',
-    content: [
-      'load                         Load colors from a CSV. Headers (name, hex, red,',
-      '.                            green, blue) are required.',
-      // 'delete                       Delete all colors.',
+    content: [{
+      name: 'load',
+      summary: 'Load colors from a CSV. Headers (name, hex, red, green, blue) are required'
+    }
+    // , {name: 'delete', summary: 'Delete all colors.'}
     ],
   },
   {
     header: 'Workflow Template Commands - Domain: workflow-templates',
     content: [
-      'deploy                       Deploy your workflow. Assumes a workflow.yml file.',
-      'delete                       Removes the workflows in the workflow.yml file.',
-      'list                         Lists the workflow templates in the org',
+      {
+        name: 'deploy',
+        summary: 'Deploy your workflow. Assumes a workflow.yml file.'
+      },
+      {
+        name: 'delete',
+        summary: 'Removes the workflows in the workflow.yml file.'
+      },
+      {
+        name: 'list',
+        summary: 'Lists the workflow templates in the org'
+      },
+    ],
+  },
+  {
+    header: 'Workflow Template Definition Commands - Domain: workflow-template-definitions',
+    content: [{
+      name: 'install',
+      summary: 'Install the template definitions of an app to your org'
+    },
+    {
+      name: 'list',
+      summary: 'Lists the workflow templates in the org'
+    }
     ],
   },
   {
     header: 'Type Commands - Domain: types',
     content: [
-      'getAll                       Get all OptionSets and Types for your Org.',
-      'uploadTypes                  Upload Types for your Org.',
-      '.                            Types are uploaded from types.yml\n',
-      'uploadOptionSets             Upload OptionSets for your Org.',
-      '.                            OptionSets are loaded from option_sets.yml\n',
-      'parseOptionSetsLocalFiles <File Paths>  Parse CSV files into OptionSets',
-      'parseTypesFromLocalFiles <File Paths>   Parse CSV files into Types and ',
-      '.                                       OptionSets from local files.\n',
-      'parseTypesFromTemplateFromLocalFiles <File Paths> Parse CSV files into ',
-      '.                                       Types and OptionSets from local files.\n',
-      'parseTypesFromFiles <fileIds>           Parse CSV files into Types and ',
-      '.                                       OptionSets from VibeIQ Files.\n',
-      'mergeOptionSets <File Path>             Merge the OptionSets from an existing',
-      '.                                       org and the OptionSets passed in.',
-      '.                                       File must be .yml\n',
-      'mergeTypeProperties <File Path> <TypePaths> ',
-      '.                                       Merge the TypeProperties from an existing',
-      '.                                       org and the TypeProperties passed in.',
-      '.                                       Add to Types via TypePath',
-      '.                                       File must be .yml\n',
+      {
+        name: 'getAll',
+        summary: 'Get all OptionSets and Types for your Org.'
+      },
+      {
+        name: 'uploadTypes',
+        summary: 'Upload Types for your Org. Types are uploaded from types.yml\n'
+      },
+      {
+        name: 'uploadOptionSets',
+        summary: 'Upload OptionSets for your Org. OptionSets are loaded from option_sets.yml\n'
+      },
+      {
+        name: 'parseOptionSetsLocalFiles <File Paths>',
+        summary: 'Parse CSV files into OptionSets'
+      },
+      {
+        name: 'parseTypesFromLocalFiles <File Paths>',
+        summary: 'Parse CSV files into Types and OptionSets from local files.\n'
+      },
+      {
+        name: 'parseTypesFromTemplateFromLocalFiles <File Paths>',
+        summary: 'Parse CSV files into Types and OptionSets from local type template files.\n'
+      },
+      {
+        name: 'parseTypesFromTemplateAndDataFromLocalFiles <File Paths>',
+        summary: 'Parse CSV files into Types and OptionSets from local type template and data files.\n'
+      },
+      {
+        name: 'parseTypesFromFiles <fileIds>',
+        summary: 'Parse CSV files into Types and OptionSets from VibeIQ Files.\n File must be .yml\n'
+      },
+      {
+        name: 'mergeTypeProperties <File Path> <TypePaths>',
+        summary: 'Merge the TypeProperties from an existing org and the TypeProperties passed in. Add to Types via TypePath File must be .yml\n'
+      },
     ],
   },
 ];

package/src/config/config.ts

@@ -38,7 +38,7 @@ export async function readVibeIQConfig() {
   }
 }
 
-export async function writeVibeIQConfig(config: Object) {
+export async function writeVibeIQConfig(config: any) {
   try {
     await fsPromises.writeFile(configFileLocation, JSON.stringify(config, null, 2));
   } catch (e) {
@@ -60,7 +60,7 @@ export async function deleteConfigs(configNames: string[]) {
   await storeConfig(currentConfig, false);
 }
 
-export async function storeConfig(incomingConfig: Object, merge=true) {
+export async function storeConfig(incomingConfig: any, merge=true) {
   let config;
   if (merge) {
     config = {

package/src/config/configCommands.ts

@@ -1,8 +1,33 @@
-import {deleteConfigs, readVibeIQConfig} from './config';
+import {deleteConfigs, readVibeIQConfig, storeConfig} from './config';
 export async function listConfig() {
   console.log(await readVibeIQConfig());
 }
 
+export async function setConfig(args) {
+  const helpConfigLine = `
+    Usage: 
+      contrail config.set key1=value1 key2=value2
+  `;
+  if (args?.length < 4) {
+    console.log(helpConfigLine);
+    throw new Error('You need to pass at least one config to set');
+  }
+  const configsToSet = args.slice(3);
+  const config = {};
+  for(const conf of configsToSet) {
+    if(conf.length < 3 || conf.indexOf('=') <= 0) {
+      console.log(helpConfigLine);
+      throw new Error(`value ${conf} does not adhere to key1=value1 standard`);
+    }
+    const [key, value] = conf.split('=');
+    console.log('key and value:', key, value);
+    console.log(conf.split('='));
+    config[key] = value;
+  }
+  console.log('config is:', config);
+  await storeConfig(config);
+}
+
 export async function removeConfig(args) {
   if (args?.length < 4) {
     throw new Error('At least one configuration must be included to be removed.');

package/src/interfaces.ts

@@ -14,7 +14,7 @@ export interface AppDeclaration {
   actions?: { [key: string]: AppActionDeclaration };
   appConfiguration: ConfigPropertyElements;
   triggers: { [key: string]: AppTriggerDeclaration };
-  workflows?: { [key: string]: WorkflowDefinition|WorkflowTemplateDeclaration };
+  workflows?: { [key: string]: WorkflowDefinition | WorkflowTemplateDeclaration };
   dockerImageRef?: string;
 }
 
@@ -23,9 +23,9 @@ export interface ConfigPropertyElements {
 }
 
 export interface ConfigPropertyElement {
-	propertyType: string;
-	options?: any[];
-	label: string;
+  propertyType: string;
+  options?: any[];
+  label: string;
   dynamic?: boolean;
 }
 
@@ -45,6 +45,7 @@ export interface AppTriggerDeclaration {
   description?: string;
 }
 
+// workflow-template and workflow-template-definition share the same interface
 export interface WorkflowDefinition {
   id?: string;
   identifier: string;
@@ -65,7 +66,7 @@ export interface WorkflowTemplateDeclaration {
 
 export interface WorkflowTemplate {
   id?: string;
-  identifier: string;
+  identifier?: string;
   name: string;
   triggerKey: string;
   workflowDefinition: WorkflowDefinitionPaths;
@@ -87,7 +88,7 @@ export interface WorkflowConditional {
 export interface ActionDefinitionConfig {
   name: string;
   action: string;
-  config?: {[key: string]: any};
+  config?: { [key: string]: any };
   id?: string;
 }
 
@@ -104,6 +105,75 @@ export interface App {
   triggerKeyDefinitions?: TriggerKeyDefinition[];
 }
 
+export interface AppOrg {
+  id: string;
+  createdOn?: Date;
+  updatedOn?: Date;
+  createdById?: string;
+  updatedById?: string;
+  createdBy?: any;
+  updatedBy?: any;
+  orgId?: string;
+  status: AppOrgStatus;
+  appId?: string;
+  app?: App;
+  appVersionId?: string;
+  appVersion?: AppVersion;
+  apiKey?: AppApiKey;
+  appConfig?: any;
+}
+
+export enum AppOrgStatus {
+  INSTALLING = 'INSTALLING',
+  FAILED_INSTALLING = 'FAILED_INSTALLING',
+  READY = 'READY',
+  DELETING = 'DELETING',
+  FAILED_DELETING = 'FAILED_DELETING',
+}
+
+export enum AppVersionStatus {
+  PUBLISHING = 'PUBLISHING',
+  FAILED_PUBLISHING = 'FAILED_PUBLISHING',
+  PUBLISHED = 'PUBLISHED',
+  ARCHIVING = 'ARCHIVING',
+  FAILED_ARCHIVING = 'FAILED_ARCHIVING',
+  ARCHIVED = 'ARCHIVED',
+}
+
+export class AppVersion {
+  id: string;
+  createdOn?: Date;
+  updatedOn?: Date;
+  createdById?: string;
+  updatedById?: string;
+  createdBy?: any;
+  updatedBy?: any;
+  orgId?: string;
+  appId?: string;
+  app?: App;
+  appOrgs?: AppOrg[];
+  versionNumber: number;
+  status: AppVersionStatus;
+  eventWorkflowTriggerKeyMapping: string;
+  configProperties?: ConfigProperty[];
+  triggerKeyDefinitions?: TriggerKeyDefinition[];
+  dockerImageRef?: string;
+}
+
+export class AppApiKey {
+  id: string;
+  createdOn?: Date;
+  updatedOn?: Date;
+  createdById?: string;
+  updatedById?: string;
+  createdBy?: any;
+  updatedBy?: any;
+  orgId?: string;
+  appOrgId?: string;
+  appOrg?: AppOrg;
+  apiKey?: string;
+}
+
 export class ConfigProperty {
   slug: string;
   propertyType: string;

package/src/types/parse-types.ts

@@ -1,4 +1,4 @@
-import { GetSuggestedTypes, GetTypesFromTemplate } from '@contrail/types';
+import { GetSuggestedTypes, GetTypesFromTemplate, GetTypesFromTemplateWithOptionSetsFromData } from '@contrail/types';
 import chalk from 'chalk';
 import fs from 'fs';
 import { getSeparatorByPlatform } from '../common';
@@ -76,6 +76,30 @@ export async function ParseTypesFromTemplateFromLocalFiles(args) {
   console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
 }
 
+export async function ParseTypesFromTemplateAndDataFromLocalFiles(args) {
+  try {
+    if (args?.length < 5) {
+      throw new Error('File names must be included.');
+    }
+    console.log('%s Parsing', chalk.yellow.bold('TYPES AND OPTION SETS'));
+    const templateFileLocation = args[3];
+    const dataFileLocations = (args as Array<string>).slice(4);
+
+    console.log('Using Template File Location: ', templateFileLocation);
+    console.log('Using Data File Location: ', dataFileLocations);
+
+    await parseTypesFromTemplateAndDataFromLocalFiles(templateFileLocation, dataFileLocations);
+    console.log('%s Parsed', chalk.yellow.bold('TYPES AND OPTION SETS'));
+
+  }
+  catch (e) {
+    console.log(`%s Parsing Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
+}
+
 async function loadDataFromLocalCSV(fileName) {
   const CURRENT_DIR = process.cwd();
   try {
@@ -137,6 +161,39 @@ async function parseTypesFromTemplateFromLocalFiles(templateFileLocation: string
   saveData({ TypePropertiesByEntity: types.TypePropertiesByEntity }, 'parsed_TypePropertiesByEntity.yml');
 }
 
+async function parseTypesFromTemplateAndDataFromLocalFiles(templateFileLocation: string, dataFileLocations: string[]) {
+
+  let templateCSVData: any[] = [];
+  try {
+    console.log('Getting template from fileLocation: ', templateFileLocation);
+    templateCSVData = await loadDataFromLocalCSV(templateFileLocation);
+    console.log(`CSV import was successful. ${templateCSVData?.length} rows found.`);
+  }
+  catch (e) {
+    console.log('Error importing csv data.', e);
+    throw e;
+  }
+
+  const dataCSVData: any[] = [];
+  for (const dataFileLocation of dataFileLocations) {
+    try {
+      console.log('Getting data for dataFileLocation: ', dataFileLocation);
+      const csvData = await loadDataFromLocalCSV(dataFileLocation);
+
+      console.log(`CSV import was successful. ${csvData?.length} rows found. Adding to total rows.`);
+      dataCSVData.push(...csvData);
+    }
+    catch (e) {
+      console.log('Error importing csv data.', e);
+      throw e;
+    }
+  }
+
+  const types = GetTypesFromTemplateWithOptionSetsFromData(templateCSVData, dataCSVData);
+  saveData({ optionSets: types.OptionSets }, 'parsed_optionSets.yml');
+  saveData({ TypePropertiesByEntity: types.TypePropertiesByEntity }, 'parsed_TypePropertiesByEntity.yml');
+}
+
 async function parseTypesFromFiles(fileIds: string[]) {
   await authUser();
 

package/src/workflow-template-definitions/workflow-template-definition-commands.ts

@@ -0,0 +1,13 @@
+
+import { authUser } from '../auth/login';
+import { WorkflowTemplateDefinitionDeployer } from './workflow-template-definition-deployer';
+
+export async function cliInstallWorkflowTemplateDefinitions() {
+  await authUser();
+  await new WorkflowTemplateDefinitionDeployer().cliInstallWorkflowTemplateDefinitions();
+}
+
+export async function listWorkflowTemplateDefinitions() {
+  await authUser();
+  await new WorkflowTemplateDefinitionDeployer().listWorkflowTemplateDefinitions();
+}