@contrail/cli 1.0.18 → 1.0.19

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.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { Auth } from '../../auth/auth';
 import { ActionsDeployer } from './actions-deployer';
 import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
+import { WorkflowDeployer } from './workflow-deployer';
 export class AppDeployer {
     async deploy(appDeclaration) {
         let app = await this.getExistingApp(appDeclaration);
@@ -15,6 +16,7 @@ export class AppDeployer {
             app = await this.updateExistingApp(appDeclaration, app);
         }
         await new ActionsDeployer().deployActions(appDeclaration, app);
+        await new WorkflowDeployer().deployWorkflows(appDeclaration, app);
     }
     async getExistingApp(appDeclaration) {
         const orgId = Auth.config.orgId;

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

@@ -18,6 +18,9 @@ export interface AppDeclaration {
     triggers: {
         [key: string]: AppTriggerDeclaration;
     };
+    workflows?: {
+        [key: string]: WorkflowDeclaration;
+    };
 }
 export interface ConfigPropertyElements {
     [key: string]: ConfigPropertyElement;
@@ -39,6 +42,30 @@ export interface AppTriggerDeclaration {
     external?: boolean;
     description?: string;
 }
+export interface WorkflowDeclaration {
+    id?: string;
+    identifier: string;
+    name: string;
+    triggerKey: string;
+    workflowDefinition: WorkflowDefinition;
+    ownerKey: string;
+    isActive: boolean;
+}
+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-deployer.d.ts

@@ -0,0 +1,10 @@
+import { App, AppDeclaration, WorkflowDeclaration } from './interfaces';
+export declare class WorkflowDeployer {
+    deployWorkflows(appDeclaration: AppDeclaration, app: App): Promise<void>;
+    getWorkflowsForApp(app: App): Promise<any>;
+    deployWorkflow(workflowKey: string, workflow: WorkflowDeclaration, 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,84 @@
+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
+        };
+        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.19",
   "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,6 +4,7 @@ import { Auth } from '../../auth/auth';
 import { ActionsDeployer } from './actions-deployer';
 import { App, AppDeclaration } from './interfaces';
 import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
+import { WorkflowDeployer } from './workflow-deployer';
 
 export class AppDeployer {
   public async deploy(appDeclaration: AppDeclaration) {
@@ -16,6 +17,7 @@ export class AppDeployer {
       app = await this.updateExistingApp(appDeclaration, app);
     }
     await new ActionsDeployer().deployActions(appDeclaration, app);
+    await new WorkflowDeployer().deployWorkflows(appDeclaration, app);
   }
 
   public async getExistingApp(appDeclaration: AppDeclaration): Promise<App> {

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]: WorkflowDeclaration }
 }
 
 export interface ConfigPropertyElements {
@@ -40,6 +41,31 @@ export interface AppTriggerDeclaration {
   description?: string;
 }
 
+export interface WorkflowDeclaration {
+  id?: string;
+  identifier: string;
+  name: string;
+  triggerKey: string;
+  workflowDefinition: WorkflowDefinition;
+  ownerKey: string;
+  isActive: boolean;
+}
+
+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-deployer.ts

@@ -0,0 +1,104 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { App, AppDeclaration, AppActionDeclaration, WorkflowDeclaration, WorkflowDefinition } 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], 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: WorkflowDeclaration, 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: WorkflowDeclaration, app: App, appDeclaration: AppDeclaration) {
+    await this.populateActionIds(workflowDeclaration, appDeclaration, app);
+    const newObject: WorkflowDeclaration = {
+      identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
+      name: workflowDeclaration.name,
+      ownerKey: `app:${app.id}`,
+      triggerKey: workflowDeclaration.triggerKey,
+      workflowDefinition: workflowDeclaration.workflowDefinition,
+      isActive: workflowDeclaration.isActive
+    };
+
+    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: WorkflowDeclaration, 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: WorkflowDeclaration, workflowDeclaration: WorkflowDeclaration, 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;
+  }
+}