@contrail/cli 2.2.6 → 2.2.8

package/README.md

@@ -17,7 +17,7 @@ $ npm install -g @contrail/cli
 $ contrail COMMAND
 running command...
 $ contrail (--version)
-@contrail/cli/2.2.6 darwin-arm64 node-v18.13.0
+@contrail/cli/2.2.8 darwin-arm64 node-v18.13.0
 $ contrail --help [COMMAND]
 USAGE
   $ contrail COMMAND

package/dist/commands/types/uploadTypePolicies.js

@@ -182,6 +182,7 @@ async function uploadTypePolicyLinks(reducedTypePolicyLinks) {
                 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: {

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

@@ -8,3 +8,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[];

package/dist/commands/types/uploadTypePropertyPolicies.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadTypePropertyPolicies = void 0;
+exports.findAllOccurrences = exports.uploadTypePropertyPolicies = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@contrail/sdk");
 const fs_1 = tslib_1.__importDefault(require("fs"));
@@ -13,6 +13,7 @@ const users_1 = require("../../api/users");
 const basecommand_1 = require("../../basecommand");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const _ = tslib_1.__importStar(require("lodash"));
 class UploadTypePropertyPolicies extends basecommand_1.BaseCommand {
     async run() {
         const { flags } = await this.parse(UploadTypePropertyPolicies);
@@ -172,75 +173,115 @@ async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
     const currentTPPLinks = await new sdk_1.Entities().get({
         entityName: 'type-property-policy-link',
     });
+    logger_1.default.info(`found ${currentTPPLinks.length} current type property policy links`);
+    logger_1.default.info(`found ${reducedTypePropertyPolicyLinks.length} type property policy links to load`);
     const currentLinksHashes = {};
     for (const currentLink of currentTPPLinks) {
-        const foundTypeProperty = typeProperties.find((tp) => tp.id === currentLink.typePropertyId);
-        const foundTPP = currentTPPs.find((tpp) => tpp.id === currentLink.typePropertyPolicyId);
-        if (!foundTypeProperty || !foundTPP) {
-            logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
-            continue;
+        const foundTPs = findAllOccurrences(typeProperties, (tp) => tp.id === currentLink.typePropertyId);
+        for (const foundTP of foundTPs) {
+            const foundTPP = currentTPPs.find((tpp) => tpp.id === currentLink.typePropertyPolicyId);
+            if (!foundTP || !foundTPP) {
+                logger_1.default.info(`skipping unhashable, invalid policy link: ${JSON.stringify(currentLink, null, 2)}`);
+                continue;
+            }
+            const hash = `${foundTP.typeSlug}|${foundTP.slug}|${foundTPP.identifier}`;
+            currentLinksHashes[hash] = currentLink;
         }
-        const hash = `${foundTypeProperty.typeSlug}${foundTypeProperty.slug}|${foundTPP.identifier}`;
-        currentLinksHashes[hash] = currentLink;
     }
+    logger_1.default.debug(`current links hashes: ${JSON.stringify(currentLinksHashes, null, 2)}`);
     const reducedLinksByHashes = {};
     for (const loadedLink of reducedTypePropertyPolicyLinks) {
         const hash = `${loadedLink.typeSlug}|${loadedLink.typePropertySlug}|${loadedLink.typePropertyPolicyIdentifier}`;
         reducedLinksByHashes[hash] = loadedLink;
     }
-    for (const loadedTPPLink of reducedTypePropertyPolicyLinks) {
+    const toCreate = Object.keys(reducedLinksByHashes)
+        .filter((x) => !currentLinksHashes[x])
+        .map((x) => {
+        return {
+            [x]: reducedLinksByHashes[x],
+        };
+    })
+        .reduce((a, b) => Object.assign(a, b), {});
+    const toDelete = _.uniqBy(Object.keys(currentLinksHashes)
+        .filter((x) => !reducedLinksByHashes[x])
+        .map((x) => {
+        return {
+            [x]: currentLinksHashes[x],
+        };
+    }), 'id').reduce((a, b) => Object.assign(a, b), {});
+    logger_1.default.debug(`reduced links hashes: ${JSON.stringify(reducedLinksByHashes, null, 2)}`);
+    logger_1.default.info(`found ${Object.keys(toCreate).length} type property policy links to create`);
+    logger_1.default.info(`found ${Object.keys(toDelete).length} type property policy links to delete`);
+    logger_1.default.debug(`to create: ${JSON.stringify(toCreate, null, 2)}`);
+    logger_1.default.debug(`to delete: ${JSON.stringify(toDelete, null, 2)}`);
+    logger_1.default.debug(`current links hashes to delete: ${JSON.stringify(Object.keys(currentLinksHashes).filter((x) => !reducedLinksByHashes[x]), null, 2)}`);
+    // fs.writeFileSync('toCreate.json', JSON.stringify(toCreate, null, 2));
+    // fs.writeFileSync('toDelete.json', JSON.stringify(toDelete, null, 2));
+    // fs.writeFileSync('currentLinksHashes.json', JSON.stringify(currentLinksHashes, null, 2));
+    // fs.writeFileSync('reducedLinksByHashes.json', JSON.stringify(reducedLinksByHashes, null, 2));
+    // fs.writeFileSync(
+    //   'current_link_hashes_to_delete.json',
+    //   JSON.stringify(
+    //     Object.keys(currentLinksHashes).filter((x) => !reducedLinksByHashes[x]),
+    //     null,
+    //     2,
+    //   ),
+    // );
+    // return;
+    for (const [hash, link] of Object.entries(toCreate)) {
         try {
-            const found = currentLinksHashes[`${loadedTPPLink.typeSlug}|${loadedTPPLink.typePropertySlug}|${loadedTPPLink.typePropertyPolicyIdentifier}`];
-            if (!found) {
-                if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
-                    continue;
-                }
-                await new sdk_1.Entities().create({
-                    entityName: 'type-property-policy-link',
-                    object: {
-                        typePropertyPolicyId: loadedTPPLink.typePropertyPolicyId,
-                        typePropertyId: loadedTPPLink.typePropertyId,
-                    },
-                });
-            }
-            else {
-                if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
-                    continue;
-                }
+            if (!transformReducedLink(link, typeProperties, currentTPPs)) {
+                continue;
             }
+            logger_1.default.info(`Creating: ${hash}: ${JSON.stringify(link, null, 2)}`);
+            await new sdk_1.Entities().create({
+                entityName: 'type-property-policy-link',
+                object: {
+                    typePropertyPolicyId: link.typePropertyPolicyId,
+                    typePropertyId: link.typePropertyId,
+                },
+            });
         }
         catch (err) {
             logger_1.default.error(`Error Uploading type property policy links: ${err}`);
         }
     }
-    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+    for (const [hash, link] of Object.entries(toDelete)) {
         try {
-            const found = reducedLinksByHashes[currentLinkHash];
-            if (!found) {
-                logger_1.default.info(`Deleting:  ${currentLinkHash}`);
-                await new sdk_1.Entities().delete({
-                    entityName: 'type-property-policy-link',
-                    id: currentLink['id'],
-                });
-            }
+            logger_1.default.info(`Deleting: ${hash}`);
+            await new sdk_1.Entities().delete({
+                entityName: 'type-property-policy-link',
+                id: link['id'],
+            });
         }
         catch (err) {
             logger_1.default.error(`Error Deleting type property policy link: ${err}`);
         }
     }
+    function transformReducedLink(TPPLink, typeProperties, typePropertyPolicies) {
+        const foundTP = typeProperties.find((tp) => tp.slug === TPPLink.typePropertySlug && tp.typeSlug === TPPLink.typeSlug);
+        if (!foundTP) {
+            logger_1.default.error(`Could not find type property with slug ${TPPLink.typePropertySlug} `);
+            return false;
+        }
+        TPPLink.typePropertyId = foundTP.id;
+        const foundTPP = typePropertyPolicies.find((tpp) => tpp.identifier === TPPLink.typePropertyPolicyIdentifier);
+        if (!foundTPP) {
+            logger_1.default.error(`Could not find type property policy with identifier ${TPPLink.typePropertyPolicyIdentifier} `);
+            return false;
+        }
+        TPPLink.typePropertyPolicyId = foundTPP.id;
+        return true;
+    }
 }
-function transformReducedLink(TPPLink, typeProperties, typePropertyPolicies) {
-    const foundTP = typeProperties.find((tp) => tp.slug === TPPLink.typePropertySlug && tp.typeSlug === TPPLink.typeSlug);
-    if (!foundTP) {
-        logger_1.default.error(`Could not find type property with slug ${TPPLink.typePropertySlug}`);
-        return false;
-    }
-    TPPLink.typePropertyId = foundTP.id;
-    const foundTPP = typePropertyPolicies.find((tpp) => tpp.identifier === TPPLink.typePropertyPolicyIdentifier);
-    if (!foundTPP) {
-        logger_1.default.error(`Could not find type property policy with identifier ${TPPLink.typePropertyPolicyIdentifier}`);
-        return false;
-    }
-    TPPLink.typePropertyPolicyId = foundTPP.id;
-    return true;
+function findAllOccurrences(array, evaluator) {
+    const found = [];
+    for (let i = 0; i < array.length; i++) {
+        const element = array[i];
+        if (evaluator(element)) {
+            found.push(element);
+        }
+    }
+    return found;
 }
+exports.findAllOccurrences = findAllOccurrences;

package/dist/helpers/app/app-config-validators.js

@@ -40,7 +40,9 @@ function visibilityValidator(appDeclaration) {
             error: 'Invalid visibility. Visibility must be "public" or "private".',
         };
     }
-    if (appDeclaration.visibility === 'private' && appDeclaration.hidden !== true) {
+    if (appDeclaration.visibility === 'private' &&
+        Object.prototype.hasOwnProperty.call(appDeclaration, 'hidden') &&
+        appDeclaration.hidden === true) {
         return {
             error: 'Apps can not be private and hidden.',
         };

package/dist/helpers/app/app-config-validators.spec.js

@@ -65,3 +65,41 @@ it('should return an error if app version has invalid format', () => {
     const validationResult = (0, app_config_validators_1.appVersionValidator)(appDeclaration);
     expect(validationResult).toEqual(expectedError);
 });
+describe('visibilityValidator', () => {
+    it('should return an error if visibility is neither "public" nor "private"', () => {
+        const appDeclaration = {
+            visibility: 'invalidVisibility',
+        };
+        const expectedError = {
+            error: 'Invalid visibility. Visibility must be "public" or "private".',
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toEqual(expectedError);
+    });
+    it('should return an error if app is private and not hidden', () => {
+        const appDeclaration = {
+            visibility: 'private',
+            hidden: true,
+        };
+        const expectedError = {
+            error: 'Apps can not be private and hidden.',
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toEqual(expectedError);
+    });
+    it('should not return an error if visibility is "public"', () => {
+        const appDeclaration = {
+            visibility: 'public',
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toBeUndefined();
+    });
+    it('should not return an error if app is private and hidden', () => {
+        const appDeclaration = {
+            visibility: 'private',
+            hidden: false,
+        };
+        const validationResult = (0, app_config_validators_1.visibilityValidator)(appDeclaration);
+        expect(validationResult).toBeUndefined();
+    });
+});

package/dist/helpers/types/type-uploader.d.ts

@@ -1 +1,18 @@
 export declare function uploadTypes(dir: string): Promise<void>;
+export interface ValueDiff {
+    adds: any[];
+    updates: any[];
+    deletions: any[];
+}
+/**
+ * compares the keys between different objects and returns the differences
+ * captures in adds, updates, and deletions. Object 1 is considered the
+ * original, and object 2 is considered the "edit".
+ *
+ * An add is a property that exists in object2 but not in 1. An edit
+ * is a property that exists in both object 1 and 2, but with different values.
+ * A deletion is a property in object 1 but not in object 2.
+ * @param object1 any object
+ * @param object2 any other object
+ */
+export declare function extractValueDifferences(object1: object, object2: object, keysToIgnore: Array<string>): ValueDiff;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadTypes = void 0;
+exports.extractValueDifferences = exports.uploadTypes = void 0;
 const tslib_1 = require("tslib");
 const sdk_1 = require("@contrail/sdk");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
@@ -61,6 +61,13 @@ async function uploadReducedTypes(dir) {
     for (const type of types) {
         newTypesBySlug[type.slug] = type;
     }
+    const optionSets = await new sdk_1.Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    if (logger_1.default.isDebugEnabled()) {
+        fs_1.default.writeFileSync('reducedTypes.json', JSON.stringify(types, null, 2));
+        fs_1.default.writeFileSync('currentTypes.json', JSON.stringify(currentTypes, null, 2));
+    }
     for (const type of types) {
         try {
             const found = currentTypesBySlug[type.slug];
@@ -81,21 +88,47 @@ async function uploadReducedTypes(dir) {
                 });
                 const newTypeProperties = (await new sdk_1.Types().getType({ id: createdType.id }))
                     .typeProperties;
-                await uploadReducedTypeProperties(createdType, newTypeProperties, type.typeProperties);
+                await uploadReducedTypeProperties(createdType, newTypeProperties, type.typeProperties, optionSets);
             }
             else {
-                logger_1.default.info(`Updating Type:  ${type.slug}`);
-                const updatedType = await new sdk_1.Entities().update({
-                    entityName: 'type',
-                    id: found.id,
-                    object: {
-                        slug: type.slug,
-                        label: type.label,
-                        typePath: type.typePath,
-                        isArchived: type.isArchived,
-                    },
-                });
-                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties);
+                const proposedType = {
+                    slug: type.slug,
+                    label: type.label,
+                    typePath: type.typePath,
+                    isArchived: type.isArchived,
+                };
+                const differences = extractValueDifferences(found, proposedType, [
+                    'id',
+                    'createdOn',
+                    'updatedOn',
+                    'createdById',
+                    'updatedById',
+                    'orgId',
+                    'typeRootId',
+                    'parentId',
+                    'typePolicyIds',
+                    'typePolicies',
+                    'typeProperties',
+                    'typePropertyPolicies',
+                    'typeRuleSets',
+                    'typeOptionSetHierarchyLinks',
+                    'relations',
+                    'typeInterfaces',
+                ]);
+                let updatedType = found;
+                if (differences.updates.length || differences.adds.length || differences.deletions.length) {
+                    logger_1.default.debug(`found differences: ${JSON.stringify(differences, null, 2)}`);
+                    logger_1.default.info(`Updating Type:  ${type.slug}`);
+                    updatedType = await new sdk_1.Entities().update({
+                        entityName: 'type',
+                        id: found.id,
+                        object: proposedType,
+                    });
+                }
+                else {
+                    logger_1.default.debug(`Skipping empty update of type ${type.slug}`);
+                }
+                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties, optionSets);
             }
         }
         catch (err) {
@@ -103,7 +136,7 @@ async function uploadReducedTypes(dir) {
         }
     }
 }
-async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes) {
+async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes, optionSets) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
     const currentPropertyTypeBySlug = {};
     for (const currentPropertyType of currentPropertyTypes) {
@@ -113,9 +146,6 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
     for (const newPropertyType of newPropertyTypes) {
         newPropertyTypesBySlug[newPropertyType.slug] = newPropertyType;
     }
-    const optionSets = await new sdk_1.Entities().get({
-        entityName: 'type-property-option-set',
-    });
     const optionSetIdBySlug = {};
     for (const optionSet of optionSets) {
         optionSetIdBySlug[optionSet.slug] = optionSet.id;
@@ -123,7 +153,7 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
     for (const newPropertyType of newPropertyTypes) {
         try {
             const found = currentPropertyTypeBySlug[newPropertyType.slug];
-            if (!found && !newPropertyType.inherited) {
+            if (!found) {
                 logger_1.default.info(`Creating Type-Property:  ${newPropertyType.slug}`);
                 await sdk_1.Request.request(`/types/${type.id}/type-properties`, {
                     method: 'POST',
@@ -154,35 +184,68 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                     },
                 });
             }
-            else if (found &&
-                !newPropertyType.inherited &&
-                !typePropertiesEqual(found, newPropertyType, optionSetIdBySlug)) {
-                logger_1.default.info(`Updating Type-Property:  ${newPropertyType.slug}`);
-                await new sdk_1.Entities().update({
-                    entityName: 'type-property',
-                    id: found.id,
-                    object: {
-                        isArchived: (_a = newPropertyType.isArchived) !== null && _a !== void 0 ? _a : null,
-                        propertyType: (_b = newPropertyType.propertyType) !== null && _b !== void 0 ? _b : null,
-                        slug: (_c = newPropertyType.slug) !== null && _c !== void 0 ? _c : null,
-                        label: (_d = newPropertyType.label) !== null && _d !== void 0 ? _d : null,
-                        editable: (_e = newPropertyType.editable) !== null && _e !== void 0 ? _e : null,
-                        searchable: (_f = newPropertyType.searchable) !== null && _f !== void 0 ? _f : null,
-                        core: (_g = newPropertyType.core) !== null && _g !== void 0 ? _g : null,
-                        typePropertyOptionSetId: (_h = optionSetIdBySlug[newPropertyType.typePropertyOptionSetSlug]) !== null && _h !== void 0 ? _h : null,
-                        formula: (_j = newPropertyType.formula) !== null && _j !== void 0 ? _j : null,
-                        referencedTypePath: (_k = newPropertyType.referencedTypePath) !== null && _k !== void 0 ? _k : null,
-                        carryOverBehavior: (_l = newPropertyType.carryOverBehavior) !== null && _l !== void 0 ? _l : null,
-                        carryOverDefault: (_m = newPropertyType.carryOverDefault) !== null && _m !== void 0 ? _m : null,
-                        referencedTypeRootSlug: (_o = newPropertyType.referencedTypeRootSlug) !== null && _o !== void 0 ? _o : null,
-                        defaultValue: (_p = newPropertyType.defaultValue) !== null && _p !== void 0 ? _p : null,
-                        propertyLevel: (_q = newPropertyType.propertyLevel) !== null && _q !== void 0 ? _q : null,
-                        formulaFunction: (_r = newPropertyType.formulaFunction) !== null && _r !== void 0 ? _r : null,
-                        validationFunction: (_s = newPropertyType.validationFunction) !== null && _s !== void 0 ? _s : null,
-                        numberFormat: (_t = newPropertyType.numberFormat) !== null && _t !== void 0 ? _t : null,
-                        sequenceSeedValue: (_u = newPropertyType.sequenceSeedValue) !== null && _u !== void 0 ? _u : null,
-                    },
-                });
+            else if (found
+            // !newPropertyType.inherited &&
+            // !typePropertiesEqual(found, newPropertyType, optionSetIdBySlug)
+            ) {
+                const proposedTP = {
+                    isArchived: (_a = newPropertyType.isArchived) !== null && _a !== void 0 ? _a : null,
+                    propertyType: (_b = newPropertyType.propertyType) !== null && _b !== void 0 ? _b : null,
+                    slug: (_c = newPropertyType.slug) !== null && _c !== void 0 ? _c : null,
+                    label: (_d = newPropertyType.label) !== null && _d !== void 0 ? _d : null,
+                    editable: (_e = newPropertyType.editable) !== null && _e !== void 0 ? _e : null,
+                    searchable: (_f = newPropertyType.searchable) !== null && _f !== void 0 ? _f : null,
+                    core: (_g = newPropertyType.core) !== null && _g !== void 0 ? _g : null,
+                    typePropertyOptionSetId: (_h = optionSetIdBySlug[newPropertyType.typePropertyOptionSetSlug]) !== null && _h !== void 0 ? _h : null,
+                    formula: (_j = newPropertyType.formula) !== null && _j !== void 0 ? _j : null,
+                    referencedTypePath: (_k = newPropertyType.referencedTypePath) !== null && _k !== void 0 ? _k : null,
+                    carryOverBehavior: (_l = newPropertyType.carryOverBehavior) !== null && _l !== void 0 ? _l : null,
+                    carryOverDefault: (_m = newPropertyType.carryOverDefault) !== null && _m !== void 0 ? _m : null,
+                    referencedTypeRootSlug: (_o = newPropertyType.referencedTypeRootSlug) !== null && _o !== void 0 ? _o : null,
+                    defaultValue: (_p = newPropertyType.defaultValue) !== null && _p !== void 0 ? _p : null,
+                    propertyLevel: (_q = newPropertyType.propertyLevel) !== null && _q !== void 0 ? _q : null,
+                    formulaFunction: (_r = newPropertyType.formulaFunction) !== null && _r !== void 0 ? _r : null,
+                    validationFunction: (_s = newPropertyType.validationFunction) !== null && _s !== void 0 ? _s : null,
+                    numberFormat: (_t = newPropertyType.numberFormat) !== null && _t !== void 0 ? _t : null,
+                    sequenceSeedValue: (_u = newPropertyType.sequenceSeedValue) !== null && _u !== void 0 ? _u : null,
+                };
+                // logger.debug(
+                //   `found type property option set: ${newPropertyType.typePropertyOptionSetSlug}, ${proposedTP.typePropertyOptionSetId}, `,
+                // );
+                const differences = extractValueDifferences(found, proposedTP, [
+                    'id',
+                    'createdOn',
+                    'updatedOn',
+                    'createdById',
+                    'updatedById',
+                    'orgId',
+                    'typePropertyUserListId',
+                    'referencedTypeRole',
+                    'referencedTypeFilterProperties',
+                    'referencedTypeId',
+                    'description',
+                    'apiDetails',
+                    'notes',
+                    'isFederationProperty',
+                    'required',
+                    'optionsSet',
+                    'options',
+                    'inherited',
+                    'used',
+                    'typePropertyPolicyIds',
+                ]);
+                if (differences.updates.length || differences.adds.length || differences.deletions.length) {
+                    logger_1.default.debug(`found differences: ${JSON.stringify(differences, null, 2)}`);
+                    logger_1.default.debug(`Updating Type-Property:  ${newPropertyType.slug}, ${found.id}, ${JSON.stringify(proposedTP, null, 2)}`);
+                    await new sdk_1.Entities().update({
+                        entityName: 'type-property',
+                        id: found.id,
+                        object: proposedTP,
+                    });
+                }
+                else {
+                    logger_1.default.debug(`Skipping empty update of type property ${newPropertyType.slug}`);
+                }
             }
         }
         catch (err) {
@@ -208,48 +271,33 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
         }
     }
 }
-function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByIdentifier) {
-    const reducedProperty1 = {
-        isArchived: typeProperty1.isArchived,
-        propertyType: typeProperty1.propertyType,
-        slug: typeProperty1.slug,
-        label: typeProperty1.label,
-        editable: typeProperty1.editable,
-        searchable: typeProperty1.searchable,
-        core: typeProperty1.core,
-        typePropertyOptionSetId: optionSetIdByIdentifier[typeProperty1.typePropertyOptionSetSlug],
-        formula: typeProperty1.formula,
-        referencedTypePath: typeProperty1.referencedTypePath,
-        referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
-        defaultValue: typeProperty1.defaultValue,
-        propertyLevel: typeProperty1.propertyLevel,
-        carryOverBehavior: typeProperty1.carryOverBehavior,
-        carryOverDefault: typeProperty1.carryOverDefault,
-        formulaFunction: typeProperty1.formulaFunction,
-        validationFunction: typeProperty1.validationFunction,
-        numberFormat: typeProperty1.numberFormat,
-        sequenceSeedValue: typeProperty1.sequenceSeedValue,
-    };
-    const reducedProperty2 = {
-        isArchived: typeProperty2.isArchived,
-        propertyType: typeProperty2.propertyType,
-        slug: typeProperty2.slug,
-        label: typeProperty2.label,
-        editable: typeProperty2.editable,
-        searchable: typeProperty2.searchable,
-        core: typeProperty2.core,
-        typePropertyOptionSetId: optionSetIdByIdentifier[typeProperty2.typePropertyOptionSetSlug],
-        formula: typeProperty2.formula,
-        referencedTypePath: typeProperty2.referencedTypePath,
-        referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
-        defaultValue: typeProperty2.defaultValue,
-        propertyLevel: typeProperty2.propertyLevel,
-        carryOverBehavior: typeProperty2.carryOverBehavior,
-        carryOverDefault: typeProperty2.carryOverDefault,
-        formulaFunction: typeProperty2.formulaFunction,
-        validationFunction: typeProperty2.validationFunction,
-        numberFormat: typeProperty2.numberFormat,
-        sequenceSeedValue: typeProperty2.sequenceSeedValue,
+/**
+ * compares the keys between different objects and returns the differences
+ * captures in adds, updates, and deletions. Object 1 is considered the
+ * original, and object 2 is considered the "edit".
+ *
+ * An add is a property that exists in object2 but not in 1. An edit
+ * is a property that exists in both object 1 and 2, but with different values.
+ * A deletion is a property in object 1 but not in object 2.
+ * @param object1 any object
+ * @param object2 any other object
+ */
+function extractValueDifferences(object1, object2, keysToIgnore) {
+    const updates = [];
+    const object1Keys = Object.keys(object1);
+    const object2keys = Object.keys(object2);
+    const adds = object2keys.filter((key) => !object1Keys.includes(key) && !keysToIgnore.includes(key));
+    const deletions = object1Keys.filter((key) => !object2keys.includes(key) && !keysToIgnore.includes(key));
+    const shared = object1Keys.filter((key) => object2keys.includes(key) && !keysToIgnore.includes(key));
+    for (const key of shared) {
+        if (!_.isEqual(object1[key], object2[key])) {
+            updates.push(key);
+        }
+    }
+    return {
+        adds,
+        updates,
+        deletions,
     };
-    return _.isEqual(reducedProperty1, reducedProperty2);
 }
+exports.extractValueDifferences = extractValueDifferences;

package/dist/helpers/types/type-uploader.spec.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const type_uploader_1 = require("./type-uploader");
+describe('extractValueDifferences', () => {
+    it('should return the correct value differences', () => {
+        const object1 = {
+            name: 'John',
+            age: 30,
+            city: 'New York',
+        };
+        const object2 = {
+            name: 'John',
+            age: 35,
+            city: 'Los Angeles',
+            country: 'USA',
+        };
+        const expectedValueDiff = {
+            adds: ['country'],
+            updates: ['age', 'city'],
+            deletions: [],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, []);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+    it('should handle empty objects', () => {
+        const object1 = {};
+        const object2 = {};
+        const expectedValueDiff = {
+            adds: [],
+            updates: [],
+            deletions: [],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, []);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+    it('should handle objects with no shared keys', () => {
+        const object1 = {
+            name: 'John',
+            age: 30,
+        };
+        const object2 = {
+            city: 'New York',
+            country: 'USA',
+        };
+        const expectedValueDiff = {
+            adds: ['city', 'country'],
+            updates: [],
+            deletions: ['name', 'age'],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, []);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+    it('should handle objects with shared keys but no differences', () => {
+        const object1 = {
+            name: 'John',
+            age: 30,
+        };
+        const object2 = {
+            name: 'John',
+            age: 30,
+        };
+        const expectedValueDiff = {
+            adds: [],
+            updates: [],
+            deletions: [],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, []);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+    it('should handle correctly ignore keys on deletion', () => {
+        const object1 = {
+            name: 'John',
+            age: 30,
+        };
+        const object2 = {
+            name: 'John',
+        };
+        const expectedValueDiff = {
+            adds: [],
+            updates: [],
+            deletions: [],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, ['age']);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+    it('should handle correctly ignore keys on updates', () => {
+        const object1 = {
+            name: 'John',
+            age: 30,
+        };
+        const object2 = {
+            name: 'John',
+            age: 15,
+        };
+        const expectedValueDiff = {
+            adds: [],
+            updates: [],
+            deletions: [],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, ['age']);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+    it('should handle correctly ignore keys on deletion', () => {
+        const object1 = {
+            name: 'John',
+        };
+        const object2 = {
+            name: 'John',
+            age: 30,
+        };
+        const expectedValueDiff = {
+            adds: [],
+            updates: [],
+            deletions: [],
+        };
+        const valueDiff = (0, type_uploader_1.extractValueDifferences)(object1, object2, ['age']);
+        expect(valueDiff).toEqual(expectedValueDiff);
+    });
+});

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.2.6",
+  "version": "2.2.8",
   "commands": {
     "app:create": {
       "id": "app:create",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/cli",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "VibeIQ's Contrail Platform CLI.",
   "bin": {
     "contrail-cli": "./bin/run",