mcdev 7.6.3 → 7.7.1

package/lib/index.js

@@ -93,6 +93,7 @@ class Mcdev {
             'errorLog',
             'execute',
             'filter',
+            'fix',
             'fixShared',
             'format',
             'fromRetrieve',
@@ -107,6 +108,8 @@ class Mcdev {
             'noUpdate',
             'autoMidSuffix',
             'publish',
+            'purge',
+            'range',
             'referenceFrom',
             'referenceTo',
             'refresh',
@@ -144,8 +147,8 @@ class Mcdev {
      * handler for 'mcdev createDeltaPkg
      *
      * @param {object} argv yargs parameters
-     * @param {string} [argv.range] git commit range
-    into deploy directory
+     * @param {string} [argv.commitrange] git commit range via positional
+     * @param {string} [argv.range] git commit range via option
      * @param {string} [argv.filter] filter file paths that start with any
      * @param {number} [argv.commitHistory] filter file paths that start with any
      * @param {DeltaPkgItem[]} [argv.diffArr] list of files to include in delta package (skips git diff when provided)
@@ -155,18 +158,23 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('Create Delta Package ::');
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
-
+        if (argv.commitrange) {
+            Util.logger.warn(
+                `Depecation Notice: Please start using --range to define the commit range or target branch. The positional argument will be removed in the next major release.`
+            );
+        }
+        const range = argv.commitrange || Util.OPTIONS.range;
         try {
             return await (argv.filter
                 ? // get source market and source BU from config
-                  DevOps.getDeltaList(properties, argv.range, true, argv.filter, argv.commitHistory)
+                  DevOps.getDeltaList(properties, range, true, argv.filter, argv.commitHistory)
                 : // If no custom filter was provided, use deployment marketLists & templating
                   DevOps.buildDeltaDefinitions(
                       properties,
-                      argv.range,
+                      range,
                       argv.diffArr,
                       argv.commitHistory
                   ));
@@ -181,9 +189,10 @@ class Mcdev {
     static async selectTypes() {
         Util.startLogger();
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         await Cli.selectTypes(properties);
     }
 
@@ -199,11 +208,11 @@ class Mcdev {
      */
     static async upgrade() {
         Util.startLogger();
-        const properties = await config.getProperties();
+        const properties = await config.getProperties(false, true);
         if (!properties) {
-            Util.logger.error('No config found. Please run mcdev init');
-            return false;
+            return;
         }
+
         if ((await InitGit.initGitRepo()).status === 'error') {
             return false;
         }
@@ -221,9 +230,7 @@ class Mcdev {
         }
         Util.OPTIONS._welcomeMessageShown = true;
 
-        const color = Util.isRunViaVSCodeExtension
-            ? { reset: '', bgWhite: '', fgBlue: '' }
-            : Util.color;
+        const color = Util.color;
         /* eslint-disable no-console */
         if (process.env['USERDNSDOMAIN'] === 'DIR.SVC.ACCENTURE.COM') {
             // Accenture internal message
@@ -262,9 +269,8 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: Retrieve');
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            // return null here to avoid seeing 2 error messages for the same issue
-            return null;
+        if (!properties) {
+            return;
         }
 
         // assume a list was passed in and check each entry's validity
@@ -390,9 +396,10 @@ class Mcdev {
         selectedTypesArr = structuredClone(selectedTypesArr);
 
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         const buObject = await Cli.getCredentialObject(
             properties,
             cred === null ? null : cred + '/' + bu,
@@ -551,9 +558,10 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: Load BUs');
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         const buObject = await Cli.getCredentialObject(properties, credentialsName, true);
         if (buObject !== null) {
             BuHelper.refreshBUProperties(properties, buObject.credential);
@@ -571,9 +579,10 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: Document');
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         if (type && !MetadataTypeInfo[type]) {
             Util.logger.error(`:: '${type}' is not a valid metadata type`);
             return;
@@ -632,9 +641,10 @@ class Mcdev {
             }
         }
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
         if (!buObject) {
             return;
@@ -656,6 +666,9 @@ class Mcdev {
             MetadataTypeInfo[type].client = client;
             MetadataTypeInfo[type].properties = properties;
             MetadataTypeInfo[type].buObject = buObject;
+
+            await MetadataTypeInfo[type].preDeleteTasks(keyArr);
+
             const deleteLimit = pLimit(20);
 
             await Promise.allSettled(
@@ -700,9 +713,10 @@ class Mcdev {
             return;
         }
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
         if (buObject !== null) {
             try {
@@ -749,9 +763,10 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: describe SOAP');
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         const credential = Object.keys(properties.credentials)[0];
         businessUnit ||=
             credential + '/' + Object.keys(properties.credentials[credential].businessUnits)[0];
@@ -796,9 +811,10 @@ class Mcdev {
     static async badKeys(businessUnit) {
         Util.startLogger();
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
         if (buObject !== null) {
             Util.logger.info('Gathering list of Name<>External Key mismatches (bad keys)');
@@ -873,9 +889,10 @@ class Mcdev {
             'mcdev:: [DEPRECATED] Retrieve as Template [DEPRECATED] - use "retrieve" + "buildTemplate" instead'
         );
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
+
         if (!Util._isValidType(selectedType)) {
             return;
         }
@@ -904,15 +921,19 @@ class Mcdev {
 
     /**
      * @param {string} businessUnit references credentials from properties.json
-     * @param {TypeKeyCombo} selectedTypes limit retrieval to given metadata type
+     * @param {TypeKeyCombo} typeKeyList limit retrieval to given metadata type
      * @returns {Promise.<TypeKeyCombo>} selected types including dependencies
      */
-    static async addDependentCbReferences(businessUnit, selectedTypes) {
+    static async addDependentCbReferences(businessUnit, typeKeyList) {
         if (!Util.OPTIONS.dependencies) {
             return;
         }
-        const initialAssetNumber = selectedTypes['asset']?.length || 0;
+        const initialAssetNumber = typeKeyList['asset']?.length || 0;
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
+
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
         Util.logger.info(
             'Searching for additional dependencies that were linked via ContentBlockByKey, ContentBlockByName and ContentBlockById'
@@ -936,7 +957,7 @@ class Mcdev {
             ])
         );
         // check all non-asset types for dependencies
-        for (const depType in selectedTypes) {
+        for (const depType in typeKeyList) {
             if (
                 !Object.prototype.hasOwnProperty.call(
                     MetadataTypeInfo[depType],
@@ -949,7 +970,7 @@ class Mcdev {
             MetadataTypeInfo[depType].properties = properties;
             MetadataTypeInfo[depType].buObject = buObject;
             await MetadataTypeInfo[depType].getCbReferenceKeys(
-                selectedTypes[depType],
+                typeKeyList[depType],
                 retrieveDir,
                 assetDependencies
             );
@@ -957,26 +978,26 @@ class Mcdev {
         // add dependencies to selectedTypes
         if (assetDependencies.size) {
             const depType = 'asset';
-            if (selectedTypes[depType]) {
-                selectedTypes[depType].push(...assetDependencies);
+            if (typeKeyList[depType]) {
+                typeKeyList[depType].push(...assetDependencies);
             } else {
-                selectedTypes[depType] = [...assetDependencies];
+                typeKeyList[depType] = [...assetDependencies];
             }
             // remove duplicates in main object after adding dependencies
-            selectedTypes[depType] = [...new Set(selectedTypes[depType])];
+            typeKeyList[depType] = [...new Set(typeKeyList[depType])];
         }
 
         // check all assets for dependencies recursively
-        if (selectedTypes.asset?.length) {
+        if (typeKeyList.asset?.length) {
             const depType = 'asset';
             const Asset = MetadataTypeInfo[depType];
             Asset.properties = properties;
             Asset.buObject = buObject;
             const additionalAssetDependencies = [
                 ...(await Asset.getCbReferenceKeys(
-                    selectedTypes[depType],
+                    typeKeyList[depType],
                     retrieveDir,
-                    new Set(selectedTypes[depType])
+                    new Set(typeKeyList[depType])
                 )),
             ];
             if (additionalAssetDependencies.length) {
@@ -988,19 +1009,19 @@ class Mcdev {
             Asset.getJsonFromFSCache = null;
 
             // remove duplicates in main object after adding dependencies
-            selectedTypes[depType] = [...new Set(selectedTypes[depType])];
+            typeKeyList[depType] = [...new Set(typeKeyList[depType])];
         }
 
-        return selectedTypes;
+        return typeKeyList;
     }
 
     /**
      *
      * @param {string} businessUnit references credentials from properties.json
-     * @param {TypeKeyCombo} selectedTypes limit retrieval to given metadata type
+     * @param {TypeKeyCombo} typeKeyList limit retrieval to given metadata type
      * @returns {Promise.<TypeKeyCombo>} dependencies
      */
-    static async addDependencies(businessUnit, selectedTypes) {
+    static async addDependencies(businessUnit, typeKeyList) {
         if (!Util.OPTIONS.dependencies) {
             return;
         }
@@ -1018,15 +1039,18 @@ class Mcdev {
         const dependencies = {};
         /** @type {TypeKeyCombo} */
         const notFoundList = {};
-        const initiallySelectedTypesArr = Object.keys(selectedTypes);
+        const initiallySelectedTypesArr = Object.keys(typeKeyList);
 
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
         const buObject = await Cli.getCredentialObject(properties, businessUnit);
         for (const type of initiallySelectedTypesArr) {
             MetadataTypeInfo[type].properties = properties;
             MetadataTypeInfo[type].buObject = buObject;
             await MetadataTypeInfo[type].getDependentFiles(
-                selectedTypes[type],
+                typeKeyList[type],
                 dependencies,
                 notFoundList,
                 true
@@ -1057,18 +1081,36 @@ class Mcdev {
                 `Found ${Util.getTypeKeyCount(dependencies)} items across ${Object.keys(dependencies).length} types.`
             );
             for (const type in dependencies) {
-                if (selectedTypes[type]) {
-                    selectedTypes[type].push(...dependencies[type]);
+                if (typeKeyList[type]) {
+                    typeKeyList[type].push(...dependencies[type]);
                 } else {
-                    selectedTypes[type] = dependencies[type];
+                    typeKeyList[type] = dependencies[type];
                 }
                 // remove duplicates in main object after adding dependencies
-                selectedTypes[type] = [...new Set(selectedTypes[type])];
+                typeKeyList[type] = [...new Set(typeKeyList[type])];
             }
         }
         return dependencies;
     }
 
+    /**
+     * Build a template based on a list of metadata files in the retrieve folder.
+     *
+     * @param {string} businessUnitTemplate references credentials from properties.json
+     * @param {string} businessUnitDefinition references credentials from properties.json
+     * @param {TypeKeyCombo} typeKeyCombo limit retrieval to given metadata type
+     * @returns {Promise.<MultiMetadataTypeList | object>} response from buildDefinition
+     */
+    static async clone(businessUnitTemplate, businessUnitDefinition, typeKeyCombo) {
+        return this.build(
+            businessUnitTemplate,
+            businessUnitDefinition,
+            typeKeyCombo,
+            ['__clone__'],
+            ['__clone__']
+        );
+    }
+
     /**
      * Build a template based on a list of metadata files in the retrieve folder.
      *
@@ -1107,29 +1149,45 @@ class Mcdev {
             }
         }
 
+        // redirect templates to temporary folder when executed via build()
+        const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
+        const templateDirBackup = properties.directories.template;
+        properties.directories.template = '.mcdev/template/';
+
         Util.logger.info('mcdev:: Build Template & Build Definition');
         await this.buildTemplate(businessUnitTemplate, typeKeyCombo, null, marketTemplate);
 
-        let isPurgeDeployFolder;
-        if (!Util.skipInteraction && !bulk) {
-            const properties = await config.getProperties();
+        if (typeof Util.OPTIONS.purge !== 'boolean') {
             // deploy folder is in targets for definition creation
             // recommend to purge their content first
-            isPurgeDeployFolder = await confirm({
-                message: `Do you want to empty the folder /${properties.directories.deploy}${businessUnitDefinition} (ensures no files from previous deployments remain)?`,
+            Util.OPTIONS.purge = await confirm({
+                message: `Do you want to empty relevant BU sub-folders in /${properties.directories.deploy} (ensures no files from previous deployments remain)?`,
                 default: true,
             });
         }
 
-        return bulk
-            ? this.buildDefinitionBulk(marketDefinition[0], typeKeyCombo, null)
-            : this.buildDefinition(
+        const response = bulk
+            ? await this.buildDefinitionBulk(marketDefinition[0], typeKeyCombo, null)
+            : await this.buildDefinition(
                   businessUnitDefinition,
                   typeKeyCombo,
                   null,
-                  marketDefinition,
-                  isPurgeDeployFolder
+                  marketDefinition
               );
+
+        // reset temporary template folder
+        try {
+            await File.remove(properties.directories.template);
+        } catch {
+            // sometimes the first attempt is not successful for some operating system reason. Trying again mostly solves this
+            await File.remove(properties.directories.template);
+        }
+        properties.directories.template = templateDirBackup;
+
+        return response;
     }
 
     /**
@@ -1147,30 +1205,25 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: Build Template from retrieved files');
         const properties = await config.getProperties();
-        const buObject = await Cli.getCredentialObject(properties, businessUnit);
-        for (const market of marketArr) {
-            if (!Util.checkMarket(market, properties)) {
-                return;
-            }
+        if (!properties) {
+            return;
         }
-        if ('string' === typeof selectedTypes) {
-            // ensure we have TypeKeyCombo here
-            selectedTypes = Util.createTypeKeyCombo(selectedTypes, keyArr);
+        const buObject = await Cli.getCredentialObject(properties, businessUnit);
+        if (!Util.checkMarketList(marketArr, properties)) {
+            return;
         }
-        // check if types are valid
-        for (const type of Object.keys(selectedTypes)) {
-            if (!Util._isValidType(type)) {
-                return;
-            }
-            if (!Array.isArray(selectedTypes[type])) {
-                Util.logger.error('You need to define keys, not just types to run buildTemplate');
-                // we need an array of keys here
-                return;
-            }
+
+        const typeKeyList = Util.checkAndPrepareTypeKeyCombo(
+            selectedTypes,
+            keyArr,
+            'buildTemplate'
+        );
+        if (!typeKeyList) {
+            return;
         }
 
         if (!Util.OPTIONS.dependencies) {
-            await this._reRetrieve(businessUnit, false, selectedTypes);
+            await this._reRetrieve(businessUnit, false, typeKeyList);
         }
         // convert names to keys
         const retrieveDir = File.normalizePath([
@@ -1178,14 +1231,14 @@ class Mcdev {
             buObject.credential,
             buObject.businessUnit,
         ]);
-        for (const type of Object.keys(selectedTypes)) {
-            const keyArr = selectedTypes[type];
+        for (const type of Object.keys(typeKeyList)) {
+            const keyArr = typeKeyList[type];
             if (keyArr.some((key) => key.startsWith('name:'))) {
                 // at least one key was provided as a name -> load all files from disk to try and find that key
                 const builTemplateCache = Object.values(
                     await MetadataTypeInfo[type].getJsonFromFS(retrieveDir + path.sep + type)
                 );
-                selectedTypes[type] = keyArr
+                typeKeyList[type] = keyArr
                     .map((key) => {
                         if (key.startsWith('name:')) {
                             // key was defined by name. try and find matching item on disk
@@ -1220,16 +1273,19 @@ class Mcdev {
         }
 
         // if dependencies are enabled, we need to search for them and add them to our
-        await this.addDependencies(businessUnit, selectedTypes);
-        await this.addDependentCbReferences(businessUnit, selectedTypes);
+        await this.addDependencies(businessUnit, typeKeyList);
+        await this.addDependentCbReferences(businessUnit, typeKeyList);
 
         /** @type {MultiMetadataTypeList} */
         const returnObj = {};
-        for (const type of Object.keys(selectedTypes)) {
+        for (const type of Object.keys(typeKeyList)) {
+            // ensure keys are sorted again, after finding dependencies, to enhance log readability
+            typeKeyList[type].sort();
+
             const result = await Builder.buildTemplate(
                 businessUnit,
                 type,
-                selectedTypes[type],
+                typeKeyList[type],
                 marketArr
             );
             returnObj[type] = result[type];
@@ -1271,61 +1327,42 @@ class Mcdev {
      * @param {string | TypeKeyCombo} selectedTypes limit retrieval to given metadata type
      * @param {string[] | undefined} nameArr name of the metadata
      * @param {string[]} marketArr market localizations
-     * @param {boolean} [isPurgeDeployFolder] whether to purge the deploy folder
      * @returns {Promise.<MultiMetadataTypeList>} -
      */
-    static async buildDefinition(
-        businessUnit,
-        selectedTypes,
-        nameArr,
-        marketArr,
-        isPurgeDeployFolder
-    ) {
+    static async buildDefinition(businessUnit, selectedTypes, nameArr, marketArr) {
         this.#welcomeMessage();
 
         Util.startLogger();
         Util.logger.info('mcdev:: Build Definition from Template');
         const properties = await config.getProperties();
-        for (const market of marketArr) {
-            if (!Util.checkMarket(market, properties)) {
-                return;
-            }
+        if (!properties) {
+            return;
         }
-        if ('string' === typeof selectedTypes) {
-            // ensure we have TypeKeyCombo here
-            selectedTypes = Util.createTypeKeyCombo(selectedTypes, nameArr);
+        if (!Util.checkMarketList(marketArr, properties)) {
+            return;
         }
-
-        // check if types are valid
-        for (const type of Object.keys(selectedTypes)) {
-            if (!Util._isValidType(type)) {
-                return;
-            }
-            if (!Array.isArray(selectedTypes[type])) {
-                Util.logger.error('You need to define keys, not just types to run buildDefinition');
-                // we need an array of keys here
-                return;
-            }
+        const typeKeyList = Util.checkAndPrepareTypeKeyCombo(
+            selectedTypes,
+            nameArr,
+            'buildDefinition'
+        );
+        if (!typeKeyList) {
+            return;
         }
-        // standard deploy folder
-        const buObject = await Cli.getCredentialObject(properties, businessUnit);
-        const deployDir = File.normalizePath([
-            properties.directories.deploy,
-            buObject.credential,
-            buObject.businessUnit,
-        ]);
-        if (isPurgeDeployFolder) {
-            // Clear output folder structure for selected sub-type
-            // only run this if the standard deploy folder is a target of buildDefinition (which technically could be changed)
-            await File.remove(deployDir);
+
+        if (Util.OPTIONS.purge) {
+            const buObject = await Cli.getCredentialObject(properties, businessUnit);
+            await Builder.purgeDeployFolder(buObject.credential + '/' + buObject.businessUnit);
+        } else {
+            Util.logger.info(` ☇ skipping purge of folder`);
         }
         /** @type {MultiMetadataTypeList} */
         const returnObj = {};
-        for (const type of Object.keys(selectedTypes)) {
+        for (const type of Object.keys(typeKeyList)) {
             const result = await Builder.buildDefinition(
                 businessUnit,
                 type,
-                selectedTypes[type],
+                typeKeyList[type],
                 marketArr
             );
             returnObj[type] = result[type];
@@ -1347,37 +1384,36 @@ class Mcdev {
 
         Util.startLogger();
         Util.logger.info('mcdev:: Build Definition from Template Bulk');
-        let selectedTypesArr;
-        if ('string' === typeof selectedTypes) {
-            selectedTypesArr = [selectedTypes];
+
+        const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
+        try {
+            Util.verifyMarketList(listName, properties);
+        } catch (ex) {
+            Util.logger.error(ex.message);
+            return;
+        }
+        const typeKeyList = Util.checkAndPrepareTypeKeyCombo(
+            selectedTypes,
+            nameArr,
+            'buildDefinitionBulk'
+        );
+        if (!typeKeyList) {
+            return;
+        }
+        if (Util.OPTIONS.purge) {
+            await Builder.purgeDeployFolderList(listName);
         } else {
-            selectedTypesArr = Object.keys(selectedTypes);
-            // check if types are valid
-            for (const selectedType of selectedTypesArr) {
-                if (!Util._isValidType(selectedType)) {
-                    return;
-                }
-                if (!Array.isArray(selectedTypes[selectedType])) {
-                    Util.logger.error(
-                        'You need to define keys, not just types to run buildDefinitionBulk'
-                    );
-                    // we need an array of keys here
-                    return;
-                }
-            }
+            Util.logger.info(` ☇ skipping purge of folder`);
         }
         /** @type {MultiMetadataTypeList} */
         const returnObj = {};
-        for (const selectedType of selectedTypesArr) {
-            if (selectedTypesArr.length > 1) {
-                Util.logger.info(Util.getGrayMsg(`buildDefinitionBulk for ${selectedType}`));
-            }
-            const result = await Builder.buildDefinitionBulk(
-                listName,
-                selectedType,
-                'string' === typeof selectedTypes ? nameArr : selectedTypes[selectedType]
-            );
-            returnObj[selectedType] = result;
+        for (const type of Object.keys(typeKeyList)) {
+            Util.logger.info(Util.getGrayMsg(`buildDefinitionBulk for ${type}`));
+            const result = await Builder.buildDefinitionBulk(listName, type, typeKeyList[type]);
+            returnObj[type] = result;
         }
         Util.logger.info('Done');
         return returnObj;
@@ -1394,8 +1430,8 @@ class Mcdev {
         Util.startLogger();
         Util.logger.info('mcdev:: getFilesToCommit');
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            return null;
+        if (!properties) {
+            return;
         }
         if (!Util._isValidType(selectedType)) {
             return;
@@ -1527,7 +1563,10 @@ class Mcdev {
         this.setOptions({ referenceFrom, referenceTo });
 
         const properties = await config.getProperties();
-        if (!Util._isValidBU(properties, businessUnit)) {
+        if (!properties) {
+            return;
+        }
+        if (!Util.isValidBU(properties, businessUnit)) {
             return;
         }
 
@@ -1584,6 +1623,9 @@ class Mcdev {
      */
     static async fixKeys(businessUnit, selectedTypes, keys) {
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
         // make sure validation rules dont keep us from fixing the keys
         this.setOptions({ skipValidation: true });
         let reRetrieveAll = false;
@@ -1785,9 +1827,8 @@ class Mcdev {
             return resultObj;
         }
         const properties = await config.getProperties();
-        if (!(await config.checkProperties(properties))) {
-            // return null here to avoid seeing 2 error messages for the same issue
-            return resultObj;
+        if (!properties) {
+            return;
         }
         for (const selectedType of selectedTypesArr || Object.keys(selectedTypesObj)) {
             Util.logger.info(`mcdev:: ${methodName} ${selectedType}`);
@@ -1912,6 +1953,9 @@ class Mcdev {
      */
     static async #runOnBU(methodName, cred, bu, type, keyArr) {
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
         const resultArr = [];
         const buObject = await Cli.getCredentialObject(
             properties,
@@ -1971,6 +2015,9 @@ class Mcdev {
      */
     static async #retrieveKeysWithLike(selectedType, buObject) {
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
 
         // cache depenencies
         const deployOrder = Util.getMetadataHierachy([selectedType]);
@@ -2038,6 +2085,9 @@ class Mcdev {
      */
     static async #fixKeys(cred, bu, type, keyArr) {
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
         let actuallyFixedKeys = [];
         const resultArr = [];
 
@@ -2121,6 +2171,9 @@ class Mcdev {
      */
     static async #replaceCbReference(cred, bu, type, keyArr) {
         const properties = await config.getProperties();
+        if (!properties) {
+            return;
+        }
         let updatedKeys = [];
         const resultArr = [];