@contrail/cli 3.3.5 → 3.3.6-alpha.0

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

@@ -4,9 +4,10 @@ export default class UploadTypes extends BaseCommand {
     static examples: string[];
     static flags: {
         dir: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        merge: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         alwaysConfirmEnv: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
         logLevel: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
     };
     run(): Promise<void>;
 }
-export declare function uploadTypes(dir: string): Promise<void>;
+export declare function uploadTypes(dir: string, isMerge: boolean): Promise<void>;

package/dist/commands/types/uploadTypes.js

@@ -18,13 +18,19 @@ class UploadTypes extends basecommand_1.BaseCommand {
             required: false,
             default: '.',
         }),
+        merge: core_1.Flags.boolean({
+            char: 'm',
+            description: 'Merge types and type properties without deleting missing ones. Only adds/updates those present in the source files.',
+            required: false,
+            default: false,
+        }),
     };
     async run() {
-        return await uploadTypes(this.flags.dir);
+        return await uploadTypes(this.flags.dir, this.flags.merge);
     }
 }
 exports.default = UploadTypes;
-async function uploadTypes(dir) {
-    await (0, type_uploader_1.uploadTypes)(dir);
+async function uploadTypes(dir, isMerge) {
+    await (0, type_uploader_1.uploadTypes)(dir, { isMerge });
 }
 exports.uploadTypes = uploadTypes;

package/dist/commands/types/uploadUsageInfo.js

@@ -103,6 +103,7 @@ async function uploadUsageInfoObjects(loadedUsageInfo) {
                         numberFormat: loadedUI.numberFormat,
                         defaultValue: loadedUI.defaultValue,
                         label: loadedUI.label,
+                        isArchived: loadedUI.isArchived,
                     },
                 });
             }
@@ -129,6 +130,7 @@ async function uploadUsageInfoObjects(loadedUsageInfo) {
                         copyBehavior: loadedUI?.copyBehavior,
                         copyDefault: loadedUI?.copyDefault,
                         propertyLevel: loadedUI?.propertyLevel,
+                        isArchived: loadedUI?.isArchived,
                     },
                 });
             }

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

@@ -1,4 +1,6 @@
-export declare function uploadTypes(dir: string): Promise<void>;
+export declare function uploadTypes(dir: string, options?: {
+    isMerge: boolean;
+}): Promise<void>;
 export interface ValueDiff {
     adds: any[];
     updates: any[];

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

@@ -10,12 +10,12 @@ const _ = tslib_1.__importStar(require("lodash"));
 const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
 const login_1 = require("../../auth/login");
 const logger_1 = tslib_1.__importDefault(require("../../logger"));
-async function uploadTypes(dir) {
+async function uploadTypes(dir, options = { isMerge: false }) {
     try {
         const userConfig = await (0, login_1.authUser)();
         logger_1.default.info(`START Getting all types for org ${userConfig.orgSlug}`);
         logger_1.default.info('TYPES Uploading ');
-        await uploadReducedTypes(dir);
+        await uploadReducedTypes(dir, options);
         logger_1.default.info(`${chalk_1.default.yellow.bold('TYPES')} Uploaded`);
     }
     catch (e) {
@@ -39,7 +39,7 @@ function loadReducedTypes(fromDir) {
         throw new Error(`ERROR PARSING YAML: ${e}`);
     }
 }
-async function uploadReducedTypes(dir) {
+async function uploadReducedTypes(dir, options) {
     const types = loadReducedTypes(dir);
     const currentTypesWithoutProperties = await new sdk_1.Entities().get({
         entityName: 'type',
@@ -88,15 +88,15 @@ async function uploadReducedTypes(dir) {
                 });
                 const newTypeProperties = (await new sdk_1.Types().getType({ id: createdType.id }))
                     .typeProperties;
-                await uploadReducedTypeProperties(createdType, newTypeProperties, type.typeProperties, optionSets);
+                await uploadReducedTypeProperties(createdType, newTypeProperties, type.typeProperties, optionSets, options);
             }
             else {
-                const proposedType = {
+                const proposedType = Object.fromEntries(Object.entries({
                     slug: type.slug,
                     label: type.label,
                     typePath: type.typePath,
                     isArchived: type.isArchived,
-                };
+                }).filter(([_, value]) => value !== undefined));
                 const differences = extractValueDifferences(found, proposedType, [
                     'id',
                     'createdOn',
@@ -116,7 +116,10 @@ async function uploadReducedTypes(dir) {
                     'typeInterfaces',
                 ]);
                 let updatedType = found;
-                if (differences.updates.length || differences.adds.length || differences.deletions.length) {
+                const hasChangesToSave = options.isMerge
+                    ? Boolean(differences.updates.length || differences.adds.length)
+                    : Boolean(differences.updates.length || differences.adds.length || differences.deletions.length);
+                if (hasChangesToSave) {
                     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({
@@ -128,7 +131,7 @@ async function uploadReducedTypes(dir) {
                 else {
                     logger_1.default.debug(`Skipping empty update of type ${type.typePath}`);
                 }
-                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties, optionSets);
+                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties, optionSets, options);
             }
         }
         catch (err) {
@@ -136,7 +139,7 @@ async function uploadReducedTypes(dir) {
         }
     }
 }
-async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes, optionSets) {
+async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes, optionSets, options) {
     const currentPropertyTypeBySlug = {};
     for (const currentPropertyType of currentPropertyTypes) {
         currentPropertyTypeBySlug[currentPropertyType.slug] = currentPropertyType;
@@ -201,40 +204,42 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
             // !typePropertiesEqual(found, newPropertyType, optionSetIdBySlug)
             ) {
                 // Skip platform-managed entities
-                if (newPropertyType.core) {
+                if (found.core || newPropertyType.core) {
                     logger_1.default.debug(`Skipping platform-managed property: ${newPropertyType.slug}`);
                     continue;
                 }
-                const proposedTP = {
-                    isArchived: newPropertyType.isArchived ?? null,
-                    propertyType: newPropertyType.propertyType ?? null,
-                    slug: newPropertyType.slug ?? null,
-                    label: newPropertyType.label ?? null,
-                    editable: newPropertyType.editable ?? null,
-                    searchable: newPropertyType.searchable ?? null,
-                    core: newPropertyType.core ?? null,
-                    typePropertyOptionSetId: optionSetIdBySlug[newPropertyType.typePropertyOptionSetSlug] ?? null,
-                    formula: newPropertyType.formula ?? null,
-                    referencedTypePath: newPropertyType.referencedTypePath ?? null,
-                    carryOverBehavior: newPropertyType.carryOverBehavior ?? null,
-                    carryOverDefault: newPropertyType.carryOverDefault ?? null,
-                    referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug ?? null,
-                    defaultValue: newPropertyType.defaultValue ?? null,
-                    propertyLevel: newPropertyType.propertyLevel ?? null,
+                const defaultValueForUndefinedEntries = options.isMerge ? undefined : null;
+                const defaultIfUndefined = (value) => value === undefined ? defaultValueForUndefinedEntries : value;
+                const proposedTypeProperty = Object.fromEntries(Object.entries({
+                    isArchived: defaultIfUndefined(newPropertyType.isArchived),
+                    propertyType: defaultIfUndefined(newPropertyType.propertyType),
+                    slug: defaultIfUndefined(newPropertyType.slug),
+                    label: defaultIfUndefined(newPropertyType.label),
+                    editable: defaultIfUndefined(newPropertyType.editable),
+                    searchable: defaultIfUndefined(newPropertyType.searchable),
+                    core: defaultIfUndefined(newPropertyType.core),
+                    typePropertyOptionSetId: defaultIfUndefined(optionSetIdBySlug[newPropertyType.typePropertyOptionSetSlug]),
+                    formula: defaultIfUndefined(newPropertyType.formula),
+                    referencedTypePath: defaultIfUndefined(newPropertyType.referencedTypePath),
+                    carryOverBehavior: defaultIfUndefined(newPropertyType.carryOverBehavior),
+                    carryOverDefault: defaultIfUndefined(newPropertyType.carryOverDefault),
+                    referencedTypeRootSlug: defaultIfUndefined(newPropertyType.referencedTypeRootSlug),
+                    defaultValue: defaultIfUndefined(newPropertyType.defaultValue),
+                    propertyLevel: defaultIfUndefined(newPropertyType.propertyLevel),
                     typePropertyUserListId,
-                    referencedTypeRole: newPropertyType.referencedTypeRole ?? null,
-                    isUniqueProperty: newPropertyType.isUniqueProperty ?? null,
-                    isUniquePropertyInFamily: newPropertyType.isUniquePropertyInFamily ?? null,
-                    formulaFunction: newPropertyType.formulaFunction ?? null,
-                    validationFunction: newPropertyType.validationFunction ?? null,
-                    numberFormat: newPropertyType.numberFormat ?? null,
-                    sequenceSeedValue: newPropertyType.sequenceSeedValue ?? null,
-                    copyBehavior: newPropertyType.copyBehavior ?? null,
-                };
+                    referencedTypeRole: defaultIfUndefined(newPropertyType.referencedTypeRole),
+                    isUniqueProperty: defaultIfUndefined(newPropertyType.isUniqueProperty),
+                    isUniquePropertyInFamily: defaultIfUndefined(newPropertyType.isUniquePropertyInFamily),
+                    formulaFunction: defaultIfUndefined(newPropertyType.formulaFunction),
+                    validationFunction: defaultIfUndefined(newPropertyType.validationFunction),
+                    numberFormat: defaultIfUndefined(newPropertyType.numberFormat),
+                    sequenceSeedValue: defaultIfUndefined(newPropertyType.sequenceSeedValue),
+                    copyBehavior: defaultIfUndefined(newPropertyType.copyBehavior),
+                }).filter(([_, value]) => value !== undefined));
                 // logger.debug(
                 //   `found type property option set: ${newPropertyType.typePropertyOptionSetSlug}, ${proposedTP.typePropertyOptionSetId}, `,
                 // );
-                const differences = extractValueDifferences(found, proposedTP, [
+                const differences = extractValueDifferences(found, proposedTypeProperty, [
                     'id',
                     'createdOn',
                     'updatedOn',
@@ -256,13 +261,16 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
                     'used',
                     'typePropertyPolicyIds',
                 ]);
-                if (differences.updates.length || differences.adds.length || differences.deletions.length) {
+                const hasChangesToSave = options.isMerge
+                    ? Boolean(differences.updates.length || differences.adds.length)
+                    : Boolean(differences.updates.length || differences.adds.length || differences.deletions.length);
+                if (hasChangesToSave) {
                     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)}`);
+                    logger_1.default.debug(`Updating Type-Property:  ${newPropertyType.slug}, ${found.id}, ${JSON.stringify(proposedTypeProperty, null, 2)}`);
                     await new sdk_1.Entities().update({
                         entityName: 'type-property',
                         id: found.id,
-                        object: proposedTP,
+                        object: proposedTypeProperty,
                     });
                 }
                 else {
@@ -274,6 +282,9 @@ async function uploadReducedTypeProperties(type, currentPropertyTypes, newProper
             logger_1.default.info(`Error Creating Properties: ${err}`);
         }
     }
+    if (options.isMerge) {
+        return;
+    }
     for (const currentPropertyType of currentPropertyTypes) {
         try {
             const found = newPropertyTypesBySlug[currentPropertyType.slug];