@contrail/cli 1.0.0 → 1.0.5

package/lib/types/types-uploader.js

@@ -0,0 +1,171 @@
+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';
+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;
+    }
+    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: newPropertyType.typePropertyOptionSetId,
+                        formula: newPropertyType.formula,
+                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        defaultValue: newPropertyType.defaultValue,
+                        propertyLevel: newPropertyType.propertyLevel,
+                    }),
+                    headers: {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+        }
+        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}`);
+        }
+    }
+}

package/package.json

@@ -1,63 +1,63 @@
-{
-  "name": "@contrail/cli",
-  "version": "1.0.0",
-  "description": "VibeIQ's Contrail Platform CLI.",
-  "main": "lib/index.js",
-  "bin": {
-    "@contrail/contrail-cli": "bin/init",
-    "contrail": "bin/init"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "cli",
-    "contrail-cli"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-    "lint": "tslint -p tsconfig.json",
-    "test": "jest --watch"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "@contrail/sdk": "^1.0.91",
-    "amazon-cognito-identity-js": "^5.2.3",
-    "arg": "^4.0.1",
-    "aws-sdk": "^2.1044.0",
-    "chalk": "^4.0.0",
-    "esm": "^3.2.25",
-    "execa": "^5.0.0",
-    "inquirer": "^8.2.0",
-    "js-yaml": "^4.1.0",
-    "listr": "^0.14.3",
-    "ncp": "^2.0.0",
-    "pkg-install": "^1.0.0"
-  },
-  "devDependencies": {
-    "@types/jest": "^23.3.14",
-    "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"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": "src",
-    "testRegex": ".spec.ts$",
-    "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
-    },
-    "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
-  }
-}
+{
+  "name": "@contrail/cli",
+  "version": "1.0.5",
+  "description": "VibeIQ's Contrail Platform CLI.",
+  "main": "lib/index.js",
+  "bin": {
+    "@contrail/contrail-cli": "bin/init",
+    "contrail": "bin/init"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "contrail-cli"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "test": "jest --watch"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@contrail/sdk": "^1.0.91",
+    "amazon-cognito-identity-js": "^5.2.3",
+    "arg": "^4.0.1",
+    "aws-sdk": "^2.1044.0",
+    "chalk": "^4.0.0",
+    "esm": "^3.2.25",
+    "execa": "^5.0.0",
+    "inquirer": "^8.2.0",
+    "js-yaml": "^4.1.0",
+    "listr": "^0.14.3",
+    "ncp": "^2.0.0",
+    "pkg-install": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^23.3.14",
+    "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"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".spec.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/publish.sh

@@ -0,0 +1,5 @@
+rm -rf lib;
+npm install;
+npm run build;
+npm version patch;
+npm publish;

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

@@ -0,0 +1,73 @@
+import arg from 'arg';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { setUpTemplate } from './setup-template';
+
+function parseArgumentsIntoOptions(rawArgs) {
+  const args = arg(
+    {
+      '--app-name': String,
+      '--template': String,
+      '-n': '--app-name',
+      '-t': '--template',
+    },
+    {
+      argv: rawArgs.slice(3),
+    },
+  );
+  return {
+    appName: args['--app-name'],
+    template: args['--template'],
+  };
+}
+async function promptForMissingOptions(options) {
+  const defaultTemplate = 'JavaScript';
+
+  const questions = [];
+  if (!options.appName) {
+    questions.push({
+      type: 'input',
+      name: 'appName',
+      validate: (val) => !!val,
+      message: 'What is the name of your app?',
+    });
+  }
+
+  if (!options.template) {
+    questions.push({
+      type: 'list',
+      name: 'template',
+      message: 'Which project template would you like to use?',
+      choices: ['JavaScript', 'TypeScript'],
+      default: defaultTemplate,
+    });
+  }
+
+  const answers = await inquirer.prompt(questions);
+  return {
+    ...options,
+    appName: options.appName || answers.appName,
+    template: options.template || answers.template,
+  };
+}
+
+export async function create(args) {
+
+  let options = parseArgumentsIntoOptions(args);
+  options = await promptForMissingOptions(options);
+  console.log('%s Setting up new new contrail application.', chalk.blue.bold('START'));
+
+  let error;
+  try {
+    await setUpTemplate(options);
+  }
+  catch (e) {
+    error = e;
+  }
+
+  if (error) {
+    console.log('%s Application initialization failed.', chalk.red.bold('FAIL'));
+  } else {
+    console.log('%s Application initialized successfully.', chalk.green.bold('COMPLETE'));
+  }
+}

package/src/apps/create-app/setup-template.ts

@@ -0,0 +1,38 @@
+
+import ncp from 'ncp';
+import path from 'path';
+import { promisify } from 'util';
+const Listr = require('listr');
+import { projectInstall } from 'pkg-install';
+const copy = promisify(ncp);
+
+const TARGET_DIR = process.cwd();
+const currentFileUrl = import .meta.url;
+
+function copyTemplate(templateDir){
+  return copy(templateDir, TARGET_DIR, {
+    clobber: false,
+  });
+}
+
+export async function setUpTemplate(options) {
+  const templateDir = path.resolve(new URL(currentFileUrl).pathname, `../../../../templates/${options.template.toLocaleLowerCase()}`).replace(/\\/g, '\\').replace(/(.):\\(.):/g, '').replace(/%20/g, ' ');
+  try {
+    const tasks = new Listr([
+      {
+        title: 'Copy template files',
+        task: () => copyTemplate(templateDir),
+      },
+      {
+        title: 'Install dependencies',
+        task: () =>
+          projectInstall({
+            cwd: TARGET_DIR,
+          }),
+      },
+    ]);
+    await tasks.run();
+  } catch (e) {
+    throw new Error(`Error copying template: ${e}`);
+  }
+}

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

@@ -1,87 +1,122 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import { App, AppDeclartion, AppActionDeclaration, EventWorkflowActionDefinition } from './interfaces';
-import fs from 'fs';
-
-export class ActionsDeployer {
-  async deployActions(appDeclaration: AppDeclartion, app: App) {
-
-    // FETCH ALL ACTIONS FROM THE API.
-    const existingActions = await this.getActionsForApp(app);
-    console.log('existingActions: ', existingActions);
-    // 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: App){
-    return await new Entities().get({ entityName: 'event-workflow-action-definition',
-                                      criteria: { ownerKey: `app:${app.id}`}});
-  }
-
-  async deployAction(actionKey: string,
-                     actionDeclaration: AppActionDeclaration,
-                     app: App,
-                     existingActions: Array<any>){
-    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);
-    }
-  }
-  private async createNewActionDefinition(actionKey: string,
-                                          actionDeclaration: AppActionDeclaration,
-                                          app: App) {
-    const newObject: EventWorkflowActionDefinition = {
-      identifier: this.getActionDeclarationIdentifier(actionKey, app),
-      name: actionDeclaration.name,
-      ownerKey: `app:${app.id}`,
-      public: !app.private,
-    };
-    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 defintion: ${actionKey}`, chalk.yellow.bold('APP'));
-    return actionDefinition;
-  }
-  private async updateActionDefinition(existingActionDefinition: EventWorkflowActionDefinition,
-                                       actionDeclaration: AppActionDeclaration) {
-    const updates: EventWorkflowActionDefinition  = {
-      name: actionDeclaration.name,
-    };
-    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 existingaction defintion: ${actionDefinition.identifier}`, chalk.yellow.bold('APP'));
-    return actionDefinition;
-  }
-  getActionDeclarationIdentifier(actionKey, app: App) {
-    return app.identifier + ':' + actionKey;
-  }
-
-  async getFunction(actionDeclaration: AppActionDeclaration): Promise<string> {
-    if (!actionDeclaration.handler) {
-      return;
-    }
-    const CURRENT_DIR = process.cwd();
-    const functionLocaiton = CURRENT_DIR + '\\' + actionDeclaration.handler;
-    console.log('getFunction: ', functionLocaiton);
-    const content = fs.readFileSync(functionLocaiton);
-    console.log('content: ', content.toString());
-    return content.toString();
-  }
-}
+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 {
+  async deployActions(appDeclaration: AppDeclaration, app: 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: App) {
+    return await new Entities().get({
+      entityName: 'event-workflow-action-definition',
+      criteria: { ownerKey: `app:${app.id}` },
+    });
+  }
+
+  async deployAction(actionKey: string, actionDeclaration: AppActionDeclaration, app: App, existingActions: Array<any>) {
+    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);
+    }
+  }
+
+  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,
+    };
+
+    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;
+  }
+
+  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,
+    };
+
+    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 existingaction defintion: ${actionDefinition.identifier}`, chalk.yellow.bold('APP'));
+
+    return actionDefinition;
+  }
+
+  getActionDeclarationIdentifier(actionKey, app: App) {
+    return app.identifier + ':' + actionKey;
+  }
+
+  async getFunction(actionDeclaration: AppActionDeclaration): Promise<string> {
+    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();
+  }
+}