@contrail/cli 2.0.18 → 2.0.21

package/README.md

@@ -15,7 +15,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/2.0.18 darwin-arm64 node-v18.13.0
+@contrail/cli/2.0.21 darwin-arm64 node-v18.13.0
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND
@@ -75,6 +75,7 @@ To get instructions on how to set up autocomplete for your shell, run `contrail
 * [`contrail types uploadOptionSets`](#contrail-types-uploadoptionsets)
 * [`contrail types uploadOptionSetsHierarchyLocalFile FILE NAME`](#contrail-types-uploadoptionsetshierarchylocalfile-file-name)
 * [`contrail types uploadRuleSets`](#contrail-types-uploadrulesets)
+* [`contrail types uploadTypePolicies`](#contrail-types-uploadtypepolicies)
 * [`contrail types uploadTypePropertyPolicies`](#contrail-types-uploadtypepropertypolicies)
 * [`contrail types uploadUsageInfo`](#contrail-types-uploadusageinfo)
 * [`contrail users export`](#contrail-users-export)
@@ -1046,6 +1047,25 @@ EXAMPLES
   $ contrail types uploadRuleSets
 ```
 
+## `contrail types uploadTypePolicies`
+
+Upload type policies
+
+```
+USAGE
+  $ contrail types uploadTypePolicies [-d <value>]
+
+FLAGS
+  -d, --dir=<value>  [default: .] The directory from which to export the type policy data. Defaults to the current
+                     directory. The type policy data will be loaded from $dir/type-policies/*.yml
+
+DESCRIPTION
+  Upload type policies
+
+EXAMPLES
+  $ contrail types UploadTypePolicies
+```
+
 ## `contrail types uploadTypePropertyPolicies`
 
 Upload type property policies

package/dist/api/types.d.ts

@@ -5,3 +5,5 @@ 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 getTypePolicyLinks(): Promise<any>;

package/dist/api/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypePropertyPolicyLinks = exports.getTypePropertyPolicies = exports.getUsageInfo = exports.getRuleSetLinks = exports.getRuleSets = exports.getOptionSetHierarchies = exports.getOptionSets = void 0;
+exports.getTypePolicyLinks = exports.getTypePolicies = exports.getTypePropertyPolicyLinks = exports.getTypePropertyPolicies = exports.getUsageInfo = exports.getRuleSetLinks = exports.getRuleSets = exports.getOptionSetHierarchies = exports.getOptionSets = void 0;
 const sdk_1 = require("@contrail/sdk");
 async function getOptionSets() {
     return await new sdk_1.Entities().get({
@@ -50,3 +50,17 @@ async function getTypePropertyPolicyLinks() {
     });
 }
 exports.getTypePropertyPolicyLinks = getTypePropertyPolicyLinks;
+async function getTypePolicies() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-policy',
+    });
+}
+exports.getTypePolicies = getTypePolicies;
+async function getTypePolicyLinks() {
+    const entitiesClient = new sdk_1.Entities();
+    return await entitiesClient.get({
+        entityName: 'type-policy-link',
+    });
+}
+exports.getTypePolicyLinks = getTypePolicyLinks;

package/dist/commands/instance/import.js

@@ -7,6 +7,7 @@ const loadAll_1 = require("../types/loadAll");
 const upload_1 = require("../users/upload");
 const upload_2 = require("../groups/upload");
 const uploadTypePropertyPolicies_1 = require("../types/uploadTypePropertyPolicies");
+const uploadTypePolicies_1 = require("../types/uploadTypePolicies");
 class ImportInstance extends core_1.Command {
     async run() {
         const { flags } = await this.parse(ImportInstance);
@@ -14,6 +15,7 @@ class ImportInstance extends core_1.Command {
         await (0, upload_1.uploadUsers)(path.join(flags.dir, 'users.yml'));
         await (0, upload_2.uploadGroups)(path.join(flags.dir, 'groups.yml'));
         await (0, uploadTypePropertyPolicies_1.uploadTypePropertyPolicies)(flags.dir);
+        await (0, uploadTypePolicies_1.uploadTypePolicies)(flags.dir);
     }
 }
 exports.default = ImportInstance;

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

@@ -8,6 +8,8 @@ export interface DataHolder {
     usageInfo: any[];
     typePropertyPolicies: any[];
     typePropertyPolicyLinks: any[];
+    typePolicies: any[];
+    typePolicyLinks: any[];
 }
 export interface ReducedDataHolder {
     reducedTypes: any[];
@@ -18,6 +20,8 @@ export interface ReducedDataHolder {
     reducedUsageInfo: any[];
     reducedTypePropertyPolicies: any[];
     reducedTypePropertyPolicyLinks: any[];
+    reducedTypePolicies: any[];
+    reducedTypePolicyLinks: any[];
 }
 export default class GetAllTypes extends Command {
     static description: string;

package/dist/commands/types/getAll.js

@@ -45,6 +45,8 @@ async function getAll(outDir, overwrite) {
             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)(),
         };
         const reducedData = await reduceData(data);
         await saveData(reducedData, outDir, overwrite);
@@ -101,11 +103,80 @@ async function reduceTypePropertyPolicies(data) {
 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));
+    // make a map of all type properties to their type ids
+    const typePropertyIdToTypeSlugMap = data.types.reduce((map, obj) => {
+        for (const tp of obj.typeProperties) {
+            map[tp.id] = obj.slug;
+        }
+        return map;
+    }, {});
     return (_b = data === null || data === void 0 ? void 0 : data.typePropertyPolicyLinks) === null || _b === void 0 ? void 0 : _b.map(x => {
+        var _a, _b;
+        const typeSlug = typePropertyIdToTypeSlugMap[x.typePropertyId];
+        const typePropertySlug = (_a = typeProperties.find(y => y.id === x.typePropertyId)) === null || _a === void 0 ? void 0 : _a.slug;
+        const typePropertyPolicyLabel = (_b = data.typePropertyPolicies.find(y => y.id === x.typePropertyPolicyId)) === null || _b === void 0 ? void 0 : _b.label;
+        if (!typeSlug ||
+            !typePropertySlug ||
+            !typePropertyPolicyLabel) {
+            console.warn('Could not reduce bad type property policy link... skipping', x);
+            return null;
+        }
+        return {
+            typeSlug,
+            typePropertySlug,
+            typePropertyPolicyLabel,
+        };
+    }).filter(x => !!x);
+}
+async function reduceTypePolicies(data) {
+    var _a;
+    const orgUsers = await (0, users_1.getUserOrgs)();
+    const groups = await (0, users_1.getGroups)();
+    function reducePrincipal(statement) {
+        var _a, _b;
+        if (!(statement === null || statement === void 0 ? void 0 : statement.principal)) {
+            return statement;
+        }
+        const [type, id] = statement.principal.split(':');
+        if (!type || !id) {
+            return statement;
+        }
+        if (type === 'group') {
+            const groupName = (_a = groups.find(x => x.id === id)) === null || _a === void 0 ? void 0 : _a.name;
+            if (!groupName) {
+                console.log(`Could not find group for statement. skipping invalid policy conversion ${id}`);
+                return statement;
+            }
+            statement.principal = `group:${groupName}`;
+        }
+        else if (type === 'user') {
+            const userEmail = (_b = orgUsers.find(x => x.user.id === id)) === null || _b === void 0 ? void 0 : _b.email;
+            if (!userEmail) {
+                console.log(`Could not find group for statement. skipping invalid policy conversion ${id}`);
+                return statement;
+            }
+            statement.principal = `user:${userEmail}`;
+        }
+        return statement;
+    }
+    return (_a = data === null || data === void 0 ? void 0 : data.typePolicies) === null || _a === void 0 ? void 0 : _a.map(x => {
+        return {
+            label: x.label,
+            policy: {
+                version: x.policy.version,
+                statements: x.policy.statements.map(x => reducePrincipal(x)),
+            }
+        };
+    });
+}
+function reduceTypePolicyLinks(data) {
+    var _a;
+    const types = data === null || data === void 0 ? void 0 : data.types;
+    return (_a = data === null || data === void 0 ? void 0 : data.typePolicyLinks) === null || _a === void 0 ? void 0 : _a.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,
+            typeSlug: (_a = types.find(y => y.id === x.typeId)) === null || _a === void 0 ? void 0 : _a.slug,
+            typePolicyLabel: (_b = data.typePolicies.find(y => y.id === x.typePolicyId)) === null || _b === void 0 ? void 0 : _b.label,
         };
     });
 }
@@ -197,7 +268,7 @@ function reduceTypes(dataHolder) {
                 core: typeProperty.core,
                 typePropertyOptionSetName: optionSetNameById[typeProperty.typePropertyOptionSetId],
                 formula: typeProperty.formula,
-                referencedTypeRootSlug: typeProperty.referencedTypeRootSlug,
+                referencedTypePath: typeProperty.referencedTypePath,
                 defaultValue: typeProperty.defaultValue,
                 propertyLevel: typeProperty.propertyLevel,
                 inherited: typeProperty.inherited,
@@ -235,6 +306,8 @@ async function reduceData(data) {
         reducedUsageInfo: reduceUsageInfo(data),
         reducedTypePropertyPolicies: await reduceTypePropertyPolicies(data),
         reducedTypePropertyPolicyLinks: reduceTypePropertyPolicyLinks(data),
+        reducedTypePolicies: await reduceTypePolicies(data),
+        reducedTypePolicyLinks: reduceTypePolicyLinks(data),
     };
 }
 exports.reduceData = reduceData;
@@ -281,6 +354,8 @@ async function saveData(reducedData, dir, overwrite) {
         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: '' },
+        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

@@ -11,6 +11,7 @@ const uploadUsageInfo_1 = require("./uploadUsageInfo");
 const uploadRuleSets_1 = require("./uploadRuleSets");
 const uploadTypePropertyPolicies_1 = require("./uploadTypePropertyPolicies");
 const type_uploader_1 = require("../../helpers/types/type-uploader");
+const uploadTypePolicies_1 = require("./uploadTypePolicies");
 class LoadAllTypes extends core_1.Command {
     async run() {
         const { flags } = await this.parse(LoadAllTypes);
@@ -36,6 +37,7 @@ async function loadAll(dir, skipPolicies = false) {
         await (0, uploadRuleSets_1.uploadRuleSets)(dir);
         if (!skipPolicies) {
             await (0, uploadTypePropertyPolicies_1.uploadTypePropertyPolicies)(dir);
+            await (0, uploadTypePolicies_1.uploadTypePolicies)(dir);
         }
     }
     catch (e) {

package/dist/commands/types/mergeTypeProperties.js

@@ -63,6 +63,8 @@ async function mergeTypeProperties(fileLocation, typePaths) {
         usageInfo: [],
         typePropertyPolicies: [],
         typePropertyPolicyLinks: [],
+        typePolicies: [],
+        typePolicyLinks: [],
     };
     const reducedData = await (0, getAll_1.reduceData)(data);
     for (const typePath of typePaths) {

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class UploadTypePolicies extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dir: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}
+export declare function uploadTypePolicies(dir: string): Promise<void>;

package/dist/commands/types/uploadTypePolicies.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadTypePolicies = void 0;
+const tslib_1 = require("tslib");
+const sdk_1 = require("@contrail/sdk");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+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 yaml = require('js-yaml');
+class UploadTypePolicies extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(UploadTypePolicies);
+        return await uploadTypePolicies(flags.dir);
+    }
+}
+exports.default = UploadTypePolicies;
+UploadTypePolicies.description = 'Upload type policies';
+UploadTypePolicies.examples = [
+    `$ contrail types UploadTypePolicies
+`,
+];
+UploadTypePolicies.flags = {
+    dir: core_1.Flags.string({ char: 'd', description: 'The directory from which to export the type policy data. Defaults to the current directory. The type policy data will be loaded from $dir/type-policies/*.yml', required: false, default: '.' }),
+};
+async function uploadTypePolicies(dir) {
+    try {
+        await (0, login_1.authUser)();
+        console.log('%s Uploading', chalk_1.default.yellow.bold('TYPE POLICY'));
+        const [reducedTypePolicies, reducedTypePolicyLinks] = await loadTypePolicies(dir);
+        await uploadTypePolicyObjects(reducedTypePolicies);
+        await uploadTypePolicyLinks(reducedTypePolicyLinks);
+        console.log('%s Uploaded', chalk_1.default.yellow.bold('TYPE POLICY'));
+    }
+    catch (e) {
+        console.log(`%s Type Policy Upload Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Type Policy Upload Complete.', chalk_1.default.green.bold('COMPLETE'));
+}
+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(yaml.load(fs_1.default.readFileSync(path.join(dir, file), 'utf8')));
+        }
+        tpLinks = yaml.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}`);
+    }
+}
+async function uploadTypePolicyObjects(reducedTypePolicies) {
+    const orgUsers = await (0, users_1.getUserOrgs)();
+    const groups = await (0, users_1.getGroups)();
+    function fillPrincipal(statement) {
+        const principal = statement === null || statement === void 0 ? void 0 : statement.principal;
+        if (!principal) {
+            console.warn(`skipping bad statement principal ${statement === null || statement === void 0 ? void 0 : statement.principal}`);
+            return statement;
+        }
+        const [type, identifier] = principal.split(':');
+        if (!type || !identifier) {
+            console.warn(`skipping bad statement principal ${statement === null || statement === void 0 ? void 0 : statement.principal}`);
+            return statement;
+        }
+        if (type === 'group') {
+            const group = groups.find(x => x.name === identifier);
+            if (!group) {
+                console.log(`Could not find group ${identifier}`);
+            }
+            else {
+                statement.principal = `group:${group.id}`;
+            }
+        }
+        else if (type === 'user') {
+            const orgUser = orgUsers.find(x => x.user.email === identifier);
+            if (!orgUser) {
+                console.log(`Could not find user ${identifier}`);
+            }
+            else {
+                statement.principal = `user:${orgUser.user.id}`;
+            }
+        }
+        return statement;
+    }
+    reducedTypePolicies.forEach(policy => {
+        policy.policy.statements = policy.policy.statements.map(x => fillPrincipal(x));
+    });
+    const currentTypePolicies = await new sdk_1.Entities().get({
+        entityName: 'type-policy',
+    });
+    const currentTypePolicyByLabel = {};
+    for (const currentTypePolicy of currentTypePolicies) {
+        currentTypePolicyByLabel[currentTypePolicy.label] = currentTypePolicy;
+    }
+    const loadedTypePolicyByName = {};
+    for (const loadedTPP of reducedTypePolicies) {
+        loadedTypePolicyByName[loadedTPP.label] = loadedTPP;
+    }
+    for (const [label, loadedTPP] of Object.entries(loadedTypePolicyByName)) {
+        try {
+            const found = currentTypePolicyByLabel[label];
+            if (!found) {
+                console.log('Creating: ', label);
+                await new sdk_1.Entities().create({
+                    entityName: 'type-policy',
+                    object: loadedTPP
+                });
+            }
+            else {
+                console.log('Updating: ', label);
+                await new sdk_1.Entities().update({
+                    entityName: 'type-policy',
+                    id: found.id,
+                    object: loadedTPP,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading Type Policy: ${err}`);
+        }
+    }
+    for (const [label, currentTPP] of Object.entries(currentTypePolicyByLabel)) {
+        try {
+            const found = loadedTypePolicyByName[label];
+            if (!found) {
+                console.log('Deleting: ', label);
+                await new sdk_1.Entities().delete({
+                    entityName: 'type-policy',
+                    id: currentTPP['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Type Policy: ${err}`);
+        }
+    }
+}
+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) {
+            console.log('skipping unhashable, invalid policy link:', currentLink);
+        }
+        const hash = `${foundType.slug}|${foundTypePolicy.label}`;
+        currentLinksHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of reducedTypePolicyLinks) {
+        const hash = `${loadedLink.typeSlug}|${loadedLink.typePolicyLabel}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    for (const loadedTPLink of reducedTypePolicyLinks) {
+        try {
+            const found = currentLinksHashes[`${loadedTPLink.typeSlug}|${loadedTPLink.typePolicyLabel}`];
+            if (!found) {
+                if (!transformReducedLink(loadedTPLink, types, currentTypePolicies)) {
+                    continue;
+                }
+                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) {
+            throw new Error(`Error Uploading type policy links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                console.log('Deleting: ', currentLinkHash);
+                await new sdk_1.Entities().delete({
+                    entityName: 'type-policy-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(typePolicyLink, types, typePolicies) {
+    const foundType = types.find(type => type.slug === typePolicyLink.typeSlug);
+    if (!foundType) {
+        console.error('Could not find type with slug', typePolicyLink.typeSlug);
+        return false;
+    }
+    typePolicyLink.typeId = foundType.id;
+    const foundTypePolicy = typePolicies.find(tpp => tpp.label === typePolicyLink.typePolicyLabel);
+    if (!foundTypePolicy) {
+        console.error('Could not find type policy with label', typePolicyLink.typePolicyLabel);
+        return false;
+    }
+    typePolicyLink.typePolicyId = foundTypePolicy.id;
+    return true;
+}

package/dist/commands/types/uploadTypePropertyPolicies.js

@@ -37,6 +37,8 @@ async function uploadTypePropertyPolicies(dir) {
     }
     catch (e) {
         console.log(`%s Type Property Policy Upload Failed. ${e}`, chalk_1.default.red.bold('FAIL'));
+        //TODO make this only print if a debug flag is set
+        console.trace(e);
         return;
     }
     console.log('%s Type Property Policy Upload Complete.', chalk_1.default.green.bold('COMPLETE'));
@@ -147,10 +149,16 @@ async function uploadTPPolicyObjects(reducedTypePropertyPolicies) {
 }
 async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
     const typesWithProperties = await (0, type_extractor_1.getTypes)();
-    const typeProperties = typesWithProperties
-        .filter(t => !!t.typeProperties)
-        .map(t => t.typeProperties)
-        .reduce((a, b) => a.concat(b));
+    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 currentTPPs = await new sdk_1.Entities().get({
         entityName: 'type-property-policy',
     });
@@ -164,17 +172,17 @@ async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
         if (!foundTypeProperty || !foundTPP) {
             console.log('skipping unhashable, invalid policy link:', currentLink);
         }
-        const hash = `${foundTypeProperty.slug}|${foundTPP.label}`;
+        const hash = `${foundTypeProperty.typeSlug}${foundTypeProperty.slug}|${foundTPP.label}`;
         currentLinksHashes[hash] = currentLink;
     }
     const reducedLinksByHashes = {};
     for (const loadedLink of reducedTypePropertyPolicyLinks) {
-        const hash = `${loadedLink.typePropertySlug}|${loadedLink.typePropertyPolicyLabel}`;
+        const hash = `${loadedLink.typeSlug}|${loadedLink.typePropertySlug}|${loadedLink.typePropertyPolicyLabel}`;
         reducedLinksByHashes[hash] = loadedLink;
     }
     for (const loadedTPPLink of reducedTypePropertyPolicyLinks) {
         try {
-            const found = currentLinksHashes[`${loadedTPPLink.typePropertySlug}|${loadedTPPLink.typePropertyPolicyLabel}`];
+            const found = currentLinksHashes[`${loadedTPPLink.typeSlug}|${loadedTPPLink.typePropertySlug}|${loadedTPPLink.typePropertyPolicyLabel}`];
             if (!found) {
                 if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
                     continue;
@@ -214,7 +222,7 @@ async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
     }
 }
 function transformReducedLink(TPPLink, typeProperties, typePropertyPolicies) {
-    const foundTP = typeProperties.find(tp => tp.slug === TPPLink.typePropertySlug);
+    const foundTP = typeProperties.find(tp => tp.slug === TPPLink.typePropertySlug && tp.typeSlug === TPPLink.typeSlug);
     if (!foundTP) {
         console.error('Could not find type property with label', TPPLink.typePropertySlug);
         return false;

package/dist/helpers/types/type-uploader.js

@@ -148,7 +148,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         core: newPropertyType.core,
                         typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
                         formula: newPropertyType.formula,
-                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        referencedTypePath: newPropertyType.referencedTypePath,
                         defaultValue: newPropertyType.defaultValue,
                         propertyLevel: newPropertyType.propertyLevel,
                         formulaFunction: newPropertyType.formulaFunction,
@@ -175,7 +175,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         core: newPropertyType.core,
                         typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
                         formula: newPropertyType.formula,
-                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        referencedTypePath: newPropertyType.referencedTypePath,
                         defaultValue: newPropertyType.defaultValue,
                         propertyLevel: newPropertyType.propertyLevel,
                         formulaFunction: newPropertyType.formulaFunction,
@@ -218,7 +218,7 @@ function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
         core: typeProperty1.core,
         typePropertyOptionSetId: optionSetIdByName[typeProperty1.typePropertyOptionSetName],
         formula: typeProperty1.formula,
-        referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
+        referencedTypePath: typeProperty1.referencedTypePath,
         defaultValue: typeProperty1.defaultValue,
         propertyLevel: typeProperty1.propertyLevel,
         formulaFunction: typeProperty1.formulaFunction,
@@ -234,7 +234,7 @@ function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
         core: typeProperty2.core,
         typePropertyOptionSetId: optionSetIdByName[typeProperty2.typePropertyOptionSetName],
         formula: typeProperty2.formula,
-        referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
+        referencedTypePath: typeProperty2.referencedTypePath,
         defaultValue: typeProperty2.defaultValue,
         propertyLevel: typeProperty2.propertyLevel,
         formulaFunction: typeProperty2.formulaFunction,

package/dist/interfaces.d.ts

@@ -301,7 +301,7 @@ export interface ReducedTypeProperty {
     core: boolean;
     typePropertyOptionSetName: string;
     formula: string;
-    referencedTypeRootSlug: string;
+    referencedTypePath: string;
     defaultValue: string;
     propertyLevel: string;
     inherited: boolean;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.18",
+  "version": "2.0.21",
   "commands": {
     "app:create": {
       "id": "app:create",
@@ -881,6 +881,30 @@
       },
       "args": {}
     },
+    "types:uploadTypePolicies": {
+      "id": "types:uploadTypePolicies",
+      "description": "Upload type policies",
+      "strict": true,
+      "pluginName": "@contrail/cli",
+      "pluginAlias": "@contrail/cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "$ contrail types UploadTypePolicies\n"
+      ],
+      "flags": {
+        "dir": {
+          "name": "dir",
+          "type": "option",
+          "char": "d",
+          "description": "The directory from which to export the type policy data. Defaults to the current directory. The type policy data will be loaded from $dir/type-policies/*.yml",
+          "required": false,
+          "multiple": false,
+          "default": "."
+        }
+      },
+      "args": {}
+    },
     "types:uploadTypePropertyPolicies": {
       "id": "types:uploadTypePropertyPolicies",
       "description": "Upload type property policies",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "2.0.18",
+  "version": "2.0.21",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",
@@ -22,7 +22,7 @@
     "/oclif.manifest.json"
   ],
   "dependencies": {
-    "@contrail/sdk": "^1.2.0",
+    "@contrail/sdk": "^1.2.3",
     "@contrail/types": "^3.0.20",
     "@contrail/util": "^1.0.17",
     "@oclif/core": "^2",
@@ -33,6 +33,7 @@
     "amazon-cognito-identity-js": "^5.2.3",
     "arg": "^4.0.1",
     "aws-sdk": "^2.1044.0",
+    "axios": "^1.3.5",
     "chalk": "^4.0.0",
     "command-line-usage": "^6.1.1",
     "csvtojson": "^2.0.10",
@@ -46,7 +47,6 @@
     "lodash": "^4.17.21",
     "ncp": "^2.0.0",
     "pkg-install": "^1.0.0",
-    "axios": "^1.3.5",
     "zip-a-folder": "^1.1.5"
   },
   "devDependencies": {