@contrail/cli 1.0.35 → 1.0.36

package/lib/apps/app-api.d.ts

@@ -0,0 +1,6 @@
+export declare function getAppVersions(app: any): Promise<any>;
+export declare function upgradeAppVersion(appOrg: any, appVersionId: any): Promise<any>;
+export declare function deleteAppOrg(appOrgId: string): Promise<any>;
+export declare function getInstalledApps(): Promise<any>;
+export declare function installAppToOrg(app: any, configProperties: any): Promise<any>;
+export declare function getAvailableApps(): Promise<any[]>;

package/lib/apps/app-api.js

@@ -0,0 +1,59 @@
+import { Entities } from '@contrail/sdk';
+import { Auth } from '../auth/auth';
+export async function getAppVersions(app) {
+    return await new Entities().get({
+        entityName: 'app-version',
+        criteria: {
+            appId: app.id
+        }
+    });
+}
+export async function upgradeAppVersion(appOrg, appVersionId) {
+    return await new Entities().update({
+        entityName: 'app-org',
+        id: appOrg.id,
+        object: {
+            appVersionId: appVersionId
+        }
+    });
+}
+export async function deleteAppOrg(appOrgId) {
+    return await new Entities().delete({
+        entityName: 'app-org',
+        id: appOrgId
+    });
+}
+export async function getInstalledApps() {
+    return await new Entities().get({
+        entityName: 'app-org',
+        relations: ['app']
+    });
+}
+export async function installAppToOrg(app, configProperties) {
+    return await new Entities().create({
+        entityName: 'app-org',
+        object: {
+            appId: app.id,
+            appConfig: configProperties
+        }
+    });
+}
+export async function getAvailableApps() {
+    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;
+}

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/apps/install-app/app-installer.d.ts

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

package/lib/apps/install-app/app-installer.js

@@ -0,0 +1,84 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { Entities } from '@contrail/sdk';
+import { authUser } from '../../auth/login';
+import { deleteAppOrg, getAvailableApps, getInstalledApps, installAppToOrg } from '../app-api';
+async function getConfigProperties(app) {
+    const config = {};
+    for (const key of Object.keys(app.configProperties)) {
+        const slug = app.configProperties[key]['slug'];
+        const name = app.configProperties[key]['label'];
+        const type = app.configProperties[key]['propertyType'];
+        const questions = [];
+        questions.push({
+            type: 'input',
+            name: 'configAnswer',
+            message: `[App config] ${name} (${type}):`,
+        });
+        const answers = await inquirer.prompt(questions);
+        config[slug] = answers.configAnswer;
+    }
+    return config;
+}
+export async function uninstallApp() {
+    await authUser();
+    const installedApps = await getInstalledApps();
+    const answers = await inquirer.prompt([{
+            type: 'list',
+            name: 'appIdentifier',
+            message: 'Which app would you like to uninstall?',
+            choices: installedApps.map(x => x.app.identifier)
+        }]);
+    const appToDelete = installedApps.find(x => x.app.identifier === answers.appIdentifier);
+    console.log('%s Uninstalling app', chalk.green.bold('APP INSTALLATION'));
+    await deleteAppOrg(appToDelete.id);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        await delay(1000);
+        try {
+            const appStillDeleting = await new Entities().get({ entityName: 'app-org', id: appToDelete.id });
+            if (!appStillDeleting) {
+                break;
+            }
+            process.stdout.write('.');
+        }
+        catch (e) {
+            console.log('Error is:', e);
+            break;
+        }
+    }
+    console.log('%s App Uninstalled', chalk.green.bold('APP INSTALLATION'));
+}
+export async function installApp() {
+    await authUser();
+    const apps = await getAvailableApps();
+    if (!apps.length) {
+        throw new Error('No apps are available to install...');
+    }
+    const installedApps = await getInstalledApps();
+    const installedAppsIds = installedApps.map(x => x.app.id);
+    const installableApps = apps.filter(x => !installedAppsIds.includes(x.id));
+    console.log(chalk.yellow.bold('Installed Apps:'));
+    for (const appOrg of installedApps) {
+        console.log(chalk.yellow.bold(`${appOrg.app.name}: ${appOrg.app.identifier}`));
+    }
+    const questions = [];
+    questions.push({
+        type: 'list',
+        name: 'appIdentifier',
+        message: 'Which app would you like to install?',
+        choices: installableApps.map(x => x.identifier)
+    });
+    const answers = await inquirer.prompt(questions);
+    const app = installableApps.find(x => x.identifier === answers.appIdentifier);
+    let configProperties;
+    if (app.configProperties) {
+        configProperties = await getConfigProperties(app);
+    }
+    console.log('%s Installing apps', chalk.green.bold('APP INSTALLATION'));
+    await installAppToOrg(app, configProperties);
+    console.log('%s App installed', chalk.green.bold('APP INSTALLATION'));
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/lib/apps/upgrade-app/app-upgrader.d.ts

@@ -0,0 +1,3 @@
+export declare function uninstallApp(): Promise<void>;
+export declare function upgradeApp(): Promise<void>;
+export declare function installApp(): Promise<void>;

package/lib/apps/upgrade-app/app-upgrader.js

@@ -0,0 +1,125 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { Entities } from '@contrail/sdk';
+import { authUser } from '../../auth/login';
+import { deleteAppOrg, getAppVersions, getAvailableApps, getInstalledApps, installAppToOrg, upgradeAppVersion } from '../app-api';
+async function getConfigProperties(app) {
+    const config = {};
+    for (const key of Object.keys(app.configProperties)) {
+        const slug = app.configProperties[key]['slug'];
+        const name = app.configProperties[key]['label'];
+        const type = app.configProperties[key]['propertyType'];
+        const questions = [];
+        questions.push({
+            type: 'input',
+            name: 'configAnswer',
+            message: `[App config] ${name} (${type}):`,
+        });
+        const answers = await inquirer.prompt(questions);
+        config[slug] = answers.configAnswer;
+    }
+    return config;
+}
+export async function uninstallApp() {
+    await authUser();
+    const installedApps = await getInstalledApps();
+    const answers = await inquirer.prompt([{
+            type: 'list',
+            name: 'appIdentifier',
+            message: 'Which app would you like to uninstall?',
+            choices: installedApps.map(x => x.app.identifier)
+        }]);
+    const appToDelete = installedApps.find(x => x.app.identifier === answers.appIdentifier);
+    console.log('%s Uninstalling app', chalk.green.bold('APP INSTALLATION'));
+    await deleteAppOrg(appToDelete.id);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        await delay(1000);
+        try {
+            const appStillDeleting = await new Entities().get({ entityName: 'app-org', id: appToDelete.id });
+            if (!appStillDeleting) {
+                break;
+            }
+            process.stdout.write('.');
+        }
+        catch (e) {
+            console.log('Error is:', e);
+            break;
+        }
+    }
+    console.log('%s App Uninstalled', chalk.green.bold('APP INSTALLATION'));
+}
+export async function upgradeApp() {
+    await authUser();
+    const allApps = await getAvailableApps();
+    const installedApps = await getInstalledApps();
+    let answers = await inquirer.prompt([{
+            type: 'list',
+            name: 'appIdentifier',
+            message: 'Which app would you like to upgrade?',
+            choices: installedApps.map(x => x.app.identifier)
+        }]);
+    const appOrgToUpgrade = installedApps.find(x => x.app.identifier === answers.appIdentifier);
+    const appToUpgrade = allApps.find(x => x.identifier === answers.appIdentifier);
+    const versions = await getAppVersions(appToUpgrade);
+    answers = await inquirer.prompt([{
+            type: 'list',
+            name: 'appVersion',
+            message: 'Which app version would you like to upgrade to?',
+            choices: versions.reverse().map(x => {
+                const name = x.id === appOrgToUpgrade.appVersionId ? `${x.versionNumber} (${x.createdOn}) (current)` : `${x.versionNumber} (${x.createdOn})`;
+                return {
+                    value: x.id, name
+                };
+            })
+        }]);
+    console.log(`%s Upgrading app to version ${answers.appVersion}`, chalk.green.bold('APP INSTALLATION'));
+    await upgradeAppVersion(appOrgToUpgrade, answers.appVersion);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        await delay(1000);
+        const appStillUpgrading = await new Entities().get({ entityName: 'app-org', id: appOrgToUpgrade.id });
+        if (appStillUpgrading.status === 'READY') {
+            console.log('%s App Upgraded', chalk.green.bold('APP INSTALLATION'));
+            return;
+        }
+        if (appStillUpgrading.status === 'FAILED_INSTALLING') {
+            console.log('%s App Upgrade FAILED!', chalk.red.bold('APP INSTALLATION'));
+            return;
+        }
+        console.log('checking app status...');
+    }
+}
+export async function installApp() {
+    await authUser();
+    const apps = await getAvailableApps();
+    if (!apps.length) {
+        throw new Error('No apps are available to install...');
+    }
+    const installedApps = await getInstalledApps();
+    const installedAppsIds = installedApps.map(x => x.app.id);
+    const installableApps = apps.filter(x => !installedAppsIds.includes(x.id));
+    console.log(chalk.yellow.bold('Installed Apps:'));
+    for (const appOrg of installedApps) {
+        console.log(chalk.yellow.bold(`${appOrg.app.name}: ${appOrg.app.identifier}`));
+    }
+    const questions = [];
+    questions.push({
+        type: 'list',
+        name: 'appIdentifier',
+        message: 'Which app would you like to install?',
+        choices: installableApps.map(x => x.identifier)
+    });
+    const answers = await inquirer.prompt(questions);
+    const app = installableApps.find(x => x.identifier === answers.appIdentifier);
+    let configProperties;
+    if (app.configProperties) {
+        configProperties = await getConfigProperties(app);
+    }
+    console.log('%s Installing apps', chalk.green.bold('APP INSTALLATION'));
+    await installAppToOrg(app, configProperties);
+    console.log('%s App installed', chalk.green.bold('APP INSTALLATION'));
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/lib/cli.js

@@ -10,6 +10,8 @@ import { ParseTypesFromFiles, ParseTypesFromLocalFiles, ParseTypesFromTemplateFr
 import { loadColors, deleteColors } from './colors/color-loader';
 import { listConfig, removeConfig } from './config/configCommands';
 import { deleteWorkflowTemplate, deployWorkflowTemplate, listWorkflowTemplate } from './workflows/workflowCommands';
+import { installApp, uninstallApp } from './apps/install-app/app-installer';
+import { upgradeApp } from './apps/upgrade-app/app-upgrader';
 const cliUsage = require('command-line-usage');
 /**
  *  Built using documentation here:
@@ -49,6 +51,18 @@ export async function cli(args) {
                     removeApp(args);
                     break;
                 }
+                case 'install': {
+                    installApp();
+                    break;
+                }
+                case 'uninstall': {
+                    uninstallApp();
+                    break;
+                }
+                case 'upgrade': {
+                    upgradeApp();
+                    break;
+                }
                 default: {
                     printIllegalCommand();
                 }
@@ -197,6 +211,8 @@ const helpSections = [
             '.                            a template directly to the org',
             'deploy                       Deploy your app.',
             'remove                       Remove your app.',
+            'install                      Install an app to your org.',
+            'uninstall                    Uninstall an app from your org.',
         ],
     },
     {

package/package.json

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

package/src/apps/app-api.ts

@@ -0,0 +1,66 @@
+import { Entities } from '@contrail/sdk';
+import { Auth } from '../auth/auth';
+
+export async function getAppVersions(app) {
+  return await new Entities().get({
+    entityName: 'app-version',
+    criteria: {
+      appId: app.id
+    }
+  });
+}
+
+export async function upgradeAppVersion(appOrg, appVersionId) {
+  return await new Entities().update({
+    entityName: 'app-org',
+    id: appOrg.id,
+    object: {
+      appVersionId: appVersionId
+    }
+  });
+}
+
+export async function deleteAppOrg(appOrgId: string) {
+  return await new Entities().delete({
+    entityName: 'app-org',
+    id: appOrgId
+  });
+}
+
+export async function getInstalledApps() {
+  return await new Entities().get({
+    entityName: 'app-org',
+    relations: ['app']
+  });
+}
+
+export async function installAppToOrg(app, configProperties) {
+  return await new Entities().create({
+    entityName: 'app-org',
+    object: {
+      appId: app.id,
+      appConfig: configProperties
+    }
+  });
+}
+
+export async function getAvailableApps() {
+  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;
+}

package/src/apps/install-app/app-installer.ts

@@ -0,0 +1,87 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { Entities } from '@contrail/sdk';
+import {authUser} from '../../auth/login';
+import { deleteAppOrg, getAvailableApps, getInstalledApps, installAppToOrg } from '../app-api';
+
+async function getConfigProperties(app) {
+  const config = {};
+  for (const key of Object.keys(app.configProperties)) {
+    const slug = app.configProperties[key]['slug'];
+    const name = app.configProperties[key]['label'];
+    const type = app.configProperties[key]['propertyType'];
+    const questions = [];
+    questions.push({
+      type: 'input',
+      name: 'configAnswer',
+      message: `[App config] ${name} (${type}):`,
+    });
+    const answers = await inquirer.prompt(questions);
+    config[slug] = answers.configAnswer;
+  }
+  return config;
+}
+export async function uninstallApp() {
+  await authUser();
+  const installedApps = await getInstalledApps();
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'appIdentifier',
+    message: 'Which app would you like to uninstall?',
+    choices: installedApps.map(x => x.app.identifier)
+  }]);
+  const appToDelete = installedApps.find(x=> x.app.identifier === answers.appIdentifier);
+  console.log('%s Uninstalling app', chalk.green.bold('APP INSTALLATION'));
+  await deleteAppOrg(appToDelete.id);
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    await delay(1000);
+    try{
+      const appStillDeleting = await new Entities().get({entityName: 'app-org', id: appToDelete.id});
+      if (!appStillDeleting) {
+        break;
+      }
+      process.stdout.write('.');
+    } catch (e) {
+      console.log('Error is:', e);
+      break;
+    }
+  }
+  console.log('%s App Uninstalled', chalk.green.bold('APP INSTALLATION'));
+}
+
+export async function installApp() {
+  await authUser();
+  const apps = await getAvailableApps();
+  if (!apps.length) {
+    throw new Error('No apps are available to install...');
+  }
+  const installedApps = await getInstalledApps();
+  const installedAppsIds = installedApps.map(x => x.app.id);
+  const installableApps = apps.filter(x => !installedAppsIds.includes(x.id));
+  console.log(chalk.yellow.bold('Installed Apps:'));
+  for (const appOrg of installedApps) {
+    console.log(chalk.yellow.bold(`${appOrg.app.name}: ${appOrg.app.identifier}`));
+  }
+  const questions = [];
+  questions.push({
+    type: 'list',
+    name: 'appIdentifier',
+    message: 'Which app would you like to install?',
+    choices: installableApps.map(x => x.identifier)
+  });
+  const answers = await inquirer.prompt(questions);
+  const app = installableApps.find(x => x.identifier === answers.appIdentifier);
+  let configProperties: any;
+  if (app.configProperties) {
+    configProperties = await getConfigProperties(app);
+  }
+  console.log('%s Installing apps', chalk.green.bold('APP INSTALLATION'));
+
+  await installAppToOrg(app, configProperties);
+  console.log('%s App installed', chalk.green.bold('APP INSTALLATION'));
+}
+
+function delay(ms: number) {
+  return new Promise( resolve => setTimeout(resolve, ms) );
+}

package/src/apps/upgrade-app/app-upgrader.ts

@@ -0,0 +1,131 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { Entities } from '@contrail/sdk';
+import { authUser } from '../../auth/login';
+import { deleteAppOrg, getAppVersions, getAvailableApps, getInstalledApps, installAppToOrg, upgradeAppVersion } from '../app-api';
+
+async function getConfigProperties(app) {
+  const config = {};
+  for (const key of Object.keys(app.configProperties)) {
+    const slug = app.configProperties[key]['slug'];
+    const name = app.configProperties[key]['label'];
+    const type = app.configProperties[key]['propertyType'];
+    const questions = [];
+    questions.push({
+      type: 'input',
+      name: 'configAnswer',
+      message: `[App config] ${name} (${type}):`,
+    });
+    const answers = await inquirer.prompt(questions);
+    config[slug] = answers.configAnswer;
+  }
+  return config;
+}
+
+export async function uninstallApp() {
+  await authUser();
+  const installedApps = await getInstalledApps();
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'appIdentifier',
+    message: 'Which app would you like to uninstall?',
+    choices: installedApps.map(x => x.app.identifier)
+  }]);
+  const appToDelete = installedApps.find(x => x.app.identifier === answers.appIdentifier);
+  console.log('%s Uninstalling app', chalk.green.bold('APP INSTALLATION'));
+  await deleteAppOrg(appToDelete.id);
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    await delay(1000);
+    try {
+      const appStillDeleting = await new Entities().get({ entityName: 'app-org', id: appToDelete.id });
+      if (!appStillDeleting) {
+        break;
+      }
+      process.stdout.write('.');
+    } catch (e) {
+      console.log('Error is:', e);
+      break;
+    }
+  }
+  console.log('%s App Uninstalled', chalk.green.bold('APP INSTALLATION'));
+}
+
+export async function upgradeApp() {
+  await authUser();
+  const allApps = await getAvailableApps();
+  const installedApps = await getInstalledApps();
+  let answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'appIdentifier',
+    message: 'Which app would you like to upgrade?',
+    choices: installedApps.map(x => x.app.identifier)
+  }]);
+  const appOrgToUpgrade = installedApps.find(x => x.app.identifier === answers.appIdentifier);
+  const appToUpgrade = allApps.find(x => x.identifier === answers.appIdentifier);
+  const versions = await getAppVersions(appToUpgrade);
+  answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'appVersion',
+    message: 'Which app version would you like to upgrade to?',
+    choices: versions.reverse().map(x => {
+      const name = x.id === appOrgToUpgrade.appVersionId? `${x.versionNumber} (${x.createdOn}) (current)`: `${x.versionNumber} (${x.createdOn})`;
+      return {
+        value: x.id, name
+      };
+    })
+  }]);
+
+  console.log(`%s Upgrading app to version ${answers.appVersion}`, chalk.green.bold('APP INSTALLATION'));
+  await upgradeAppVersion(appOrgToUpgrade, answers.appVersion);
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    await delay(1000);
+    const appStillUpgrading = await new Entities().get({ entityName: 'app-org', id: appOrgToUpgrade.id });
+    if (appStillUpgrading.status === 'READY') {
+      console.log('%s App Upgraded', chalk.green.bold('APP INSTALLATION'));
+      return;
+    }
+    if (appStillUpgrading.status === 'FAILED_INSTALLING') {
+      console.log('%s App Upgrade FAILED!', chalk.red.bold('APP INSTALLATION'));
+      return;
+    }
+    console.log('checking app status...');
+  }
+}
+
+export async function installApp() {
+  await authUser();
+  const apps = await getAvailableApps();
+  if (!apps.length) {
+    throw new Error('No apps are available to install...');
+  }
+  const installedApps = await getInstalledApps();
+  const installedAppsIds = installedApps.map(x => x.app.id);
+  const installableApps = apps.filter(x => !installedAppsIds.includes(x.id));
+  console.log(chalk.yellow.bold('Installed Apps:'));
+  for (const appOrg of installedApps) {
+    console.log(chalk.yellow.bold(`${appOrg.app.name}: ${appOrg.app.identifier}`));
+  }
+  const questions = [];
+  questions.push({
+    type: 'list',
+    name: 'appIdentifier',
+    message: 'Which app would you like to install?',
+    choices: installableApps.map(x => x.identifier)
+  });
+  const answers = await inquirer.prompt(questions);
+  const app = installableApps.find(x => x.identifier === answers.appIdentifier);
+  let configProperties: any;
+  if (app.configProperties) {
+    configProperties = await getConfigProperties(app);
+  }
+  console.log('%s Installing apps', chalk.green.bold('APP INSTALLATION'));
+
+  await installAppToOrg(app, configProperties);
+  console.log('%s App installed', chalk.green.bold('APP INSTALLATION'));
+}
+
+function delay(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/cli.ts

@@ -9,8 +9,10 @@ import { MergeOptionSets } from './types/option-set-merger';
 import { MergeTypeProperties } from './types/types-properties-merger';
 import { ParseTypesFromFiles, ParseTypesFromLocalFiles, ParseTypesFromTemplateFromLocalFiles } from './types/parse-types';
 import { loadColors, deleteColors } from './colors/color-loader';
-import {listConfig, removeConfig} from './config/configCommands';
-import {deleteWorkflowTemplate, deployWorkflowTemplate, listWorkflowTemplate} from './workflows/workflowCommands';
+import { listConfig, removeConfig } from './config/configCommands';
+import { deleteWorkflowTemplate, deployWorkflowTemplate, listWorkflowTemplate } from './workflows/workflowCommands';
+import { installApp, uninstallApp } from './apps/install-app/app-installer';
+import { upgradeApp } from './apps/upgrade-app/app-upgrader';
 const cliUsage = require('command-line-usage');
 
 /**
@@ -22,7 +24,7 @@ export async function cli(args) {
   const fullCommand = args[2];
   let domain;
   let command;
-  if(!fullCommand) {
+  if (!fullCommand) {
     printIllegalCommand();
     return;
   }
@@ -33,7 +35,7 @@ export async function cli(args) {
     return;
   }
 
-  if (commandParts?.length < 2 && commandParts[0].toLowerCase() !== 'help'  && commandParts[0].toLowerCase() !== '-help' && commandParts[0].toLowerCase() !== '--help') {
+  if (commandParts?.length < 2 && commandParts[0].toLowerCase() !== 'help' && commandParts[0].toLowerCase() !== '-help' && commandParts[0].toLowerCase() !== '--help') {
     printIllegalCommand();
     return;
   }
@@ -56,6 +58,18 @@ export async function cli(args) {
       removeApp(args);
       break;
     }
+    case 'install': {
+      installApp();
+      break;
+    }
+    case 'uninstall': {
+      uninstallApp();
+      break;
+    }
+    case 'upgrade': {
+      upgradeApp();
+      break;
+    }
     default: {
       printIllegalCommand();
     }
@@ -210,6 +224,8 @@ const helpSections = [
       '.                            a template directly to the org',
       'deploy                       Deploy your app.',
       'remove                       Remove your app.',
+      'install                      Install an app to your org.',
+      'uninstall                    Uninstall an app from your org.',
     ],
   },
   {