@contrail/cli 1.0.53 → 1.0.55

package/lib/cli.js

@@ -1,10 +1,11 @@
 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';
@@ -17,6 +18,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');
 /**
  *  Built using documentation here:
@@ -78,7 +83,7 @@ export async function cli(args) {
         case 'types': {
             switch (command) {
                 case 'getAll': {
-                    getTypes(args);
+                    getAll(args);
                     break;
                 }
                 case 'uploadTypes': {
@@ -93,12 +98,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': {
@@ -384,11 +409,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/lib/types/option-set-hierarchy-exporter.d.ts

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

package/lib/types/option-set-hierarchy-exporter.js

@@ -0,0 +1,113 @@
+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/lib/types/option-set-hierarchy-parser.d.ts

@@ -1,2 +1,2 @@
-export declare function ParseOptionSetsHierarchyLocalFiles(args: any): Promise<void>;
-export declare function UploadOptionSetsHierarchyLocalFiles(args: any): Promise<void>;
+export declare function ParseOptionSetsHierarchyLocalFile(args: any): Promise<void>;
+export declare function UploadOptionSetsHierarchyLocalFile(args: any): Promise<void>;

package/lib/types/option-set-hierarchy-parser.js

@@ -5,7 +5,7 @@ const csv = require('csvtojson');
 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();
         if ((args === null || args === void 0 ? void 0 : args.length) < 4) {
@@ -14,7 +14,7 @@ export async function ParseOptionSetsHierarchyLocalFiles(args) {
         console.log('%s Importing local file', chalk.yellow.bold('OPTION SET HIERARCHY PARSE'));
         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'));
     }
     catch (e) {
@@ -23,7 +23,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();
         if ((args === null || args === void 0 ? void 0 : args.length) < 4) {
@@ -34,7 +34,7 @@ export async function UploadOptionSetsHierarchyLocalFiles(args) {
         const name = args[4];
         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'));
     }
     catch (e) {
@@ -55,7 +55,7 @@ async function loadOptionSetHierarchyCSV(fileLocation) {
         throw new Error(`ERROR PARSING CSV: ${e}`);
     }
 }
-async function parseOptionSetHierarchiesLocalFiles(fileLocation) {
+async function parseOptionSetHierarchiesLocalFile(fileLocation) {
     const uploadedOptionHierarchyData = await loadOptionSetHierarchyCSV(fileLocation);
     const optionSetHierarchy = {
         hierarchy: [],
@@ -90,12 +90,12 @@ 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({
         entityName: 'option-set-hierarchy',

package/lib/types/option-set-hierarchy-uploader.d.ts

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

package/lib/types/option-set-hierarchy-uploader.js

@@ -0,0 +1,110 @@
+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/lib/types/option-set-uploader.js

@@ -23,7 +23,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}`);

package/lib/types/rule-set-uploader.d.ts

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

package/lib/types/rule-set-uploader.js

@@ -0,0 +1,175 @@
+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 uploadRuleSets(args) {
+    try {
+        await authUser();
+        console.log('%s Uploading', chalk.yellow.bold('RULE SET'));
+        const [reducedRuleSets, reducedRuleSetLinks] = await loadReducedRuleSets();
+        await uploadRuleSetObjects(reducedRuleSets);
+        await uploadRuleSetLinkObjects(reducedRuleSetLinks);
+        console.log('%s Uploaded', chalk.yellow.bold('RULE SET'));
+    }
+    catch (e) {
+        console.log(`%s Rule Set Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Rule set Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadReducedRuleSets() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'types.yml', 'utf8'));
+        return [doc.reducedRuleSets, doc.reducedRuleSetLinks];
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadRuleSetObjects(reducedRuleSets) {
+    const currentRuleSets = await new Entities().get({
+        entityName: 'type-rule-set',
+    });
+    const currentRuleSetsByName = {};
+    for (const currentRuleSet of currentRuleSets) {
+        currentRuleSetsByName[currentRuleSet.name] = currentRuleSet;
+    }
+    const loadedRuleSetsByName = {};
+    for (const loadedRuleSet of reducedRuleSets) {
+        loadedRuleSetsByName[loadedRuleSet.name] = loadedRuleSet;
+    }
+    console.debug('current rule sets:', currentRuleSets);
+    console.debug('reduced rule sets:', reducedRuleSets);
+    for (const reducedRuleSet of reducedRuleSets) {
+        try {
+            const found = currentRuleSetsByName[reducedRuleSet.name];
+            if (!found) {
+                console.log('Creating: ', reducedRuleSet.name);
+                await new Entities().create({
+                    entityName: 'type-rule-set',
+                    object: reducedRuleSet
+                });
+            }
+            else {
+                console.log('Updating: ', reducedRuleSet.name);
+                await new Entities().update({
+                    entityName: 'type-rule-set',
+                    id: found.id,
+                    object: reducedRuleSet,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading rule sets: ${err}`);
+        }
+    }
+    for (const currentRuleSet of currentRuleSets) {
+        try {
+            const found = loadedRuleSetsByName[currentRuleSet.name];
+            if (!found) {
+                console.log('Deleting: ', currentRuleSet.name);
+                await new Entities().delete({
+                    entityName: 'type-rule-set',
+                    id: currentRuleSet.id,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set: ${err}`);
+        }
+    }
+}
+async function uploadRuleSetLinkObjects(loadedRuleSetLinks) {
+    const types = await new Entities().get({
+        entityName: 'type',
+    });
+    const currentRuleSets = await new Entities().get({
+        entityName: 'type-rule-set',
+    });
+    const currentRuleSetLinks = await new Entities().get({
+        entityName: 'type-rule-set-link',
+    });
+    const currentLinksHashes = {};
+    for (const currentLink of currentRuleSetLinks) {
+        const foundType = types.find(t => t.id === currentLink.typeId);
+        const foundRuleSet = currentRuleSets.find(rs => rs.id === currentLink.typeRuleSetId);
+        const hash = `${foundType.slug}|${foundRuleSet.name}`;
+        currentLinksHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of loadedRuleSetLinks) {
+        const hash = `${loadedLink.type}|${loadedLink.ruleSet}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    console.debug('current rule set links:', currentLinksHashes);
+    console.debug('reduced rule set links:', reducedLinksByHashes);
+    for (const loadedRuleSetLink of loadedRuleSetLinks) {
+        try {
+            const found = currentLinksHashes[`${loadedRuleSetLink.type}|${loadedRuleSetLink.ruleSet}`];
+            if (!found) {
+                if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) {
+                    continue;
+                }
+                console.log('Creating: ', loadedRuleSetLink);
+                await new Entities().create({
+                    entityName: 'type-rule-set-link',
+                    object: {
+                        typeRuleSetId: loadedRuleSetLink.ruleSet,
+                        typeId: loadedRuleSetLink.type,
+                    },
+                });
+            }
+            else {
+                if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) {
+                    continue;
+                }
+                console.log('Updating: ', loadedRuleSetLink);
+                await new Entities().update({
+                    entityName: 'type-rule-set-link',
+                    id: found.id,
+                    object: {
+                        typeRuleSetId: loadedRuleSetLink.ruleSet,
+                        typeId: loadedRuleSetLink.type,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading rule set links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                console.log('Deleting: ', currentLinkHash);
+                await new Entities().delete({
+                    entityName: 'type-rule-set-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(ruleSetLink, types, ruleSets) {
+    const foundType = types.find(t => t.slug === ruleSetLink.type);
+    if (!foundType) {
+        console.error('Could not find type with name', ruleSetLink.type);
+        return false;
+    }
+    ruleSetLink.type = foundType.id;
+    const foundRuleSet = ruleSets.find(rs => rs.name === ruleSetLink.ruleSet);
+    if (!foundRuleSet) {
+        console.error('Could not find rule set with name', foundType.ruleSet);
+        return false;
+    }
+    ruleSetLink.ruleSet = foundRuleSet.id;
+    return true;
+}

package/lib/types/type-property-policy-uploader.d.ts

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