@contrail/cli 1.0.0

package/.vscode/settings.json

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

package/bin/init

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

package/lib/auth/login.d.ts

@@ -0,0 +1 @@
+export declare function authUser(): Promise<unknown>;

package/lib/auth/login.js

@@ -0,0 +1,79 @@
+const AmazonCognitoIdentity = require('amazon-cognito-identity-js');
+import inquirer from 'inquirer';
+import { setConfig } from '@contrail/sdk';
+const CONFIGURATION = {
+    userPoolId: 'us-east-1_x8hXZUsL6',
+    clientId: process.env.CONTRAIL_COGNITO_CLIENT_ID || '2oubek96sue5rsncovtqhs3scm',
+};
+export async function authUser() {
+    const questions = [];
+    if (!process.env.CONTRAIL_CLI_EMAIL) {
+        questions.push({
+            type: 'input',
+            name: 'email',
+            validate: (val) => !!val,
+            message: 'Email',
+        });
+    }
+    if (!process.env.CONTRAIL_CLI_PASSWORD) {
+        questions.push({
+            type: 'password',
+            name: 'password',
+            validate: (val) => !!val,
+            message: 'Password',
+        });
+    }
+    if (!process.env.CONTRAIL_CLI_ORGSLUG) {
+        questions.push({
+            type: 'input',
+            name: 'orgSlug',
+            validate: (val) => !!val,
+            message: 'Org (slug)',
+        });
+    }
+    const answers = await inquirer.prompt(questions);
+    const params = {
+        email: process.env.CONTRAIL_CLI_EMAIL || answers.email,
+        password: process.env.CONTRAIL_CLI_PASSWORD || answers.password,
+        orgSlug: process.env.CONTRAIL_CLI_ORGSLUG || answers.orgSlug,
+    };
+    if (!params.email || !params.password) {
+        throw new Error('email and password required');
+    }
+    const poolData = {
+        UserPoolId: CONFIGURATION.userPoolId,
+        ClientId: CONFIGURATION.clientId,
+    };
+    const userPool = new AmazonCognitoIdentity.CognitoUserPool(poolData);
+    const authData = {
+        Username: params.email,
+        Password: params.password,
+    };
+    const authDetails = new AmazonCognitoIdentity.AuthenticationDetails(authData);
+    const userData = {
+        Username: params.email,
+        Pool: userPool,
+    };
+    const cognitoUser = new AmazonCognitoIdentity.CognitoUser(userData);
+    return new Promise((resolve, reject) => {
+        cognitoUser.authenticateUser(authDetails, {
+            onSuccess: async (result) => {
+                const user = result;
+                await setSDKConfig(user, params.orgSlug);
+                resolve({ success: true, data: result });
+            },
+            onFailure: (err) => {
+                console.log('authUser error: ' + err);
+                reject(err);
+            },
+        });
+    });
+}
+async function setSDKConfig(user, orgSlug) {
+    // console.log('user:', user);
+    setConfig({
+        apiUserToken: user.idToken.jwtToken,
+        apiGateway: process.env.API_GATEWAY,
+        orgSlug,
+    });
+}

package/lib/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  Built using documentation here:
+ *  https://www.twilio.com/blog/how-to-build-a-cli-with-node-js
+ */
+export declare function cli(args: any): Promise<void>;

package/lib/cli.js

@@ -0,0 +1,30 @@
+import { create } from './create-app/create';
+import { deployApp, removeApp } from './deploy-app/deploy';
+/**
+ *  Built using documentation here:
+ *  https://www.twilio.com/blog/how-to-build-a-cli-with-node-js
+ */
+export async function cli(args) {
+    const command = args[2];
+    switch (command) {
+        case 'create-app': {
+            create(args);
+            break;
+        }
+        case 'deploy-app': {
+            deployApp(args);
+            break;
+        }
+        case 'remove-app': {
+            removeApp(args);
+            break;
+        }
+        case 'extract-types': {
+            removeApp(args);
+            break;
+        }
+        default: {
+            console.log('Illegal command.');
+        }
+    }
+}

package/lib/create-app/create.d.ts

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

package/lib/create-app/create.js

@@ -0,0 +1,48 @@
+import arg from 'arg';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { setUpTemplate } from './setup-template';
+function parseArgumentsIntoOptions(rawArgs) {
+    const args = arg({
+        '--create-app': Boolean,
+        '--app-name': String,
+        '-c': '--create-app',
+        '-n': '--app-name',
+    }, {
+        argv: rawArgs.slice(2),
+    });
+    return {
+        createApp: args['--create-app'] || false,
+        appName: args['--app-name']
+    };
+}
+async function promptForMissingOptions(options) {
+    const defaultTemplate = 'JavaScript';
+    if (options.skipPrompts) {
+        return {
+            ...options,
+            template: options.template || defaultTemplate,
+        };
+    }
+    const questions = [];
+    if (!options.appName) {
+        questions.push({
+            type: 'input',
+            name: 'appName',
+            validate: (val) => { return !!val; },
+            message: 'What is the name of your app?',
+        });
+    }
+    const answers = await inquirer.prompt(questions);
+    return {
+        ...options,
+        appName: options.appName || answers.appName,
+    };
+}
+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'));
+    await setUpTemplate();
+    console.log('%s Application initialized successfully.', chalk.green.bold('COMPLETE'));
+}

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

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

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

@@ -0,0 +1,48 @@
+import ncp from 'ncp';
+import path from 'path';
+import { promisify } from 'util';
+import execa from 'execa';
+const Listr = require('listr');
+import { projectInstall } from 'pkg-install';
+const copy = promisify(ncp);
+const TARGET_DIR = process.cwd();
+const currentFileUrl = import.meta.url;
+const TEMPLATE_DIR = path.resolve(new URL(currentFileUrl).pathname, '../../../templates/javascript').replace(/\\/g, '\\').replace(/C:\\C:/g, '');
+// console.log("TEMPLATE_DIR: ", TEMPLATE_DIR)
+// console.log("TARGET_DIR: ", TARGET_DIR)
+function copyTemplate() {
+    return copy(TEMPLATE_DIR, TARGET_DIR, {
+        clobber: false,
+    });
+}
+function npmInstall() {
+    async function initGit(options) {
+        const result = await execa('git', ['init'], {
+            cwd: options.targetDirectory,
+        });
+        if (result.failed) {
+            return Promise.reject(new Error('Failed to initialize git'));
+        }
+        return;
+    }
+}
+export async function setUpTemplate() {
+    try {
+        const tasks = new Listr([
+            {
+                title: 'Copy template files',
+                task: () => copyTemplate(),
+            },
+            {
+                title: 'Install dependencies',
+                task: () => projectInstall({
+                    cwd: TARGET_DIR,
+                }),
+            },
+        ]);
+        await tasks.run();
+    }
+    catch (e) {
+        console.log('Error copying template: ', e);
+    }
+}

package/lib/deploy-app/actions-deployer.d.ts

@@ -0,0 +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>;
+}

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

@@ -0,0 +1,78 @@
+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();
+    }
+}

package/lib/deploy-app/actions.d.ts

@@ -0,0 +1,5 @@
+import { AppDeclartion } from './app-declaration';
+export interface EventWorkflowActionDefinition {
+    id?: string;
+}
+export declare function deployActions(appDeclaration: AppDeclartion): Promise<void>;

package/lib/deploy-app/actions.js

@@ -0,0 +1,17 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+export async function deployActions(appDeclaration) {
+    // FETCH ALL ACTIONS FROM THE API.
+    // UPSERT / DELETE BASED ON ACTION IDENTIFIER
+    console.log('%s \tDeploying actions.', chalk.yellow.bold('ACTION'));
+    for (const action of Object.keys(appDeclaration.actions)) {
+        console.log(`%s \tDeploying action: ${action}`, chalk.yellow.bold('ACTION'));
+    }
+}
+/**
+ *
+ */
+async function getActionsForApp() {
+    const workspaces = await new Entities().get({ entityName: 'event-workflow-actions' });
+    console.log('workspaces: ', workspaces);
+}

package/lib/deploy-app/app-declaration.d.ts

@@ -0,0 +1,20 @@
+/** Describes the derivative JSON / object represented
+ * in app.yml file.
+ */
+export interface AppDeclartion {
+    appIdentifier: string;
+    appName: string;
+    appDescription?: string;
+    visibility: 'private' | 'public';
+    publisher: string;
+    version: string;
+    thumbnail?: string;
+    actions?: {
+        [key: string]: AppActionDeclaration;
+    };
+}
+export interface AppActionDeclaration {
+    handler: string;
+    name: string;
+    description?: string;
+}

package/lib/deploy-app/app-deployer.d.ts

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

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

@@ -0,0 +1,58 @@
+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;
+    }
+}

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

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

package/lib/deploy-app/app.js

@@ -0,0 +1,56 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+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);
+        }
+    }
+    async remove(appDeclaration) {
+        const app = await this.getExistingApp(appDeclaration);
+        if (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);
+        const existing = apps.find(app => app.identifier === appDeclaration.appIdentifier);
+        return existing;
+    }
+    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;
+    }
+}

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

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

package/lib/deploy-app/deploy.js

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

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

@@ -0,0 +1,34 @@
+/** Describes the derivative JSON / object represented
+ * in app.yml file.
+ */
+export interface AppDeclartion {
+    appIdentifier: string;
+    appName: string;
+    appDescription?: string;
+    visibility: 'private' | 'public';
+    publisher: string;
+    version: string;
+    thumbnail?: string;
+    actions?: {
+        [key: string]: AppActionDeclaration;
+    };
+}
+export interface AppActionDeclaration {
+    handler: string;
+    name: string;
+    description?: string;
+}
+export interface App {
+    id: string;
+    identifier: string;
+    name: string;
+    private: boolean;
+}
+export interface EventWorkflowActionDefinition {
+    id?: string;
+    identifier?: string;
+    name?: string;
+    executeFunctionString?: string;
+    ownerKey?: string;
+    public?: boolean;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@contrail/cli",
+  "version": "1.0.0",
+  "description": "VibeIQ's Contrail Platform CLI.",
+  "main": "lib/index.js",
+  "bin": {
+    "@contrail/contrail-cli": "bin/init",
+    "contrail": "bin/init"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "contrail-cli"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "test": "jest --watch"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@contrail/sdk": "^1.0.91",
+    "amazon-cognito-identity-js": "^5.2.3",
+    "arg": "^4.0.1",
+    "aws-sdk": "^2.1044.0",
+    "chalk": "^4.0.0",
+    "esm": "^3.2.25",
+    "execa": "^5.0.0",
+    "inquirer": "^8.2.0",
+    "js-yaml": "^4.1.0",
+    "listr": "^0.14.3",
+    "ncp": "^2.0.0",
+    "pkg-install": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^23.3.14",
+    "jest": "^23.6.0",
+    "prettier": "^1.19.1",
+    "ts-jest": "^23.10.5",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^3.0.1",
+    "@types/node": "^14.6.4"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/src/auth/login.ts

@@ -0,0 +1,89 @@
+const AmazonCognitoIdentity = require('amazon-cognito-identity-js');
+import inquirer from 'inquirer';
+import { Entities, setConfig } from '@contrail/sdk';
+
+const CONFIGURATION = {
+    userPoolId: 'us-east-1_x8hXZUsL6',
+    clientId: process.env.CONTRAIL_COGNITO_CLIENT_ID || '2oubek96sue5rsncovtqhs3scm',
+};
+
+export async function authUser(){
+    const questions = [];
+    if (!process.env.CONTRAIL_CLI_EMAIL) {
+        questions.push({
+            type: 'input',
+            name: 'email',
+            validate: (val) => !!val,
+            message: 'Email',
+        });
+    }
+    if (!process.env.CONTRAIL_CLI_PASSWORD) {
+        questions.push({
+            type: 'password',
+            name: 'password',
+            validate: (val) => !!val,
+            message: 'Password',
+        });
+    }
+    if (!process.env.CONTRAIL_CLI_ORGSLUG) {
+        questions.push({
+            type: 'input',
+            name: 'orgSlug',
+            validate: (val) => !!val,
+            message: 'Org (slug)',
+        });
+    }
+
+    const answers = await inquirer.prompt(questions);
+    const params = {
+        email: process.env.CONTRAIL_CLI_EMAIL || answers.email,
+        password: process.env.CONTRAIL_CLI_PASSWORD || answers.password,
+        orgSlug: process.env.CONTRAIL_CLI_ORGSLUG || answers.orgSlug,
+    };
+    if (!params.email || !params.password){
+        throw new Error('email and password required');
+    }
+
+    const poolData = {
+        UserPoolId: CONFIGURATION.userPoolId,
+        ClientId: CONFIGURATION.clientId,
+    };
+
+    const userPool = new AmazonCognitoIdentity.CognitoUserPool(poolData);
+    const authData = {
+        Username: params.email,
+        Password: params.password,
+    };
+
+    const authDetails = new AmazonCognitoIdentity.AuthenticationDetails(authData);
+    const userData = {
+        Username: params.email,
+        Pool: userPool,
+    };
+
+    const cognitoUser = new AmazonCognitoIdentity.CognitoUser(userData);
+
+    return new Promise( (resolve, reject) => {
+        cognitoUser.authenticateUser(authDetails, {
+            onSuccess: async (result) => {
+                const user = result;
+                await setSDKConfig(user, params.orgSlug);
+                resolve({success: true, data: result});
+            },
+            onFailure: (err) => {
+                console.log('authUser error: ' + err);
+                reject(err);
+            },
+        });
+    });
+
+}
+
+async function setSDKConfig(user, orgSlug){
+    // console.log('user:', user);
+    setConfig({
+        apiUserToken: user.idToken.jwtToken,
+        apiGateway: process.env.API_GATEWAY,
+        orgSlug,
+    });
+}

package/src/cli.ts

@@ -0,0 +1,33 @@
+
+import { create } from './create-app/create';
+import { deployApp, removeApp } from './deploy-app/deploy';
+/**
+ *  Built using documentation here:
+ *  https://www.twilio.com/blog/how-to-build-a-cli-with-node-js
+ */
+
+export async function cli(args) {
+  const command = args[2];
+  switch (command) {
+    case 'create-app': {
+      create(args);
+      break;
+    }
+    case 'deploy-app': {
+      deployApp(args);
+      break;
+    }
+    case 'remove-app': {
+      removeApp(args);
+      break;
+    }
+    case 'extract-types': {
+      removeApp(args);
+      break;
+    }
+    default: {
+      console.log('Illegal command.');
+    }
+  }
+}
+

package/src/create-app/create.ts

@@ -0,0 +1,58 @@
+import arg from 'arg';
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk'
+import { setUpTemplate } from './setup-template';
+
+function parseArgumentsIntoOptions(rawArgs) {
+  const args = arg(
+    {
+      '--create-app': Boolean,
+      '--app-name': String,
+      '-c': '--create-app',
+      '-n': '--app-name',
+    },
+    {
+      argv: rawArgs.slice(2),
+    }
+  );
+  return {
+    createApp: args['--create-app'] || false,
+    appName:  args['--app-name']
+  };
+}
+async function promptForMissingOptions(options) {
+  const defaultTemplate = 'JavaScript';
+  if (options.skipPrompts) {
+    return {
+       ...options,
+       template: options.template || defaultTemplate,
+     };
+   }
+  
+   const questions = [];
+   if (!options.appName) {
+     questions.push({
+       type: 'input',
+       name: 'appName',
+       validate: (val) => { return !!val },
+       message: 'What is the name of your app?',
+     });
+   }
+
+  const answers = await inquirer.prompt(questions);
+  return {
+    ...options,
+    appName: options.appName || answers.appName,
+  };
+}
+
+
+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'));
+  await setUpTemplate();
+  console.log('%s Application initialized successfully.', chalk.green.bold('COMPLETE'));
+}

package/src/create-app/setup-template.ts

@@ -0,0 +1,61 @@
+
+import ncp from 'ncp';
+import path from 'path';
+import { promisify } from 'util';
+import execa from 'execa';
+const Listr = require('listr');
+import { projectInstall } from 'pkg-install';
+const copy = promisify(ncp);
+const TARGET_DIR = process.cwd();
+
+const currentFileUrl = import .meta.url;
+const TEMPLATE_DIR = path.resolve(
+   new URL(currentFileUrl).pathname,
+   '../../../templates/javascript',
+).replace(/\\/g, '\\').replace(/C:\\C:/g, '');
+
+// console.log("TEMPLATE_DIR: ", TEMPLATE_DIR)
+// console.log("TARGET_DIR: ", TARGET_DIR)
+
+function copyTemplate(){
+  return copy(TEMPLATE_DIR, TARGET_DIR, {
+    clobber: false,
+  });
+}
+
+function npmInstall(){
+  async function initGit(options) {
+    const result = await execa('git', ['init'], {
+      cwd: options.targetDirectory,
+    });
+    if (result.failed) {
+      return Promise.reject(new Error('Failed to initialize git'));
+    }
+    return;
+   }
+}
+
+export async function setUpTemplate() {
+  try {
+    const tasks = new Listr([
+      {
+        title: 'Copy template files',
+        task: () => copyTemplate(),
+      },
+      {
+        title: 'Install dependencies',
+        task: () =>
+          projectInstall({
+            cwd: TARGET_DIR,
+          }),
+        // skip: () =>
+        //   !options.runInstall
+        //     ? 'Pass --install to automatically install dependencies'
+        //     : undefined,
+      },
+    ]);
+    await tasks.run();
+  } catch (e) {
+    console.log('Error copying template: ', e);
+  }
+}

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

@@ -0,0 +1,87 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { App, AppDeclartion, AppActionDeclaration, EventWorkflowActionDefinition } from './interfaces';
+import fs from 'fs';
+
+export class ActionsDeployer {
+  async deployActions(appDeclaration: AppDeclartion, app: 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: App){
+    return await new Entities().get({ entityName: 'event-workflow-action-definition',
+                                      criteria: { ownerKey: `app:${app.id}`}});
+  }
+
+  async deployAction(actionKey: string,
+                     actionDeclaration: AppActionDeclaration,
+                     app: App,
+                     existingActions: Array<any>){
+    console.log(`%s \tDeploying action: ${actionKey}`, chalk.yellow.bold('ACTION'));
+    const identifier = this.getActionDeclarationIdentifier(actionKey, app);
+    const existingDefinition = existingActions.find(ad => ad.identifier === identifier);
+    if (!existingDefinition) {
+      await this.createNewActionDefinition(actionKey, actionDeclaration, app);
+    } else {
+      await this.updateActionDefinition(existingDefinition, actionDeclaration);
+    }
+  }
+  private async createNewActionDefinition(actionKey: string,
+                                          actionDeclaration: AppActionDeclaration,
+                                          app: App) {
+    const newObject: EventWorkflowActionDefinition = {
+      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;
+  }
+  private async updateActionDefinition(existingActionDefinition: EventWorkflowActionDefinition,
+                                       actionDeclaration: AppActionDeclaration) {
+    const updates: EventWorkflowActionDefinition  = {
+      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: App) {
+    return app.identifier + ':' + actionKey;
+  }
+
+  async getFunction(actionDeclaration: AppActionDeclaration): Promise<string> {
+    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();
+  }
+}

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

@@ -0,0 +1,63 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { ActionsDeployer } from './actions-deployer';
+import { App, AppDeclartion } from './interfaces';
+
+export class AppDeployer {
+  private app: App;
+  public async deploy(appDeclaration: AppDeclartion) {
+    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);
+  }
+
+  public async remove(appDeclaration: AppDeclartion) {
+    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'));
+    }
+  }
+
+  public async getExistingApp(appDeclaration: AppDeclartion) {
+    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);
+  }
+  public async updateExistingApp(appDeclaration: AppDeclartion, 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;
+
+  }
+  private async createNewApp(appDeclaration: AppDeclartion) {
+    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;
+  }
+}

package/src/deploy-app/deploy.ts

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import { AppDeployer } from './app-deployer';
+import { AppDeclartion } from './interfaces';
+const yaml = require('js-yaml');
+
+function loadAppConfig(){
+  const TARGET_DIR = process.cwd();
+  try {
+    const doc = yaml.load(fs.readFileSync(TARGET_DIR + '/app.yml', 'utf8'));
+    console.log(doc);
+    return doc;
+  } catch (e) {
+    console.log('ERROR PARSING YAML: ', e);
+  }
+}
+
+export async function deployApp(args) {
+  const appDeclaration: AppDeclartion = loadAppConfig();
+
+  console.log(`%s Deploying application. ${appDeclaration.appIdentifier}`, chalk.blue.bold('START'));
+  const user = await authUser();
+  await new AppDeployer().deploy(appDeclaration);
+  console.log('%s Deployment complete.', chalk.green.bold('COMPLETE'));
+}
+
+export async function removeApp(args) {
+  const appDeclaration: AppDeclartion = loadAppConfig();
+  console.log(`%s Removing application. ${appDeclaration.appIdentifier}`, chalk.blue.bold('START'));
+  await authUser();
+  await new AppDeployer().remove(appDeclaration);
+  console.log('%s Removing complete.', chalk.green.bold('COMPLETE'));
+}

package/src/deploy-app/interfaces.ts

@@ -0,0 +1,35 @@
+/** Describes the derivative JSON / object represented
+ * in app.yml file.
+ */
+export interface AppDeclartion {
+  appIdentifier: string;
+  appName: string;
+  appDescription?: string;
+  visibility: 'private' | 'public';
+  publisher: string;
+  version: string;
+  thumbnail?: string;
+  actions?: { [key: string]: AppActionDeclaration };
+}
+
+export interface AppActionDeclaration {
+  handler: string;
+  name: string;
+  description?: string;
+}
+
+export interface App {
+  id: string;
+  identifier: string;
+  name: string;
+  private: boolean;
+}
+
+export interface EventWorkflowActionDefinition {
+  id?: string;
+  identifier?: string;
+  name?: string;
+  executeFunctionString?: string;
+  ownerKey?: string;
+  public?: boolean;
+}

package/templates/javascript/actions/example/action.js

@@ -0,0 +1,38 @@
+async function execute(config, event, Functions) {        
+  const getBodyFromEvent = (config, event) => {            
+    let body = Functions.StringUtil.parseVariables(config.message, event);            
+    console.log('body: ', body);            
+    if (config.sendDetails) {                
+      const data = event;                
+      const properties = {};                
+      let addedProperty = false;                
+      for (const property of config.fieldsToForward) {                    
+        const variableLevels = property.split('.');                    
+        let replacementValue = data;                    
+        for (let i = 0; i < variableLevels.length; i++) {                        
+          replacementValue = replacementValue[variableLevels[i]];                    
+        }                    
+        properties[property] = replacementValue;                    
+        addedProperty = true;                
+      }                
+      if (addedProperty) {                    
+        body = body + ' Properties: ' + JSON.stringify(properties) + '.';                
+      }            
+    }            
+    return JSON.stringify({ text: body });        
+  };        
+  const body = getBodyFromEvent(config, event);        
+  console.log('Sending message: ', body);        
+  const response = await Functions.fetch(config.url, {            
+    method: 'POST',            
+    body: body,            
+    headers: { 'Content-Type': 'application/json' }        
+  });        
+  if (!response.ok) {            
+    console.log('Webhook event failed to publish');            
+    console.log('Response: ', JSON.stringify(response));        
+  }        
+  else {            
+    console.log('Published!');        
+  }    
+}

package/templates/javascript/app.yml

@@ -0,0 +1,42 @@
+appIdentifier: "@your-co/app-name"
+appName: "Your App Name"
+appDescription: "Your app description."
+visibility: public
+publisher: "Your company name"
+version: 1.0
+
+appConfiguration: 
+  apiHost: 
+    label: "API Host"
+    propertyType: "string"
+  userName: 
+    label: "User Name"
+    propertyType: "string"
+  password: 
+    label: "Password"
+    propertyType: "string"
+
+actions: 
+  updateProduct: 
+    handler: actions/example/action.js
+    name: "Update Product"
+    description: "Updates a product in the destination system."
+
+triggers: 
+  trigger1: 
+    key: product|create
+    name: "Produt Created"
+
+workflows: 
+  workflow1: 
+    name: "Update item on product creation"
+    triggerKey: product|create
+    paths:
+      path1: 
+        conditional: "{retailPrice} > 10"
+        actions: 
+          updateItem: 
+            actionId: updateItem
+            configuration:
+
+

package/templates/javascript/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "test-app",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "@contrail/contrail-cli": "bin/init",
+    "contrail": "bin/init"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^4.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "declaration": true,
+    "esModuleInterop": true,
+    "outDir": "./lib",
+    "strict": false,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "noImplicitAny": false,
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node"
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/__tests__/*"
+  ]
+}

package/tslint.json

@@ -0,0 +1,57 @@
+{
+  "defaultSeverity": "error",
+  "extends": [
+    "tslint:recommended"
+  ],
+  "jsRules": {
+    "no-unused-expression": true
+  },
+  "rules": {
+    "eofline": false,
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "no-shadowed-variable": false,
+    "indent": false,
+    "member-access": [
+      false
+    ],
+    "no-string-literal": false,
+    "ordered-imports": [
+      false
+    ],
+    "max-line-length": [
+      false,
+      150
+    ],
+    "member-ordering": [
+      false
+    ],
+    "curly": false,
+    "interface-name": [
+      false
+    ],
+    "array-type": [
+      false
+    ],
+    "no-empty-interface": false,
+    "no-empty": false,
+    "arrow-parens": false,
+    "object-literal-sort-keys": false,
+    "no-unused-expression": false,
+    "max-classes-per-file": [
+      false
+    ],
+    "variable-name": [
+      false
+    ],
+    "one-line": [
+      false
+    ],
+    "one-variable-per-declaration": [
+      false
+    ]
+  },
+  "rulesDirectory": []
+}