@contrail/cli 1.0.0 → 1.0.5

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

@@ -0,0 +1,74 @@
+/** 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;
+    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[];
+}
+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/auth/auth.d.ts

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

package/lib/auth/auth.js

@@ -0,0 +1,2 @@
+export class Auth {
+}

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

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

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

package/lib/cli.js

@@ -1,30 +1,36 @@
-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/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,51 @@
+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;
+    typePropertyOptionSetId: string;
+    formula: string;
+    referencedTypeRootSlug: string;
+    defaultValue: string;
+    propertyLevel: string;
+    inherited: boolean;
+}
+export interface ReducedOptionSet {
+    id: string;
+    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/types-extractor.d.ts

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

package/lib/types/types-extractor.js

@@ -0,0 +1,93 @@
+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'));
+        await getOptionSets();
+        console.log(`%s Retrieved`, chalk.yellow.bold('OPTION SETS'));
+        console.log(`%s Retrieving`, chalk.yellow.bold('TYPES'));
+        await getReducedTypes();
+        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() {
+    const optionSets = await new Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const reducedOptionSets = [];
+    for (const optionSet of optionSets) {
+        const reducedOptionSet = {
+            id: optionSet.id,
+            name: optionSet.name,
+            isArchived: optionSet.isArchived,
+            optionSet: optionSet.optionSet,
+        };
+        reducedOptionSets.push(reducedOptionSet);
+    }
+    const optionSetsHolder = {
+        optionSets: reducedOptionSets,
+    };
+    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() {
+    const types = await new Entities().get({
+        entityName: 'type',
+    });
+    console.log('Found types: ', types.length);
+    const reducedTypes = [];
+    for (const type of types) {
+        const typeWithProperties = await new Entities().get({
+            entityName: 'type',
+            id: type.id,
+            relations: ['typeProperties'],
+        });
+        const reducedTypeProperties = [];
+        for (const typeProperty of typeWithProperties.typeProperties) {
+            const reducedTypeProperty = {
+                id: typeProperty.id,
+                isArchived: typeProperty.isArchived,
+                propertyType: typeProperty.propertyType,
+                slug: typeProperty.slug,
+                label: typeProperty.label,
+                editable: typeProperty.editable,
+                core: typeProperty.core,
+                typePropertyOptionSetId: typeProperty.typePropertyOptionSetId,
+                formula: typeProperty.formula,
+                referencedTypeRootSlug: typeProperty.referencedTypeRootSlug,
+                defaultValue: typeProperty.defaultValue,
+                propertyLevel: typeProperty.propertyLevel,
+                inherited: typeProperty.inherited,
+            };
+            reducedTypeProperties.push(reducedTypeProperty);
+        }
+        const reducedType = {
+            slug: typeWithProperties.slug,
+            label: typeWithProperties.label,
+            typePath: typeWithProperties.typePath,
+            isArchived: typeWithProperties.isArchived,
+            typeProperties: reducedTypeProperties,
+        };
+        reducedTypes.push(reducedType);
+    }
+    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>;