@contrail/cli 1.0.18 → 1.0.20

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

@@ -1,10 +1,10 @@
 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 {
     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/actions-deployer.js

@@ -3,25 +3,28 @@ import chalk from 'chalk';
 import { ConfigPropertiesParser } from './app-template-parsers';
 import { getSeparatorByPlatform } from '../../common';
 import fs from 'fs';
+export async function getActionsForApp(app) {
+    return await new Entities().get({
+        entityName: 'event-workflow-action-definition',
+        criteria: { ownerKey: `app:${app.id}` },
+    });
+}
+export function getActionDeclarationIdentifier(actionKey, app) {
+    return app.identifier + ':' + actionKey;
+}
 export class ActionsDeployer {
     async deployActions(appDeclaration, app) {
         // FETCH ALL ACTIONS FROM THE API.
-        const existingActions = await this.getActionsForApp(app);
+        const existingActions = await 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 identifier = getActionDeclarationIdentifier(actionKey, app);
         const existingDefinition = existingActions.find(ad => ad.identifier === identifier);
         if (!existingDefinition) {
             await this.createNewActionDefinition(actionKey, actionDeclaration, app);
@@ -36,7 +39,7 @@ export class ActionsDeployer {
             configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
         }
         const newObject = {
-            identifier: this.getActionDeclarationIdentifier(actionKey, app),
+            identifier: getActionDeclarationIdentifier(actionKey, app),
             name: actionDeclaration.name,
             ownerKey: `app:${app.id}`,
             public: app.public,
@@ -78,9 +81,6 @@ export class ActionsDeployer {
         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;

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

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

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

@@ -3,8 +3,10 @@ import chalk from 'chalk';
 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) {
+    async deploy(appDeclaration, deployWorkflowTemplateOnly = false) {
         let app = await this.getExistingApp(appDeclaration);
         if (!app) {
             console.log(`%s      Creating new app.`, chalk.yellow.bold('APP'));
@@ -15,6 +17,12 @@ 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);
+        }
     }
     async getExistingApp(appDeclaration) {
         const orgId = Auth.config.orgId;

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

@@ -26,9 +26,10 @@ 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);
+        await new AppDeployer().deploy(appDeclaration, templateOnly);
     }
     catch (e) {
         console.log(`%s Application Deployment Failed. ${e}`, chalk.red.bold('FAIL'));

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

@@ -18,6 +18,9 @@ export interface AppDeclaration {
     triggers: {
         [key: string]: AppTriggerDeclaration;
     };
+    workflows?: {
+        [key: string]: WorkflowDefinitionDeclaration | WorkflowTemplateDeclaration;
+    };
 }
 export interface ConfigPropertyElements {
     [key: string]: ConfigPropertyElement;
@@ -39,6 +42,44 @@ export interface AppTriggerDeclaration {
     external?: boolean;
     description?: string;
 }
+export interface WorkflowDefinitionDeclaration {
+    id?: string;
+    identifier: string;
+    name: string;
+    triggerKey: string;
+    workflowDefinition: WorkflowDefinition;
+    ownerKey: string;
+    isActive: boolean;
+    public: boolean;
+    supportingAppId?: string;
+}
+export interface WorkflowTemplateDeclaration {
+    id?: string;
+    identifier: string;
+    name: string;
+    triggerKey: string;
+    workflowDefinition: WorkflowDefinition;
+    ownerKey: string;
+    isActive: boolean;
+    supportingAppId?: string;
+    messageGroupId?: string;
+    parallelWorkerCount?: number;
+}
+export interface WorkflowDefinition {
+    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;

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

@@ -0,0 +1,10 @@
+import { App, AppDeclaration, WorkflowDefinitionDeclaration } 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>;
+    private createNewWorkflowDefinition;
+    private populateActionIds;
+    private updateWorkflowDefinition;
+    getWorkflowDeclarationIdentifier(actionKey: any, app: App): string;
+}

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

@@ -0,0 +1,85 @@
+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'));
+        for (const workflowKey of Object.keys(appDeclaration.workflows)) {
+            await this.deployWorkflow(workflowKey, appDeclaration.workflows[workflowKey], app, existingWorkflows, appDeclaration);
+        }
+    }
+    async getWorkflowDefinitionsForApp(app) {
+        return await new Entities().get({
+            entityName: 'event-workflow-template-definition',
+            criteria: { ownerKey: `app:${app.id}` },
+        });
+    }
+    async deployWorkflow(workflowKey, workflow, app, existingWorkflows, appDeclaration) {
+        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.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,
+            public: workflowDeclaration.public,
+            isActive: workflowDeclaration.isActive,
+        };
+        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(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 workflow definition ${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-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {

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

@@ -6,11 +6,24 @@ import { getSeparatorByPlatform } from '../../common';
 
 import fs from 'fs';
 
+
+export async function getActionsForApp(app: App) {
+  return await new Entities().get({
+    entityName: 'event-workflow-action-definition',
+    criteria: { ownerKey: `app:${app.id}` },
+  });
+}
+
+
+export function getActionDeclarationIdentifier(actionKey, app: App) {
+  return app.identifier + ':' + actionKey;
+}
+
 export class ActionsDeployer {
   async deployActions(appDeclaration: AppDeclaration, app: App) {
 
     // FETCH ALL ACTIONS FROM THE API.
-    const existingActions = await this.getActionsForApp(app);
+    const existingActions = await getActionsForApp(app);
 
     // UPSERT / DELETE BASED ON ACTION IDENTIFIER
     console.log('%s \tDeploying actions.', chalk.yellow.bold('ACTION'));
@@ -19,18 +32,10 @@ export class ActionsDeployer {
       await this.deployAction(actionKey, appDeclaration.actions[actionKey], app, existingActions);
     }
   }
-
-  async getActionsForApp(app: App) {
-    return await new Entities().get({
-      entityName: 'event-workflow-action-definition',
-      criteria: { ownerKey: `app:${app.id}` },
-    });
-  }
-
   async deployAction(actionKey: string, actionDeclaration: AppActionDeclaration, app: App, existingActions: Array<any>) {
     console.log(`%s \tDeploying action: ${actionKey}`, chalk.yellow.bold('ACTION'));
 
-    const identifier = this.getActionDeclarationIdentifier(actionKey, app);
+    const identifier = getActionDeclarationIdentifier(actionKey, app);
     const existingDefinition = existingActions.find(ad => ad.identifier === identifier);
 
     if (!existingDefinition) {
@@ -46,7 +51,7 @@ export class ActionsDeployer {
       configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
     }
     const newObject: EventWorkflowActionDefinition = {
-      identifier: this.getActionDeclarationIdentifier(actionKey, app),
+      identifier: getActionDeclarationIdentifier(actionKey, app),
       name: actionDeclaration.name,
       ownerKey: `app:${app.id}`,
       public: app.public,  // TODO - an actions visibility is not tied to the visibility of the app
@@ -100,9 +105,6 @@ export class ActionsDeployer {
     return actionDefinition;
   }
 
-  getActionDeclarationIdentifier(actionKey, app: App) {
-    return app.identifier + ':' + actionKey;
-  }
 
   async getFunction(actionDeclaration: AppActionDeclaration): Promise<string> {
     if (!actionDeclaration.handler) {

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

@@ -4,9 +4,11 @@ import { Auth } from '../../auth/auth';
 import { ActionsDeployer } from './actions-deployer';
 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) {
+  public async deploy(appDeclaration: AppDeclaration, deployWorkflowTemplateOnly = false) {
     let app = await this.getExistingApp(appDeclaration);
     if (!app) {
       console.log(`%s      Creating new app.`, chalk.yellow.bold('APP'));
@@ -16,6 +18,11 @@ 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);
+    }
   }
 
   public async getExistingApp(appDeclaration: AppDeclaration): Promise<App> {

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

@@ -29,10 +29,10 @@ 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);
+    await new AppDeployer().deploy(appDeclaration, templateOnly);
   }
   catch (e) {
     console.log(`%s Application Deployment Failed. ${e}`, chalk.red.bold('FAIL'));

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

@@ -14,6 +14,7 @@ export interface AppDeclaration {
   actions?: { [key: string]: AppActionDeclaration };
   appConfiguration: ConfigPropertyElements;
   triggers: { [key: string]: AppTriggerDeclaration };
+  workflows?: { [key: string]: WorkflowDefinitionDeclaration|WorkflowTemplateDeclaration }
 }
 
 export interface ConfigPropertyElements {
@@ -40,6 +41,47 @@ export interface AppTriggerDeclaration {
   description?: string;
 }
 
+
+export interface WorkflowDefinitionDeclaration {
+  id?: string;
+  identifier: string;
+  name: string;
+  triggerKey: string;
+  workflowDefinition: WorkflowDefinition;
+  ownerKey: string;
+  isActive: boolean;
+  public: boolean;
+  supportingAppId?: string;
+}
+
+export interface WorkflowTemplateDeclaration {
+  id?: string;
+  identifier: string;
+  name: string;
+  triggerKey: string;
+  workflowDefinition: WorkflowDefinition;
+  ownerKey: string;
+  isActive: boolean;
+  supportingAppId?: string;
+  messageGroupId?: string;
+  parallelWorkerCount?: number;
+}
+
+export interface WorkflowDefinition {
+  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;

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

@@ -0,0 +1,110 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { App, AppDeclaration, WorkflowDefinitionDeclaration } from './interfaces';
+import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer'
+
+export class WorkflowDefinitionDeployer {
+  async deployWorkflowDefinitions(appDeclaration: AppDeclaration, app: 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'));
+
+    for (const workflowKey of Object.keys(appDeclaration.workflows)) {
+      await this.deployWorkflow(
+        workflowKey, appDeclaration.workflows[workflowKey] as WorkflowDefinitionDeclaration,
+        app,
+        existingWorkflows,
+        appDeclaration
+      );
+    }
+  }
+
+  async getWorkflowDefinitionsForApp(app: App) {
+    return await new Entities().get({
+      entityName: 'event-workflow-template-definition',
+      criteria: { ownerKey: `app:${app.id}` },
+    });
+  }
+
+  async deployWorkflow(workflowKey: string, workflow: WorkflowDefinitionDeclaration, app: App, existingWorkflows: Array<any>, appDeclaration: AppDeclaration) {
+    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.createNewWorkflowDefinition(workflowKey, workflow, app, appDeclaration);
+  }
+
+  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowDefinitionDeclaration, app: App, appDeclaration: AppDeclaration) {
+    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+    const newObject: WorkflowDefinitionDeclaration = {
+      identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
+      name: workflowDeclaration.name,
+      ownerKey: `app:${app.id}`,
+      triggerKey: workflowDeclaration.triggerKey,
+      workflowDefinition: workflowDeclaration.workflowDefinition,
+      public: workflowDeclaration.public,
+      isActive: workflowDeclaration.isActive,
+    };
+
+    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;
+  }
+
+  private async populateActionIds(workflowDeclaration: WorkflowDefinitionDeclaration, 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 workflow definition ${workflowDeclaration.name}`);
+        }
+        actionConfiguration.id = action.id;
+      }
+    }
+  }
+
+  private async updateWorkflowDefinition(existingWorkflowDefinition: WorkflowDefinitionDeclaration, workflowDeclaration: WorkflowDefinitionDeclaration, 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-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: App) {
+    return app.identifier + ':' + actionKey;
+  }
+}

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

@@ -0,0 +1,111 @@
+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;
+  }
+}

package/templates/javascript/app.yml

@@ -38,17 +38,16 @@ triggers:
     external: true
     description: "Triggers on externally created products"
 
-# TODO - This is not read
-workflows: 
-  workflow1: 
-    name: "Update item on product creation"
-    triggerKey: product|create
-    paths:
-      path1: 
-        conditional: "{retailPrice} > 10"
-        actions: 
-          updateItem: 
-            actionId: updateItem
-            configuration:
-
-
+# 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"