@contrail/cli 1.0.3 → 1.0.7

package/lib/types/types-uploader.js

@@ -0,0 +1,228 @@
+import { Entities, Request } from '@contrail/sdk';
+import { uploadOptionSets } from './option-set-uploader';
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import { getSeparatorByPlatform } from '../common';
+import * as _ from 'lodash';
+const yaml = require('js-yaml');
+export async function uploadTypes(args) {
+    try {
+        const userConfig = await authUser();
+        console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
+        console.log(`%s Uploading`, chalk.yellow.bold('OPTION SETS'));
+        await uploadOptionSets();
+        console.log(`%s Uploaded`, chalk.yellow.bold('OPTION SETS'));
+        console.log(`%s Uploading`, chalk.yellow.bold('TYPES'));
+        await uploadReducedTypes();
+        console.log(`%s Uploaded`, chalk.yellow.bold('TYPES'));
+    }
+    catch (e) {
+        console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadReducedTypes() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'types.yml', 'utf8'));
+        return doc.types;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadReducedTypes() {
+    const types = loadReducedTypes();
+    const currentTypesWithoutProperties = await new Entities().get({
+        entityName: 'type',
+    });
+    const currentTypes = [];
+    for (const currentTypeWithoutProperties of currentTypesWithoutProperties) {
+        const typeWithProperties = await new Entities().get({
+            entityName: 'type',
+            id: currentTypeWithoutProperties.id,
+            relations: ['typeProperties'],
+        });
+        currentTypes.push(typeWithProperties);
+    }
+    const currentTypesBySlug = {};
+    for (const currentType of currentTypes) {
+        currentTypesBySlug[currentType.slug] = currentType;
+    }
+    const newTypesBySlug = {};
+    for (const type of types) {
+        newTypesBySlug[type.slug] = type;
+    }
+    for (const type of types) {
+        try {
+            const found = currentTypesBySlug[type.slug];
+            if (!found) {
+                if (!type.typePath.includes(':')) {
+                    console.log('Cannot create a base type. Skipping: ', type.slug);
+                    continue;
+                }
+                console.log('Creating Type: ', type.slug);
+                const createdType = await new Entities().create({
+                    entityName: 'type',
+                    object: {
+                        slug: type.slug,
+                        label: type.label,
+                        typePath: type.typePath,
+                        isArchived: type.isArchived,
+                    },
+                });
+                await uploadReducedTypeProperties(createdType, [], type.typeProperties);
+            }
+            else {
+                console.log('Updating Type: ', type.slug);
+                const updatedType = await new Entities().update({
+                    entityName: 'type',
+                    id: found.id,
+                    object: {
+                        slug: type.slug,
+                        label: type.label,
+                        typePath: type.typePath,
+                        isArchived: type.isArchived,
+                    },
+                });
+                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties);
+            }
+        }
+        catch (err) {
+            console.log('Error Uploading Types: ', err);
+        }
+    }
+    for (const currentType of currentTypes) {
+        try {
+            const found = newTypesBySlug[currentType.slug];
+            if (!found) {
+                console.log('Deleting Type: ', currentType.slug);
+                await new Entities().delete({
+                    entityName: 'type',
+                    id: currentType.id,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting Types: ${err}`);
+        }
+    }
+}
+async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes) {
+    const currentPropertyTypeBySlug = {};
+    for (const currentPropertyType of currentPropertyTypes) {
+        currentPropertyTypeBySlug[currentPropertyType.slug] = currentPropertyType;
+    }
+    const newPropertyTypesBySlug = {};
+    for (const newPropertyType of newPropertyTypes) {
+        newPropertyTypesBySlug[newPropertyType.slug] = newPropertyType;
+    }
+    const optionSets = await new Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const optionSetIdByName = {};
+    for (const optionSet of optionSets) {
+        optionSetIdByName[optionSet.name] = optionSet.id;
+    }
+    for (const newPropertyType of newPropertyTypes) {
+        try {
+            const found = currentPropertyTypeBySlug[newPropertyType.slug];
+            if (!found && !newPropertyType.inherited) {
+                console.log('Creating Type-Property: ', newPropertyType.slug);
+                await Request.request(`/types/${type.id}/type-properties`, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        isArchived: newPropertyType.isArchived,
+                        propertyType: newPropertyType.propertyType,
+                        slug: newPropertyType.slug,
+                        label: newPropertyType.label,
+                        editable: newPropertyType.editable,
+                        core: newPropertyType.core,
+                        typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
+                        formula: newPropertyType.formula,
+                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        defaultValue: newPropertyType.defaultValue,
+                        propertyLevel: newPropertyType.propertyLevel,
+                    }),
+                    headers: {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+            else if (found && !newPropertyType.inherited && !typePropertiesEqual(found, newPropertyType, optionSetIdByName)) {
+                console.log('Updating Type-Property: ', newPropertyType.slug);
+                await new Entities().update({
+                    entityName: 'type-property',
+                    id: found.id,
+                    object: {
+                        isArchived: newPropertyType.isArchived,
+                        propertyType: newPropertyType.propertyType,
+                        slug: newPropertyType.slug,
+                        label: newPropertyType.label,
+                        editable: newPropertyType.editable,
+                        core: newPropertyType.core,
+                        typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
+                        formula: newPropertyType.formula,
+                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        defaultValue: newPropertyType.defaultValue,
+                        propertyLevel: newPropertyType.propertyLevel,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            console.log('Error Creating Properties: ', err);
+        }
+    }
+    for (const currentPropertyType of currentPropertyTypes) {
+        try {
+            const found = newPropertyTypesBySlug[currentPropertyType.slug];
+            if (!found && !currentPropertyType.inherited) {
+                console.log('Deleting Type-Property: ', currentPropertyType.slug);
+                await Request.request(`/types/${type.id}/type-properties/${currentPropertyType.id}`, {
+                    method: 'DELETE',
+                    headers: {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting Properties: ${err}`);
+        }
+    }
+}
+function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
+    const reducedProperty1 = {
+        isArchived: typeProperty1.isArchived,
+        propertyType: typeProperty1.propertyType,
+        slug: typeProperty1.slug,
+        label: typeProperty1.label,
+        editable: typeProperty1.editable,
+        core: typeProperty1.core,
+        typePropertyOptionSetId: optionSetIdByName[typeProperty1.typePropertyOptionSetName],
+        formula: typeProperty1.formula,
+        referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
+        defaultValue: typeProperty1.defaultValue,
+        propertyLevel: typeProperty1.propertyLevel,
+    };
+    const reducedProperty2 = {
+        isArchived: typeProperty2.isArchived,
+        propertyType: typeProperty2.propertyType,
+        slug: typeProperty2.slug,
+        label: typeProperty2.label,
+        editable: typeProperty2.editable,
+        core: typeProperty2.core,
+        typePropertyOptionSetId: optionSetIdByName[typeProperty2.typePropertyOptionSetName],
+        formula: typeProperty2.formula,
+        referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
+        defaultValue: typeProperty2.defaultValue,
+        propertyLevel: typeProperty2.propertyLevel,
+    };
+    return _.isEqual(reducedProperty1, reducedProperty2);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "1.0.3",
+  "version": "1.0.7",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {
@@ -24,27 +24,32 @@
   "license": "ISC",
   "dependencies": {
     "@contrail/sdk": "^1.0.91",
+    "@contrail/util": "^1.0.17",
     "amazon-cognito-identity-js": "^5.2.3",
     "arg": "^4.0.1",
     "aws-sdk": "^2.1044.0",
     "chalk": "^4.0.0",
+    "command-line-usage": "^6.1.1",
+    "csvtojson": "^2.0.10",
     "esm": "^3.2.25",
     "execa": "^5.0.0",
     "inquirer": "^8.2.0",
     "js-yaml": "^4.1.0",
     "listr": "^0.14.3",
+    "lodash": "^4.17.21",
     "ncp": "^2.0.0",
     "pkg-install": "^1.0.0"
   },
   "devDependencies": {
     "@types/jest": "^23.3.14",
+    "@types/lodash": "^4.14.178",
+    "@types/node": "^14.6.4",
     "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"
+    "typescript": "^3.0.1"
   },
   "jest": {
     "moduleFileExtensions": [

package/src/{create-app → apps/create-app}/setup-template.ts

@@ -16,7 +16,7 @@ function copyTemplate(templateDir){
 }
 
 export async function setUpTemplate(options) {
-  const templateDir = path.resolve(new URL(currentFileUrl).pathname, `../../../templates/${options.template.toLocaleLowerCase()}`).replace(/\\/g, '\\').replace(/(.):\\(.):/g, '').replace(/%20/g, ' ');
+  const templateDir = path.resolve(new URL(currentFileUrl).pathname, `../../../../templates/${options.template.toLocaleLowerCase()}`).replace(/\\/g, '\\').replace(/(.):\\(.):/g, '').replace(/%20/g, ' ');
   try {
     const tasks = new Listr([
       {

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

@@ -2,6 +2,8 @@ import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
 import { App, AppDeclaration, AppActionDeclaration, EventWorkflowActionDefinition } from './interfaces';
 import { ConfigPropertiesParser } from './app-template-parsers';
+import { getSeparatorByPlatform } from '../../common';
+
 import fs from 'fs';
 
 export class ActionsDeployer {
@@ -39,12 +41,16 @@ export class ActionsDeployer {
   }
 
   private async createNewActionDefinition(actionKey: string, actionDeclaration: AppActionDeclaration, app: App) {
+    let configProperties;
+    if (actionDeclaration?.actionConfiguration) {
+      configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
+    }
     const newObject: EventWorkflowActionDefinition = {
       identifier: this.getActionDeclarationIdentifier(actionKey, app),
       name: actionDeclaration.name,
       ownerKey: `app:${app.id}`,
       public: app.public,  // TODO - an actions visibility is not tied to the visibility of the app
-      configProperties: ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration),
+      configProperties,
     };
 
     const functionString = await this.getFunction(actionDeclaration);
@@ -62,12 +68,20 @@ export class ActionsDeployer {
     return actionDefinition;
   }
 
-  private async updateActionDefinition(existingActionDefinition: EventWorkflowActionDefinition,
-                                       actionDeclaration: AppActionDeclaration) {
+  private async updateActionDefinition(existingActionDefinition: EventWorkflowActionDefinition, actionDeclaration: AppActionDeclaration) {
+
+    let configProperties;
+    if (actionDeclaration?.actionConfiguration) {
+      configProperties = ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration);
+    }
+    else if (!actionDeclaration?.actionConfiguration && existingActionDefinition.configProperties) {
+      configProperties = null;
+    }
+
     const updates: EventWorkflowActionDefinition = {
       name: actionDeclaration.name,
       // public: actionDeclaration.public, // TODO - an actions visibility is allowed to change
-      configProperties: ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration),
+      configProperties,
     };
 
     const functionString = await this.getFunction(actionDeclaration);
@@ -81,7 +95,7 @@ export class ActionsDeployer {
       object: updates,
     });
 
-    console.log(`%s      Updated existingaction defintion: ${actionDefinition.identifier}`, chalk.yellow.bold('APP'));
+    console.log(`%s      Updated existing action definition: ${actionDefinition.identifier}`, chalk.yellow.bold('APP'));
 
     return actionDefinition;
   }
@@ -99,11 +113,10 @@ export class ActionsDeployer {
       throw new Error('Action handler must be a .js file.');
     }
     const CURRENT_DIR = process.cwd();
-    const isWin = process.platform === 'win32';
-    const separator = isWin ? '\\' : '/';
+    const separator = getSeparatorByPlatform();
 
-    const functionLocaiton = CURRENT_DIR + separator + actionDeclaration.handler;
-    const content = fs.readFileSync(functionLocaiton);
+    const functionLocation = CURRENT_DIR + separator + actionDeclaration.handler;
+    const content = fs.readFileSync(functionLocation);
     return content.toString();
   }
 }

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

@@ -1,6 +1,6 @@
 import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
-import { Auth } from '../auth/auth';
+import { Auth } from '../../auth/auth';
 import { ActionsDeployer } from './actions-deployer';
 import { App, AppDeclaration } from './interfaces';
 import { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';

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

@@ -1,14 +1,16 @@
 import chalk from 'chalk';
 import fs from 'fs';
-import { authUser } from '../auth/login';
+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 doc = yaml.load(fs.readFileSync(TARGET_DIR + '/app.yml', 'utf8'));
+    const separator = getSeparatorByPlatform();
+    const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'app.yml', 'utf8'));
     console.log(doc);
     return doc;
   } catch (e) {

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

@@ -30,7 +30,7 @@ export interface AppActionDeclaration {
   handler: string;
   name: string;
   description?: string;
-  actionConfiguration: ConfigPropertyElements;
+  actionConfiguration?: ConfigPropertyElements;
 }
 
 export interface AppTriggerDeclaration {

package/src/auth/login.ts

@@ -1,14 +1,14 @@
 const AmazonCognitoIdentity = require('amazon-cognito-identity-js');
 import inquirer from 'inquirer';
 import { Request, setConfig } from '@contrail/sdk';
-import { Auth } from './auth';
+import { Auth, AuthContext } from './auth';
 
 const CONFIGURATION = {
     userPoolId: 'us-east-1_x8hXZUsL6',
     clientId: process.env.CONTRAIL_COGNITO_CLIENT_ID || '2oubek96sue5rsncovtqhs3scm',
 };
 
-export async function authUser(){
+export async function authUser(): Promise<AuthContext>{
     const questions = [];
     if (!process.env.CONTRAIL_CLI_EMAIL) {
         questions.push({
@@ -68,9 +68,9 @@ export async function authUser(){
         cognitoUser.authenticateUser(authDetails, {
             onSuccess: async (result) => {
                 const user = result;
-                await setAuthContext(user, params);
+                const config = await setAuthContext(user, params);
 
-                resolve({success: true, data: result});
+                resolve(config);
             },
             onFailure: (err) => {
                 reject(err);
@@ -79,7 +79,7 @@ export async function authUser(){
     });
 }
 
-async function setAuthContext(user, params){
+async function setAuthContext(user, params): Promise<AuthContext> {
 
     // TODO Dont allow user to set this - they could set dev
     const questions = [];
@@ -122,4 +122,6 @@ async function setAuthContext(user, params){
     if (org) {
         Auth.config.orgId = org.orgId || org.id;
     }
+
+    return Object.assign({}, Auth.config);
 }

package/src/cli.ts

@@ -1,32 +1,132 @@
 
-import { create } from './create-app/create';
-import { deployApp, removeApp } from './deploy-app/deploy';
+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';
+import { parseOptionSet } from './types/parse-optionSet';
+const cliUsage = require('command-line-usage');
+
 /**
  *  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);
+  const fullCommand = args[2];
+  let domain;
+  let command;
+  const commandParts = fullCommand.split('.');
+
+  if (!commandParts?.length) {
+    printIllegalCommand();
+    return;
+  }
+
+  if (commandParts?.length < 2 && commandParts[0].toLowerCase() !== 'help'  && commandParts[0].toLowerCase() !== '-help' && commandParts[0].toLowerCase() !== '--help') {
+    printIllegalCommand();
+    return;
+  }
+
+  domain = commandParts[0];
+  command = commandParts[1];
+
+  switch (domain) {
+    case 'app': {
+      switch (command) {
+        case 'create': {
+          create(args);
+          break;
+        }
+        case 'deploy': {
+          deployApp(args);
+          break;
+        }
+        case 'remove': {
+          removeApp(args);
+          break;
+        }
+        default: {
+          printIllegalCommand();
+        }
+      }
       break;
     }
-    case 'remove-app': {
-      removeApp(args);
+    case 'types': {
+      switch (command) {
+        case 'getAll': {
+          getTypes(args);
+          break;
+        }
+        case 'upload': {
+          uploadTypes(args);
+          break;
+        }
+        case 'parseOptionSet': {
+          parseOptionSet(args);
+          break;
+        }
+        default: {
+          printIllegalCommand();
+        }
+      }
       break;
     }
-    case 'extract-types': {
-      // TODO
+    case 'help':
+    case '-help':
+    case '--help': {
+      printHelp();
       break;
     }
     default: {
-      console.log('Illegal command.');
+      printIllegalCommand();
     }
   }
 }
+
+function printHelp() {
+  const sections = [
+    {
+      header: 'VibeIQ CLI',
+      content: 'From your friends at VibeIQ!',
+    },
+    ...helpSections,
+  ];
+
+  const usage = cliUsage(sections);
+  console.log(usage);
+}
+
+function printIllegalCommand() {
+  console.log('Illegal command.');
+
+  const usage = cliUsage(helpSections);
+  console.log(usage);
+}
+
+const helpSections = [
+  {
+    header: 'General Usage',
+    content: [
+      'Commands are run by pairing a domain with a command, joining them using a "."',
+      'e.g. app.create',
+      '',
+      'All <File Path> options should use the file path relative to the folder the command is being run in and include the file ext.',
+    ],
+  },
+  {
+    header: 'App Commands - Domain: app',
+    content: [
+      'create                       Create a new app workspace.',
+      'deploy                       Deploy your app.',
+      'remove                       Remove your app.',
+    ],
+  },
+  {
+    header: 'Type Commands - Domain: types',
+    content: [
+      'getAll                       Get all OptionSets and Types for your Org.',
+      'upload                       Upload OptionSets and Types for your Org.',
+      'parseOptionSet <File Path>   Parse a CSV file into OptionSets.',
+    ],
+  },
+];

package/src/common.ts

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

package/src/types/interfaces.ts

@@ -0,0 +1,53 @@
+export interface ReducedType {
+  slug: string;
+  label: string;
+  typePath: string;
+  isArchived: boolean;
+  typeProperties: ReducedType[];
+}
+
+export interface ReducedTypeProperties {
+  id: string;
+  isArchived: boolean;
+  propertyType: PropertyType;
+  slug: string;
+  label: string;
+  editable: boolean;
+  core: boolean;
+  typePropertyOptionSetName: string;
+  formula: string;
+  referencedTypeRootSlug: string;
+  defaultValue: string;
+  propertyLevel: string;
+  inherited: boolean;
+}
+
+export interface ReducedOptionSet {
+  name: string;
+  isArchived: boolean;
+  optionSet: any[];
+}
+
+export declare enum PropertyType {
+  Text = 'text',
+  String = 'string',
+  Number = 'number',
+  Date = 'date',
+  Boolean = 'boolean',
+  MultiSelect = 'multi_select',
+  SingleSelect = 'choice',
+  Url = 'url',
+  Currency = 'currency',
+  Percent = 'percent',
+  Rating = 'rating',
+  Formula = 'formula',
+  ObjectReference = 'object_reference',
+  ObjectReferenceList = 'object_ref_list',
+  DataGrid = 'data_grid',
+  CascadingSelect = 'cascading_select',
+  Sequence = 'sequence',
+  Constant = 'constant',
+  Composite = 'composite',
+  UserList = 'userList',
+  Image = 'image',
+}