@contrail/cli 1.0.54 → 1.0.56

package/lib/types/types-extractor.js

@@ -2,24 +2,29 @@ import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
 import fs from 'fs';
 import { authUser } from '../auth/login';
-import { getSeparatorByPlatform } from '../common';
+import * as path from 'path';
+import pLimit from 'p-limit';
+const limit = pLimit(30);
 const yaml = require('js-yaml');
-export async function getTypes(args) {
+export async function getAll(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'));
-        const reducedTypes = await getReducedTypes(optionSets);
-        const typesHolder = {
-            types: reducedTypes,
+        // make directory to house exports
+        const dir = `./contrail-export-${Date.now()}`;
+        fs.mkdirSync(dir);
+        const data = {
+            types: await getTypes(),
+            optionSets: await getOptionSets(),
+            optionSetHierarchies: await getOptionSetHierarchies(),
+            ruleSets: await getRuleSets(),
+            ruleSetLinks: await getRuleSetLinks(),
+            usageInfo: await getUsageInfo(),
+            typePropertyPolicies: await getTypePropertyPolicies(),
+            typePropertyPolicyLinks: await getTypePropertyPolicyLinks(),
         };
-        saveData(typesHolder);
+        const reducedData = reduceData(data);
+        saveData(reducedData, dir);
         console.log('%s Retrieved', chalk.yellow.bold('TYPES'));
     }
     catch (e) {
@@ -28,43 +33,170 @@ export async function getTypes(args) {
     }
     console.log('%s Types Retrieval Complete.', chalk.green.bold('COMPLETE'));
 }
-async function getOptionSets(optionSets) {
-    let reducedOptionSets = [];
-    for (const optionSet of optionSets) {
-        const reducedOptionSet = {
+/**
+ *  stores reduced option sets and returns full option sets */
+export async function getOptionSets() {
+    console.log('%s Retrieving', chalk.yellow.bold('OPTION SETS'));
+    const optionSets = await new Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    console.log('%s Retrieved', chalk.yellow.bold('OPTION SETS'));
+    return optionSets;
+}
+export async function getTypes() {
+    console.log('%s Retrieving', chalk.yellow.bold('TYPES'));
+    const entitiesClient = new Entities();
+    const types = await entitiesClient.get({
+        entityName: 'type',
+    });
+    console.log(`${chalk.yellow.bold('TYPES')} Found ${types.length} types`);
+    const typesWithProperties = [];
+    const promises = [];
+    for (const type of types) {
+        const promise = limit(async () => {
+            const t = await entitiesClient.get({
+                entityName: 'type',
+                id: type.id,
+                relations: ['typeProperties'],
+            });
+            typesWithProperties.push(t);
+        });
+        promises.push(promise);
+    }
+    await Promise.all(promises);
+    return typesWithProperties;
+}
+async function getOptionSetHierarchies() {
+    const entitiesClient = new Entities();
+    return await entitiesClient.get({
+        entityName: 'option-set-hierarchy',
+    });
+}
+async function getRuleSets() {
+    const entitiesClient = new Entities();
+    return await entitiesClient.get({
+        entityName: 'type-rule-set',
+    });
+}
+async function getRuleSetLinks() {
+    const entitiesClient = new Entities();
+    return await entitiesClient.get({
+        entityName: 'type-rule-set-link',
+    });
+}
+async function getUsageInfo() {
+    const entitiesClient = new Entities();
+    return await entitiesClient.get({
+        entityName: 'type-property-usage-info',
+    });
+}
+async function getTypePropertyPolicies() {
+    const entitiesClient = new Entities();
+    return await entitiesClient.get({
+        entityName: 'type-property-policy',
+    });
+}
+async function getTypePropertyPolicyLinks() {
+    const entitiesClient = new Entities();
+    return await entitiesClient.get({
+        entityName: 'type-property-policy-link',
+    });
+}
+function reduceTypePropertyPolicies(data) {
+    var _a;
+    return (_a = data === null || data === void 0 ? void 0 : data.typePropertyPolicies) === null || _a === void 0 ? void 0 : _a.map(x => {
+        return {
+            label: x.label,
+            policy: {
+                version: x.policy.version,
+                statements: x.policy.statements,
+            }
+        };
+    });
+}
+function reduceTypePropertyPolicyLinks(data) {
+    var _a, _b;
+    const typeProperties = (_a = data === null || data === void 0 ? void 0 : data.types) === null || _a === void 0 ? void 0 : _a.map(x => x.typeProperties).reduce((x, y) => x.concat(y));
+    return (_b = data === null || data === void 0 ? void 0 : data.typePropertyPolicyLinks) === null || _b === void 0 ? void 0 : _b.map(x => {
+        var _a, _b;
+        return {
+            typePropertySlug: (_a = typeProperties.find(y => y.id === x.typePropertyId)) === null || _a === void 0 ? void 0 : _a.slug,
+            typePropertyPolicyLabel: (_b = data.typePropertyPolicies.find(y => y.id === x.typePropertyPolicyId)) === null || _b === void 0 ? void 0 : _b.label,
+        };
+    });
+}
+function reduceUsageInfo(data) {
+    var _a, _b;
+    const typeProperties = (_a = data === null || data === void 0 ? void 0 : data.types) === null || _a === void 0 ? void 0 : _a.map(x => x.typeProperties).reduce((x, y) => x.concat(y));
+    return (_b = data === null || data === void 0 ? void 0 : data.usageInfo) === null || _b === void 0 ? void 0 : _b.map(x => {
+        var _a, _b;
+        return {
+            used: x.used,
+            editable: x.editable,
+            typeSlug: (_a = data.types.find(y => y.id === x.typeId)) === null || _a === void 0 ? void 0 : _a.slug,
+            typePropertySlug: (_b = typeProperties.find(y => y.id === x.typePropertyId)) === null || _b === void 0 ? void 0 : _b.slug,
+        };
+    });
+}
+function reduceRuleSetLinks(data) {
+    var _a, _b;
+    const reducedRuleSetLinks = [];
+    if (!(data === null || data === void 0 ? void 0 : data.ruleSetLinks.length)) {
+        return [];
+    }
+    for (const ruleSetLink of data.ruleSetLinks) {
+        const ruleSet = (_a = data === null || data === void 0 ? void 0 : data.ruleSets) === null || _a === void 0 ? void 0 : _a.find(x => x.id === ruleSetLink.typeRuleSetId);
+        const type = (_b = data === null || data === void 0 ? void 0 : data.types) === null || _b === void 0 ? void 0 : _b.find(x => x.id === ruleSetLink.typeId);
+        if (!ruleSet || !type) {
+            console.log('%s Skipping bad rule set link', ruleSetLink.id, chalk.red.bold('TYPES'));
+        }
+        reducedRuleSetLinks.push({
+            ruleSet: ruleSet.name,
+            type: type.slug
+        });
+    }
+    return reducedRuleSetLinks;
+}
+function reduceRuleSets(data) {
+    var _a;
+    return (_a = data === null || data === void 0 ? void 0 : data.ruleSets) === null || _a === void 0 ? void 0 : _a.map(x => {
+        return {
+            ruleSet: x.ruleSet,
+            name: x.name,
+        };
+    });
+}
+function reduceOptionSets(data) {
+    var _a;
+    return (_a = data.optionSets) === null || _a === void 0 ? void 0 : _a.map(optionSet => {
+        return {
             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');
-}
-export async function getReducedTypes(optionSets) {
-    const types = await new Entities().get({
-        entityName: 'type',
     });
-    console.log('Found types: ', types.length);
+}
+function reduceOptionSetHierarchies(data) {
+    var _a;
+    return (_a = data.optionSetHierarchies) === null || _a === void 0 ? void 0 : _a.map(x => {
+        const hierarchyByName = x.hierarchy.map(optionSetId => { var _a, _b; return (_b = (_a = data.optionSets) === null || _a === void 0 ? void 0 : _a.find(x => x.id === optionSetId)) === null || _b === void 0 ? void 0 : _b.name; });
+        return {
+            hierarchy: hierarchyByName,
+            options: x.options,
+            name: x.name
+        };
+    });
+}
+export function reduceTypes(dataHolder) {
+    console.log('Found types: ', dataHolder.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 optionSetNameById = {};
+    for (const optionSet of dataHolder.optionSets) {
+        optionSetNameById[optionSet.id] = optionSet.name;
+    }
+    for (const type of dataHolder.types) {
         const reducedTypeProperties = [];
-        for (const typeProperty of typeWithProperties.typeProperties) {
+        for (const typeProperty of type.typeProperties) {
             const reducedTypeProperty = {
                 slug: typeProperty.slug,
                 id: typeProperty.id,
@@ -86,10 +218,10 @@ export async function getReducedTypes(optionSets) {
             reducedTypeProperties.push(reducedTypeProperty);
         }
         const reducedType = {
-            typePath: typeWithProperties.typePath,
-            slug: typeWithProperties.slug,
-            label: typeWithProperties.label,
-            isArchived: typeWithProperties.isArchived,
+            typePath: type.typePath,
+            slug: type.slug,
+            label: type.label,
+            isArchived: type.isArchived,
             typeProperties: reducedTypeProperties,
         };
         reducedTypes.push(reducedType);
@@ -97,9 +229,48 @@ export async function getReducedTypes(optionSets) {
     reducedTypes = reducedTypes.sort((one, two) => (one.typePath < two.typePath ? -1 : 1));
     return reducedTypes;
 }
-function saveData(data) {
-    const yamlStr = yaml.dump(data);
-    const CURRENT_DIR = process.cwd();
-    const separator = getSeparatorByPlatform();
-    fs.writeFileSync(CURRENT_DIR + separator + 'types.yml', yamlStr, 'utf8');
+export function reduceData(data) {
+    return {
+        reducedTypes: reduceTypes(data),
+        reducedOptionSets: reduceOptionSets(data),
+        reducedOptionSetHierarchies: reduceOptionSetHierarchies(data),
+        reducedRuleSets: reduceRuleSets(data),
+        reducedRuleSetLinks: reduceRuleSetLinks(data),
+        reducedUsageInfo: reduceUsageInfo(data),
+        reducedTypePropertyPolicies: reduceTypePropertyPolicies(data),
+        reducedTypePropertyPolicyLinks: reduceTypePropertyPolicyLinks(data),
+    };
+}
+function saveData(reducedData, dir) {
+    const propertyToFolderMap = {
+        reducedTypes: { filename: 'types', split: true, fileLabel: 'slug' },
+        reducedOptionSets: { filename: 'option-sets', split: true, fileLabel: 'name' },
+        reducedOptionSetHierarchies: { filename: 'option-set-hierarchies', split: true, fileLabel: 'name' },
+        reducedRuleSets: { filename: 'rule-sets', split: true, fileLabel: 'name' },
+        reducedRuleSetLinks: { filename: 'rule-set-links', split: false, fileLabel: '' },
+        reducedUsageInfo: { filename: 'usage-info', split: false, fileLabel: '' },
+        reducedTypePropertyPolicies: { filename: 'type-property-policies', split: true, fileLabel: 'label' },
+        reducedTypePropertyPolicyLinks: { filename: 'type-property-policy-links', split: false, fileLabel: '' },
+    };
+    for (const [key, folder] of Object.entries(propertyToFolderMap)) {
+        const CURRENT_DIR = process.cwd();
+        if (folder.split) {
+            const subDir = path.join(CURRENT_DIR, dir, folder.filename);
+            if (!fs.existsSync(subDir)) {
+                fs.mkdirSync(subDir);
+            }
+            for (const item of reducedData[key]) {
+                const yamlStr = yaml.dump(item);
+                const fileLabel = item[folder.fileLabel];
+                if (!fileLabel) {
+                    console.warn('skipping bad data:', item);
+                }
+                fs.writeFileSync(path.join(subDir, `${fileLabel}.yml`), yamlStr, 'utf8');
+            }
+        }
+        else {
+            const yamlStr = yaml.dump(reducedData[key]);
+            fs.writeFileSync(path.join(CURRENT_DIR, dir, `${folder.filename}.yml`), yamlStr, 'utf8');
+        }
+    }
 }

package/lib/types/types-properties-merger.js

@@ -1,5 +1,4 @@
-import { Entities } from '@contrail/sdk';
-import { getReducedTypes } from './types-extractor';
+import { getOptionSets, getTypes, reduceData } from './types-extractor';
 import fs from 'fs';
 import { getSeparatorByPlatform } from '../common';
 import { authUser } from '../auth/login';
@@ -40,18 +39,25 @@ function loadTypeProperties(fileLocation) {
 async function mergeTypeProperties(fileLocation, typePaths) {
     const uploadedTypeProperties = loadTypeProperties(fileLocation);
     await authUser();
-    const optionSets = await new Entities().get({
-        entityName: 'type-property-option-set',
-    });
-    const reducedTypes = await getReducedTypes(optionSets);
+    const data = {
+        types: await getTypes(),
+        optionSets: await getOptionSets(),
+        optionSetHierarchies: [],
+        ruleSets: [],
+        ruleSetLinks: [],
+        usageInfo: [],
+        typePropertyPolicies: [],
+        typePropertyPolicyLinks: [],
+    };
+    const reducedData = await reduceData(data);
     for (const typePath of typePaths) {
-        const foundType = reducedTypes.find(reducedTypes => reducedTypes.typePath === typePath);
+        const foundType = reducedData.reducedTypes.find(reducedTypes => reducedTypes.typePath === typePath);
         if (!foundType) {
             console.log(`%s No Type found for: ${typePath}`, chalk.red.bold('WARNING'));
         }
         mergeType(foundType, uploadedTypeProperties);
     }
-    saveData({ types: reducedTypes });
+    saveData({ types: reducedData.reducedTypes });
 }
 function mergeType(reducedType, typePropertiesToAdd) {
     for (const typeProperty of typePropertiesToAdd) {

package/lib/types/types-uploader.js

@@ -2,7 +2,7 @@ import { Entities, Request } from '@contrail/sdk';
 import chalk from 'chalk';
 import fs from 'fs';
 import { authUser } from '../auth/login';
-import { getSeparatorByPlatform } from '../common';
+import * as path from 'path';
 import * as _ from 'lodash';
 import yaml from 'js-yaml';
 export async function uploadTypes() {
@@ -22,9 +22,12 @@ export async function uploadTypes() {
 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;
+        const files = fs.readdirSync(path.join(TARGET_DIR, 'types'));
+        const types = [];
+        for (const file of files) {
+            types.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'types', file), 'utf8')));
+        }
+        return types;
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);

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

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

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

@@ -0,0 +1,127 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+import { getTypes } from './types-extractor';
+import * as path from 'path';
+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 doc = yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'usage-info.yml'), 'utf8'));
+        return doc;
+    }
+    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.54",
+  "version": "1.0.56",
   "description": "VibeIQ's Contrail Platform CLI.",
   "main": "lib/index.js",
   "bin": {

package/src/cli.ts

@@ -1,7 +1,7 @@
 
 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';
@@ -19,6 +19,11 @@ 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';
+import { uploadAll } from './types/allUploader';
 
 const cliUsage = require('command-line-usage');
 
@@ -89,7 +94,11 @@ export async function cli(args) {
   case 'types': {
     switch (command) {
     case 'getAll': {
-      getTypes(args);
+      getAll(args);
+      break;
+    }
+    case 'uploadAll': {
+      uploadAll();
       break;
     }
     case 'uploadTypes': {
@@ -116,6 +125,22 @@ export async function cli(args) {
       ExportOptionSetsHierarchies();
       break;
     }
+    case 'uploadOptionSetsHierarchies': {
+      UploadOptionSetHierarchies(args);
+      break;
+    }
+    case 'uploadRuleSets': {
+      uploadRuleSets(args);
+      break;
+    }
+    case 'uploadUsageInfo': {
+      uploadUsageInfo(args);
+      break;
+    }
+    case 'uploadTypePropertyPolicies': {
+      uploadTypePropertyPolicies(args);
+      break;
+    }
     case 'parseTypesFromLocalFiles': {
       ParseTypesFromLocalFiles(args);
       break;
@@ -418,6 +443,30 @@ const helpSections = [
         name: 'exportOptionSetsHierarchies',
         summary: 'export OptionSetHierarchies into CSVs.\n'
       },
+      {
+        name: 'uploadAll',
+        summary: 'Upload an extracted archive of types:getAll.'
+      },
+      {
+        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: 'uploadTypePropertyPolicies',
+        summary: 'Upload type property policies.'
+      },
+      {
+        name: 'uploadOptionSetsHierarchyLocalFiles <File Paths> <name>',
+        summary: 'upload CSV files into OptionSetHierarchies.'
+      },
       {
         name: 'parseTypesFromLocalFiles <File Paths>',
         summary: 'Parse CSV files into Types and OptionSets from local files.\n'

package/src/types/allUploader.ts

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { authUser } from '../auth/login';
+
+import { UploadOptionSets } from './option-set-uploader';
+import { UploadOptionSetHierarchies } from './option-set-hierarchy-uploader';
+import { uploadTypes } from './types-uploader';
+import { uploadUsageInfo } from './usage-info-uploader';
+import { uploadRuleSets } from './rule-set-uploader';
+import { uploadTypePropertyPolicies } from './type-property-policy-uploader';
+
+export async function uploadAll() {
+  try {
+    await authUser();
+    await UploadOptionSets(null);
+    await UploadOptionSetHierarchies(null);
+    await uploadTypes();
+    await uploadUsageInfo(null);
+    await uploadRuleSets(null);
+    await uploadTypePropertyPolicies(null);
+
+  }
+  catch (e) {
+    console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+    return;
+  }
+
+  console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
+}