@contrail/cli 1.0.3 → 1.0.7

package/src/types/option-set-uploader.ts

@@ -0,0 +1,83 @@
+import { Entities } from '@contrail/sdk';
+import { ReducedOptionSet } from './interfaces';
+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: ReducedOptionSet[] = 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/src/types/parse-optionSet.ts

@@ -0,0 +1,96 @@
+import { StringUtil } from '@contrail/util';
+import { ReducedOptionSet } from './interfaces';
+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?.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<string>();
+  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 as string).toLowerCase() === 'false' || (value as string).toLowerCase() === 'true') {
+        removedFields.add(key);
+        continue;
+      }
+
+      if (!value) {
+        continue;
+      }
+
+      if (!valuesByFieldName[key]) {
+        valuesByFieldName[key] = new Set<string>();
+      }
+      (valuesByFieldName[key] as Set<string>).add(value as string);
+    }
+  }
+
+  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 as Set<string>).values()) {
+      optionSet.push({
+        value: StringUtil.convertToCamelCase(entry),
+        display: isUpperCase(entry) ? entry : StringUtil.convertToTitleCase(entry), // if all uppercase dont convert
+      });
+    }
+
+    const reducedOptionSet: 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/src/types/types-extractor.ts

@@ -0,0 +1,125 @@
+import { Entities } from '@contrail/sdk';
+import { ReducedType, ReducedOptionSet, ReducedTypeProperties } from './interfaces';
+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: 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: ReducedTypeProperties = {
+        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: 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/src/types/types-uploader.ts

@@ -0,0 +1,261 @@
+import { Entities, Request } from '@contrail/sdk';
+import { ReducedType, ReducedTypeProperties } from './interfaces';
+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: ReducedType[] = 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): boolean {
+
+  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/templates/javascript/actions/example/action.js

@@ -1,6 +1,6 @@
 async function execute(config, event, Functions) {        
   const getBodyFromEvent = (config, event) => {            
-    let body = Functions.StringUtil.parseVariables(config.message, event);            
+    let body = Functions.stringUtil.parseVariables(config.message, event);            
     console.log('body: ', body);            
     if (config.sendDetails) {                
       const data = event;                

package/templates/typescript/actions/exampleAction.ts

@@ -1,38 +1,39 @@
-async function execute(config, event, Functions) {        
-  const getBodyFromEvent = (config, event) => {            
-    let body = Functions.StringUtil.parseVariables(config.message, event);            
-    console.log('body: ', body);            
-    if (config.sendDetails) {                
-      const data = event;                
-      const properties = {};                
-      let addedProperty = false;                
-      for (const property of config.fieldsToForward) {                    
-        const variableLevels = property.split('.');                    
-        let replacementValue = data;                    
-        for (let i = 0; i < variableLevels.length; i++) {                        
-          replacementValue = replacementValue[variableLevels[i]];                    
-        }                    
-        properties[property] = replacementValue;                    
-        addedProperty = true;                
-      }                
-      if (addedProperty) {                    
-        body = body + ' Properties: ' + JSON.stringify(properties) + '.';                
-      }            
-    }            
-    return JSON.stringify({ text: body });        
-  };        
-  const body = getBodyFromEvent(config, event);        
-  console.log('Sending message: ', body);        
-  const response = await Functions.fetch(config.url, {            
-    method: 'POST',            
-    body: body,            
-    headers: { 'Content-Type': 'application/json' }        
-  });        
-  if (!response.ok) {            
-    console.log('Webhook event failed to publish');            
-    console.log('Response: ', JSON.stringify(response));        
-  }        
-  else {            
-    console.log('Published!');        
-  }    
+export { } // Leave empty export - This allows for multiple files with a function named execute.
+async function execute(config, event, Functions) {
+  const getBodyFromEvent = (config, event) => {
+    let body = Functions.stringUtil.parseVariables(config.message, event);
+    console.log('body: ', body);
+    if (config.sendDetails) {
+      const data = event;
+      const properties = {};
+      let addedProperty = false;
+      for (const property of config.fieldsToForward) {
+        const variableLevels = property.split('.');
+        let replacementValue = data;
+        for (let i = 0; i < variableLevels.length; i++) {
+          replacementValue = replacementValue[variableLevels[i]];
+        }
+        properties[property] = replacementValue;
+        addedProperty = true;
+      }
+      if (addedProperty) {
+        body = body + ' Properties: ' + JSON.stringify(properties) + '.';
+      }
+    }
+    return JSON.stringify({ text: body });
+  };
+  const body = getBodyFromEvent(config, event);
+  console.log('Sending message: ', body);
+  const response = await Functions.fetch(config.url, {
+    method: 'POST',
+    body: body,
+    headers: { 'Content-Type': 'application/json' }
+  });
+  if (!response.ok) {
+    console.log('Webhook event failed to publish');
+    console.log('Response: ', JSON.stringify(response));
+  }
+  else {
+    console.log('Published!');
+  }
 }

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "esnext",
+    "target": "es2017",
     "module": "esnext",
     "declaration": true,
     "esModuleInterop": true,
@@ -11,7 +11,15 @@
     "noImplicitAny": false,
     "emitDecoratorMetadata": true,
     "skipLibCheck": true,
-    "moduleResolution": "node"
+    "moduleResolution": "node",
+    "lib": [
+      "es5",
+      "ES2015",
+      "ES2016",
+      "ES2017",
+      "dom",
+      "esnext.asynciterable"
+    ],
   },
   "include": [
     "src"

package/templates/javascript/set_auth.bat

@@ -1,3 +0,0 @@
-set CONTRAIL_CLI_EMAIL=
-set CONTRAIL_CLI_PASSWORD=
-set CONTRAIL_CLI_ORGSLUG=

package/templates/javascript/set_auth.sh

@@ -1,3 +0,0 @@
-export CONTRAIL_CLI_EMAIL=
-export CONTRAIL_CLI_PASSWORD=
-export CONTRAIL_CLI_ORGSLUG=

package/templates/typescript/set_auth.bat

@@ -1,3 +0,0 @@
-set CONTRAIL_CLI_EMAIL=
-set CONTRAIL_CLI_PASSWORD=
-set CONTRAIL_CLI_ORGSLUG=