@contrail/cli 2.1.1 → 2.1.3

package/README.md

@@ -15,7 +15,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/2.1.1 darwin-arm64 node-v18.13.0
+@contrail/cli/2.1.3 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)
@@ -764,11 +765,11 @@ Get all Types and associated data for your Org
 
 ```
 USAGE
-  $ contrail types getAll [-d <value>] [--overwrite]
+  $ contrail types getAll [-d <value>] [-f]
 
 FLAGS
   -d, --outDir=<value>  [default: .] The directory to which to export the type data. Defaults to the current directory
-  --overwrite           Replaces any existing export files in outDir
+  -f, --overwrite       Replaces any existing export files in outDir
 
 DESCRIPTION
   Get all Types and associated data for your Org
@@ -1047,6 +1048,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

@@ -1,7 +1,10 @@
 export declare function getOptionSets(): 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 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.getOptionSetHierarchyLinks = exports.getOptionSetHierarchies = exports.getOptionSets = void 0;
 const sdk_1 = require("@contrail/sdk");
 async function getOptionSets() {
     return await new sdk_1.Entities().get({
@@ -15,6 +15,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({
@@ -50,3 +57,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

@@ -3,21 +3,27 @@ export interface DataHolder {
     types: any[];
     optionSets: any[];
     optionSetHierarchies: any[];
+    optionSetHierarchyLinks: any[];
     ruleSets: any[];
     ruleSetLinks: any[];
     usageInfo: any[];
     typePropertyPolicies: any[];
     typePropertyPolicyLinks: any[];
+    typePolicies: any[];
+    typePolicyLinks: any[];
 }
 export interface ReducedDataHolder {
     reducedTypes: any[];
     reducedOptionSets: any[];
     reducedOptionSetHierarchies: any[];
+    reducedOptionSetHierarchyLinks: any[];
     reducedRuleSets: any[];
     reducedRuleSetLinks: any[];
     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

@@ -26,7 +26,7 @@ GetAllTypes.examples = [
 ];
 GetAllTypes.flags = {
     outDir: core_1.Flags.string({ char: 'd', description: 'The directory to which to export the type data. Defaults to the current directory', required: false, default: '.' }),
-    overwrite: core_1.Flags.boolean({ description: 'Replaces any existing export files in outDir', required: false, default: false })
+    overwrite: core_1.Flags.boolean({ char: 'f', description: 'Replaces any existing export files in outDir', required: false, default: false })
 };
 async function getAll(outDir, overwrite) {
     try {
@@ -40,11 +40,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)(),
         };
         const reducedData = await reduceData(data);
         await saveData(reducedData, outDir, overwrite);
@@ -101,11 +104,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,
         };
     });
 }
@@ -176,6 +248,36 @@ function reduceOptionSetHierarchies(data) {
         };
     });
 }
+function reduceOptionSetHierarchyLinks(data) {
+    var _a;
+    return (_a = data.optionSetHierarchyLinks) === null || _a === void 0 ? void 0 : _a.map(x => {
+        var _a;
+        const osh = data.optionSetHierarchies.find(y => y.id === x.optionSetHierarchyId);
+        if (!osh) {
+            console.log('OSH Link: could not find option set hierarchy', x.optionSetHierarchyId, 'skipping...');
+            return null;
+        }
+        const type = data.types.find(y => y.id === x.typeId);
+        if (!type) {
+            console.log('OSH Link: could not find type', x.typeId, 'skipping...');
+            return null;
+        }
+        const typePropertySlugs = [];
+        for (const tpId of x.hierarchyTypePropertyIds) {
+            const typePropertySlug = (_a = type.typeProperties.find(y => y.id === tpId)) === null || _a === void 0 ? void 0 : _a.slug;
+            if (!typePropertySlug) {
+                console.log('OSH Link: could not find type property', tpId, 'skipping...');
+                return null;
+            }
+            typePropertySlugs.push(typePropertySlug);
+        }
+        return {
+            optionSetHierarchyName: osh.name,
+            typeSlug: type.slug,
+            typePropertySlugs,
+        };
+    }).filter(x => !!x);
+}
 function reduceTypes(dataHolder) {
     console.log('Found types: ', dataHolder.types.length);
     let reducedTypes = [];
@@ -197,6 +299,7 @@ function reduceTypes(dataHolder) {
                 core: typeProperty.core,
                 typePropertyOptionSetName: optionSetNameById[typeProperty.typePropertyOptionSetId],
                 formula: typeProperty.formula,
+                referencedTypePath: typeProperty.referencedTypePath,
                 referencedTypeRootSlug: typeProperty.referencedTypeRootSlug,
                 defaultValue: typeProperty.defaultValue,
                 propertyLevel: typeProperty.propertyLevel,
@@ -230,11 +333,14 @@ async function reduceData(data) {
         reducedTypes: reduceTypes(data),
         reducedOptionSets: reduceOptionSets(data),
         reducedOptionSetHierarchies: reduceOptionSetHierarchies(data),
+        reducedOptionSetHierarchyLinks: reduceOptionSetHierarchyLinks(data),
         reducedRuleSets: reduceRuleSets(data),
         reducedRuleSetLinks: reduceRuleSetLinks(data),
         reducedUsageInfo: reduceUsageInfo(data),
         reducedTypePropertyPolicies: await reduceTypePropertyPolicies(data),
         reducedTypePropertyPolicyLinks: reduceTypePropertyPolicyLinks(data),
+        reducedTypePolicies: await reduceTypePolicies(data),
+        reducedTypePolicyLinks: reduceTypePolicyLinks(data),
     };
 }
 exports.reduceData = reduceData;
@@ -276,11 +382,14 @@ async function saveData(reducedData, dir, overwrite) {
         reducedTypes: { filename: 'types', split: false, fileLabel: 'slug', saveFunction: saveTypesFunction },
         reducedOptionSets: { filename: 'option-sets', split: true, fileLabel: 'name' },
         reducedOptionSetHierarchies: { filename: 'option-set-hierarchies', split: true, fileLabel: 'name' },
+        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: '' },
+        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);
@@ -30,12 +31,13 @@ async function loadAll(dir, skipPolicies = false) {
     try {
         await (0, login_1.authUser)();
         await (0, uploadOptionSets_1.uploadOptionSets)(dir);
-        await (0, uploadOptionSetHierarchies_1.uploadOptionSetHierarchies)(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);
+            await (0, uploadTypePolicies_1.uploadTypePolicies)(dir);
         }
     }
     catch (e) {

package/dist/commands/types/mergeTypeProperties.js

@@ -58,11 +58,14 @@ async function mergeTypeProperties(fileLocation, typePaths) {
         types: await (0, type_extractor_1.getTypes)(),
         optionSets: await (0, types_1.getOptionSets)(),
         optionSetHierarchies: [],
+        optionSetHierarchyLinks: [],
         ruleSets: [],
         ruleSetLinks: [],
         usageInfo: [],
         typePropertyPolicies: [],
         typePropertyPolicyLinks: [],
+        typePolicies: [],
+        typePolicyLinks: [],
     };
     const reducedData = await (0, getAll_1.reduceData)(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 yaml = require('js-yaml');
 class UploadOptionSetHierarchies extends core_1.Command {
     async run() {
@@ -30,6 +31,8 @@ async function uploadOptionSetHierarchies(dir) {
         console.log('%s Uploading', chalk_1.default.yellow.bold('OPTION SET HIERARCHIES'));
         const optionSetHierarchies = await loadOptionSetHierarchies(dir);
         await uploadOSH(optionSetHierarchies);
+        const optionSetHierarchyLinks = await loadOptionSetHierarchyLinks(dir);
+        await uploadOSHLinks(optionSetHierarchyLinks);
         console.log('%s Uploaded', chalk_1.default.yellow.bold('OPTION SET HIERARCHIES'));
     }
     catch (e) {
@@ -53,6 +56,14 @@ function loadOptionSetHierarchies(fromDir) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
     }
 }
+function loadOptionSetHierarchyLinks(fromDir) {
+    try {
+        return yaml.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',
@@ -132,3 +143,96 @@ 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 => { var _a; return (_a = currentLink === null || currentLink === void 0 ? void 0 : currentLink.hierarchyTypePropertyIds) === null || _a === void 0 ? void 0 : _a.includes(x.id); }).map(x => x.slug);
+        if (!foundType || !foundOSH || (foundTPSlugs.length !== currentLink.hierarchyTypePropertyIds.length)) {
+            console.log('skipping unhashable, invalid type option set hierarchy link:', currentLink);
+        }
+        const hash = `${foundType.slug}|${foundOSH.name}|${foundTPSlugs.sort().join('|')}`;
+        currentOSHLinkHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of reducedOSHLinks) {
+        const hash = `${loadedLink.typeSlug}|${loadedLink.optionSetHierarchyName}|${loadedLink.typePropertySlugs.sort().join('|')}}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    for (const loadedLink of reducedOSHLinks) {
+        try {
+            const found = currentOSHLinkHashes[`${loadedLink.typeSlug}|${loadedLink.optionSetHierarchyName}|${loadedLink.typePropertySlugs.sort().join('|')}`];
+            if (!found) {
+                if (!transformReducedLink(loadedLink, typesWithProperties, currentOSHs)) {
+                    continue;
+                }
+                await new sdk_1.Entities().create({
+                    entityName: 'type-option-set-hierarchy-link',
+                    object: {
+                        hierarchyTypePropertyIds: loadedLink.hierarchyTypePropertyIds,
+                        optionSetHierarchyId: loadedLink.optionSetHierarchyId,
+                        typeId: loadedLink.typeId,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error uploading type option set hierarchy links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentOSHLinkHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                console.log('Deleting: ', currentLinkHash);
+                await new sdk_1.Entities().delete({
+                    entityName: 'type-option-set-hierarchy-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(OSHLink, typesWithProperties, OSHs) {
+    var _a, _b;
+    const foundType = typesWithProperties.find(x => x.slug === OSHLink.typeSlug);
+    if (!foundType) {
+        console.error('OSH Links: Could not find type with slug', OSHLink.typeSlug);
+        return false;
+    }
+    OSHLink.typeId = foundType.id;
+    const foundTPs = (_b = (_a = foundType === null || foundType === void 0 ? void 0 : foundType.typeProperties) === null || _a === void 0 ? void 0 : _a.filter(x => OSHLink.typePropertySlugs.includes(x.slug))) !== null && _b !== void 0 ? _b : [];
+    if (foundTPs.length !== OSHLink.typePropertySlugs.length) {
+        console.error('OSH Links: Could not find all type properties with slugs', OSHLink.typePropertySlugs);
+        return false;
+    }
+    OSHLink.hierarchyTypePropertyIds = foundTPs.map(x => x.id);
+    const foundOSH = OSHs.find(x => x.name === OSHLink.optionSetHierarchyName);
+    if (!foundOSH) {
+        console.error('OSH Links: Could not find option set hierarchy with name', OSHLink.optionSetHierarchyName);
+        return false;
+    }
+    OSHLink.optionSetHierarchyId = foundOSH.id;
+    return true;
+}

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;
@@ -209,12 +217,12 @@ async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
             }
         }
         catch (err) {
-            throw new Error(`Error Deleting rule set link: ${err}`);
+            throw new Error(`Error Deleting type property policy link: ${err}`);
         }
     }
 }
 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-extractor.d.ts

@@ -1 +1 @@
-export declare function getTypes(): Promise<any[]>;
+export declare function getTypes(withTypeProperties?: boolean): Promise<any>;

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

@@ -6,13 +6,16 @@ const sdk_1 = require("@contrail/sdk");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const p_limit_1 = tslib_1.__importDefault(require("p-limit"));
 const limit = (0, p_limit_1.default)(30);
-async function getTypes() {
+async function getTypes(withTypeProperties = true) {
     console.log('%s Retrieving', chalk_1.default.yellow.bold('TYPES'));
     const entitiesClient = new sdk_1.Entities();
     const types = await entitiesClient.get({
         entityName: 'type',
     });
     console.log(`${chalk_1.default.yellow.bold('TYPES')} Found ${types.length} types`);
+    if (!withTypeProperties) {
+        return types;
+    }
     const typesWithProperties = [];
     const promises = [];
     for (const type of types) {

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

@@ -78,7 +78,8 @@ async function uploadReducedTypes(dir) {
                         isArchived: type.isArchived,
                     },
                 });
-                await uploadReducedTypeProperties(createdType, [], type.typeProperties);
+                const newTypeProperties = (await new sdk_1.Types().getType({ id: createdType.id })).typeProperties;
+                await uploadReducedTypeProperties(createdType, newTypeProperties, type.typeProperties);
             }
             else {
                 console.log('Updating Type: ', type.slug);
@@ -148,11 +149,13 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         core: newPropertyType.core,
                         typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
                         formula: newPropertyType.formula,
+                        referencedTypePath: newPropertyType.referencedTypePath,
                         referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
                         defaultValue: newPropertyType.defaultValue,
                         propertyLevel: newPropertyType.propertyLevel,
                         formulaFunction: newPropertyType.formulaFunction,
                         validationFunction: newPropertyType.validationFunction,
+                        numberFormat: newPropertyType.numberFormat,
                     }),
                     headers: {
                         Accept: 'application/json',
@@ -175,11 +178,13 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                         core: newPropertyType.core,
                         typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
                         formula: newPropertyType.formula,
+                        referencedTypePath: newPropertyType.referencedTypePath,
                         referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
                         defaultValue: newPropertyType.defaultValue,
                         propertyLevel: newPropertyType.propertyLevel,
                         formulaFunction: newPropertyType.formulaFunction,
                         validationFunction: newPropertyType.validationFunction,
+                        numberFormat: newPropertyType.numberFormat,
                     },
                 });
             }
@@ -218,11 +223,13 @@ function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
         core: typeProperty1.core,
         typePropertyOptionSetId: optionSetIdByName[typeProperty1.typePropertyOptionSetName],
         formula: typeProperty1.formula,
+        referencedTypePath: typeProperty1.referencedTypePath,
         referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
         defaultValue: typeProperty1.defaultValue,
         propertyLevel: typeProperty1.propertyLevel,
         formulaFunction: typeProperty1.formulaFunction,
         validationFunction: typeProperty1.validationFunction,
+        numberFormat: typeProperty1.numberFormat,
     };
     const reducedProperty2 = {
         isArchived: typeProperty2.isArchived,
@@ -234,11 +241,13 @@ function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
         core: typeProperty2.core,
         typePropertyOptionSetId: optionSetIdByName[typeProperty2.typePropertyOptionSetName],
         formula: typeProperty2.formula,
+        referencedTypePath: typeProperty2.referencedTypePath,
         referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
         defaultValue: typeProperty2.defaultValue,
         propertyLevel: typeProperty2.propertyLevel,
         formulaFunction: typeProperty2.formulaFunction,
         validationFunction: typeProperty2.validationFunction,
+        numberFormat: typeProperty2.numberFormat,
     };
     return _.isEqual(reducedProperty1, reducedProperty2);
 }

package/dist/interfaces.d.ts

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

package/dist/templates/typescript/package.json

@@ -12,8 +12,8 @@
   },
   "scripts": {
     "build": "tsc",
-    "start": "nodemon --watch \"src/**/*.ts\" --exec ts-node src/module.ts",
-    "debug": "nodemon -r ts-node/register --inspect=127.0.0.1:60002 --watch 'actions/**/*.ts' --exec node src/module.ts",
+    "start": "nodemon --watch \"src/**/*.ts\" --exec ts-node src/main.ts",
+    "debug": "nodemon -r ts-node/register --inspect=127.0.0.1:60002 --watch 'actions/**/*.ts' --exec node src/main.ts",
     "lint": "eslint . --fix",
     "test": "jest",
     "test-watch": "jest --watch"
@@ -22,7 +22,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@contrail/app-framework": "^1.0.7",
+    "@contrail/app-framework": "^1.0.9",
     "@contrail/sdk": "^1.1.54",
     "chalk": "^4.0.0",
     "js-yaml": "^4.1.0"

package/dist/templates/typescript/src/main.ts

@@ -1,4 +1,4 @@
-import { ContrailAppModule, loadAppConfig, registerAppInfo, runMockServer, AppActionRequest, AppActionResponse, ActionDispatcher } from '@contrail/app-framework';
+import { ContrailAppModule, loadAppConfig, registerAppInfo, runMockServer, AppActionRequest, AppActionResponse, ActionDispatcher, GLOBAL_ACTION_REGISTRY } from '@contrail/app-framework';
 
 // we can't use static import here. Require only
 import fs from 'fs';
@@ -18,11 +18,18 @@ export class AppModule extends ContrailAppModule {
 
     // register app's actions
     for (const file of fs.readdirSync(path.join(__dirname, 'actions'))) {
-      if (!file.endsWith('.js')) {
-        continue;
+      // only parse js and ts file, avoid property files
+      if (
+        file.endsWith('.js') ||
+        (file.endsWith('.ts') && !file.endsWith('.d.ts'))
+      ) {
+        require(path.join(__dirname, 'actions', file));
       }
-      console.log('reading file', file);
-      require(path.join(__dirname, 'actions', file));
+    }
+
+    console.log(`Registered ${Object.keys(GLOBAL_ACTION_REGISTRY).length} action(s):`);
+    for(const key of Object.keys(GLOBAL_ACTION_REGISTRY)) {
+      console.log(`\t- ${appConfig.appIdentifier}:${key}`);
     }
   }
 }

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.1.1",
+  "version": "2.1.3",
   "commands": {
     "app:create": {
       "id": "app:create",
@@ -556,6 +556,7 @@
         "overwrite": {
           "name": "overwrite",
           "type": "boolean",
+          "char": "f",
           "description": "Replaces any existing export files in outDir",
           "required": false,
           "allowNo": false
@@ -890,6 +891,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.1.1",
+  "version": "2.1.3",
   "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",