@contrail/cli 1.0.54 → 1.0.55

package/lib/types/types-extractor.js

@@ -3,23 +3,29 @@ import chalk from 'chalk';
 import fs from 'fs';
 import { authUser } from '../auth/login';
 import { getSeparatorByPlatform } from '../common';
+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 = `./types-${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);
+        storeOptionSets(data, dir);
+        saveData(reducedData, dir);
         console.log('%s Retrieved', chalk.yellow.bold('TYPES'));
     }
     catch (e) {
@@ -28,43 +34,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',
+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
+        };
     });
-    console.log('Found types: ', types.length);
+}
+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 +219,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 +230,32 @@ 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);
+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 storeOptionSets(data, dir) {
+    let reducedOptionSets = reduceOptionSets(data);
+    reducedOptionSets = reducedOptionSets.sort((one, two) => (one.name < two.name ? -1 : 1));
+    const optionSetsHolder = {
+        reducedOptionSets,
+    };
+    const CURRENT_DIR = process.cwd();
+    const separator = getSeparatorByPlatform();
+    const yamlStr = yaml.dump(optionSetsHolder);
+    fs.writeFileSync(CURRENT_DIR + separator + dir + separator + 'option_sets.yml', yamlStr, 'utf8');
+}
+function saveData(reducedData, dir) {
+    const yamlStr = yaml.dump(reducedData);
     const CURRENT_DIR = process.cwd();
     const separator = getSeparatorByPlatform();
-    fs.writeFileSync(CURRENT_DIR + separator + 'types.yml', yamlStr, 'utf8');
+    fs.writeFileSync(CURRENT_DIR + separator + dir + separator + 'types.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

@@ -24,7 +24,7 @@ function loadReducedTypes() {
     try {
         const separator = getSeparatorByPlatform();
         const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'types.yml', 'utf8'));
-        return doc.types;
+        return doc.reducedTypes;
     }
     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,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.54",
+  "version": "1.0.55",
   "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,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');
 
@@ -89,7 +93,7 @@ export async function cli(args) {
   case 'types': {
     switch (command) {
     case 'getAll': {
-      getTypes(args);
+      getAll(args);
       break;
     }
     case 'uploadTypes': {
@@ -116,6 +120,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 +438,26 @@ const helpSections = [
         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: '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/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;
+}