@contrail/cli 1.0.22 → 1.0.24

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;
@@ -63,6 +57,7 @@ export class AppDeployer {
             keywords: appDeclaration.keywords,
             configProperties,
             triggerKeyDefinitions,
+            isDockerBased: appDeclaration.isDockerBased,
         };
         const app = await new Entities().create({ entityName: 'app', object: newApp });
         console.log(`%s      Created new app: ${app.name}`, chalk.yellow.bold('APP'));
@@ -87,6 +82,7 @@ export class AppDeployer {
             keywords: appDeclaration.keywords,
             configProperties,
             triggerKeyDefinitions,
+            isDockerBased: appDeclaration.isDockerBased,
         };
         const app = await new Entities().update({ entityName: 'app', id: existingApp.id, object: updates });
         console.log(`%s      Updated app: ${app.name}`, chalk.yellow.bold('APP'));

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/docker-action-builder.d.ts

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

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

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

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

@@ -18,9 +18,7 @@ export interface AppDeclaration {
     triggers: {
         [key: string]: AppTriggerDeclaration;
     };
-    workflows?: {
-        [key: string]: WorkflowDefinitionDeclaration | WorkflowTemplateDeclaration;
-    };
+    isDockerBased?: boolean;
 }
 export interface ConfigPropertyElements {
     [key: string]: ConfigPropertyElement;
@@ -42,44 +40,6 @@ 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;
@@ -106,6 +66,7 @@ export interface EventWorkflowActionDefinition {
     ownerKey?: string;
     public?: boolean;
     configProperties?: ConfigProperty[];
+    isDockerBased?: boolean;
 }
 export declare class TriggerKeyDefinition {
     name: string;

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,124 @@
+/** 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;
+    };
+    isDockerBased?: boolean;
+}
+export interface ConfigPropertyElements {
+    [key: string]: ConfigPropertyElement;
+}
+export interface ConfigPropertyElement {
+    propertyType: string;
+    options?: any[];
+    label: string;
+}
+export interface AppActionDeclaration {
+    handler: string;
+    name: string;
+    description?: string;
+    actionConfiguration?: ConfigPropertyElements;
+}
+export interface AppTriggerDeclaration {
+    key: string;
+    name: string;
+    external?: boolean;
+    description?: string;
+}
+export interface 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[];
+    isDockerBased?: boolean;
+}
+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>;