@contrail/cli 1.0.27 → 1.0.29

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

@@ -35,7 +35,7 @@ export class ActionsDeployer {
             await this.createNewActionDefinition(actionKey, actionDeclaration, app);
         }
         else {
-            await this.updateActionDefinition(existingDefinition, actionDeclaration);
+            await this.updateActionDefinition(existingDefinition, actionDeclaration, app);
         }
     }
     async createNewActionDefinition(actionKey, actionDeclaration, app) {
@@ -47,7 +47,7 @@ export class ActionsDeployer {
             identifier: getActionDeclarationIdentifier(actionKey, app),
             name: actionDeclaration.name,
             ownerKey: `app:${app.id}`,
-            public: app.public,
+            public: 'public' in actionDeclaration ? actionDeclaration.public : app.public,
             configProperties,
         };
         const functionString = await this.getFunction(actionDeclaration);
@@ -61,7 +61,7 @@ export class ActionsDeployer {
         console.log(`%s      Created new action definition: ${actionKey}`, chalk.yellow.bold('APP'));
         return actionDefinition;
     }
-    async updateActionDefinition(existingActionDefinition, actionDeclaration) {
+    async updateActionDefinition(existingActionDefinition, actionDeclaration, app) {
         let configProperties;
         if (actionDeclaration === null || actionDeclaration === void 0 ? void 0 : actionDeclaration.actionConfiguration) {
             configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
@@ -71,7 +71,7 @@ export class ActionsDeployer {
         }
         const updates = {
             name: actionDeclaration.name,
-            // public: actionDeclaration.public, // TODO - an actions visibility is allowed to change
+            public: 'public' in actionDeclaration ? actionDeclaration.public : app.public,
             configProperties,
         };
         const functionString = await this.getFunction(actionDeclaration);

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

@@ -0,0 +1,76 @@
+/** 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;
+    };
+    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 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/apps/deploy-app/interfaces.js

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

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/lib/interfaces.d.ts

@@ -34,6 +34,7 @@ export interface ConfigPropertyElement {
 }
 export interface AppActionDeclaration {
     handler: string;
+    public?: boolean;
     name: string;
     description?: string;
     actionConfiguration?: ConfigPropertyElements;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {
@@ -45,9 +45,9 @@
     "@types/jest": "^23.3.14",
     "@types/lodash": "^4.14.178",
     "@types/node": "^14.6.4",
-    "jest": "^23.6.0",
+    "jest": "^29.3.1",
     "prettier": "^1.19.1",
-    "ts-jest": "^23.10.5",
+    "ts-jest": "^29.0.3",
     "tslint": "^5.11.0",
     "tslint-config-prettier": "^1.18.0",
     "typescript": "^3.0.1"

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

@@ -46,7 +46,7 @@ export class ActionsDeployer {
     if (!existingDefinition) {
       await this.createNewActionDefinition(actionKey, actionDeclaration, app);
     } else {
-      await this.updateActionDefinition(existingDefinition, actionDeclaration);
+      await this.updateActionDefinition(existingDefinition, actionDeclaration, app);
     }
   }
 
@@ -59,7 +59,7 @@ export class ActionsDeployer {
       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
+      public: 'public' in actionDeclaration? actionDeclaration.public: app.public,
       configProperties,
     };
 
@@ -78,7 +78,7 @@ export class ActionsDeployer {
     return actionDefinition;
   }
 
-  private async updateActionDefinition(existingActionDefinition: EventWorkflowActionDefinition, actionDeclaration: AppActionDeclaration) {
+  private async updateActionDefinition(existingActionDefinition: EventWorkflowActionDefinition, actionDeclaration: AppActionDeclaration, app: App) {
 
     let configProperties;
     if (actionDeclaration?.actionConfiguration) {
@@ -90,7 +90,7 @@ export class ActionsDeployer {
 
     const updates: EventWorkflowActionDefinition = {
       name: actionDeclaration.name,
-      // public: actionDeclaration.public, // TODO - an actions visibility is allowed to change
+      public: 'public' in actionDeclaration? actionDeclaration.public: app.public,
       configProperties,
     };
 

package/src/interfaces.ts

@@ -31,6 +31,7 @@ export interface ConfigPropertyElement {
 
 export interface AppActionDeclaration {
   handler: string;
+  public?: boolean;
   name: string;
   description?: string;
   actionConfiguration?: ConfigPropertyElements;