@contrail/cli 1.0.22 → 1.0.23

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

@@ -1,4 +1,4 @@
-import { App, AppDeclaration, AppActionDeclaration } from './interfaces';
+import { App, AppDeclaration, AppActionDeclaration } from '../../interfaces';
 export declare function getActionsForApp(app: App): Promise<any>;
 export declare function getActionDeclarationIdentifier(actionKey: any, app: App): string;
 export declare class ActionsDeployer {

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

@@ -1,6 +1,6 @@
-import { App, AppDeclaration } from './interfaces';
+import { App, AppDeclaration } from '../../interfaces';
 export declare class AppDeployer {
-    deploy(appDeclaration: AppDeclaration, deployWorkflowTemplateOnly?: boolean): Promise<void>;
+    deploy(appDeclaration: AppDeclaration): Promise<void>;
     getExistingApp(appDeclaration: AppDeclaration): Promise<App>;
     private createNewApp;
     updateExistingApp(appDeclaration: AppDeclaration, existingApp: any): Promise<any>;

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

@@ -4,9 +4,8 @@ import { Auth } from '../../auth/auth';
 import { ActionsDeployer } from './actions-deployer';
 import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
 import { WorkflowDefinitionDeployer } from './workflow-definition-deployer';
-import { WorkflowDeployer } from './workflow-deployer';
 export class AppDeployer {
-    async deploy(appDeclaration, deployWorkflowTemplateOnly = false) {
+    async deploy(appDeclaration) {
         let app = await this.getExistingApp(appDeclaration);
         if (!app) {
             console.log(`%s      Creating new app.`, chalk.yellow.bold('APP'));
@@ -17,12 +16,7 @@ export class AppDeployer {
             app = await this.updateExistingApp(appDeclaration, app);
         }
         await new ActionsDeployer().deployActions(appDeclaration, app);
-        if (deployWorkflowTemplateOnly) {
-            await new WorkflowDeployer().deployWorkflows(appDeclaration, app);
-        }
-        else {
-            await new WorkflowDefinitionDeployer().deployWorkflowDefinitions(appDeclaration, app);
-        }
+        await new WorkflowDefinitionDeployer().deployWorkflowDefinitions(appDeclaration, app);
     }
     async getExistingApp(appDeclaration) {
         const orgId = Auth.config.orgId;

package/lib/apps/deploy-app/app-template-parsers.d.ts

@@ -1,4 +1,4 @@
-import { AppDeclaration, TriggerKeyDefinition, ConfigPropertyElements } from './interfaces';
+import { AppDeclaration, TriggerKeyDefinition, ConfigPropertyElements } from '../../interfaces';
 export declare class TriggerKeyDefinitionParser {
     static buildTriggersArray(appDeclaration: AppDeclaration): Array<TriggerKeyDefinition>;
 }

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

@@ -26,10 +26,9 @@ export async function deployApp(args) {
         return;
     }
     console.log(`%s Deploying Application. ${appDeclaration.appIdentifier}`, chalk.blue.bold('START'));
-    const templateOnly = args && args.includes('--template-only');
     try {
         await authUser();
-        await new AppDeployer().deploy(appDeclaration, templateOnly);
+        await new AppDeployer().deploy(appDeclaration);
     }
     catch (e) {
         console.log(`%s Application Deployment Failed. ${e}`, chalk.red.bold('FAIL'));

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

@@ -1,8 +1,8 @@
-import { App, AppDeclaration, WorkflowDefinitionDeclaration } from './interfaces';
+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: WorkflowDefinitionDeclaration, app: App, existingWorkflows: Array<any>, appDeclaration: AppDeclaration): Promise<any>;
+    deployWorkflow(workflowKey: string, workflow: WorkflowDefinition, app: App, existingWorkflows: Array<any>): Promise<any>;
     private createNewWorkflowDefinition;
     private populateActionIds;
     private updateWorkflowDefinition;

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

@@ -8,7 +8,7 @@ export class WorkflowDefinitionDeployer {
         // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
         console.log('%s \tDeploying workflow definitions.', chalk.yellow.bold('WORKFLOW DEFINITION'));
         for (const workflowKey of Object.keys(appDeclaration.workflows)) {
-            await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows, appDeclaration);
+            await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows);
         }
     }
     async getWorkflowDefinitionsForApp(app) {
@@ -17,17 +17,17 @@ export class WorkflowDefinitionDeployer {
             criteria: { ownerKey: `app:${app.id}` },
         });
     }
-    async deployWorkflow(workflowKey, workflow, app, existingWorkflows, appDeclaration) {
+    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, appDeclaration);
+            return await this.updateWorkflowDefinition(existingDefinition, workflow, app);
         }
-        return await this.createNewWorkflowDefinition(workflowKey, workflow, app, appDeclaration);
+        return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
     }
-    async createNewWorkflowDefinition(workflowKey, workflowDeclaration, app, appDeclaration) {
-        await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+    async createNewWorkflowDefinition(workflowKey, workflowDeclaration, app) {
+        await this.populateActionIds(workflowDeclaration, app);
         const newObject = {
             identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
             name: workflowDeclaration.name,
@@ -36,6 +36,8 @@ export class WorkflowDefinitionDeployer {
             workflowDefinition: workflowDeclaration.workflowDefinition,
             public: workflowDeclaration.public,
             isActive: workflowDeclaration.isActive,
+            messageGroupId: workflowDeclaration.messageGroupId,
+            parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
         };
         const workflowTemplate = await new Entities().create({
             entityName: 'event-workflow-template-definition',
@@ -44,13 +46,13 @@ export class WorkflowDefinitionDeployer {
         console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
         return workflowTemplate;
     }
-    async populateActionIds(workflowDeclaration, appDeclaration, app) {
+    async populateActionIds(workflowDefinition, app) {
         var _a;
         let availableAppActions = await getActionsForApp(app);
-        if (!((_a = workflowDeclaration.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
+        if (!((_a = workflowDefinition.workflowDefinition) === null || _a === void 0 ? void 0 : _a.paths)) {
             return;
         }
-        for (const path of workflowDeclaration.workflowDefinition.paths) {
+        for (const path of workflowDefinition.workflowDefinition.paths) {
             if (!(path === null || path === void 0 ? void 0 : path.actionDefinitionConfigs)) {
                 continue;
             }
@@ -58,18 +60,20 @@ export class WorkflowDefinitionDeployer {
                 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 ${workflowDeclaration.name}`);
+                    throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
                 }
                 actionConfiguration.id = action.id;
             }
         }
     }
-    async updateWorkflowDefinition(existingWorkflowDefinition, workflowDeclaration, app, appDeclaration) {
-        await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+    async updateWorkflowDefinition(existingWorkflowDefinition, workflowDefinition, app) {
+        await this.populateActionIds(workflowDefinition, app);
         const updates = Object.assign(new Object(), {
-            name: workflowDeclaration.name,
-            triggerKey: workflowDeclaration.triggerKey,
-            workflowDefinition: workflowDeclaration.workflowDefinition
+            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',

package/lib/cli.js

@@ -7,8 +7,9 @@ import { ParseOptionSetsLocalFiles } from './types/option-set-parser';
 import { MergeOptionSets } from './types/option-set-merger';
 import { MergeTypeProperties } from './types/types-properties-merger';
 import { ParseTypesFromFiles, ParseTypesFromLocalFiles } from './types/parse-types';
-import { loadColors } from './colors/color-loader';
+import { loadColors, deleteColors } from './colors/color-loader';
 import { listConfig, removeConfig } from './config/configCommands';
+import { deleteWorkflowTemplate, deployWorkflowTemplate, listWorkflowTemplate } from './workflows/workflowCommands';
 const cliUsage = require('command-line-usage');
 /**
  *  Built using documentation here:
@@ -100,10 +101,30 @@ export async function cli(args) {
                     await loadColors();
                     break;
                 }
-                // case 'delete': {
-                //   await deleteColors();
-                //   break;
-                // }
+                case 'delete': {
+                    await deleteColors();
+                    break;
+                }
+                default: {
+                    printIllegalCommand();
+                }
+            }
+            break;
+        }
+        case 'workflow-templates': {
+            switch (command) {
+                case 'load': {
+                    await deployWorkflowTemplate();
+                    break;
+                }
+                case 'delete': {
+                    await deleteWorkflowTemplate();
+                    break;
+                }
+                case 'list': {
+                    await listWorkflowTemplate();
+                    break;
+                }
                 default: {
                     printIllegalCommand();
                 }
@@ -120,10 +141,6 @@ export async function cli(args) {
                     await removeConfig(args);
                     break;
                 }
-                // case 'delete': {
-                //   await deleteColors();
-                //   break;
-                // }
                 default: {
                     printIllegalCommand();
                 }
@@ -185,6 +202,14 @@ const helpSections = [
             '.                            green, blue) are required.',
         ],
     },
+    {
+        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',
+        ],
+    },
     {
         header: 'Type Commands - Domain: types',
         content: [

package/lib/colors/color-loader.js

@@ -47,7 +47,9 @@ async function getLocalColors() {
 async function getExistingColors() {
     console.log(`%s Getting Existing Colors`, chalk.yellow.bold('COLORS'));
     try {
-        return new Entities().get({ entityName: 'color' }); //, useSearch: false }); Not in EntitiesClientGetOptions yet
+        const result = await new Entities().get({ entityName: 'color', take: 3000 }); //, useSearch: false }); Not in EntitiesClientGetOptions yet
+        console.log("Found %s existing colors", result.length);
+        return result;
     }
     catch (e) {
         throw new Error(`ERROR DOWNLOADING COLORS: ${e}`);

package/lib/interfaces.d.ts

@@ -0,0 +1,122 @@
+/** 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;
+    };
+    workflows?: {
+        [key: string]: WorkflowDefinition | WorkflowTemplateDeclaration;
+    };
+}
+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 WorkflowDefinition {
+    id?: string;
+    identifier: string;
+    name: string;
+    triggerKey: string;
+    workflowDefinition: WorkflowDefinitionPaths;
+    ownerKey: string;
+    isActive: boolean;
+    public: boolean;
+    supportingAppId?: string;
+    messageGroupId?: string;
+    parallelWorkerCount?: number;
+}
+export interface WorkflowTemplateDeclaration {
+    workflows?: {
+        [key: string]: WorkflowTemplate;
+    };
+}
+export interface WorkflowTemplate {
+    id?: string;
+    identifier: string;
+    name: string;
+    triggerKey: string;
+    workflowDefinition: WorkflowDefinitionPaths;
+    isActive: boolean;
+    ownerKey?: string;
+    supportingAppId?: string;
+    messageGroupId?: string;
+    parallelWorkerCount?: number;
+}
+export interface WorkflowDefinitionPaths {
+    paths: WorkflowConditional[];
+}
+export interface WorkflowConditional {
+    conditional: string;
+    actionDefinitionConfigs: ActionDefinitionConfig[];
+}
+export interface ActionDefinitionConfig {
+    name: string;
+    action: string;
+    config?: {
+        [key: string]: any;
+    };
+    id?: 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[];
+}
+export declare class TriggerKeyDefinition {
+    name: string;
+    description?: string;
+    triggerKey: string;
+    external?: boolean;
+}

package/lib/interfaces.js

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

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,129 @@
+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);
+                    console.log("response for action find:", actionEntity);
+                    actionConfiguration.id = actionEntity.id;
+                    console.log("found action 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.22",
+  "version": "1.0.23",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {

package/src/apps/deploy-app/actions-deployer.ts

@@ -1,6 +1,6 @@
 import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
-import { App, AppDeclaration, AppActionDeclaration, EventWorkflowActionDefinition } from './interfaces';
+import { App, AppDeclaration, AppActionDeclaration, EventWorkflowActionDefinition } from '../../interfaces';
 import { ConfigPropertiesParser } from './app-template-parsers';
 import { getSeparatorByPlatform } from '../../common';
 

package/src/apps/deploy-app/app-deployer.ts

@@ -2,13 +2,12 @@ import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
 import { Auth } from '../../auth/auth';
 import { ActionsDeployer } from './actions-deployer';
-import { App, AppDeclaration } from './interfaces';
+import { App, AppDeclaration } from '../../interfaces';
 import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
 import { WorkflowDefinitionDeployer } from './workflow-definition-deployer';
-import { WorkflowDeployer } from './workflow-deployer';
 
 export class AppDeployer {
-  public async deploy(appDeclaration: AppDeclaration, deployWorkflowTemplateOnly = false) {
+  public async deploy(appDeclaration: AppDeclaration) {
     let app = await this.getExistingApp(appDeclaration);
     if (!app) {
       console.log(`%s      Creating new app.`, chalk.yellow.bold('APP'));
@@ -18,11 +17,7 @@ export class AppDeployer {
       app = await this.updateExistingApp(appDeclaration, app);
     }
     await new ActionsDeployer().deployActions(appDeclaration, app);
-    if (deployWorkflowTemplateOnly) {
-      await new WorkflowDeployer().deployWorkflows(appDeclaration, app);
-    } else {
-      await new WorkflowDefinitionDeployer().deployWorkflowDefinitions(appDeclaration, app);
-    }
+    await new WorkflowDefinitionDeployer().deployWorkflowDefinitions(appDeclaration, app);
   }
 
   public async getExistingApp(appDeclaration: AppDeclaration): Promise<App> {

package/src/apps/deploy-app/app-template-parsers.ts

@@ -1,4 +1,4 @@
-import { AppDeclaration, TriggerKeyDefinition, ConfigPropertyElements } from './interfaces';
+import { AppDeclaration, TriggerKeyDefinition, ConfigPropertyElements } from '../../interfaces';
 
 export class TriggerKeyDefinitionParser {
   public static buildTriggersArray(appDeclaration: AppDeclaration): Array<TriggerKeyDefinition> {

package/src/apps/deploy-app/deploy.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import fs from 'fs';
 import { authUser } from '../../auth/login';
 import { AppDeployer } from './app-deployer';
-import { AppDeclaration } from './interfaces';
+import { AppDeclaration } from '../../interfaces';
 import { getSeparatorByPlatform } from '../../common';
 const yaml = require('js-yaml');
 
@@ -29,10 +29,9 @@ export async function deployApp(args) {
   }
 
   console.log(`%s Deploying Application. ${appDeclaration.appIdentifier}`, chalk.blue.bold('START'));
-  const templateOnly = args && args.includes('--template-only')
   try {
     await authUser();
-    await new AppDeployer().deploy(appDeclaration, templateOnly);
+    await new AppDeployer().deploy(appDeclaration);
   }
   catch (e) {
     console.log(`%s Application Deployment Failed. ${e}`, chalk.red.bold('FAIL'));

package/src/apps/deploy-app/workflow-definition-deployer.ts

@@ -1,6 +1,6 @@
 import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
-import { App, AppDeclaration, WorkflowDefinitionDeclaration } from './interfaces';
+import { App, AppDeclaration, WorkflowDefinition } from '../../interfaces';
 import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer'
 
 export class WorkflowDefinitionDeployer {
@@ -14,10 +14,9 @@ export class WorkflowDefinitionDeployer {
 
     for (const workflowKey of Object.keys(appDeclaration.workflows)) {
       await this.deployWorkflow(
-        workflowKey, appDeclaration.workflows[workflowKey] as WorkflowDefinitionDeclaration,
+        workflowKey, appDeclaration.workflows[workflowKey] as WorkflowDefinition,
         app,
         existingWorkflows,
-        appDeclaration
       );
     }
   }
@@ -29,21 +28,21 @@ export class WorkflowDefinitionDeployer {
     });
   }
 
-  async deployWorkflow(workflowKey: string, workflow: WorkflowDefinitionDeclaration, app: App, existingWorkflows: Array<any>, appDeclaration: AppDeclaration) {
+  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.updateWorkflowDefinition(existingDefinition, workflow, app, appDeclaration);
+      return await this.updateWorkflowDefinition(existingDefinition, workflow, app);
     }
-    return await this.createNewWorkflowDefinition(workflowKey, workflow, app, appDeclaration);
+    return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
   }
 
-  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowDefinitionDeclaration, app: App, appDeclaration: AppDeclaration) {
-    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
-    const newObject: WorkflowDefinitionDeclaration = {
+  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}`,
@@ -51,6 +50,8 @@ export class WorkflowDefinitionDeployer {
       workflowDefinition: workflowDeclaration.workflowDefinition,
       public: workflowDeclaration.public,
       isActive: workflowDeclaration.isActive,
+      messageGroupId: workflowDeclaration.messageGroupId,
+      parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
     };
 
     const workflowTemplate = await new Entities().create({
@@ -63,12 +64,12 @@ export class WorkflowDefinitionDeployer {
     return workflowTemplate;
   }
 
-  private async populateActionIds(workflowDeclaration: WorkflowDefinitionDeclaration, appDeclaration: AppDeclaration, app: App) {
+  private async populateActionIds(workflowDefinition: WorkflowDefinition, app: App) {
     let availableAppActions = await getActionsForApp(app);
-    if (!workflowDeclaration.workflowDefinition?.paths) {
+    if (!workflowDefinition.workflowDefinition?.paths) {
       return;
     }
-    for (const path of workflowDeclaration.workflowDefinition.paths) {
+    for (const path of workflowDefinition.workflowDefinition.paths) {
       if (!path?.actionDefinitionConfigs) {
         continue;
       }
@@ -78,19 +79,21 @@ export class WorkflowDefinitionDeployer {
           action => action.identifier === getActionDeclarationIdentifier(actionKey, app)
         )
         if (!action) {
-          throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDeclaration.name}`);
+          throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
         }
         actionConfiguration.id = action.id;
       }
     }
   }
 
-  private async updateWorkflowDefinition(existingWorkflowDefinition: WorkflowDefinitionDeclaration, workflowDeclaration: WorkflowDefinitionDeclaration, app: App, appDeclaration: AppDeclaration) {
-    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+  private async updateWorkflowDefinition(existingWorkflowDefinition: WorkflowDefinition, workflowDefinition: WorkflowDefinition, app: App) {
+    await this.populateActionIds(workflowDefinition, app);
     const updates = Object.assign(new Object(), {
-      name: workflowDeclaration.name,
-      triggerKey: workflowDeclaration.triggerKey,
-      workflowDefinition: workflowDeclaration.workflowDefinition
+      name: workflowDefinition.name,
+      triggerKey: workflowDefinition.triggerKey,
+      workflowDefinition: workflowDefinition.workflowDefinition,
+      messageGroupId: workflowDefinition.messageGroupId,
+      parallelWorkerCount: workflowDefinition.parallelWorkerCount,
     });
 
     const updatedWorkflowDefinition = await new Entities().update({

package/src/cli.ts

@@ -10,7 +10,7 @@ import { MergeTypeProperties } from './types/types-properties-merger';
 import { ParseTypesFromFiles, ParseTypesFromLocalFiles } from './types/parse-types';
 import { loadColors, deleteColors } from './colors/color-loader';
 import {listConfig, removeConfig} from './config/configCommands'
-
+import {deleteWorkflowTemplate, deployWorkflowTemplate, listWorkflowTemplate} from './workflows/workflowCommands';
 const cliUsage = require('command-line-usage');
 
 /**
@@ -109,10 +109,30 @@ export async function cli(args) {
           await loadColors();
           break;
         }
-        // case 'delete': {
-        //   await deleteColors();
-        //   break;
-        // }
+        case 'delete': {
+          await deleteColors();
+          break;
+        }
+        default: {
+          printIllegalCommand();
+        }
+      }
+      break;
+    }
+    case 'workflow-templates': {
+      switch (command) {
+        case 'load': {
+          await deployWorkflowTemplate();
+          break;
+        }
+        case 'delete': {
+          await deleteWorkflowTemplate();
+          break;
+        }
+        case 'list': {
+          await listWorkflowTemplate();
+          break;
+        }
         default: {
           printIllegalCommand();
         }
@@ -129,10 +149,6 @@ export async function cli(args) {
           await removeConfig(args);
           break;
         }
-        // case 'delete': {
-        //   await deleteColors();
-        //   break;
-        // }
         default: {
           printIllegalCommand();
         }
@@ -200,6 +216,14 @@ const helpSections = [
       // 'delete                       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',
+    ],
+  },
   {
     header: 'Type Commands - Domain: types',
     content: [

package/src/colors/color-loader.ts

@@ -62,7 +62,9 @@ async function getLocalColors() {
 async function getExistingColors() {
   console.log(`%s Getting Existing Colors`, chalk.yellow.bold('COLORS'));
   try {
-    return new Entities().get({ entityName: 'color'}); //, useSearch: false }); Not in EntitiesClientGetOptions yet
+    const result = await new Entities().get({ entityName: 'color', take: 3000}); //, useSearch: false }); Not in EntitiesClientGetOptions yet
+    console.log("Found %s existing colors", result.length)
+    return result;
   } catch (e) {
     throw new Error(`ERROR DOWNLOADING COLORS: ${e}`);
   }

package/src/{apps/deploy-app/interfaces.ts → interfaces.ts}

@@ -14,7 +14,7 @@ export interface AppDeclaration {
   actions?: { [key: string]: AppActionDeclaration };
   appConfiguration: ConfigPropertyElements;
   triggers: { [key: string]: AppTriggerDeclaration };
-  workflows?: { [key: string]: WorkflowDefinitionDeclaration|WorkflowTemplateDeclaration }
+  workflows?: { [key: string]: WorkflowDefinition|WorkflowTemplateDeclaration }
 }
 
 export interface ConfigPropertyElements {
@@ -42,32 +42,38 @@ export interface AppTriggerDeclaration {
 }
 
 
-export interface WorkflowDefinitionDeclaration {
+export interface WorkflowDefinition {
   id?: string;
   identifier: string;
   name: string;
   triggerKey: string;
-  workflowDefinition: WorkflowDefinition;
+  workflowDefinition: WorkflowDefinitionPaths;
   ownerKey: string;
   isActive: boolean;
   public: boolean;
   supportingAppId?: string;
+  messageGroupId?: string;
+  parallelWorkerCount?: number;
 }
 
 export interface WorkflowTemplateDeclaration {
+  workflows?: { [key: string]: WorkflowTemplate }
+}
+
+export interface WorkflowTemplate {
   id?: string;
   identifier: string;
   name: string;
   triggerKey: string;
-  workflowDefinition: WorkflowDefinition;
-  ownerKey: string;
+  workflowDefinition: WorkflowDefinitionPaths;
   isActive: boolean;
+  ownerKey?: string;
   supportingAppId?: string;
   messageGroupId?: string;
   parallelWorkerCount?: number;
 }
 
-export interface WorkflowDefinition {
+export interface WorkflowDefinitionPaths {
   paths: WorkflowConditional[]
 }
 

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

@@ -0,0 +1,159 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { App, AppDeclaration, WorkflowTemplate, WorkflowTemplateDeclaration } from '../interfaces';
+import { getActionDeclarationIdentifier, getActionsForApp } from '../apps/deploy-app/actions-deployer'
+import { deleteWorkflowTemplate } from './workflowCommands';
+
+export class WorkflowTemplateDeployer {
+  async deployWorkflows(wtDeclaration: WorkflowTemplateDeclaration) {
+
+    // 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] as WorkflowTemplate,
+        existingWorkflows,
+      );
+    }
+  }
+
+  async getExistingWorkflowTemplates() {
+    return await new Entities().get({
+      entityName: 'event-workflow-template'
+    });
+  }
+
+  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 new Entities().create({
+      entityName: 'event-workflow-template',
+      object: 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);
+          console.log("response for action find:", actionEntity)
+          actionConfiguration.id = actionEntity.id;
+          console.log("found action 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 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;
+  }
+
+  public async deleteWorkflowTemplates(wtDeclaration: WorkflowTemplateDeclaration) {
+    // 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);
+
+      }
+    }
+
+  }
+
+  private async deleteWorkflowTemplate(identifier: string) {
+    return await new Entities().delete({
+      entityName: 'event-workflow-template',
+      id: identifier,
+    });
+  }
+
+  public async listExistingWorkflowTemplates() {
+    const templates =  await this.getExistingWorkflowTemplates();
+    console.log(templates);
+    return templates;
+  }
+}
+
+export function getWorkflowTemplateIdentifier(workflowKey: string) {
+  return workflowKey;
+}
+
+export async function getActionByIdentifier(identifier: string) {
+  const result = await new Entities().get({
+    entityName: 'event-workflow-action-definition',
+    criteria: { identifier },
+  });
+  return result.length > 0? result[0]: {};
+}

package/src/workflows/workflowCommands.ts

@@ -0,0 +1,54 @@
+
+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 { WorkflowTemplateDeployer } from './workflow-template-deployer';
+
+export async function deleteWorkflowTemplate() {
+  let wtDeclaration: WorkflowTemplateDeclaration;
+  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: WorkflowTemplateDeclaration;
+  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/src/apps/deploy-app/workflow-deployer.ts

@@ -1,111 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import { App, AppDeclaration, WorkflowTemplateDeclaration } from './interfaces';
-import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer'
-
-export class WorkflowDeployer {
-  async deployWorkflows(appDeclaration: AppDeclaration, app: 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] as WorkflowTemplateDeclaration,
-        app,
-        existingWorkflows,
-        appDeclaration);
-    }
-  }
-
-  async getWorkflowsForApp(app: App) {
-    return await new Entities().get({
-      entityName: 'event-workflow-template',
-      criteria: { ownerKey: `app:${app.id}` },
-    });
-  }
-
-  async deployWorkflow(workflowKey: string, workflow: WorkflowTemplateDeclaration, app: App, existingWorkflows: Array<any>, appDeclaration: 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);
-  }
-
-  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowTemplateDeclaration, app: App, appDeclaration: AppDeclaration) {
-    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
-    const newObject: WorkflowTemplateDeclaration = {
-      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;
-  }
-
-  private async populateActionIds(workflowDeclaration: WorkflowTemplateDeclaration, appDeclaration: AppDeclaration, app: App) {
-    let availableAppActions = await getActionsForApp(app);
-    if (!workflowDeclaration.workflowDefinition?.paths) {
-      return;
-    }
-    for (const path of workflowDeclaration.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 ${workflowDeclaration.name}`);
-        }
-        actionConfiguration.id = action.id;
-      }
-    }
-  }
-
-  private async updateWorkflowDefinition(existingWorkflowDefinition: WorkflowTemplateDeclaration, workflowDeclaration: WorkflowTemplateDeclaration, app: App, appDeclaration: 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: App) {
-    return app.identifier + ':' + actionKey;
-  }
-}