@contrail/cli 1.0.0 → 1.0.5

package/src/{deploy-app → apps/deploy-app}/app-deployer.ts

@@ -1,63 +1,86 @@
-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;
-  }
-}
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import { Auth } from '../../auth/auth';
+import { ActionsDeployer } from './actions-deployer';
+import { App, AppDeclaration } from './interfaces';
+import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
+
+export class AppDeployer {
+  public async deploy(appDeclaration: 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);
+  }
+
+  public async getExistingApp(appDeclaration: AppDeclaration): Promise<App> {
+    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);
+  }
+
+  private async createNewApp(appDeclaration: 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;
+  }
+
+  public async updateExistingApp(appDeclaration: 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;
+  }
+
+  public async remove(appDeclaration: 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/src/apps/deploy-app/app-template-parsers.ts

@@ -0,0 +1,43 @@
+import { AppDeclaration, TriggerKeyDefinition, ConfigPropertyElements } from './interfaces';
+
+export class TriggerKeyDefinitionParser {
+  public static buildTriggersArray(appDeclaration: AppDeclaration): Array<TriggerKeyDefinition> {
+    const triggers: Array<TriggerKeyDefinition> = [];
+
+    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 {
+  public static getConfigProperties(configPropertyElements: ConfigPropertyElements) {
+    const appConfiguration = [];
+    for (const configKey of Object.keys(configPropertyElements)) {
+      const declaration = configPropertyElements[configKey];
+      const config: any = {
+        label: declaration.label,
+        slug: configKey,
+        propertyType: declaration.propertyType, // TODO should support options
+      };
+      if (declaration.options) {
+        config.options = declaration.options;
+      }
+      appConfiguration.push(config);
+    }
+    return appConfiguration;
+  }
+}

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

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../../auth/login';
+import { AppDeployer } from './app-deployer';
+import { AppDeclaration } from './interfaces';
+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: 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: 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'));
+}

package/src/apps/deploy-app/interfaces.ts

@@ -0,0 +1,78 @@
+/** 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 };
+}
+
+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; // should be a public link
+  eventWorkflowTriggerKeyMapping: string;
+  configProperties?: ConfigProperty[];
+  triggerKeyDefinitions?: TriggerKeyDefinition[];
+}
+
+export 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[];
+}
+
+export class TriggerKeyDefinition {
+	name: string;
+	description?: string;
+	triggerKey: string;
+  external?: boolean;
+}

package/src/auth/auth.ts

@@ -0,0 +1,10 @@
+export interface AuthContext {
+  apiUserToken: string;
+  apiGateway?: string;
+  orgSlug?: string;
+  orgId?: string;
+}
+
+export class Auth {
+  public static config: AuthContext;
+}

package/src/auth/login.ts

@@ -1,89 +1,127 @@
-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,
-    });
-}
+const AmazonCognitoIdentity = require('amazon-cognito-identity-js');
+import inquirer from 'inquirer';
+import { Request, setConfig } from '@contrail/sdk';
+import { Auth, AuthContext } from './auth';
+
+const CONFIGURATION = {
+    userPoolId: 'us-east-1_x8hXZUsL6',
+    clientId: process.env.CONTRAIL_COGNITO_CLIENT_ID || '2oubek96sue5rsncovtqhs3scm',
+};
+
+export async function authUser(): Promise<AuthContext>{
+    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;
+                const config = await setAuthContext(user, params);
+
+                resolve(config);
+            },
+            onFailure: (err) => {
+                reject(err);
+            },
+        });
+    });
+}
+
+async function setAuthContext(user, params): Promise<AuthContext> {
+
+    // TODO Dont allow user to set this - they could set dev
+    const questions = [];
+    questions.push({
+        type: 'list',
+        name: 'environment',
+        message: 'Which environment would you like to use?',
+        choices: ['Dev', 'Prod'],
+        default: 'Dev',
+    });
+
+    let apiGateway;
+    const answers = await inquirer.prompt(questions);
+    if (answers.environment === 'Dev') {
+        apiGateway = 'https://api.vibeiq.com/dev/api';
+    } else {
+        apiGateway = 'https://api.vibeiq.com/prod/api';
+    }
+
+    // Set Auth Config
+    Auth.config = {
+        apiUserToken: user.idToken.jwtToken,
+        apiGateway,
+        orgSlug: params.orgSlug,
+    };
+    // SET SDK CONFIG
+    setConfig(Auth.config);
+
+    const currentUser = await Request.request('/users/current', {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!currentUser) {
+        throw Error('Could not get current user');
+    }
+    const org = currentUser.orgs.find(o => o.orgSlug === Auth.config.orgSlug);
+    if (org) {
+        Auth.config.orgId = org.orgId || org.id;
+    }
+
+    return Object.assign({}, Auth.config);
+}

package/src/cli.ts

@@ -1,33 +1,38 @@
-
-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.');
-    }
-  }
-}
-
+
+import { create } from './apps/create-app/create';
+import { deployApp, removeApp } from './apps/deploy-app/deploy';
+import { getTypes } from './types/types-extractor';
+import { uploadTypes } from './types/types-uploader';
+/**
+ *  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': {
+      getTypes(args);
+      break;
+    }
+    case 'upload-types': {
+      uploadTypes(args);
+      break;
+    }
+    default: {
+      console.log('Illegal command.');
+    }
+  }
+}

package/src/common.ts

@@ -0,0 +1,5 @@
+export function getSeparatorByPlatform() {
+  const isWin = process.platform === 'win32';
+  const separator = isWin ? '\\' : '/';
+  return separator;
+}