@contrail/cli 1.0.19 → 1.0.20

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,9 +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'));
@@ -16,7 +17,12 @@ export class AppDeployer {
             app = await this.updateExistingApp(appDeclaration, app);
         }
         await new ActionsDeployer().deployActions(appDeclaration, app);
-        await new WorkflowDeployer().deployWorkflows(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

@@ -19,7 +19,7 @@ export interface AppDeclaration {
         [key: string]: AppTriggerDeclaration;
     };
     workflows?: {
-        [key: string]: WorkflowDeclaration;
+        [key: string]: WorkflowDefinitionDeclaration | WorkflowTemplateDeclaration;
     };
 }
 export interface ConfigPropertyElements {
@@ -42,7 +42,7 @@ export interface AppTriggerDeclaration {
     external?: boolean;
     description?: string;
 }
-export interface WorkflowDeclaration {
+export interface WorkflowDefinitionDeclaration {
     id?: string;
     identifier: string;
     name: string;
@@ -50,6 +50,20 @@ export interface WorkflowDeclaration {
     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[];

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

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

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

@@ -34,7 +34,10 @@ export class WorkflowDeployer {
             ownerKey: `app:${app.id}`,
             triggerKey: workflowDeclaration.triggerKey,
             workflowDefinition: workflowDeclaration.workflowDefinition,
-            isActive: workflowDeclaration.isActive
+            isActive: workflowDeclaration.isActive,
+            supportingAppId: workflowDeclaration.supportingAppId,
+            messageGroupId: workflowDeclaration.messageGroupId,
+            parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
         };
         const workflowTemplate = await new Entities().create({
             entityName: 'event-workflow-template',

package/package.json

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

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

@@ -4,10 +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'));
@@ -17,7 +18,11 @@ export class AppDeployer {
       app = await this.updateExistingApp(appDeclaration, app);
     }
     await new ActionsDeployer().deployActions(appDeclaration, app);
-    await new WorkflowDeployer().deployWorkflows(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,7 +14,7 @@ export interface AppDeclaration {
   actions?: { [key: string]: AppActionDeclaration };
   appConfiguration: ConfigPropertyElements;
   triggers: { [key: string]: AppTriggerDeclaration };
-  workflows?: { [key: string]: WorkflowDeclaration }
+  workflows?: { [key: string]: WorkflowDefinitionDeclaration|WorkflowTemplateDeclaration }
 }
 
 export interface ConfigPropertyElements {
@@ -41,7 +41,20 @@ export interface AppTriggerDeclaration {
   description?: string;
 }
 
-export interface WorkflowDeclaration {
+
+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;
@@ -49,6 +62,9 @@ export interface WorkflowDeclaration {
   workflowDefinition: WorkflowDefinition;
   ownerKey: string;
   isActive: boolean;
+  supportingAppId?: string;
+  messageGroupId?: string;
+  parallelWorkerCount?: number;
 }
 
 export interface WorkflowDefinition {

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

@@ -1,7 +1,7 @@
 import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
-import { App, AppDeclaration, AppActionDeclaration, WorkflowDeclaration, WorkflowDefinition } from './interfaces';
-import {getActionDeclarationIdentifier, getActionsForApp} from './actions-deployer'
+import { App, AppDeclaration, WorkflowTemplateDeclaration } from './interfaces';
+import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer'
 
 export class WorkflowDeployer {
   async deployWorkflows(appDeclaration: AppDeclaration, app: App) {
@@ -13,7 +13,11 @@ export class WorkflowDeployer {
     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);
+      await this.deployWorkflow(workflowKey,
+        appDeclaration.workflows[workflowKey] as WorkflowTemplateDeclaration,
+        app,
+        existingWorkflows,
+        appDeclaration);
     }
   }
 
@@ -24,7 +28,7 @@ export class WorkflowDeployer {
     });
   }
 
-  async deployWorkflow(workflowKey: string, workflow: WorkflowDeclaration, app: App, existingWorkflows: Array<any>, appDeclaration: AppDeclaration) {
+  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);
@@ -36,15 +40,18 @@ export class WorkflowDeployer {
     return await this.createNewWorkflowDefinition(workflowKey, workflow, app, appDeclaration);
   }
 
-  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowDeclaration, app: App, appDeclaration: AppDeclaration) {
+  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowTemplateDeclaration, app: App, appDeclaration: AppDeclaration) {
     await this.populateActionIds(workflowDeclaration, appDeclaration, app);
-    const newObject: WorkflowDeclaration = {
+    const newObject: WorkflowTemplateDeclaration = {
       identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
       name: workflowDeclaration.name,
       ownerKey: `app:${app.id}`,
       triggerKey: workflowDeclaration.triggerKey,
       workflowDefinition: workflowDeclaration.workflowDefinition,
-      isActive: workflowDeclaration.isActive
+      isActive: workflowDeclaration.isActive,
+      supportingAppId: workflowDeclaration.supportingAppId,
+      messageGroupId: workflowDeclaration.messageGroupId,
+      parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
     };
 
     const workflowTemplate = await new Entities().create({
@@ -57,16 +64,16 @@ export class WorkflowDeployer {
     return workflowTemplate;
   }
 
-  private async populateActionIds(workflowDeclaration: WorkflowDeclaration, appDeclaration: AppDeclaration, app: App){
+  private async populateActionIds(workflowDeclaration: WorkflowTemplateDeclaration, appDeclaration: AppDeclaration, app: App) {
     let availableAppActions = await getActionsForApp(app);
-    if(!workflowDeclaration.workflowDefinition?.paths) {
+    if (!workflowDeclaration.workflowDefinition?.paths) {
       return;
     }
-    for(const path of workflowDeclaration.workflowDefinition.paths){
-      if(!path?.actionDefinitionConfigs) {
+    for (const path of workflowDeclaration.workflowDefinition.paths) {
+      if (!path?.actionDefinitionConfigs) {
         continue;
       }
-      for(const actionConfiguration of path.actionDefinitionConfigs) {
+      for (const actionConfiguration of path.actionDefinitionConfigs) {
         const actionKey = actionConfiguration.action;
         const action = availableAppActions.find(
           action => action.identifier === getActionDeclarationIdentifier(actionKey, app)
@@ -79,7 +86,7 @@ export class WorkflowDeployer {
     }
   }
 
-  private async updateWorkflowDefinition(existingWorkflowDefinition: WorkflowDeclaration, workflowDeclaration: WorkflowDeclaration, app: App, appDeclaration: AppDeclaration) {
+  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,

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"