@contrail/cli 1.0.41 → 1.0.43

package/lib/api/event-workflow-template-definition.d.ts

@@ -3,3 +3,4 @@ export declare function updateWorkflowTemplateDefinition(options: {
     id: string;
     updates: any;
 }): Promise<any>;
+export declare function deleteWorkflowTemplateDefinition(templateId: string): Promise<any>;

package/lib/api/event-workflow-template-definition.js

@@ -12,3 +12,9 @@ export async function updateWorkflowTemplateDefinition(options) {
         object: options.updates,
     });
 }
+export async function deleteWorkflowTemplateDefinition(templateId) {
+    return await new Entities().delete({
+        entityName: 'event-workflow-template-definition',
+        id: templateId,
+    });
+}

package/lib/apps/app-api.d.ts

@@ -0,0 +1,6 @@
+export declare function getAppVersions(app: any): Promise<any>;
+export declare function upgradeAppVersion(appOrg: any, appVersionId: any): Promise<any>;
+export declare function deleteAppOrg(appOrgId: string): Promise<any>;
+export declare function getInstalledApps(): Promise<any>;
+export declare function installAppToOrg(app: any, configProperties: any): Promise<any>;
+export declare function getAvailableApps(): Promise<any[]>;

package/lib/apps/app-api.js

@@ -0,0 +1,59 @@
+import { Entities } from '@contrail/sdk';
+import { Auth } from '../auth/auth';
+export async function getAppVersions(app) {
+    return await new Entities().get({
+        entityName: 'app-version',
+        criteria: {
+            appId: app.id
+        }
+    });
+}
+export async function upgradeAppVersion(appOrg, appVersionId) {
+    return await new Entities().update({
+        entityName: 'app-org',
+        id: appOrg.id,
+        object: {
+            appVersionId: appVersionId
+        }
+    });
+}
+export async function deleteAppOrg(appOrgId) {
+    return await new Entities().delete({
+        entityName: 'app-org',
+        id: appOrgId
+    });
+}
+export async function getInstalledApps() {
+    return await new Entities().get({
+        entityName: 'app-org',
+        relations: ['app']
+    });
+}
+export async function installAppToOrg(app, configProperties) {
+    return await new Entities().create({
+        entityName: 'app-org',
+        object: {
+            appId: app.id,
+            appConfig: configProperties
+        }
+    });
+}
+export async function getAvailableApps() {
+    const orgId = Auth.config.orgId;
+    const apps = [];
+    apps.push(...await new Entities().get({
+        entityName: 'app',
+        criteria: {
+            orgId,
+            private: true,
+        },
+    }));
+    apps.push(...await new Entities().get({
+        entityName: 'app',
+        criteria: {
+            orgId,
+            private: false,
+        },
+    }));
+    return apps;
+}

package/lib/apps/deploy-app/docker-action-builder.d.ts

@@ -0,0 +1,10 @@
+import { App, AppDeclaration, AppActionDeclaration } from '../../interfaces';
+export declare class ActionsDeployer {
+  deployActions(appDeclaration: AppDeclaration, app: App): Promise<void>;
+  getActionsForApp(app: App): Promise<any>;
+  deployAction(actionKey: string, actionDeclaration: AppActionDeclaration, app: App, existingActions: Array<any>): Promise<void>;
+  private createNewActionDefinition;
+  private updateActionDefinition;
+  getActionDeclarationIdentifier(actionKey: any, app: App): string;
+  getFunction(actionDeclaration: AppActionDeclaration): Promise<string>;
+}

package/lib/apps/deploy-app/docker-action-builder.js

@@ -0,0 +1,97 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { ConfigPropertiesParser } from './app-template-parsers';
+import { getSeparatorByPlatform } from '../../common';
+import fs from 'fs';
+export class ActionsDeployer {
+  async deployActions(appDeclaration, app) {
+    // FETCH ALL ACTIONS FROM THE API.
+    const existingActions = await this.getActionsForApp(app);
+    // UPSERT / DELETE BASED ON ACTION IDENTIFIER
+    console.log('%s \tDeploying actions.', chalk.yellow.bold('ACTION'));
+    for (const actionKey of Object.keys(appDeclaration.actions)) {
+      await this.deployAction(actionKey, appDeclaration.actions[actionKey], app, existingActions);
+    }
+  }
+  async getActionsForApp(app) {
+    return await new Entities().get({
+      entityName: 'event-workflow-action-definition',
+      criteria: { ownerKey: `app:${app.id}` },
+    });
+  }
+  async deployAction(actionKey, actionDeclaration, app, existingActions) {
+    console.log(`%s \tDeploying action: ${actionKey}`, chalk.yellow.bold('ACTION'));
+    const identifier = this.getActionDeclarationIdentifier(actionKey, app);
+    const existingDefinition = existingActions.find(ad => ad.identifier === identifier);
+    if (!existingDefinition) {
+      await this.createNewActionDefinition(actionKey, actionDeclaration, app);
+    }
+    else {
+      await this.updateActionDefinition(existingDefinition, actionDeclaration);
+    }
+  }
+  async createNewActionDefinition(actionKey, actionDeclaration, app) {
+    let configProperties;
+    if (actionDeclaration === null || actionDeclaration === void 0 ? void 0 : actionDeclaration.actionConfiguration) {
+      configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
+    }
+    const newObject = {
+      identifier: this.getActionDeclarationIdentifier(actionKey, app),
+      name: actionDeclaration.name,
+      ownerKey: `app:${app.id}`,
+      public: app.public,
+      configProperties,
+    };
+    const functionString = await this.getFunction(actionDeclaration);
+    if (functionString) {
+      newObject.executeFunctionString = functionString;
+    }
+    const actionDefinition = await new Entities().create({
+      entityName: 'event-workflow-action-definition',
+      object: newObject,
+    });
+    console.log(`%s      Created new action definition: ${actionKey}`, chalk.yellow.bold('APP'));
+    return actionDefinition;
+  }
+  async updateActionDefinition(existingActionDefinition, actionDeclaration) {
+    let configProperties;
+    if (actionDeclaration === null || actionDeclaration === void 0 ? void 0 : actionDeclaration.actionConfiguration) {
+      configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
+    }
+    else if (!(actionDeclaration === null || actionDeclaration === void 0 ? void 0 : actionDeclaration.actionConfiguration) && existingActionDefinition.configProperties) {
+      configProperties = null;
+    }
+    const updates = {
+      name: actionDeclaration.name,
+      // public: actionDeclaration.public, // TODO - an actions visibility is allowed to change
+      configProperties,
+    };
+    const functionString = await this.getFunction(actionDeclaration);
+    if (functionString) {
+      updates.executeFunctionString = functionString;
+    }
+    const actionDefinition = await new Entities().update({
+      entityName: 'event-workflow-action-definition',
+      id: existingActionDefinition.id,
+      object: updates,
+    });
+    console.log(`%s      Updated existing action definition: ${actionDefinition.identifier}`, chalk.yellow.bold('APP'));
+    return actionDefinition;
+  }
+  getActionDeclarationIdentifier(actionKey, app) {
+    return app.identifier + ':' + actionKey;
+  }
+  async getFunction(actionDeclaration) {
+    if (!actionDeclaration.handler) {
+      return;
+    }
+    if (!actionDeclaration.handler.endsWith('.js')) {
+      throw new Error('Action handler must be a .js file.');
+    }
+    const CURRENT_DIR = process.cwd();
+    const separator = getSeparatorByPlatform();
+    const functionLocation = CURRENT_DIR + separator + actionDeclaration.handler;
+    const content = fs.readFileSync(functionLocation);
+    return content.toString();
+  }
+}

package/lib/apps/deploy-app/interfaces.d.ts

@@ -0,0 +1,76 @@
+/** Describes the derivative JSON / object represented
+ * in app.yml file.
+ */
+export interface AppDeclaration {
+    appIdentifier: string;
+    appName: string;
+    appDescription?: string;
+    visibility: 'private' | 'public';
+    publisher: string;
+    version: string;
+    eventWorkflowTriggerKeyMapping: string;
+    thumbnail?: string;
+    keywords?: Array<string>;
+    actions?: {
+        [key: string]: AppActionDeclaration;
+    };
+    appConfiguration: ConfigPropertyElements;
+    triggers: {
+        [key: string]: AppTriggerDeclaration;
+    };
+    isDockerBased?: boolean;
+}
+export interface ConfigPropertyElements {
+    [key: string]: ConfigPropertyElement;
+}
+export interface ConfigPropertyElement {
+    propertyType: string;
+    options?: any[];
+    label: string;
+}
+export interface AppActionDeclaration {
+    handler: string;
+    name: string;
+    description?: string;
+    actionConfiguration?: ConfigPropertyElements;
+}
+export interface AppTriggerDeclaration {
+    key: string;
+    name: string;
+    external?: boolean;
+    description?: string;
+}
+export interface App {
+    id: string;
+    identifier: string;
+    name: string;
+    public: boolean;
+    description?: string;
+    publisher: string;
+    thumbnail: string;
+    eventWorkflowTriggerKeyMapping: string;
+    configProperties?: ConfigProperty[];
+    triggerKeyDefinitions?: TriggerKeyDefinition[];
+}
+export declare class ConfigProperty {
+  slug: string;
+  propertyType: string;
+  options?: any[];
+  label: string;
+}
+export interface EventWorkflowActionDefinition {
+    id?: string;
+    identifier?: string;
+    name?: string;
+    executeFunctionString?: string;
+    ownerKey?: string;
+    public?: boolean;
+    configProperties?: ConfigProperty[];
+    isDockerBased?: boolean;
+}
+export declare class TriggerKeyDefinition {
+  name: string;
+  description?: string;
+  triggerKey: string;
+  external?: boolean;
+}

package/lib/apps/deploy-app/interfaces.js

@@ -0,0 +1,4 @@
+export class ConfigProperty {
+}
+export class TriggerKeyDefinition {
+}

package/lib/apps/deploy-app/workflow-definition-deployer.d.ts

@@ -0,0 +1,10 @@
+import { App, AppDeclaration, WorkflowDefinition } from '../../interfaces';
+export declare class WorkflowDefinitionDeployer {
+    deployWorkflowDefinitions(appDeclaration: AppDeclaration, app: App): Promise<void>;
+    getWorkflowDefinitionsForApp(app: App): Promise<any>;
+    deployWorkflow(workflowKey: string, workflow: WorkflowDefinition, app: App, existingWorkflows: Array<any>): Promise<any>;
+    private createNewWorkflowDefinition;
+    private populateActionIds;
+    private updateWorkflowDefinition;
+    getWorkflowDeclarationIdentifier(actionKey: any, app: App): string;
+}

package/lib/apps/deploy-app/workflow-definition-deployer.js

@@ -0,0 +1,95 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer';
+export class WorkflowDefinitionDeployer {
+    async deployWorkflowDefinitions(appDeclaration, app) {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await this.getWorkflowDefinitionsForApp(app);
+        // 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 === null || localWorkflows === void 0 ? void 0 : localWorkflows.length) > 0) {
+                for (const workflowKey of localWorkflows) {
+                    await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows);
+                }
+            }
+        }
+    }
+    async getWorkflowDefinitionsForApp(app) {
+        return await new Entities().get({
+            entityName: 'event-workflow-template-definition',
+            criteria: { ownerKey: `app:${app.id}` },
+        });
+    }
+    async deployWorkflow(workflowKey, workflow, app, existingWorkflows) {
+        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.updateWorkflowDefinition(existingDefinition, workflow, app);
+        }
+        return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
+    }
+    async createNewWorkflowDefinition(workflowKey, workflowDeclaration, app) {
+        var _a;
+        await this.populateActionIds(workflowDeclaration, app);
+        const newObject = {
+            identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
+            name: workflowDeclaration.name,
+            ownerKey: `app:${app.id}`,
+            triggerKey: workflowDeclaration.triggerKey,
+            workflowDefinition: workflowDeclaration.workflowDefinition,
+            public: (_a = workflowDeclaration.public) !== null && _a !== void 0 ? _a : false,
+            isActive: workflowDeclaration.isActive,
+            messageGroupId: workflowDeclaration.messageGroupId,
+            parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
+        };
+        const workflowTemplate = await new Entities().create({
+            entityName: 'event-workflow-template-definition',
+            object: newObject,
+        });
+        console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
+        return workflowTemplate;
+    }
+    async populateActionIds(workflowDefinition, app) {
+        var _a;
+        const availableAppActions = await getActionsForApp(app);
+        if (!((_a = workflowDefinition.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
+            return;
+        }
+        for (const path of workflowDefinition.workflowDefinition.paths) {
+            if (!(path === null || path === void 0 ? void 0 : 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;
+            }
+        }
+    }
+    async updateWorkflowDefinition(existingWorkflowDefinition, workflowDefinition, 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 new Entities().update({
+            entityName: 'event-workflow-template-definition',
+            id: existingWorkflowDefinition.id,
+            object: updates,
+        });
+        console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
+        return updatedWorkflowDefinition;
+    }
+    getWorkflowDeclarationIdentifier(actionKey, app) {
+        return app.identifier + ':' + actionKey;
+    }
+}

package/lib/apps/deploy-app/workflow-deployer.d.ts

@@ -0,0 +1,10 @@
+import { App, AppDeclaration, WorkflowTemplateDeclaration } from './interfaces';
+export declare class WorkflowDeployer {
+  deployWorkflows(appDeclaration: AppDeclaration, app: App): Promise<void>;
+  getWorkflowsForApp(app: App): Promise<any>;
+  deployWorkflow(workflowKey: string, workflow: WorkflowTemplateDeclaration, app: App, existingWorkflows: Array<any>, appDeclaration: AppDeclaration): Promise<any>;
+  private createNewWorkflowDefinition;
+  private populateActionIds;
+  private updateWorkflowDefinition;
+  getWorkflowDeclarationIdentifier(actionKey: any, app: App): string;
+}

package/lib/apps/deploy-app/workflow-deployer.js

@@ -0,0 +1,87 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer';
+export class WorkflowDeployer {
+  async deployWorkflows(appDeclaration, app) {
+    // FETCH ALL WORKFLOWS FROM THE API.
+    const existingWorkflows = await this.getWorkflowsForApp(app);
+    // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
+    console.log('%s \tDeploying workflows.', chalk.yellow.bold('WORKFLOW'));
+    for (const workflowKey of Object.keys(appDeclaration.workflows)) {
+      await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows, appDeclaration);
+    }
+  }
+  async getWorkflowsForApp(app) {
+    return await new Entities().get({
+      entityName: 'event-workflow-template',
+      criteria: { ownerKey: `app:${app.id}` },
+    });
+  }
+  async deployWorkflow(workflowKey, workflow, app, existingWorkflows, appDeclaration) {
+    console.log(`%s \tDeploying workflow: ${workflowKey}`, chalk.yellow.bold('WORKFLOW'));
+    const identifier = this.getWorkflowDeclarationIdentifier(workflowKey, app);
+    const existingDefinition = existingWorkflows.find(ad => ad.identifier === identifier);
+    if (existingDefinition) {
+      return await this.updateWorkflowDefinition(existingDefinition, workflow, app, appDeclaration);
+    }
+    return await this.createNewWorkflowDefinition(workflowKey, workflow, app, appDeclaration);
+  }
+  async createNewWorkflowDefinition(workflowKey, workflowDeclaration, app, appDeclaration) {
+    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+    const newObject = {
+      identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
+      name: workflowDeclaration.name,
+      ownerKey: `app:${app.id}`,
+      triggerKey: workflowDeclaration.triggerKey,
+      workflowDefinition: workflowDeclaration.workflowDefinition,
+      isActive: workflowDeclaration.isActive,
+      supportingAppId: workflowDeclaration.supportingAppId,
+      messageGroupId: workflowDeclaration.messageGroupId,
+      parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
+    };
+    const workflowTemplate = await new Entities().create({
+      entityName: 'event-workflow-template',
+      object: newObject,
+    });
+    console.log(`%s      Created new workflow definition: ${workflowKey}`, chalk.yellow.bold('WORKFLOW'));
+    return workflowTemplate;
+  }
+  async populateActionIds(workflowDeclaration, appDeclaration, app) {
+    var _a;
+    let availableAppActions = await getActionsForApp(app);
+    if (!((_a = workflowDeclaration.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
+      return;
+    }
+    for (const path of workflowDeclaration.workflowDefinition.paths) {
+      if (!(path === null || path === void 0 ? void 0 : 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 ${workflowDeclaration.name}`);
+        }
+        actionConfiguration.id = action.id;
+      }
+    }
+  }
+  async updateWorkflowDefinition(existingWorkflowDefinition, workflowDeclaration, app, appDeclaration) {
+    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+    const updates = Object.assign(new Object(), {
+      name: workflowDeclaration.name,
+      triggerKey: workflowDeclaration.triggerKey,
+      workflowDefinition: workflowDeclaration.workflowDefinition
+    });
+    const updatedWorkflowDefinition = await new Entities().update({
+      entityName: 'event-workflow-template',
+      id: existingWorkflowDefinition.id,
+      object: updates,
+    });
+    console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk.yellow.bold('WORKFLOW'));
+    return updatedWorkflowDefinition;
+  }
+  getWorkflowDeclarationIdentifier(actionKey, app) {
+    return app.identifier + ':' + actionKey;
+  }
+}

package/lib/workflow-template-definitions/workflow-template-definition-deployer.js

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { getInstalledApps, getWorkflowTemplateDefinitionsForApp } from '../api/apps';
 import { createWorkflowTemplate } from '../api/event-workflow-templates';
-import { createWorkflowTemplateDefinition, updateWorkflowTemplateDefinition as apiUpdateWorkflowTemplateDefinition } from '../api/event-workflow-template-definition';
+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() {
@@ -11,7 +11,7 @@ export class WorkflowTemplateDefinitionDeployer {
             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;
         }
-        let answers = await inquirer.prompt([{
+        const answers = await inquirer.prompt([{
                 type: 'list',
                 name: 'appIdentifier',
                 message: 'Which app\'s workflow would you like to install?',
@@ -22,27 +22,24 @@ export class WorkflowTemplateDefinitionDeployer {
         for (const definition of workflowTemplateDefinitions) {
             console.log(chalk.yellow.bold(`- ${definition.name}`));
         }
-        answers = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'shouldInstall',
-                message: 'Confirmation: would you like to install these workflows? (yes)',
-                default: true,
-            }]);
-        if (!answers.shouldInstall) {
-            console.log('%s      Canceling installing workflows template definitions.', chalk.yellow.bold('WORKFLOW DEFINITION TEMPLATE'));
-            return;
-        }
         await this.installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
     }
     async installWorkflowTemplateDefinitions(workflowTemplateDefinitions) {
-        const answers = await inquirer.prompt([{
+        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 workflowTemplateDefinitions) {
+        for (const definition of workflowTemplateDefinitionsToInstall) {
             const newObject = {
                 name: definition.name,
                 triggerKey: definition.triggerKey,
@@ -81,6 +78,12 @@ export class WorkflowTemplateDefinitionDeployer {
                     await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], 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, workflow, app, existingWorkflows) {

package/lib/workflow-templates/workflow-template-commands.d.ts

@@ -1,4 +1,4 @@
 export declare function deleteWorkflowTemplates(): Promise<void>;
 export declare function localDeleteWorkflowTemplate(): Promise<void>;
 export declare function localDeployWorkflowTemplate(): Promise<void>;
-export declare function listWorkflowTemplate(): Promise<any>;
+export declare function listWorkflowTemplate(): Promise<void>;

package/lib/workflow-templates/workflow-template-deployer.d.ts

@@ -1,4 +1,4 @@
 export declare class WorkflowTemplateDeployer {
     deleteWorkflowTemplates(): Promise<void>;
-    listExistingWorkflowTemplates(): Promise<any>;
+    listExistingWorkflowTemplates(): Promise<void>;
 }

package/lib/workflow-templates/workflow-template-deployer.js

@@ -19,7 +19,8 @@ export class WorkflowTemplateDeployer {
     }
     async listExistingWorkflowTemplates() {
         const templates = await getExistingWorkflowTemplates();
-        console.log(templates);
-        return templates;
+        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/lib/workflows/workflow-template-deployer.d.ts

@@ -0,0 +1,14 @@
+import { WorkflowTemplate, WorkflowTemplateDeclaration } from '../interfaces';
+export declare class WorkflowTemplateDeployer {
+    deployWorkflows(wtDeclaration: WorkflowTemplateDeclaration): Promise<void>;
+    getExistingWorkflowTemplates(): Promise<any>;
+    deployWorkflowTemplate(workflowKey: string, workflow: WorkflowTemplate, existingWorkflows: Array<any>): Promise<any>;
+    private createNewWorkflowTemplate;
+    private populateActionIds;
+    private updateWorkflowTemplate;
+    deleteWorkflowTemplates(wtDeclaration: WorkflowTemplateDeclaration): Promise<void>;
+    private deleteWorkflowTemplate;
+    listExistingWorkflowTemplates(): Promise<any>;
+}
+export declare function getWorkflowTemplateIdentifier(workflowKey: string): string;
+export declare function getActionByIdentifier(identifier: string): Promise<any>;

package/lib/workflows/workflow-template-deployer.js

@@ -0,0 +1,127 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+export class WorkflowTemplateDeployer {
+    async deployWorkflows(wtDeclaration) {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await this.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], existingWorkflows);
+        }
+    }
+    async getExistingWorkflowTemplates() {
+        return await new Entities().get({
+            entityName: 'event-workflow-template'
+        });
+    }
+    async deployWorkflowTemplate(workflowKey, workflow, existingWorkflows) {
+        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);
+    }
+    async createNewWorkflowTemplate(workflowKey, workflowTemplate) {
+        await this.populateActionIds(workflowTemplate, workflowKey);
+        const newObject = {
+            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 new Entities().create({
+            entityName: 'event-workflow-template',
+            object: newObject,
+        });
+        console.log(`%s      Created new workflow definition: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
+        return newWorkflowTemplate;
+    }
+    async populateActionIds(workflowTemplate, workflowKey) {
+        var _a;
+        if (!((_a = workflowTemplate === null || workflowTemplate === void 0 ? void 0 : workflowTemplate.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
+            return;
+        }
+        for (const path of workflowTemplate.workflowDefinition.paths) {
+            if (!(path === null || path === void 0 ? void 0 : path.actionDefinitionConfigs)) {
+                continue;
+            }
+            for (const actionConfiguration of path.actionDefinitionConfigs) {
+                const actionKey = actionConfiguration.action;
+                try {
+                    const actionEntity = 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}`);
+                }
+            }
+        }
+    }
+    async updateWorkflowTemplate(workflowKey, existingWorkflowTemplate, workflowTemplate) {
+        await this.populateActionIds(workflowTemplate, workflowKey);
+        const updates = Object.assign(new Object(), {
+            name: workflowTemplate.name,
+            triggerKey: workflowTemplate.triggerKey,
+            workflowDefinition: workflowTemplate.workflowDefinition
+        });
+        const updatedWorkflowTemplate = await new Entities().update({
+            entityName: 'event-workflow-template',
+            id: existingWorkflowTemplate.id,
+            object: updates,
+        });
+        console.log(`%s      Updated existing workflow template: ${updatedWorkflowTemplate.identifier}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
+        return updatedWorkflowTemplate;
+    }
+    async deleteWorkflowTemplates(wtDeclaration) {
+        // FETCH ALL WORKFLOWS FROM THE API.
+        const existingWorkflows = await this.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 this.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);
+            }
+        }
+    }
+    async deleteWorkflowTemplate(identifier) {
+        return await new Entities().delete({
+            entityName: 'event-workflow-template',
+            id: identifier,
+        });
+    }
+    async listExistingWorkflowTemplates() {
+        const templates = await this.getExistingWorkflowTemplates();
+        console.log(templates);
+        return templates;
+    }
+}
+export function getWorkflowTemplateIdentifier(workflowKey) {
+    return workflowKey;
+}
+export async function getActionByIdentifier(identifier) {
+    const result = await new Entities().get({
+        entityName: 'event-workflow-action-definition',
+        criteria: { identifier },
+    });
+    return result.length > 0 ? result[0] : {};
+}

package/lib/workflows/workflowCommands.d.ts

@@ -0,0 +1,3 @@
+export declare function deleteWorkflowTemplate(): Promise<void>;
+export declare function deployWorkflowTemplate(): Promise<void>;
+export declare function listWorkflowTemplate(): Promise<any>;

package/lib/workflows/workflowCommands.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import { getSeparatorByPlatform } from '../common';
+const yaml = require('js-yaml');
+import { WorkflowTemplateDeployer } from './workflow-template-deployer';
+export async function deleteWorkflowTemplate() {
+    let wtDeclaration;
+    try {
+        wtDeclaration = loadTemplateConfig();
+    }
+    catch (e) {
+        console.log(`%s Workflow Deletion Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    await authUser();
+    await new WorkflowTemplateDeployer().deleteWorkflowTemplates(wtDeclaration);
+}
+export async function deployWorkflowTemplate() {
+    let wtDeclaration;
+    try {
+        wtDeclaration = loadTemplateConfig();
+    }
+    catch (e) {
+        console.log(`%s Workflow Deletion Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    await authUser();
+    await new WorkflowTemplateDeployer().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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {
@@ -24,7 +24,7 @@
   "license": "ISC",
   "dependencies": {
     "@contrail/sdk": "^1.0.154",
-    "@contrail/types": "^2.0.74",
+    "@contrail/types": "^2.0.75",
     "@contrail/util": "^1.0.17",
     "amazon-cognito-identity-js": "^5.2.3",
     "arg": "^4.0.1",

package/src/api/event-workflow-template-definition.ts

@@ -13,4 +13,11 @@ export async function updateWorkflowTemplateDefinition(options: {id: string, upd
     id: options.id,
     object: options.updates,
   });
+}
+
+export async function deleteWorkflowTemplateDefinition(templateId: string) {
+  return await new Entities().delete({
+    entityName: 'event-workflow-template-definition',
+    id: templateId,
+  });
 }

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

@@ -3,7 +3,7 @@ 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, updateWorkflowTemplateDefinition as apiUpdateWorkflowTemplateDefinition } from '../api/event-workflow-template-definition';
+import { createWorkflowTemplateDefinition, deleteWorkflowTemplateDefinition, updateWorkflowTemplateDefinition as apiUpdateWorkflowTemplateDefinition } from '../api/event-workflow-template-definition';
 import { getActionDeclarationIdentifier, getActionsForApp } from '../apps/deploy-app/actions-deployer';
 
 export class WorkflowTemplateDefinitionDeployer {
@@ -15,7 +15,7 @@ export class WorkflowTemplateDefinitionDeployer {
       return;
     }
 
-    let answers = await inquirer.prompt([{
+    const answers = await inquirer.prompt([{
       type: 'list',
       name: 'appIdentifier',
       message: 'Which app\'s workflow would you like to install?',
@@ -26,31 +26,26 @@ export class WorkflowTemplateDefinitionDeployer {
     for (const definition of workflowTemplateDefinitions) {
       console.log(chalk.yellow.bold(`- ${definition.name}`));
     }
-    answers = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'shouldInstall',
-      message: 'Confirmation: would you like to install these workflows? (yes)',
-      default: true,
-    }]);
-
-    if (!answers.shouldInstall) {
-      console.log('%s      Canceling installing workflows template definitions.', chalk.yellow.bold('WORKFLOW DEFINITION TEMPLATE'));
-      return;
-    }
-
     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 answers = await inquirer.prompt([{
+    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 workflowTemplateDefinitions) {
+    for (const definition of workflowTemplateDefinitionsToInstall) {
       const newObject: WorkflowTemplate = {
         name: definition.name,
         triggerKey: definition.triggerKey,
@@ -100,6 +95,13 @@ export class WorkflowTemplateDefinitionDeployer {
           );
         }
       }
+
+      // 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);
+      }
     }
   }
 

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

@@ -23,7 +23,8 @@ export class WorkflowTemplateDeployer {
 
   public async listExistingWorkflowTemplates() {
     const templates = await getExistingWorkflowTemplates();
-    console.log(templates);
-    return templates;
+    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')));
   }
 }