@contrail/cli 1.0.3 → 1.0.7

package/lib/{create-app → apps/create-app}/create.js

@@ -37,11 +37,7 @@ async function promptForMissingOptions(options) {
         });
     }
     const answers = await inquirer.prompt(questions);
-    return {
-        ...options,
-        appName: options.appName || answers.appName,
-        template: options.template || answers.template,
-    };
+    return Object.assign(Object.assign({}, options), { appName: options.appName || answers.appName, template: options.template || answers.template });
 }
 export async function create(args) {
     let options = parseArgumentsIntoOptions(args);

package/lib/{create-app → apps/create-app}/setup-template.js

@@ -12,7 +12,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/lib/{deploy-app → apps/deploy-app}/actions-deployer.js

@@ -1,6 +1,7 @@
 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) {
@@ -30,12 +31,16 @@ export class ActionsDeployer {
         }
     }
     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: ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration),
+            configProperties,
         };
         const functionString = await this.getFunction(actionDeclaration);
         if (functionString) {
@@ -49,10 +54,17 @@ export class ActionsDeployer {
         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: ConfigPropertiesParser.getConfigProperties(actionDeclaration.actionConfiguration),
+            configProperties,
         };
         const functionString = await this.getFunction(actionDeclaration);
         if (functionString) {
@@ -63,7 +75,7 @@ export class ActionsDeployer {
             id: existingActionDefinition.id,
             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;
     }
     getActionDeclarationIdentifier(actionKey, app) {
@@ -77,10 +89,9 @@ 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 functionLocaiton = CURRENT_DIR + separator + actionDeclaration.handler;
-        const content = fs.readFileSync(functionLocaiton);
+        const separator = getSeparatorByPlatform();
+        const functionLocation = CURRENT_DIR + separator + actionDeclaration.handler;
+        const content = fs.readFileSync(functionLocation);
         return content.toString();
     }
 }

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

@@ -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 { TriggerKeyDefinitionParser, ConfigPropertiesParser } from './app-template-parsers';
 export class AppDeployer {

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

@@ -1,12 +1,14 @@
 import chalk from 'chalk';
 import fs from 'fs';
-import { authUser } from '../auth/login';
+import { authUser } from '../../auth/login';
 import { AppDeployer } from './app-deployer';
+import { getSeparatorByPlatform } from '../../common';
 const yaml = require('js-yaml');
 function loadAppConfig() {
     const TARGET_DIR = process.cwd();
     try {
-        const 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;
     }

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

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

package/lib/auth/login.d.ts

@@ -1 +1,2 @@
-export declare function authUser(): Promise<unknown>;
+import { AuthContext } from './auth';
+export declare function authUser(): Promise<AuthContext>;

package/lib/auth/login.js

@@ -60,8 +60,8 @@ export async function authUser() {
         cognitoUser.authenticateUser(authDetails, {
             onSuccess: async (result) => {
                 const user = result;
-                await setAuthContext(user, params);
-                resolve({ success: true, data: result });
+                const config = await setAuthContext(user, params);
+                resolve(config);
             },
             onFailure: (err) => {
                 reject(err);
@@ -109,4 +109,5 @@ async function setAuthContext(user, params) {
     if (org) {
         Auth.config.orgId = org.orgId || org.id;
     }
+    return Object.assign({}, Auth.config);
 }

package/lib/cli.js

@@ -1,30 +1,120 @@
-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 === null || commandParts === void 0 ? void 0 : commandParts.length)) {
+        printIllegalCommand();
+        return;
+    }
+    if ((commandParts === null || commandParts === void 0 ? void 0 : 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/lib/common.d.ts

@@ -0,0 +1 @@
+export declare function getSeparatorByPlatform(): "\\" | "/";

package/lib/common.js

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

package/lib/types/interfaces.d.ts

@@ -0,0 +1,50 @@
+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"
+}

package/lib/types/option-set-uploader.d.ts

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

package/lib/types/option-set-uploader.js

@@ -0,0 +1,75 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+const yaml = require('js-yaml');
+function loadOptionSets() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'option_sets.yml', 'utf8'));
+        return doc.optionSets;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+export async function uploadOptionSets() {
+    const optionSets = loadOptionSets();
+    const currentOptionSets = await new Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const currentOptionSetsByName = {};
+    for (const currentOptionSet of currentOptionSets) {
+        currentOptionSetsByName[currentOptionSet.name] = currentOptionSet;
+    }
+    const newOptionSetsByName = {};
+    for (const optionSet of optionSets) {
+        newOptionSetsByName[optionSet.name] = optionSet;
+    }
+    for (const optionSet of optionSets) {
+        try {
+            const found = currentOptionSetsByName[optionSet.name];
+            if (!found) {
+                console.log('Creating: ', optionSet.name);
+                await new Entities().create({
+                    entityName: 'type-property-option-set',
+                    object: {
+                        name: optionSet.name,
+                        optionSet: optionSet.optionSet,
+                        isArchived: optionSet.isArchived,
+                    },
+                });
+            }
+            else {
+                console.log('Updating: ', optionSet.name);
+                await new Entities().update({
+                    entityName: 'type-property-option-set',
+                    id: found.id,
+                    object: {
+                        name: optionSet.name,
+                        optionSet: optionSet.optionSet,
+                        isArchived: optionSet.isArchived,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading OptionSets: ${err}`);
+        }
+    }
+    for (const currentOptionSet of currentOptionSets) {
+        try {
+            const found = newOptionSetsByName[currentOptionSet.name];
+            if (!found) {
+                console.log('Deleting: ', currentOptionSet.name);
+                await new Entities().delete({
+                    entityName: 'type-property-option-set',
+                    id: currentOptionSet.id,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting OptionSets: ${err}`);
+        }
+    }
+}

package/lib/types/parse-optionSet.d.ts

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

package/lib/types/parse-optionSet.js

@@ -0,0 +1,79 @@
+import { StringUtil } from '@contrail/util';
+import chalk from 'chalk';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+import * as csvToJson from 'csvtojson';
+const yaml = require('js-yaml');
+export async function parseOptionSet(args) {
+    try {
+        if ((args === null || args === void 0 ? void 0 : args.length) < 4) {
+            throw new Error('File name must be included.');
+        }
+        console.log(`%s Parsing`, chalk.yellow.bold('OPTION SETS'));
+        await parseOptionSets(args[3]);
+        console.log(`%s Parsed`, chalk.yellow.bold('OPTION SETS'));
+    }
+    catch (e) {
+        console.log(`%s Parsing Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Parsing Complete.', chalk.green.bold('COMPLETE'));
+}
+async function loadDataFromCSV(fileName) {
+    const CURRENT_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const csvData = await csvToJson.default().fromFile(CURRENT_DIR + separator + fileName);
+        return csvData;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING CSV: ${e}`);
+    }
+}
+export async function parseOptionSets(fileName) {
+    const csvData = await loadDataFromCSV(fileName);
+    const removedFields = new Set();
+    const valuesByFieldName = {};
+    for (const row of csvData) {
+        for (const [key, value] of Object.entries(row)) {
+            // Dont parse boolean fields - later log removed fields
+            if (value.toLowerCase() === 'false' || value.toLowerCase() === 'true') {
+                removedFields.add(key);
+                continue;
+            }
+            if (!value) {
+                continue;
+            }
+            if (!valuesByFieldName[key]) {
+                valuesByFieldName[key] = new Set();
+            }
+            valuesByFieldName[key].add(value);
+        }
+    }
+    for (const removed of removedFields.values()) {
+        console.log(`Removed Boolean Field: ${removed}`);
+    }
+    const reducedOptionSets = [];
+    for (const [key, value] of Object.entries(valuesByFieldName)) {
+        const optionSet = [];
+        for (const entry of value.values()) {
+            optionSet.push({
+                value: StringUtil.convertToCamelCase(entry),
+                display: isUpperCase(entry) ? entry : StringUtil.convertToTitleCase(entry),
+            });
+        }
+        const reducedOptionSet = {
+            name: StringUtil.convertToTitleCase(key),
+            isArchived: false,
+            optionSet,
+        };
+        reducedOptionSets.push(reducedOptionSet);
+    }
+    const yamlStr = yaml.dump(reducedOptionSets);
+    const CURRENT_DIR = process.cwd();
+    const separator = getSeparatorByPlatform();
+    fs.writeFileSync(CURRENT_DIR + separator + 'parsed_option_sets.yml', yamlStr, 'utf8');
+}
+function isUpperCase(str) {
+    return str === str.toUpperCase();
+}

package/lib/types/types-extractor.d.ts

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

package/lib/types/types-extractor.js

@@ -0,0 +1,98 @@
+import { Entities } from '@contrail/sdk';
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import { getSeparatorByPlatform } from '../common';
+const yaml = require('js-yaml');
+export async function getTypes(args) {
+    try {
+        const userConfig = await authUser();
+        console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
+        console.log(`%s Retrieving`, chalk.yellow.bold('OPTION SETS'));
+        const optionSets = await new Entities().get({
+            entityName: 'type-property-option-set',
+        });
+        await getOptionSets(optionSets);
+        console.log(`%s Retrieved`, chalk.yellow.bold('OPTION SETS'));
+        console.log(`%s Retrieving`, chalk.yellow.bold('TYPES'));
+        await getReducedTypes(optionSets);
+        console.log(`%s Retrieved`, chalk.yellow.bold('TYPES'));
+    }
+    catch (e) {
+        console.log(`%s Types Retrieval Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Types Retrieval Complete.', chalk.green.bold('COMPLETE'));
+}
+async function getOptionSets(optionSets) {
+    let reducedOptionSets = [];
+    for (const optionSet of optionSets) {
+        const reducedOptionSet = {
+            name: optionSet.name,
+            isArchived: optionSet.isArchived,
+            optionSet: optionSet.optionSet,
+        };
+        reducedOptionSets.push(reducedOptionSet);
+    }
+    const optionSetsHolder = {
+        optionSets: reducedOptionSets,
+    };
+    reducedOptionSets = reducedOptionSets.sort((one, two) => (one.name < two.name ? -1 : 1));
+    const CURRENT_DIR = process.cwd();
+    const separator = getSeparatorByPlatform();
+    const yamlStr = yaml.dump(optionSetsHolder);
+    fs.writeFileSync(CURRENT_DIR + separator + 'option_sets.yml', yamlStr, 'utf8');
+}
+async function getReducedTypes(optionSets) {
+    const types = await new Entities().get({
+        entityName: 'type',
+    });
+    console.log('Found types: ', types.length);
+    let reducedTypes = [];
+    for (const type of types) {
+        const typeWithProperties = await new Entities().get({
+            entityName: 'type',
+            id: type.id,
+            relations: ['typeProperties'],
+        });
+        const optionSetNameById = {};
+        for (const optionSet of optionSets) {
+            optionSetNameById[optionSet.id] = optionSet.name;
+        }
+        const reducedTypeProperties = [];
+        for (const typeProperty of typeWithProperties.typeProperties) {
+            const reducedTypeProperty = {
+                slug: typeProperty.slug,
+                id: typeProperty.id,
+                isArchived: typeProperty.isArchived,
+                propertyType: typeProperty.propertyType,
+                label: typeProperty.label,
+                editable: typeProperty.editable,
+                core: typeProperty.core,
+                typePropertyOptionSetName: optionSetNameById[typeProperty.typePropertyOptionSetId],
+                formula: typeProperty.formula,
+                referencedTypeRootSlug: typeProperty.referencedTypeRootSlug,
+                defaultValue: typeProperty.defaultValue,
+                propertyLevel: typeProperty.propertyLevel,
+                inherited: typeProperty.inherited,
+            };
+            reducedTypeProperties.push(reducedTypeProperty);
+        }
+        const reducedType = {
+            typePath: typeWithProperties.typePath,
+            slug: typeWithProperties.slug,
+            label: typeWithProperties.label,
+            isArchived: typeWithProperties.isArchived,
+            typeProperties: reducedTypeProperties,
+        };
+        reducedTypes.push(reducedType);
+    }
+    reducedTypes = reducedTypes.sort((one, two) => (one.typePath < two.typePath ? -1 : 1));
+    const typesHolder = {
+        types: reducedTypes,
+    };
+    const CURRENT_DIR = process.cwd();
+    const separator = getSeparatorByPlatform();
+    const yamlStr = yaml.dump(typesHolder);
+    fs.writeFileSync(CURRENT_DIR + separator + 'types.yml', yamlStr, 'utf8');
+}

package/lib/types/types-uploader.d.ts

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