@contrail/cli 1.0.53 → 1.0.55

package/lib/types/usage-info-uploader.js

@@ -0,0 +1,128 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+import { getTypes } from './types-extractor';
+const yaml = require('js-yaml');
+export async function uploadUsageInfo(args) {
+    try {
+        await authUser();
+        console.log('%s Uploading', chalk.yellow.bold('USAGE INFO'));
+        const reducedUsageInfo = await loadUsageInfo();
+        await uploadUsageInfoObjects(reducedUsageInfo);
+        console.log('%s Uploaded', chalk.yellow.bold('USAGE INFO'));
+    }
+    catch (e) {
+        console.log(`%s Usage Info Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Usage Info Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadUsageInfo() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'types.yml', 'utf8'));
+        return doc.reducedUsageInfo;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadUsageInfoObjects(loadedUsageInfo) {
+    const typesWithProperties = await getTypes();
+    const typeProperties = typesWithProperties
+        .filter(t => !!t.typeProperties)
+        .map(t => t.typeProperties)
+        .reduce((a, b) => a.concat(b));
+    const currentUsageInfo = await new Entities().get({
+        entityName: 'type-property-usage-info',
+    });
+    const currentUsageInfosHashes = {};
+    for (const currentUI of currentUsageInfo) {
+        const foundType = typesWithProperties.find(t => t.id === currentUI.typeId);
+        const foundTypeProperty = typeProperties.find(tp => tp.id === currentUI.typePropertyId);
+        if (!foundType || !foundTypeProperty) {
+            console.log('skipping unhashable, invalid usage info:', currentUI);
+            continue;
+        }
+        const hash = `${foundType.slug}|${foundTypeProperty.slug}`;
+        currentUsageInfosHashes[hash] = currentUI;
+    }
+    const reducedUsageInfoHashes = {};
+    for (const loadedUI of loadedUsageInfo) {
+        const hash = `${loadedUI.typeSlug}|${loadedUI.typePropertySlug}`;
+        reducedUsageInfoHashes[hash] = loadedUI;
+    }
+    console.debug('current usage info:', currentUsageInfo);
+    console.debug('loaded usage info:', loadedUsageInfo);
+    for (const loadedUI of loadedUsageInfo) {
+        try {
+            const found = currentUsageInfosHashes[`${loadedUI.typeSlug}|${loadedUI.typePropertySlug}`];
+            if (!found) {
+                if (!transformReducedUI(loadedUI, typesWithProperties, typeProperties)) {
+                    continue;
+                }
+                console.debug('Creating: ', loadedUI);
+                await new Entities().create({
+                    entityName: 'type-property-usage-info',
+                    object: {
+                        typePropertyId: loadedUI.typePropertyId,
+                        typeId: loadedUI.typeId,
+                        editable: loadedUI.editable,
+                        used: loadedUI.used,
+                    }
+                });
+            }
+            else {
+                if (!transformReducedUI(loadedUI, typesWithProperties, typeProperties)) {
+                    continue;
+                }
+                console.log('Updating: ', loadedUI);
+                await new Entities().update({
+                    entityName: 'type-property-usage-info',
+                    id: found.id,
+                    object: {
+                        editable: loadedUI.editable,
+                        used: loadedUI.used,
+                    }
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading usage info: ${err}`);
+        }
+    }
+    for (const [hash, currentUI] of Object.entries(currentUsageInfosHashes)) {
+        try {
+            const found = reducedUsageInfoHashes[hash];
+            if (!found) {
+                console.debug('Deleting: ', hash);
+                await new Entities().delete({
+                    entityName: 'type-property-usage-info',
+                    id: currentUI['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting usage info: ${err}`);
+        }
+    }
+}
+// transforms the reduced Usage Info from name slugs to ids
+function transformReducedUI(reducedUsageInfo, types, typeProperties) {
+    const foundType = types.find(t => t.slug === reducedUsageInfo.typeSlug);
+    if (!foundType) {
+        console.error('Could not find type with slug', reducedUsageInfo.typeSlug, 'while transforming', reducedUsageInfo);
+        return false;
+    }
+    reducedUsageInfo.typeId = foundType.id;
+    const foundTypeProperty = typeProperties.find(tp => tp.slug === reducedUsageInfo.typePropertySlug);
+    if (!foundTypeProperty) {
+        console.error('Could not find type property with slug', reducedUsageInfo.typePropertySlug, 'while transforming', reducedUsageInfo);
+        return false;
+    }
+    reducedUsageInfo.typePropertyId = foundTypeProperty.id;
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {
@@ -37,6 +37,7 @@
     "execa": "^5.0.0",
     "inquirer": "^8.2.0",
     "js-yaml": "^4.1.0",
+    "json2csv": "^5.0.7",
     "listr": "^0.14.3",
     "lodash": "^4.17.21",
     "ncp": "^2.0.0",

package/src/cli.ts

@@ -1,11 +1,12 @@
 
 import { create } from './apps/create-app/create';
 import { deployApp, removeApp } from './apps/deploy-app/deploy';
-import { getTypes } from './types/types-extractor';
+import { getAll } from './types/types-extractor';
 import { uploadTypes } from './types/types-uploader';
 import { UploadOptionSets } from './types/option-set-uploader';
 import { ParseOptionSetsLocalFiles } from './types/option-set-parser';
-import { ParseOptionSetsHierarchyLocalFiles, UploadOptionSetsHierarchyLocalFiles } from './types/option-set-hierarchy-parser';
+import { ParseOptionSetsHierarchyLocalFile, UploadOptionSetsHierarchyLocalFile } from './types/option-set-hierarchy-parser';
+import { ExportOptionSetsHierarchies } from './types/option-set-hierarchy-exporter';
 import { MergeOptionSets } from './types/option-set-merger';
 import { MergeTypeProperties } from './types/types-properties-merger';
 import { ParseTypesFromFiles, ParseTypesFromLocalFiles, ParseTypesFromTemplateFromLocalFiles, ParseTypesFromTemplateAndDataFromLocalFiles } from './types/parse-types';
@@ -18,6 +19,10 @@ import { cliInstallWorkflowTemplateDefinitions, listWorkflowTemplateDefinitions
 import { configureProject } from './projects/project-uploader';
 import { ListProjects, ExportProject } from './projects/project-exporter';
 import { Load, UploadAndLoad } from './loader-process/loader-process';
+import { uploadUsageInfo } from './types/usage-info-uploader';
+import { uploadRuleSets } from './types/rule-set-uploader';
+import { UploadOptionSetHierarchies } from './types/option-set-hierarchy-uploader';
+import { uploadTypePropertyPolicies } from './types/type-property-policy-uploader';
 
 const cliUsage = require('command-line-usage');
 
@@ -88,7 +93,7 @@ export async function cli(args) {
   case 'types': {
     switch (command) {
     case 'getAll': {
-      getTypes(args);
+      getAll(args);
       break;
     }
     case 'uploadTypes': {
@@ -103,12 +108,32 @@ export async function cli(args) {
       ParseOptionSetsLocalFiles(args);
       break;
     }
-    case 'parseOptionSetsHierarchyLocalFiles': {
-      ParseOptionSetsHierarchyLocalFiles(args);
+    case 'parseOptionSetsHierarchyLocalFile': {
+      ParseOptionSetsHierarchyLocalFile(args);
       break;
     }
-    case 'uploadOptionSetsHierarchyLocalFiles': {
-      UploadOptionSetsHierarchyLocalFiles(args);
+    case 'uploadOptionSetsHierarchyLocalFile': {
+      UploadOptionSetsHierarchyLocalFile(args);
+      break;
+    }
+    case 'exportOptionSetsHierarchies': {
+      ExportOptionSetsHierarchies();
+      break;
+    }
+    case 'uploadOptionSetsHierarchies': {
+      UploadOptionSetHierarchies(args);
+      break;
+    }
+    case 'uploadRuleSets': {
+      uploadRuleSets(args);
+      break;
+    }
+    case 'uploadUsageInfo': {
+      uploadUsageInfo(args);
+      break;
+    }
+    case 'uploadTypePropertyPolicies': {
+      uploadTypePropertyPolicies(args);
       break;
     }
     case 'parseTypesFromLocalFiles': {
@@ -399,11 +424,35 @@ const helpSections = [
       },
       {
         name: 'parseOptionSetsLocalFiles <File Paths>',
-        summary: 'Parse CSV files into OptionSets.'
+        summary: 'Parse CSV files into OptionSets.\n'
+      },
+      {
+        name: 'parseOptionSetsHierarchyLocalFile <File Path>',
+        summary: 'Parse CSV file into OptionSetHierarchy.'
+      },
+      {
+        name: 'uploadOptionSetsHierarchyLocalFile <File Path> <name>',
+        summary: 'upload CSV file into OptionSetHierarchy.'
+      },
+      {
+        name: 'exportOptionSetsHierarchies',
+        summary: 'export OptionSetHierarchies into CSVs.\n'
+      },
+      {
+        name: 'uploadOptionSetsHierarchies',
+        summary: 'Upload an extracted option set hierarchies.'
+      },
+      {
+        name: 'uploadRuleSets',
+        summary: 'Upload an extracted rule set.'
+      },
+      {
+        name: 'uploadUsageInfo',
+        summary: 'Upload extracted usage info.'
       },
       {
-        name: 'parseOptionSetsHierarchyLocalFiles <File Paths>',
-        summary: 'Parse CSV files into OptionSetHierarchies.'
+        name: 'uploadTypePropertyPolicies',
+        summary: 'Upload type property policies.'
       },
       {
         name: 'uploadOptionSetsHierarchyLocalFiles <File Paths> <name>',

package/src/types/option-set-hierarchy-exporter.ts

@@ -0,0 +1,125 @@
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+import chalk from 'chalk';
+import { Entities } from '@contrail/sdk';
+import { authUser } from '../auth/login';
+import { ObjectUtil, StringUtil } from '@contrail/util';
+const { Parser } = require('json2csv');
+
+export async function ExportOptionSetsHierarchies() {
+  try {
+    await authUser();
+
+    console.log('%s Exporting local file', chalk.yellow.bold('OPTION SET HIERARCHY EXPORT'));
+    await exportOptionSetHierarchies();
+    console.log('%s Exported', chalk.yellow.bold('OPTION SET HIERARCHY EXPORT'));
+
+  }
+  catch (e) {
+    console.log(`%s EXPORT Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s EXPORT Complete.', chalk.green.bold('COMPLETE'));
+}
+
+async function exportOptionSetHierarchies() {
+  const allOptionSetHierarchies = await new Entities().get({
+    entityName: 'option-set-hierarchy',
+  });
+
+  const currentOptionSets = await new Entities().get({
+    entityName: 'type-property-option-set',
+  });
+
+  for (const optionSetHierarchy of allOptionSetHierarchies) {
+    const levelNameInOrder = [];
+    for (const optionSetId of optionSetHierarchy.hierarchy) {
+      const os = currentOptionSets.find(os => os.id === optionSetId);
+      levelNameInOrder.push(StringUtil.convertToCamelCase(os.name));
+    }
+    transformAndSave(optionSetHierarchy, levelNameInOrder);
+  }
+}
+
+function transformAndSave(optionSetHierarchy, levelNameInOrder) {
+  const finalObjects = [];
+  transform(optionSetHierarchy.options, levelNameInOrder, [], finalObjects);
+  saveData(optionSetHierarchy.name, finalObjects, levelNameInOrder);
+}
+
+/*
+  Transform will take in a set if options, the names left to process, the partly completed objects, and the list to place the final objects.
+  On the first pass the list of names will be full and the list of partial objects will be empty. On this pass we create objects
+  with one field, the name of the field is the first name in levelNameInOrder. These objects are added to the workingObjects list
+  for the next run. On the following (recursive) runs there will be one less name in the levelNameInOrder (we remove the name we just processed)
+  and there will be objects to clone and add to in the workingObjects list. When all the objects have been created (There are no names
+  left in the levelNameInOrder list), all the objects are added to the finalObjects list.
+
+  Initial Input:
+  options: {value: "BTP", options: [{value: "The Great"}, {value: "The Best"}]}
+  levelNameInOrder: ["name", "title"]
+  workingObjects: []
+  finalObjects: []
+
+  Level 2 Input 1:
+  options: [{value: "The Great"}]
+  levelNameInOrder: ["title"]
+  workingObjects: [{name: "BTP"}]
+  finalObjects: []
+
+  Level 2 Input 2:
+  options: [{value: "The Best"}]
+  levelNameInOrder: ["title"]
+  workingObjects: [{name: "BTP"}]
+  finalObjects: []
+
+  Final Objects:
+  [{name: "BTP", title: "The Great"}, {name: "BTP", title: "The Best"}]
+*/
+function transform(options, levelNameInOrder, workingObjects, finalObjects) {
+  for (const option of options) {
+    const localObjects = [];
+    if (workingObjects.length === 0) {
+      localObjects.push({[levelNameInOrder[0]]: option.value});
+      if (levelNameInOrder.length <= 1) {
+        finalObjects.push(...localObjects);
+      }
+      else {
+        transform(option.options, levelNameInOrder.slice(1,), localObjects, finalObjects);
+      }
+    }
+    else {
+      for (const workingObject of workingObjects) {
+        const clone = ObjectUtil.cloneDeep(workingObject);
+        clone[levelNameInOrder[0]] = option.value;
+        localObjects.push(clone);
+      }
+
+      if (levelNameInOrder.length <= 1) {
+        finalObjects.push(...localObjects);
+      }
+      else {
+        transform(option.options, levelNameInOrder.slice(1,), localObjects, finalObjects);
+      }
+    }
+  }
+
+}
+
+function saveData(name, data, fieldNames) {
+  const CURRENT_DIR = process.cwd();
+  const separator = getSeparatorByPlatform();
+  const opts = { fieldNames };
+
+  try {
+    const parser = new Parser(opts);
+    const csv = parser.parse(data);
+    fs.mkdirSync(CURRENT_DIR + separator + 'option-set-hierarchies', { recursive: true });
+    fs.writeFileSync(CURRENT_DIR + separator + 'option-set-hierarchies' + separator + name + '.csv', csv, {
+      flag: 'w',
+    });
+  } catch (err) {
+    console.error(err);
+  }
+}

package/src/types/option-set-hierarchy-parser.ts

@@ -6,7 +6,7 @@ import { Entities } from '@contrail/sdk';
 import { StringUtil } from '@contrail/util';
 import { authUser } from '../auth/login';
 
-export async function ParseOptionSetsHierarchyLocalFiles(args) {
+export async function ParseOptionSetsHierarchyLocalFile(args) {
   try {
     await authUser();
 
@@ -17,7 +17,7 @@ export async function ParseOptionSetsHierarchyLocalFiles(args) {
     const fileLocation = args[3];
     console.log('Using File: ', fileLocation);
 
-    await parseAndSaveOptionSetHierarchiesLocalFiles(fileLocation);
+    await parseAndSaveOptionSetHierarchiesLocalFile(fileLocation);
     console.log('%s Parsed', chalk.yellow.bold('OPTION SET HIERARCHY PARSE'));
 
   }
@@ -29,7 +29,7 @@ export async function ParseOptionSetsHierarchyLocalFiles(args) {
   console.log('%s PARSE Complete.', chalk.green.bold('COMPLETE'));
 }
 
-export async function UploadOptionSetsHierarchyLocalFiles(args) {
+export async function UploadOptionSetsHierarchyLocalFile(args) {
   try {
     await authUser();
 
@@ -42,7 +42,7 @@ export async function UploadOptionSetsHierarchyLocalFiles(args) {
     console.log('Using File: ', fileLocation);
     console.log('Using Name: ', name);
 
-    await uploadOptionSetHierarchiesLocalFiles(fileLocation, name);
+    await uploadOptionSetHierarchiesLocalFile(fileLocation, name);
     console.log('%s Uploaded', chalk.yellow.bold('OPTION SET HIERARCHY UPLOAD'));
 
   }
@@ -68,7 +68,7 @@ async function loadOptionSetHierarchyCSV(fileLocation) {
   }
 }
 
-async function parseOptionSetHierarchiesLocalFiles(fileLocation) {
+async function parseOptionSetHierarchiesLocalFile(fileLocation) {
   const uploadedOptionHierarchyData = await loadOptionSetHierarchyCSV(fileLocation);
 
   const optionSetHierarchy = {
@@ -112,13 +112,13 @@ async function parseOptionSetHierarchiesLocalFiles(fileLocation) {
   return optionSetHierarchy;
 }
 
-async function parseAndSaveOptionSetHierarchiesLocalFiles(fileLocation) {
-  const optionSetHierarchy = await parseOptionSetHierarchiesLocalFiles(fileLocation);
+async function parseAndSaveOptionSetHierarchiesLocalFile(fileLocation) {
+  const optionSetHierarchy = await parseOptionSetHierarchiesLocalFile(fileLocation);
   saveData(optionSetHierarchy.options);
 }
 
-async function uploadOptionSetHierarchiesLocalFiles(fileLocation, name) {
-  const optionSetHierarchy = await parseOptionSetHierarchiesLocalFiles(fileLocation);
+async function uploadOptionSetHierarchiesLocalFile(fileLocation, name) {
+  const optionSetHierarchy = await parseOptionSetHierarchiesLocalFile(fileLocation);
   optionSetHierarchy.name = name;
 
   const currentOptionSetHierarchies = await new Entities().get({

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

@@ -0,0 +1,119 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+
+const yaml = require('js-yaml');
+
+export async function UploadOptionSetHierarchies(args) {
+  try {
+    await authUser();
+
+    console.log('%s Uploading', chalk.yellow.bold('OPTION SET HIERARCHIES'));
+    const optionSetHierarchies = await loadOptionSetHierarchies();
+    await uploadOptionSetHierarchies(optionSetHierarchies);
+    console.log('%s Uploaded', chalk.yellow.bold('OPTION SET HIERARCHIES'));
+
+  }
+  catch (e) {
+    console.log(`%s Option set hierarchy Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Option set hierarchy Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+
+function loadOptionSetHierarchies() {
+  const TARGET_DIR = process.cwd();
+  try {
+    const separator = getSeparatorByPlatform();
+    const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'types.yml', 'utf8'));
+    return doc.reducedOptionSetHierarchies;
+  } catch (e) {
+    throw new Error(`ERROR PARSING YAML: ${e}`);
+  }
+}
+
+async function uploadOptionSetHierarchies(loadedOSHs) {
+
+  const optionSets = await new Entities().get({
+    entityName: 'type-property-option-set',
+  });
+
+  const currentOSHs = await new Entities().get({
+    entityName: 'option-set-hierarchy',
+  });
+
+  const optionSetsByName = {};
+  for (const optionSet of optionSets) {
+    optionSetsByName[optionSet.name] = optionSet;
+  }
+
+  const currentOSHByName = {};
+  for (const currentOSH of currentOSHs) {
+    currentOSHByName[currentOSH.name] = currentOSH;
+  }
+
+  const loadedOSHByName = {};
+  for (const loadedOSH of loadedOSHs) {
+    loadedOSHByName[loadedOSH.name] = loadedOSH;
+  }
+
+  console.debug('current OSH:', currentOSHs);
+  console.debug('loaded OSH:', loadedOSHs);
+
+  for (const osh of loadedOSHs) {
+    try {
+      const found = currentOSHByName[osh.name];
+      if (!found) {
+        if (!transformOSHNameToID(osh.hierarchy, optionSets)) { continue; }
+        console.log('Creating: ', osh);
+        await new Entities().create({
+          entityName: 'option-set-hierarchy',
+          object: osh
+        });
+      } else {
+        if (!transformOSHNameToID(osh.hierarchy, optionSets)) { continue; }
+        console.log('Updating: ', osh);
+        await new Entities().update({
+          entityName: 'option-set-hierarchy',
+          id: found.id,
+          object: osh,
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Uploading option set hierarchy: ${err}`);
+    }
+  }
+
+  for (const currentOSH of currentOSHs) {
+    try {
+      const found = loadedOSHByName[currentOSH.name];
+      if (!found) {
+        console.log('Deleting: ', currentOSH.name);
+        await new Entities().delete({
+          entityName: 'option-set-hierarchy',
+          id: currentOSH.id,
+        });
+      }
+    } catch (err) {
+      throw new Error(`Error Deleting Option set hierarchy: ${err}`);
+    }
+  }
+
+}
+
+// transforms the passed hierarchy from names to ids, and returns true if operation succeeded.
+function transformOSHNameToID(hierarchy, optionSets) {
+  console.log('passed hierarhy:', hierarchy);
+  for (let i = 0; i < hierarchy.length; i++) {
+    const os = optionSets.find(os => os.name === hierarchy[i]);
+    if (!os) {
+      console.error('could not find option set with name', hierarchy[i], ' at position', i, 'skipping...');
+      return false;
+    }
+    hierarchy[i] = os.id;
+  }
+  return true;
+}

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

@@ -30,7 +30,7 @@ function loadOptionSets(){
   try {
     const separator = getSeparatorByPlatform();
     const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'option_sets.yml', 'utf8'));
-    return doc.optionSets;
+    return doc.reducedOptionSets;
   } catch (e) {
     throw new Error(`ERROR PARSING YAML: ${e}`);
   }
@@ -70,9 +70,7 @@ async function uploadOptionSets() {
             isArchived: optionSet.isArchived,
           },
         });
-      }
-      else
-      {
+      } else {
         console.log('Updating: ', optionSet.name);
         await new Entities().update({
           entityName: 'type-property-option-set',