@contrail/cli 1.0.0 → 1.0.5

package/.vscode/settings.json

@@ -1,6 +1,6 @@
-{
-  "editor.tabSize": 2,
-  "editor.codeActionsOnSave": {
-    "source.fixAll.tslint": true
-  }
+{
+  "editor.tabSize": 2,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.tslint": true
+  }
 }

package/bin/init

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
-
-require = require('esm')(module /*, options*/);
+#!/usr/bin/env node
+
+require = require('esm')(module /*, options*/);
 require('../lib/cli').cli(process.argv);

package/lib/{create-app → apps/create-app}/create.d.ts

@@ -1 +1 @@
-export declare function create(args: any): Promise<void>;
+export declare function create(args: any): Promise<void>;

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

@@ -0,0 +1,59 @@
+import arg from 'arg';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { setUpTemplate } from './setup-template';
+function parseArgumentsIntoOptions(rawArgs) {
+    const args = arg({
+        '--app-name': String,
+        '--template': String,
+        '-n': '--app-name',
+        '-t': '--template',
+    }, {
+        argv: rawArgs.slice(3),
+    });
+    return {
+        appName: args['--app-name'],
+        template: args['--template'],
+    };
+}
+async function promptForMissingOptions(options) {
+    const defaultTemplate = 'JavaScript';
+    const questions = [];
+    if (!options.appName) {
+        questions.push({
+            type: 'input',
+            name: 'appName',
+            validate: (val) => !!val,
+            message: 'What is the name of your app?',
+        });
+    }
+    if (!options.template) {
+        questions.push({
+            type: 'list',
+            name: 'template',
+            message: 'Which project template would you like to use?',
+            choices: ['JavaScript', 'TypeScript'],
+            default: defaultTemplate,
+        });
+    }
+    const answers = await inquirer.prompt(questions);
+    return Object.assign(Object.assign({}, options), { appName: options.appName || answers.appName, template: options.template || answers.template });
+}
+export async function create(args) {
+    let options = parseArgumentsIntoOptions(args);
+    options = await promptForMissingOptions(options);
+    console.log('%s Setting up new new contrail application.', chalk.blue.bold('START'));
+    let error;
+    try {
+        await setUpTemplate(options);
+    }
+    catch (e) {
+        error = e;
+    }
+    if (error) {
+        console.log('%s Application initialization failed.', chalk.red.bold('FAIL'));
+    }
+    else {
+        console.log('%s Application initialized successfully.', chalk.green.bold('COMPLETE'));
+    }
+}

package/lib/apps/create-app/setup-template.d.ts

@@ -0,0 +1 @@
+export declare function setUpTemplate(options: any): Promise<void>;

package/lib/apps/create-app/setup-template.js

@@ -0,0 +1,34 @@
+import ncp from 'ncp';
+import path from 'path';
+import { promisify } from 'util';
+const Listr = require('listr');
+import { projectInstall } from 'pkg-install';
+const copy = promisify(ncp);
+const TARGET_DIR = process.cwd();
+const currentFileUrl = import.meta.url;
+function copyTemplate(templateDir) {
+    return copy(templateDir, TARGET_DIR, {
+        clobber: false,
+    });
+}
+export async function setUpTemplate(options) {
+    const templateDir = path.resolve(new URL(currentFileUrl).pathname, `../../../../templates/${options.template.toLocaleLowerCase()}`).replace(/\\/g, '\\').replace(/(.):\\(.):/g, '').replace(/%20/g, ' ');
+    try {
+        const tasks = new Listr([
+            {
+                title: 'Copy template files',
+                task: () => copyTemplate(templateDir),
+            },
+            {
+                title: 'Install dependencies',
+                task: () => projectInstall({
+                    cwd: TARGET_DIR,
+                }),
+            },
+        ]);
+        await tasks.run();
+    }
+    catch (e) {
+        throw new Error(`Error copying template: ${e}`);
+    }
+}

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

@@ -1,10 +1,10 @@
-import { App, AppDeclartion, AppActionDeclaration } from './interfaces';
-export declare class ActionsDeployer {
-    deployActions(appDeclaration: AppDeclartion, 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>;
-}
+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/{deploy-app → apps/deploy-app}/actions-deployer.js

@@ -1,78 +1,97 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import fs from 'fs';
-export class ActionsDeployer {
-    async deployActions(appDeclaration, app) {
-        // FETCH ALL ACTIONS FROM THE API.
-        const existingActions = await this.getActionsForApp(app);
-        console.log('existingActions: ', existingActions);
-        // 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) {
-        const newObject = {
-            identifier: this.getActionDeclarationIdentifier(actionKey, app),
-            name: actionDeclaration.name,
-            ownerKey: `app:${app.id}`,
-            public: !app.private,
-        };
-        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 defintion: ${actionKey}`, chalk.yellow.bold('APP'));
-        return actionDefinition;
-    }
-    async updateActionDefinition(existingActionDefinition, actionDeclaration) {
-        const updates = {
-            name: actionDeclaration.name,
-        };
-        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 existingaction defintion: ${actionDefinition.identifier}`, chalk.yellow.bold('APP'));
-        return actionDefinition;
-    }
-    getActionDeclarationIdentifier(actionKey, app) {
-        return app.identifier + ':' + actionKey;
-    }
-    async getFunction(actionDeclaration) {
-        if (!actionDeclaration.handler) {
-            return;
-        }
-        const CURRENT_DIR = process.cwd();
-        const functionLocaiton = CURRENT_DIR + '\\' + actionDeclaration.handler;
-        console.log('getFunction: ', functionLocaiton);
-        const content = fs.readFileSync(functionLocaiton);
-        console.log('content: ', content.toString());
-        return content.toString();
-    }
-}
+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 existingaction defintion: ${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/app-deployer.d.ts

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

package/lib/{deploy-app → apps/deploy-app}/app-deployer.js

@@ -1,58 +1,79 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import { ActionsDeployer } from './actions-deployer';
-export class AppDeployer {
-    async deploy(appDeclaration) {
-        let app = await this.getExistingApp(appDeclaration);
-        if (!app) {
-            app = await this.createNewApp(appDeclaration);
-        }
-        else {
-            app = await this.updateExistingApp(appDeclaration, app);
-        }
-        this.app = app;
-        await new ActionsDeployer().deployActions(appDeclaration, this.app);
-    }
-    async remove(appDeclaration) {
-        let app = await this.getExistingApp(appDeclaration);
-        if (app) {
-            app = await new Entities().delete({ entityName: 'app', id: app.id });
-            console.log(`%s      Deleted app: ${app.name}`, chalk.yellow.bold('APP'));
-        }
-        else {
-            console.log(`%s      App not found. Can not remove`, chalk.red.bold('APP'));
-        }
-    }
-    async getExistingApp(appDeclaration) {
-        const apps = await new Entities().get({ entityName: 'app', criteria: { orgId: '-VMrLJrt3clDKPi0', private: (appDeclaration.visibility === 'private') } });
-        //    console.log('Existing: ', apps);
-        return apps.find(app => app.identifier === appDeclaration.appIdentifier);
-    }
-    async updateExistingApp(appDeclaration, existingApp) {
-        const updates = {
-            name: appDeclaration.appName,
-            public: appDeclaration.visibility === 'public',
-            description: appDeclaration.appDescription,
-            publisher: appDeclaration.publisher,
-            thumbnail: appDeclaration.thumbnail,
-            eventWorkflowTriggerKeyMapping: 'NONE',
-        };
-        const app = await new Entities().update({ entityName: 'app', id: existingApp.id, object: updates });
-        console.log(`%s      Updated app: ${app.name}`, chalk.yellow.bold('APP'));
-        return app;
-    }
-    async createNewApp(appDeclaration) {
-        const newApp = {
-            identifier: appDeclaration.appIdentifier,
-            name: appDeclaration.appName,
-            public: appDeclaration.visibility === 'public',
-            description: appDeclaration.appDescription,
-            publisher: appDeclaration.publisher,
-            thumbnail: appDeclaration.thumbnail,
-            eventWorkflowTriggerKeyMapping: 'NONE',
-        };
-        const app = await new Entities().create({ entityName: 'app', object: newApp });
-        console.log(`%s      Created new app: ${app.name}`, chalk.yellow.bold('APP'));
-        return app;
-    }
-}
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { Auth } from '../../auth/auth';
+import { ActionsDeployer } from './actions-deployer';
+import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
+export class AppDeployer {
+    async deploy(appDeclaration) {
+        let app = await this.getExistingApp(appDeclaration);
+        if (!app) {
+            app = await this.createNewApp(appDeclaration);
+        }
+        else {
+            app = await this.updateExistingApp(appDeclaration, app);
+        }
+        await new ActionsDeployer().deployActions(appDeclaration, app);
+    }
+    async getExistingApp(appDeclaration) {
+        const orgId = Auth.config.orgId;
+        const apps = [];
+        apps.push(...await new Entities().get({
+            entityName: 'app',
+            criteria: {
+                orgId,
+                private: true,
+            },
+        }));
+        apps.push(...await new Entities().get({
+            entityName: 'app',
+            criteria: {
+                orgId,
+                private: false,
+            },
+        }));
+        return apps.find(app => app.identifier === appDeclaration.appIdentifier);
+    }
+    async createNewApp(appDeclaration) {
+        const newApp = {
+            identifier: appDeclaration.appIdentifier,
+            name: appDeclaration.appName,
+            public: appDeclaration.visibility === 'public',
+            description: appDeclaration.appDescription,
+            publisher: appDeclaration.publisher,
+            thumbnail: appDeclaration.thumbnail,
+            eventWorkflowTriggerKeyMapping: appDeclaration.eventWorkflowTriggerKeyMapping,
+            keywords: appDeclaration.keywords,
+            configProperties: ConfigPropertiesParser.getConfigProperties(appDeclaration.appConfiguration),
+            triggerKeyDefinitions: TriggerKeyDefinitionParser.buildTriggersArray(appDeclaration),
+        };
+        const app = await new Entities().create({ entityName: 'app', object: newApp });
+        console.log(`%s      Created new app: ${app.name}`, chalk.yellow.bold('APP'));
+        return app;
+    }
+    async updateExistingApp(appDeclaration, existingApp) {
+        const updates = {
+            name: appDeclaration.appName,
+            public: appDeclaration.visibility === 'public',
+            description: appDeclaration.appDescription,
+            publisher: appDeclaration.publisher,
+            thumbnail: appDeclaration.thumbnail,
+            eventWorkflowTriggerKeyMapping: appDeclaration.eventWorkflowTriggerKeyMapping,
+            keywords: appDeclaration.keywords,
+            configProperties: ConfigPropertiesParser.getConfigProperties(appDeclaration.appConfiguration),
+            triggerKeyDefinitions: TriggerKeyDefinitionParser.buildTriggersArray(appDeclaration),
+        };
+        const app = await new Entities().update({ entityName: 'app', id: existingApp.id, object: updates });
+        console.log(`%s      Updated app: ${app.name}`, chalk.yellow.bold('APP'));
+        return app;
+    }
+    async remove(appDeclaration) {
+        let app = await this.getExistingApp(appDeclaration);
+        if (app) {
+            app = await new Entities().delete({ entityName: 'app', id: app.id });
+            console.log(`%s      Deleted app: ${app.name}`, chalk.yellow.bold('APP'));
+        }
+        else {
+            throw new Error('App not found.');
+        }
+    }
+}

package/lib/apps/deploy-app/app-template-parsers.d.ts

@@ -0,0 +1,7 @@
+import { AppDeclaration, TriggerKeyDefinition, ConfigPropertyElements } from './interfaces';
+export declare class TriggerKeyDefinitionParser {
+    static buildTriggersArray(appDeclaration: AppDeclaration): Array<TriggerKeyDefinition>;
+}
+export declare class ConfigPropertiesParser {
+    static getConfigProperties(configPropertyElements: ConfigPropertyElements): any[];
+}

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

@@ -0,0 +1,37 @@
+export class TriggerKeyDefinitionParser {
+    static buildTriggersArray(appDeclaration) {
+        const triggers = [];
+        for (const triggerName of Object.keys(appDeclaration.triggers)) {
+            const triggerDeclaration = appDeclaration.triggers[triggerName];
+            const triggerDefinition = {
+                triggerKey: triggerDeclaration.external ? `${appDeclaration.appIdentifier}:${triggerDeclaration.key}` : triggerDeclaration.key,
+                name: triggerDeclaration.name,
+                external: triggerDeclaration.external,
+                description: triggerDeclaration.description,
+            };
+            if (!triggerDefinition.triggerKey || !triggerDefinition.name) {
+                throw new Error('Illegal trigger declaration: must have key and name');
+            }
+            triggers.push(triggerDefinition);
+        }
+        return triggers;
+    }
+}
+export class ConfigPropertiesParser {
+    static getConfigProperties(configPropertyElements) {
+        const appConfiguration = [];
+        for (const configKey of Object.keys(configPropertyElements)) {
+            const declaration = configPropertyElements[configKey];
+            const config = {
+                label: declaration.label,
+                slug: configKey,
+                propertyType: declaration.propertyType,
+            };
+            if (declaration.options) {
+                config.options = declaration.options;
+            }
+            appConfiguration.push(config);
+        }
+        return appConfiguration;
+    }
+}

package/lib/{deploy-app → apps/deploy-app}/deploy.d.ts

@@ -1,2 +1,2 @@
-export declare function deployApp(args: any): Promise<void>;
-export declare function removeApp(args: any): Promise<void>;
+export declare function deployApp(args: any): Promise<void>;
+export declare function removeApp(args: any): Promise<void>;

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

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../../auth/login';
+import { AppDeployer } from './app-deployer';
+import { getSeparatorByPlatform } from '../../common';
+const yaml = require('js-yaml');
+function loadAppConfig() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'app.yml', 'utf8'));
+        console.log(doc);
+        return doc;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+export async function deployApp(args) {
+    let appDeclaration;
+    try {
+        appDeclaration = loadAppConfig();
+    }
+    catch (e) {
+        console.log(`%s Application Deployment Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log(`%s Deploying Application. ${appDeclaration.appIdentifier}`, chalk.blue.bold('START'));
+    try {
+        await authUser();
+        await new AppDeployer().deploy(appDeclaration);
+    }
+    catch (e) {
+        console.log(`%s Application Deployment Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Deployment Complete.', chalk.green.bold('COMPLETE'));
+}
+export async function removeApp(args) {
+    let appDeclaration;
+    try {
+        appDeclaration = loadAppConfig();
+    }
+    catch (e) {
+        console.log(`%s Application Removal Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log(`%s Removing Application. ${appDeclaration.appIdentifier}`, chalk.blue.bold('START'));
+    try {
+        await authUser();
+        await new AppDeployer().remove(appDeclaration);
+    }
+    catch (e) {
+        console.log(`%s Application Removal Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Application Removal Complete.', chalk.green.bold('COMPLETE'));
+}