@contrail/cli 1.0.71 → 2.0.1

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

@@ -1,184 +0,0 @@
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import { App, AppDeclaration, WorkflowDefinition, WorkflowTemplate } from '../interfaces';
-import { getInstalledApps, getWorkflowTemplateDefinitionsForApp } from '../api/apps';
-import { createWorkflowTemplate } from '../api/event-workflow-templates';
-import { createWorkflowTemplateDefinition, deleteWorkflowTemplateDefinition, updateWorkflowTemplateDefinition as apiUpdateWorkflowTemplateDefinition } from '../api/event-workflow-template-definition';
-import { getActionDeclarationIdentifier, getActionsForApp } from '../apps/deploy-app/actions-deployer';
-
-export class WorkflowTemplateDefinitionDeployer {
-
-  async cliInstallWorkflowTemplateDefinitions() {
-    const installedApps = await getInstalledApps();
-    if (!installedApps.length) {
-      console.log('%s \nNo apps are currently installed. You must install an app before installing its associated workflow template definitions.', chalk.red.bold('WORKFLOW DEFINITION'));
-      return;
-    }
-
-    const answers = await inquirer.prompt([{
-      type: 'list',
-      name: 'appIdentifier',
-      message: 'Which app\'s workflow would you like to install?',
-      choices: installedApps.map(x => x.app.identifier)
-    }]);
-    const app = installedApps.find(x => x.app.identifier === answers.appIdentifier).app;
-    const workflowTemplateDefinitions = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
-    for (const definition of workflowTemplateDefinitions) {
-      console.log(chalk.yellow.bold(`- ${definition.name}`));
-    }
-    await this.installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
-  }
-
-  async installWorkflowTemplateDefinitions(workflowTemplateDefinitions: WorkflowTemplate[]) {
-    let answers = await inquirer.prompt([{
-      type: 'checkbox',
-      name: 'workflowTemplateDefinitionsToInstall',
-      message: 'Which workflow templates would you like to install?',
-      choices: workflowTemplateDefinitions.map(x => {return {value: x.identifier, name: x.name};}),
-    }]);
-
-    const workflowTemplateDefinitionsToInstall = workflowTemplateDefinitions.filter(x => answers.workflowTemplateDefinitionsToInstall.includes(x.identifier));
-    answers = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'makeActive',
-      message: 'Should the workflows be active ?(yes)',
-      default: true,
-    }]);
-    const makeActive = answers.makeActive;
-    for (const definition of workflowTemplateDefinitionsToInstall) {
-      const newObject: WorkflowTemplate = {
-        name: definition.name,
-        triggerKey: definition.triggerKey,
-        workflowDefinition: definition.workflowDefinition,
-        isActive: makeActive,
-        supportingAppId: definition.supportingAppId,
-      };
-      await createWorkflowTemplate(newObject);
-    }
-    console.log('%s \nInstalled workflows', chalk.green.bold('WORKFLOW DEFINITION'));
-  }
-
-  async listWorkflowTemplateDefinitions() {
-    const installedApps = await getInstalledApps();
-    const workflowTemplateDefinitions = [];
-    for (const appOrg of installedApps) {
-      workflowTemplateDefinitions.push(...await (await getWorkflowTemplateDefinitionsForApp({ appId: appOrg.appId })).map(
-        x => {
-          return {
-            appName: appOrg.app.name,
-            workflowName: x.name,
-          };
-        }
-      ));
-    }
-    console.log('(app name) workflow name');
-    console.log('------------------------');
-    console.log(chalk.green.bold(workflowTemplateDefinitions.map(x => `(${x.appName}) ${x.workflowName} `).join('\n')));
-  }
-
-  async deployWorkflowTemplateDefinitions(appDeclaration: AppDeclaration, app: App) {
-
-    // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
-
-    // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
-    console.log('%s \tDeploying workflow definitions.', chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    if (appDeclaration.workflows) {
-      const localWorkflows = Object.keys(appDeclaration.workflows);
-      if (localWorkflows?.length > 0) {
-        for (const workflowKey of localWorkflows) {
-          await this.deployWorkflow(
-            workflowKey, appDeclaration.workflows[workflowKey] as WorkflowDefinition,
-            app,
-            existingWorkflows,
-          );
-        }
-      }
-
-      // remove old templates that were removed by the app publisher
-      const localIdentifiers = localWorkflows.map(x=> this.getWorkflowDeclarationIdentifier(x, app));
-      const workflowTemplateDefinitionsToDelete = existingWorkflows.filter(x=> !localIdentifiers.includes(x.identifier));
-      for(const templateToDelete of workflowTemplateDefinitionsToDelete) {
-        await deleteWorkflowTemplateDefinition(templateToDelete.id);
-      }
-    }
-  }
-
-  async deployWorkflow(workflowKey: string, workflow: WorkflowDefinition, app: App, existingWorkflows: Array<any>) {
-    console.log(`%s \tDeploying workflow definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    const identifier = this.getWorkflowDeclarationIdentifier(workflowKey, app);
-    const existingDefinition = existingWorkflows.find(ad => ad.identifier === identifier);
-
-    if (existingDefinition) {
-      return await this.updateWorkflowTemplateDefinition(existingDefinition, workflow, app);
-    }
-    return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
-  }
-
-  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowDefinition, app: App) {
-    await this.populateActionIds(workflowDeclaration, app);
-    const newObject: WorkflowDefinition = {
-      identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
-      name: workflowDeclaration.name,
-      ownerKey: `app:${app.id}`,
-      triggerKey: workflowDeclaration.triggerKey,
-      workflowDefinition: workflowDeclaration.workflowDefinition,
-      public: workflowDeclaration.public,
-      isActive: workflowDeclaration.isActive,
-      messageGroupId: workflowDeclaration.messageGroupId,
-      parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
-    };
-
-    const workflowTemplate = await createWorkflowTemplateDefinition(newObject);
-
-    console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    return workflowTemplate;
-  }
-
-  private async populateActionIds(workflowDefinition: WorkflowDefinition, app: App) {
-    const availableAppActions = await getActionsForApp(app);
-    if (!workflowDefinition.workflowDefinition?.paths) {
-      return;
-    }
-    for (const path of workflowDefinition.workflowDefinition.paths) {
-      if (!path?.actionDefinitionConfigs) {
-        continue;
-      }
-      for (const actionConfiguration of path.actionDefinitionConfigs) {
-        const actionKey = actionConfiguration.action;
-        const action = availableAppActions.find(
-          action => action.identifier === getActionDeclarationIdentifier(actionKey, app)
-        );
-        if (!action) {
-          throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
-        }
-        actionConfiguration.id = action.id;
-      }
-    }
-  }
-
-  private async updateWorkflowTemplateDefinition(existingWorkflowDefinition: WorkflowDefinition, workflowDefinition: WorkflowDefinition, app: App) {
-    await this.populateActionIds(workflowDefinition, app);
-    const updates = Object.assign(new Object(), {
-      name: workflowDefinition.name,
-      triggerKey: workflowDefinition.triggerKey,
-      workflowDefinition: workflowDefinition.workflowDefinition,
-      messageGroupId: workflowDefinition.messageGroupId,
-      parallelWorkerCount: workflowDefinition.parallelWorkerCount,
-    });
-
-    const updatedWorkflowDefinition = await apiUpdateWorkflowTemplateDefinition({ id: existingWorkflowDefinition.id, updates });
-
-    console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    return updatedWorkflowDefinition;
-  }
-
-  getWorkflowDeclarationIdentifier(actionKey, app: App) {
-    return app.identifier + ':' + actionKey;
-  }
-
-}

package/src/workflow-templates/local-workflow-template-deployer.ts

@@ -1,126 +0,0 @@
-import chalk from 'chalk';
-import { getEventWorkflowActionDefinition } from '../api/event-workflow-action-definition';
-import { createWorkflowTemplate, deleteWorkflowTemplate, getExistingWorkflowTemplates, updateWorkflowTemplate as apiUpdateWorkflowTemplate } from '../api/event-workflow-templates';
-import { WorkflowTemplate, WorkflowTemplateDeclaration } from '../interfaces';
-
-export class LocalWorkflowTemplateDeployer {
-  async deployWorkflows(wtDeclaration: WorkflowTemplateDeclaration) {
-
-    // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await getExistingWorkflowTemplates();
-
-    // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
-    console.log('%s \tDeploying workflow templates.', chalk.yellow.bold('WORKFLOW TEMPLATES'));
-
-    for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
-      await this.deployWorkflowTemplate(
-        workflowKey,
-        wtDeclaration.workflows[workflowKey] as WorkflowTemplate,
-        existingWorkflows,
-      );
-    }
-  }
-
-  async deployWorkflowTemplate(workflowKey: string, workflow: WorkflowTemplate, existingWorkflows: Array<any>) {
-    console.log(`%s \tDeploying workflow: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
-
-    const identifier = getWorkflowTemplateIdentifier(workflowKey);
-    const existingTemplate = existingWorkflows.find(ad => ad.identifier === identifier);
-
-    if (existingTemplate) {
-      return await this.updateWorkflowTemplate(workflowKey, existingTemplate, workflow);
-    }
-    return await this.createNewWorkflowTemplate(workflowKey, workflow);
-  }
-
-  private async createNewWorkflowTemplate(workflowKey: string, workflowTemplate: WorkflowTemplate) {
-    await this.populateActionIds(workflowTemplate, workflowKey);
-    const newObject: WorkflowTemplate = {
-      identifier: getWorkflowTemplateIdentifier(workflowKey),
-      name: workflowTemplate.name,
-      triggerKey: workflowTemplate.triggerKey,
-      workflowDefinition: workflowTemplate.workflowDefinition,
-      isActive: workflowTemplate.isActive,
-      supportingAppId: workflowTemplate.supportingAppId,
-      messageGroupId: workflowTemplate.messageGroupId,
-      parallelWorkerCount: workflowTemplate.parallelWorkerCount,
-    };
-
-    const newWorkflowTemplate = await createWorkflowTemplate(newObject);
-    console.log(`%s      Created new workflow definition: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
-
-    return newWorkflowTemplate;
-  }
-
-  private async populateActionIds(workflowTemplate: WorkflowTemplate, workflowKey: string) {
-    if (!workflowTemplate?.workflowDefinition?.paths) {
-      return;
-    }
-    for (const path of workflowTemplate.workflowDefinition.paths) {
-      if (!path?.actionDefinitionConfigs) {
-        continue;
-      }
-      for (const actionConfiguration of path.actionDefinitionConfigs) {
-        const actionKey = actionConfiguration.action;
-        try {
-          const actionEntity: any = await getActionByIdentifier(actionKey);
-          actionConfiguration.id = actionEntity.id;
-        } catch (e) {
-          console.log(e);
-        }
-        if(!actionConfiguration.id) {
-          throw new Error(`Could not find action ${actionKey} declared in ${workflowKey}`);
-        }
-      }
-    }
-  }
-
-  private async updateWorkflowTemplate(workflowKey: string, existingWorkflowTemplate: WorkflowTemplate, workflowTemplate: WorkflowTemplate) {
-    await this.populateActionIds(workflowTemplate, workflowKey);
-    const updates = Object.assign(new Object(), {
-      name: workflowTemplate.name,
-      triggerKey: workflowTemplate.triggerKey,
-      workflowDefinition: workflowTemplate.workflowDefinition
-    });
-
-    const updatedWorkflowTemplate = await apiUpdateWorkflowTemplate({id: existingWorkflowTemplate.id, updates});
-
-    console.log(`%s      Updated existing workflow template: ${updatedWorkflowTemplate.identifier}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
-
-    return updatedWorkflowTemplate;
-  }
-
-  public async deleteWorkflowTemplates(wtDeclaration: WorkflowTemplateDeclaration) {
-    // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await getExistingWorkflowTemplates();
-
-    // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
-    console.log('%s \tDELETING workflow templates.', chalk.yellow.bold('WORKFLOW TEMPLATES'));
-
-    for (const workflowKey of Object.keys(wtDeclaration.workflows)) {
-      const identifier = getWorkflowTemplateIdentifier(workflowKey);
-      const existingTemplate = existingWorkflows.find(ad => ad.identifier === identifier);
-
-      if (existingTemplate) {
-        try {
-          await deleteWorkflowTemplate(identifier);
-        } catch (e) {
-          console.log('%s \tFAILED to delete workflow template %s.', chalk.red.bold('WORKFLOW TEMPLATES'), identifier);
-        }
-      } else {
-        console.log('%s \tUnable to locate workflow template %s.', chalk.yellow.bold('WORKFLOW TEMPLATES'), identifier);
-
-      }
-    }
-
-  }
-}
-
-export function getWorkflowTemplateIdentifier(workflowKey: string) {
-  return workflowKey;
-}
-
-export async function getActionByIdentifier(identifier: string) {
-  const result = await getEventWorkflowActionDefinition({identifier});
-  return result.length > 0? result[0]: {};
-}

package/src/workflow-templates/workflow-template-commands.ts

@@ -1,59 +0,0 @@
-
-import chalk from 'chalk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import { WorkflowTemplateDeclaration } from '../interfaces';
-import { getSeparatorByPlatform } from '../common';
-const yaml = require('js-yaml');
-import { LocalWorkflowTemplateDeployer } from './local-workflow-template-deployer';
-import { WorkflowTemplateDeployer } from './workflow-template-deployer';
-
-export async function deleteWorkflowTemplates() {
-  await authUser();
-  await new WorkflowTemplateDeployer().deleteWorkflowTemplates();
-}
-
-export async function localDeleteWorkflowTemplate() {
-  let wtDeclaration: WorkflowTemplateDeclaration;
-  try {
-    wtDeclaration = loadTemplateConfig();
-  }
-  catch (e) {
-    console.log(`%s Workflow Deletion Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  await authUser();
-  await new LocalWorkflowTemplateDeployer().deleteWorkflowTemplates(wtDeclaration);
-}
-
-export async function localDeployWorkflowTemplate() {
-  let wtDeclaration: WorkflowTemplateDeclaration;
-  try {
-    wtDeclaration = loadTemplateConfig();
-  }
-  catch (e) {
-    console.log(`%s Workflow Deletion Failed. ${e}`, chalk.red.bold('FAIL'));
-    return;
-  }
-
-  await authUser();
-  await new LocalWorkflowTemplateDeployer().deployWorkflows(wtDeclaration);
-}
-
-export async function listWorkflowTemplate() {
-  await authUser();
-  return await new WorkflowTemplateDeployer().listExistingWorkflowTemplates();
-}
-
-function loadTemplateConfig() {
-  const TARGET_DIR = process.cwd();
-  try {
-    const separator = getSeparatorByPlatform();
-    const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'workflow.yml', 'utf8'));
-    console.log(doc);
-    return doc;
-  } catch (e) {
-    throw new Error(`ERROR PARSING YAML: ${e}`);
-  }
-}

package/src/workflow-templates/workflow-template-deployer.ts

@@ -1,30 +0,0 @@
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { deleteWorkflowTemplate as apiDeleteWorkflowTemplate } from '../api/event-workflow-templates';
-import { getExistingWorkflowTemplates } from '../api/event-workflow-templates';
-
-export class WorkflowTemplateDeployer {
-
-  async deleteWorkflowTemplates() {
-
-    // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await getExistingWorkflowTemplates();
-    const answers = await inquirer.prompt([{
-      type: 'checkbox',
-      name: 'wfTemplatesToDelete',
-      message: 'Which templates would you like to delete (one or more)?',
-      choices: existingWorkflows.map(x => { return { value: x.id, name: `(${x.createdOn}) ${x.name}` }; })
-    }]);
-    for (const idToDelete of answers.wfTemplatesToDelete) {
-      await apiDeleteWorkflowTemplate(idToDelete);
-    }
-    console.log('%s \tDeleted workflow templates!', chalk.green.bold('WORKFLOW TEMPLATES'));
-  }
-
-  public async listExistingWorkflowTemplates() {
-    const templates = await getExistingWorkflowTemplates();
-    console.log('(Date Created) (active) workflow name');
-    console.log('------------------------');
-    console.log(chalk.green.bold(templates.map(x => `(${x.createdOn}) (${x.isActive? 'active': 'inactive'}) ${x.name} `).join('\n')));
-  }
-}

package/templates/javascript/actions/example/action.js

@@ -1,38 +0,0 @@
-async function execute(config, event, Functions) {
-  const getBodyFromEvent = (config, event) => {
-    let body = Functions.stringUtil.parseVariables(config.message, event);
-    console.log('body: ', body);
-    if (config.sendDetails) {
-      const data = event;
-      const properties = {};
-      let addedProperty = false;
-      for (const property of config.fieldsToForward) {
-        const variableLevels = property.split('.');
-        let replacementValue = data;
-        for (let i = 0; i < variableLevels.length; i++) {
-          replacementValue = replacementValue[variableLevels[i]];
-        }
-        properties[property] = replacementValue;
-        addedProperty = true;
-      }
-      if (addedProperty) {
-        body = body + ' Properties: ' + JSON.stringify(properties) + '.';
-      }
-    }
-    return JSON.stringify({ text: body });
-  };
-  const body = getBodyFromEvent(config, event);
-  console.log('Sending message: ', body);
-  const response = await Functions.fetch(config.url, {
-    method: 'POST',
-    body: body,
-    headers: { 'Content-Type': 'application/json' }
-  });
-  if (!response.ok) {
-    console.log('Webhook event failed to publish');
-    console.log('Response: ', JSON.stringify(response));
-  }
-  else {
-    console.log('Published!');
-  }
-}

package/templates/javascript/app.yml

@@ -1,53 +0,0 @@
-appIdentifier: "@your-co/app-name"
-appName: "Your App Name"
-appDescription: "Your app description."
-visibility: public
-publisher: "Your company name"
-version: 1.0
-
-# eventWorkflowTriggerKeyMapping will be used to parse an incoming event into a key that can trigger workflows
-# {} indicates a field on the event. You can use nested fields by separating the levels with a '.'
-# i.e. an event {details: {eventType: 'apparel'}, actionType: 'create'} can be parsed to apparel|create with the following
-eventWorkflowTriggerKeyMapping: "{details.eventType}|{actionType}" 
-
-appConfiguration: 
-  apiHost: 
-    label: "API Host"
-    propertyType: "string"
-  userName: 
-    label: "User Name"
-    propertyType: "string"
-  password: 
-    label: "Password"
-    propertyType: "string"
-
-actions: 
-  updateProduct: 
-    handler: actions/example/action.js
-    name: "Update Product"
-    description: "Updates a product in the destination system."
-    actionConfiguration: 
-      email: 
-        label: "Email Address"
-        propertyType: "string"
-
-triggers: 
-  trigger1: 
-    key: product|create
-    name: "External Product Created"
-    external: true
-    description: "Triggers on externally created products"
-
-# workflows:
-#   workflow1:
-#     triggerKey: item|update
-#     isActive: true
-#     name: test wf from cli
-#     workflowDefinition:
-#       paths:
-#         - conditional: "true"
-#           actionDefinitionConfigs:
-#             - action: updateProduct
-#               name: handle product update
-#               config:
-#                 message: "hello world"

package/templates/javascript/package.json

@@ -1,23 +0,0 @@
-{
-  "name": "test-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "bin": {
-    "@contrail/contrail-cli": "bin/init",
-    "contrail": "bin/init"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-  ],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "chalk": "^4.0.0"
-  }
-}

package/templates/typescript/package-lock.json

@@ -1,14 +0,0 @@
-{
-  "name": "test-app",
-  "version": "1.0.0",
-  "lockfileVersion": 1,
-  "requires": true,
-  "dependencies": {
-    "typescript": {
-      "version": "4.7.4",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.4.tgz",
-      "integrity": "sha512-C0WQT0gezHuw6AdY1M2jxUO83Rjf0HP7Sk1DtXj6j1EwkQNZrHAg2XPWlq62oqEhYvONq5pkC2Y9oPljWToLmQ==",
-      "dev": true
-    }
-  }
-}

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2017",
-    "module": "esnext",
-    "declaration": true,
-    "esModuleInterop": true,
-    "outDir": "./lib",
-    "strict": false,
-    "experimentalDecorators": true,
-    "strictPropertyInitialization": false,
-    "noImplicitAny": false,
-    "emitDecoratorMetadata": true,
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "lib": [
-      "es5",
-      "ES2015",
-      "ES2016",
-      "ES2017",
-      "ES2020",
-      "dom",
-      "esnext.asynciterable"
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/__tests__/*"
-  ]
-}