@contrail/cli 3.4.11-alpha.0f34b47 → 3.4.11-alpha.11e1d43

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/3.4.11-alpha.0f34b47 linux-x64 node-v24.14.1
+@contrail/cli/3.4.11-alpha.11e1d43 linux-x64 node-v24.14.1
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND
@@ -1405,7 +1405,7 @@ EXAMPLES
 
 ## `contrail types uploadUsageInfo`
 
-[DEPRECATED] Upload extracted usage info. Use uploadTypeOverrides instead.
+Upload extracted usage info
 
 ```
 USAGE
@@ -1420,7 +1420,7 @@ FLAGS
                                    <options: error|warn|info|debug>
 
 DESCRIPTION
-  [DEPRECATED] Upload extracted usage info. Use uploadTypeOverrides instead.
+  Upload extracted usage info
 
 EXAMPLES
   $ contrail types uploadUsageInfo

package/dist/api/types.d.ts

@@ -1,8 +1,13 @@
 export declare function getOptionSets(): Promise<any[]>;
 export declare function getUserLists(): Promise<any[]>;
 export declare function getOptionSetHierarchies(): Promise<any[]>;
+export declare function getOptionSetHierarchyLinks(): Promise<any[]>;
 export declare function getRuleSets(): Promise<any[]>;
+export declare function getRuleSetLinks(): Promise<any[]>;
+export declare function getUsageInfo(): Promise<any[]>;
 export declare function getTypePropertyPolicies(): Promise<any[]>;
+export declare function getTypePropertyPolicyLinks(): Promise<any[]>;
 export declare function getTypePolicies(): Promise<any[]>;
 export declare function getTypeOverrideCopies(): Promise<any[]>;
 export declare function uploadTypeOverrideObjects(reducedOverrides: any): Promise<void>;
+export declare function getTypePolicyLinks(): Promise<any[]>;

package/dist/api/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadTypeOverrideObjects = exports.getTypeOverrideCopies = exports.getTypePolicies = exports.getTypePropertyPolicies = exports.getRuleSets = exports.getOptionSetHierarchies = exports.getUserLists = exports.getOptionSets = void 0;
+exports.getTypePolicyLinks = exports.uploadTypeOverrideObjects = exports.getTypeOverrideCopies = exports.getTypePolicies = exports.getTypePropertyPolicyLinks = exports.getTypePropertyPolicies = exports.getUsageInfo = exports.getRuleSetLinks = exports.getRuleSets = exports.getOptionSetHierarchyLinks = exports.getOptionSetHierarchies = exports.getUserLists = exports.getOptionSets = void 0;
 const sdk_1 = require("@contrail/sdk");
 async function getOptionSets() {
     return await new sdk_1.Entities().get({
@@ -21,6 +21,13 @@ async function getOptionSetHierarchies() {
     });
 }
 exports.getOptionSetHierarchies = getOptionSetHierarchies;
+async function getOptionSetHierarchyLinks() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-option-set-hierarchy-link',
+    });
+}
+exports.getOptionSetHierarchyLinks = getOptionSetHierarchyLinks;
 async function getRuleSets() {
     const entitiesClient = new sdk_1.Entities();
     return await entitiesClient.get({
@@ -28,6 +35,20 @@ async function getRuleSets() {
     });
 }
 exports.getRuleSets = getRuleSets;
+async function getRuleSetLinks() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-rule-set-link',
+    });
+}
+exports.getRuleSetLinks = getRuleSetLinks;
+async function getUsageInfo() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-property-usage-info',
+    });
+}
+exports.getUsageInfo = getUsageInfo;
 async function getTypePropertyPolicies() {
     const entitiesClient = new sdk_1.Entities();
     return await entitiesClient.get({
@@ -35,6 +56,13 @@ async function getTypePropertyPolicies() {
     });
 }
 exports.getTypePropertyPolicies = getTypePropertyPolicies;
+async function getTypePropertyPolicyLinks() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-property-policy-link',
+    });
+}
+exports.getTypePropertyPolicyLinks = getTypePropertyPolicyLinks;
 async function getTypePolicies() {
     const entitiesClient = new sdk_1.Entities();
     return await entitiesClient.get({
@@ -58,3 +86,10 @@ async function uploadTypeOverrideObjects(reducedOverrides) {
     });
 }
 exports.uploadTypeOverrideObjects = uploadTypeOverrideObjects;
+async function getTypePolicyLinks() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-policy-link',
+    });
+}
+exports.getTypePolicyLinks = getTypePolicyLinks;

package/dist/commands/types/getAll.js

@@ -54,9 +54,14 @@ async function getAll(outDir, overwrite) {
             types: await (0, type_extractor_1.getTypes)(),
             optionSets: await (0, types_1.getOptionSets)(),
             optionSetHierarchies: await (0, types_1.getOptionSetHierarchies)(),
+            optionSetHierarchyLinks: await (0, types_1.getOptionSetHierarchyLinks)(),
             ruleSets: await (0, types_1.getRuleSets)(),
+            ruleSetLinks: await (0, types_1.getRuleSetLinks)(),
+            usageInfo: await (0, types_1.getUsageInfo)(),
             typePropertyPolicies: await (0, types_1.getTypePropertyPolicies)(),
+            typePropertyPolicyLinks: await (0, types_1.getTypePropertyPolicyLinks)(),
             typePolicies: await (0, types_1.getTypePolicies)(),
+            typePolicyLinks: await (0, types_1.getTypePolicyLinks)(),
             typeOverrides: await (0, types_1.getTypeOverrideCopies)(),
             orgUsers: await (0, users_1.getUserOrgs)(),
             groups: await (0, users_1.getGroups)(),
@@ -120,18 +125,31 @@ async function saveData(reducedData, dir, overwrite) {
             split: true,
             fileLabel: 'identifier',
         },
+        reducedOptionSetHierarchyLinks: {
+            filename: 'type-option-set-hierarchy-links',
+            split: false,
+            fileLabel: '',
+        },
         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: '',
+        },
         reducedOverrides: {
             filename: 'type-overrides',
             split: false,
             fileLabel: '',
         },
         reducedTypePolicies: { filename: 'type-policies', split: true, fileLabel: 'label' },
+        reducedTypePolicyLinks: { filename: 'type-policy-links', split: false, fileLabel: '' },
     };
     for (const [key, folder] of Object.entries(propertyToFolderMap)) {
         const CURRENT_DIR = process.cwd();

package/dist/commands/types/loadAll.js

@@ -7,6 +7,7 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const login_1 = require("../../auth/login");
 const uploadOptionSets_1 = require("./uploadOptionSets");
 const uploadOptionSetHierarchies_1 = require("./uploadOptionSetHierarchies");
+const uploadUsageInfo_1 = require("./uploadUsageInfo");
 const uploadRuleSets_1 = require("./uploadRuleSets");
 const uploadTypePropertyPolicies_1 = require("./uploadTypePropertyPolicies");
 const type_uploader_1 = require("../../helpers/types/type-uploader");
@@ -40,6 +41,7 @@ async function loadAll(dir, skipPolicies = false) {
         await (0, uploadOptionSets_1.uploadOptionSets)(dir);
         await (0, type_uploader_1.uploadTypes)(dir);
         await (0, uploadOptionSetHierarchies_1.uploadOptionSetHierarchies)(dir);
+        await (0, uploadUsageInfo_1.uploadUsageInfo)(dir);
         await (0, uploadRuleSets_1.uploadRuleSets)(dir);
         if (!skipPolicies) {
             await (0, uploadTypePropertyPolicies_1.uploadTypePropertyPolicies)(dir);

package/dist/commands/types/mergeTypeProperties.js

@@ -62,9 +62,14 @@ async function mergeTypeProperties(fileLocation, typePaths) {
         types: await (0, type_extractor_1.getTypes)(),
         optionSets: await (0, types_2.getOptionSets)(),
         optionSetHierarchies: [],
+        optionSetHierarchyLinks: [],
         ruleSets: [],
+        ruleSetLinks: [],
+        usageInfo: [],
         typePropertyPolicies: [],
+        typePropertyPolicyLinks: [],
         typePolicies: [],
+        typePolicyLinks: [],
     };
     const reducedData = await (0, types_1.getAllReducedTypes)(data);
     for (const typePath of typePaths) {

package/dist/commands/types/uploadOptionSetHierarchies.js

@@ -8,6 +8,7 @@ const path = tslib_1.__importStar(require("path"));
 const login_1 = require("../../auth/login");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const core_1 = require("@oclif/core");
+const type_extractor_1 = require("../../helpers/types/type-extractor");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
@@ -37,6 +38,8 @@ async function uploadOptionSetHierarchies(dir) {
         logger_1.default.info(`${chalk_1.default.yellow.bold('OPTION SET HIERARCHIES')} Uploading`);
         const optionSetHierarchies = await loadOptionSetHierarchies(dir);
         await uploadOSH(optionSetHierarchies);
+        const optionSetHierarchyLinks = await loadOptionSetHierarchyLinks(dir);
+        await uploadOSHLinks(optionSetHierarchyLinks);
         logger_1.default.info(`${chalk_1.default.yellow.bold('OPTION SET HIERARCHIES')} Uploaded`);
     }
     catch (e) {
@@ -60,6 +63,14 @@ function loadOptionSetHierarchies(fromDir) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
     }
 }
+function loadOptionSetHierarchyLinks(fromDir) {
+    try {
+        return js_yaml_1.default.load(fs_1.default.readFileSync(path.join(fromDir, 'type-option-set-hierarchy-links.yml'), 'utf8'));
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
 async function uploadOSH(loadedOSHs) {
     const optionSets = await new sdk_1.Entities().get({
         entityName: 'type-property-option-set',
@@ -139,3 +150,109 @@ function transformOSHNameToID(hierarchy, optionSets) {
     }
     return true;
 }
+async function uploadOSHLinks(reducedOSHLinks) {
+    const typesWithProperties = await (0, type_extractor_1.getTypes)();
+    const typeProperties = [];
+    typesWithProperties.forEach((type) => {
+        if (type.typeProperties) {
+            for (const tp of type.typeProperties) {
+                tp.typeId = type.id;
+                tp.typeSlug = type.slug;
+                typeProperties.push(tp);
+            }
+        }
+    });
+    const currentOSHs = await new sdk_1.Entities().get({
+        entityName: 'option-set-hierarchy',
+    });
+    const currentOSHLinks = await new sdk_1.Entities().get({
+        entityName: 'type-option-set-hierarchy-link',
+    });
+    const currentOSHLinkHashes = {};
+    for (const currentLink of currentOSHLinks) {
+        const foundType = typesWithProperties.find((x) => x.id === currentLink.typeId);
+        const foundOSH = currentOSHs.find((osh) => osh.id === currentLink.optionSetHierarchyId);
+        const foundTPSlugs = typeProperties
+            .filter((x) => currentLink?.hierarchyTypePropertyIds?.includes(x.id))
+            .map((x) => x.slug);
+        if (!foundType ||
+            !foundOSH ||
+            foundTPSlugs.length !== currentLink.hierarchyTypePropertyIds.length) {
+            logger_1.default.info(`skipping unhashable, invalid type option set hierarchy link: ${JSON.stringify(currentLink, null, 2)}`);
+        }
+        // don't mutate original array
+        const sortedFoundTPSlugs = [...foundTPSlugs].sort();
+        const hash = `${foundType.slug}|${foundOSH.name}|${sortedFoundTPSlugs.join('|')}`;
+        currentOSHLinkHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of reducedOSHLinks) {
+        // don't mutate original array
+        const sortedTPSlugs = [...loadedLink.typePropertySlugs].sort();
+        const hash = `${loadedLink.typeSlug}|${loadedLink.optionSetHierarchyIdentifier}|${sortedTPSlugs.join('|')}}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    for (const loadedLink of reducedOSHLinks) {
+        try {
+            // don't mutate original array
+            const sortedTPSlugs = [...loadedLink.typePropertySlugs].sort();
+            const found = currentOSHLinkHashes[`${loadedLink.typeSlug}|${loadedLink.optionSetHierarchyIdentifier}|${sortedTPSlugs.join('|')}`];
+            if (!found) {
+                if (!transformReducedLink(loadedLink, typesWithProperties, currentOSHs)) {
+                    continue;
+                }
+                logger_1.default.debug(`Creating:  ${JSON.stringify(loadedLink, null, 2)}`);
+                await new sdk_1.Entities().create({
+                    entityName: 'type-option-set-hierarchy-link',
+                    object: {
+                        hierarchyTypePropertyIds: loadedLink.hierarchyTypePropertyIds,
+                        optionSetHierarchyId: loadedLink.optionSetHierarchyId,
+                        typeId: loadedLink.typeId,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`Error uploading type option set hierarchy links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentOSHLinkHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                logger_1.default.debug(`Deleting: ${JSON.stringify(currentLinkHash)}`);
+                await new sdk_1.Entities().delete({
+                    entityName: 'type-option-set-hierarchy-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(OSHLink, typesWithProperties, OSHs) {
+    logger_1.default.debug(`OSHLink before transform: ${JSON.stringify(OSHLink, null, 2)}`);
+    const foundType = typesWithProperties.find((x) => x.slug === OSHLink.typeSlug);
+    if (!foundType) {
+        logger_1.default.error(`OSH Links: Could not find type with slug ${OSHLink.typeSlug}`);
+        return false;
+    }
+    OSHLink.typeId = foundType.id;
+    const foundTPs = foundType?.typeProperties?.filter((x) => OSHLink.typePropertySlugs.includes(x.slug)) ?? [];
+    if (foundTPs.length !== OSHLink.typePropertySlugs.length) {
+        logger_1.default.error(`OSH Links: Could not find all type properties with slugs ${OSHLink.typePropertySlugs}`);
+        return false;
+    }
+    logger_1.default.debug(`foundTPs: ${JSON.stringify(foundTPs)}`);
+    OSHLink.hierarchyTypePropertyIds = foundTPs.map((x) => x.id);
+    const foundOSH = OSHs.find((x) => x.identifier === OSHLink.optionSetHierarchyIdentifier);
+    if (!foundOSH) {
+        logger_1.default.error(`OSH Links: Could not find option set hierarchy with identifier ${OSHLink.optionSetHierarchyIdentifier}`);
+        return false;
+    }
+    OSHLink.optionSetHierarchyId = foundOSH.id;
+    logger_1.default.debug(`OSHLink after transform: ${JSON.stringify(OSHLink, null, 2)}`);
+    return true;
+}

package/dist/commands/types/uploadRuleSets.js

@@ -35,8 +35,9 @@ async function uploadRuleSets(dir) {
     try {
         await (0, login_1.authUser)();
         logger_1.default.info(`${chalk_1.default.yellow.bold('RULE SET')} Uploading`);
-        const reducedRuleSets = await loadReducedRuleSets(dir);
+        const [reducedRuleSets, reducedRuleSetLinks] = await loadReducedRuleSets(dir);
         await uploadRuleSetObjects(reducedRuleSets);
+        await uploadRuleSetLinkObjects(reducedRuleSetLinks);
         logger_1.default.info(`${chalk_1.default.yellow.bold('RULE SET')} Uploaded`);
     }
     catch (e) {
@@ -48,13 +49,15 @@ async function uploadRuleSets(dir) {
 exports.uploadRuleSets = uploadRuleSets;
 function loadReducedRuleSets(fromDir) {
     const ruleSets = [];
+    let ruleSetLinks = [];
     const dir = path.join(fromDir, 'rule-sets');
     try {
         const files = fs_1.default.readdirSync(dir);
         for (const file of files) {
             ruleSets.push(js_yaml_1.default.load(fs_1.default.readFileSync(path.join(dir, file), 'utf8')));
         }
-        return ruleSets;
+        ruleSetLinks = js_yaml_1.default.load(fs_1.default.readFileSync(path.join(fromDir, 'rule-set-links.yml'), 'utf8'));
+        return [ruleSets, ruleSetLinks];
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
@@ -113,3 +116,83 @@ async function uploadRuleSetObjects(reducedRuleSets) {
         }
     }
 }
+async function uploadRuleSetLinkObjects(loadedRuleSetLinks) {
+    const types = await new sdk_1.Entities().get({
+        entityName: 'type',
+    });
+    const currentRuleSets = await new sdk_1.Entities().get({
+        entityName: 'type-rule-set',
+    });
+    const currentRuleSetLinks = await new sdk_1.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;
+    }
+    for (const loadedRuleSetLink of loadedRuleSetLinks) {
+        try {
+            const found = currentLinksHashes[`${loadedRuleSetLink.type}|${loadedRuleSetLink.ruleSet}`];
+            if (!found) {
+                if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) {
+                    continue;
+                }
+                logger_1.default.info(`Creating: ${JSON.stringify(loadedRuleSetLink, null, 2)}`);
+                await new sdk_1.Entities().create({
+                    entityName: 'type-rule-set-link',
+                    object: {
+                        typeRuleSetId: loadedRuleSetLink.ruleSet,
+                        typeId: loadedRuleSetLink.type,
+                    },
+                });
+            }
+            else {
+                if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) {
+                    continue;
+                }
+                logger_1.default.info(`skipping updating existing rule set link: ${loadedRuleSetLink}`);
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`Error Uploading rule set links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                logger_1.default.info(`Deleting: ${currentLinkHash}`);
+                await new sdk_1.Entities().delete({
+                    entityName: 'type-rule-set-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(ruleSetLink, types, ruleSets) {
+    const foundType = types.find((t) => t.slug === ruleSetLink.type);
+    if (!foundType) {
+        logger_1.default.error(`Could not find type with name ${ruleSetLink.type}`);
+        return false;
+    }
+    ruleSetLink.type = foundType.id;
+    const foundRuleSet = ruleSets.find((rs) => rs.identifier === ruleSetLink.ruleSet);
+    if (!foundRuleSet) {
+        logger_1.default.error(`Could not find rule set with name ${foundType.ruleSet}`);
+        return false;
+    }
+    ruleSetLink.ruleSet = foundRuleSet.id;
+    return true;
+}

package/dist/commands/types/uploadTypePolicies.js

@@ -8,6 +8,7 @@ const path = tslib_1.__importStar(require("path"));
 const login_1 = require("../../auth/login");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const core_1 = require("@oclif/core");
+const type_extractor_1 = require("../../helpers/types/type-extractor");
 const users_1 = require("../../api/users");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
@@ -36,8 +37,9 @@ async function uploadTypePolicies(dir) {
     try {
         await (0, login_1.authUser)();
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE POLICY')} Uploading`);
-        const reducedTypePolicies = await loadTypePolicies(dir);
+        const [reducedTypePolicies, reducedTypePolicyLinks] = await loadTypePolicies(dir);
         await uploadTypePolicyObjects(reducedTypePolicies);
+        await uploadTypePolicyLinks(reducedTypePolicyLinks);
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPE POLICY')} Uploaded`);
     }
     catch (e) {
@@ -49,13 +51,15 @@ async function uploadTypePolicies(dir) {
 exports.uploadTypePolicies = uploadTypePolicies;
 function loadTypePolicies(fromDir) {
     const tps = [];
+    let tpLinks = [];
     const dir = path.join(fromDir, 'type-policies');
     try {
         const files = fs_1.default.readdirSync(dir);
         for (const file of files) {
             tps.push(js_yaml_1.default.load(fs_1.default.readFileSync(path.join(dir, file), 'utf8')));
         }
-        return tps;
+        tpLinks = js_yaml_1.default.load(fs_1.default.readFileSync(path.join(fromDir, 'type-policy-links.yml'), 'utf8'));
+        return [tps, tpLinks];
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
@@ -148,3 +152,83 @@ async function uploadTypePolicyObjects(reducedTypePolicies) {
         }
     }
 }
+async function uploadTypePolicyLinks(reducedTypePolicyLinks) {
+    const types = await (0, type_extractor_1.getTypes)();
+    const currentTypePolicies = await new sdk_1.Entities().get({
+        entityName: 'type-policy',
+    });
+    const currentTypePolicyLinks = await new sdk_1.Entities().get({
+        entityName: 'type-policy-link',
+    });
+    const currentLinksHashes = {};
+    for (const currentLink of currentTypePolicyLinks) {
+        const foundType = types.find((type) => type.id === currentLink.typeId);
+        const foundTypePolicy = currentTypePolicies.find((tp) => tp.id === currentLink.typePolicyId);
+        if (!foundType || !foundTypePolicy) {
+            logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
+        }
+        const hash = `${foundType.slug}|${foundTypePolicy.identifier}`;
+        currentLinksHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of reducedTypePolicyLinks) {
+        const hash = `${loadedLink.typeSlug}|${loadedLink.typePolicyIdentifier}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    for (const loadedTPLink of reducedTypePolicyLinks) {
+        try {
+            const found = currentLinksHashes[`${loadedTPLink.typeSlug}|${loadedTPLink.typePolicyIdentifier}`];
+            if (!found) {
+                if (!transformReducedLink(loadedTPLink, types, currentTypePolicies)) {
+                    continue;
+                }
+                logger_1.default.info(`Creating:  ${loadedTPLink.typeSlug}|${loadedTPLink.typePolicyIdentifier}`);
+                await new sdk_1.Entities().create({
+                    entityName: 'type-policy-link',
+                    object: {
+                        typePolicyId: loadedTPLink.typePolicyId,
+                        typeId: loadedTPLink.typeId,
+                    },
+                });
+            }
+            else {
+                if (!transformReducedLink(loadedTPLink, types, currentTypePolicies)) {
+                    continue;
+                }
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`Error Uploading type policy links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                logger_1.default.info(`Deleting:  ${currentLinkHash}`);
+                await new sdk_1.Entities().delete({
+                    entityName: 'type-policy-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            logger_1.default.error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(typePolicyLink, types, typePolicies) {
+    const foundType = types.find((type) => type.slug === typePolicyLink.typeSlug);
+    if (!foundType) {
+        logger_1.default.error(`Could not find type with slug ${typePolicyLink.typeSlug}`);
+        return false;
+    }
+    typePolicyLink.typeId = foundType.id;
+    const foundTypePolicy = typePolicies.find((tpp) => tpp.identifier === typePolicyLink.typePolicyIdentifier);
+    if (!foundTypePolicy) {
+        logger_1.default.error(`Could not find type policy with identifier ${typePolicyLink.typePolicyIdentifier}`);
+        return false;
+    }
+    typePolicyLink.typePolicyId = foundTypePolicy.id;
+    return true;
+}

package/dist/commands/types/uploadTypePropertyPolicies.d.ts

@@ -10,3 +10,4 @@ export default class UploadTypePropertyPolicies extends BaseCommand {
     run(): Promise<void>;
 }
 export declare function uploadTypePropertyPolicies(dir: string): Promise<void>;
+export declare function findAllOccurrences(array: any, evaluator: any): any[];