mcdev 5.1.0 → 5.3.0

package/lib/index.js

@@ -51,15 +51,21 @@ class Mcdev {
     static setOptions(argv) {
         const knownOptions = [
             'api',
-            'commitHistory',
             'changeKeyField',
             'changeKeyValue',
+            'commitHistory',
+            'execute',
             'filter',
+            'fixShared',
             'fromRetrieve',
             'json',
+            'like',
+            'noLogColors',
+            'noLogFile',
             'refresh',
+            '_runningTest',
+            'schedule',
             'skipInteraction',
-            'noLogFile',
         ];
         for (const option of knownOptions) {
             if (argv[option] !== undefined) {
@@ -153,6 +159,7 @@ class Mcdev {
      * @returns {Promise.<object>} -
      */
     static async retrieve(businessUnit, selectedTypesArr, keys, changelogOnly) {
+        console.time('Time'); // eslint-disable-line no-console
         Util.startLogger();
         Util.logger.info('mcdev:: Retrieve');
         const properties = await config.getProperties();
@@ -171,22 +178,32 @@ class Mcdev {
                 }
             }
         }
-
+        const resultsObj = {};
         if (businessUnit === '*') {
-            Util.logger.info('\n               :: Retrieving all BUs for all credentials');
+            Util.logger.info(':: Retrieving all BUs for all credentials');
             let counter_credTotal = 0;
             for (const cred in properties.credentials) {
-                Util.logger.info(`\n               :: Retrieving all BUs for ${cred}`);
+                Util.logger.info(`:: Retrieving all BUs for ${cred}`);
                 let counter_credBu = 0;
                 for (const bu in properties.credentials[cred].businessUnits) {
-                    await this._retrieveBU(cred, bu, selectedTypesArr, keys);
+                    resultsObj[`${cred}/${bu}`] = await this.#retrieveBU(
+                        cred,
+                        bu,
+                        selectedTypesArr,
+                        keys
+                    );
                     counter_credBu++;
                     Util.startLogger(true);
                 }
                 counter_credTotal += counter_credBu;
-                Util.logger.info(`\n               :: ${counter_credBu} BUs for ${cred}\n`);
+                Util.logger.info(`:: ${counter_credBu} BUs of ${cred}\n`);
             }
-            Util.logger.info(`\n               :: ${counter_credTotal} BUs in total\n`);
+            const credentialCount = Object.keys(properties.credentials).length;
+            Util.logger.info(
+                `:: Done for ${counter_credTotal} BUs of ${credentialCount} credential${
+                    credentialCount === 1 ? '' : 's'
+                } in total\n`
+            );
         } else {
             let [cred, bu] = businessUnit ? businessUnit.split('/') : [null, null];
             // to allow all-BU via user selection we need to run this here already
@@ -210,17 +227,22 @@ class Mcdev {
             }
 
             if (bu === '*' && properties.credentials && properties.credentials[cred]) {
-                Util.logger.info(`\n               :: Retrieving all BUs for ${cred}`);
+                Util.logger.info(`:: Retrieving all BUs for ${cred}`);
                 let counter_credBu = 0;
                 for (const bu in properties.credentials[cred].businessUnits) {
-                    await this._retrieveBU(cred, bu, selectedTypesArr, keys);
+                    resultsObj[`${cred}/${bu}`] = await this.#retrieveBU(
+                        cred,
+                        bu,
+                        selectedTypesArr,
+                        keys
+                    );
                     counter_credBu++;
                     Util.startLogger(true);
                 }
-                Util.logger.info(`\n               :: ${counter_credBu} BUs for ${cred}\n`);
+                Util.logger.info(`:: Done for ${counter_credBu} BUs of ${cred}\n`);
             } else {
                 // retrieve a single BU; return
-                const retrieveChangelog = await this._retrieveBU(
+                const retrieveChangelog = await this.#retrieveBU(
                     cred,
                     bu,
                     selectedTypesArr,
@@ -228,14 +250,33 @@ class Mcdev {
                     changelogOnly
                 );
                 if (changelogOnly) {
+                    console.timeEnd('Time'); // eslint-disable-line no-console
                     return retrieveChangelog;
+                } else {
+                    resultsObj[`${cred}/${bu}`] = retrieveChangelog;
                 }
                 Util.logger.info(`:: Done\n`);
             }
         }
+
+        // merge all results into one object
+        for (const credBu in resultsObj) {
+            for (const type in resultsObj[credBu]) {
+                const base = resultsObj[credBu][type][0];
+
+                for (let i = 1; i < resultsObj[credBu][type].length; i++) {
+                    // merge all items into the first array
+                    Object.assign(base, resultsObj[credBu][type][i]);
+                }
+                resultsObj[credBu][type] = resultsObj[credBu][type][0];
+            }
+        }
+        console.timeEnd('Time'); // eslint-disable-line no-console
+
+        return resultsObj;
     }
     /**
-     * helper for {@link retrieve}
+     * helper for {@link Mcdev.retrieve}
      *
      * @private
      * @param {string} cred name of Credential
@@ -245,7 +286,7 @@ class Mcdev {
      * @param {boolean} [changelogOnly] skip saving, only create json in memory
      * @returns {Promise.<object>} ensure that BUs are worked on sequentially
      */
-    static async _retrieveBU(cred, bu, selectedTypesArr, keys, changelogOnly) {
+    static async #retrieveBU(cred, bu, selectedTypesArr, keys, changelogOnly) {
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
@@ -263,6 +304,7 @@ class Mcdev {
             // clean up old folders after types were renamed
             // TODO: Remove renamedTypes-logic 6 months after version 5 release
             const renamedTypes = {
+                attributeSet: 'setDefinition',
                 emailSend: 'emailSendDefinition',
                 event: 'eventDefinition',
                 fileLocation: 'ftpLocation',
@@ -270,7 +312,8 @@ class Mcdev {
                 triggeredSend: 'triggeredSendDefinition',
                 user: 'accountUser',
             };
-            Util.logger.info(`\n               :: Retrieving ${cred}/${bu}\n`);
+            Util.logger.info('');
+            Util.logger.info(`:: Retrieving ${cred}/${bu}`);
             const retrieveTypesArr = [];
             if (selectedTypesArr) {
                 for (const selectedType of Array.isArray(selectedTypesArr)
@@ -337,9 +380,7 @@ class Mcdev {
                     null,
                     changelogOnly
                 );
-                if (changelogOnly) {
-                    return retrieveChangelog;
-                }
+                return retrieveChangelog;
             } catch (ex) {
                 Util.logger.errorStack(ex, 'mcdev.retrieve failed');
             }
@@ -352,12 +393,14 @@ class Mcdev {
      * @param {string} businessUnit references credentials from properties.json
      * @param {TYPE.SupportedMetadataTypes[]} [selectedTypesArr] limit deployment to given metadata type
      * @param {string[]} [keyArr] limit deployment to given metadata keys
-     * @param {boolean} [fromRetrieve] optionally deploy whats defined via selectedTypesArr + keyArr directly from retrieve folder instead of from deploy folder
      * @returns {Promise.<Object.<string,TYPE.MultiMetadataTypeMap>>} deployed metadata per BU (first key: bu name, second key: metadata type)
      */
-    static async deploy(businessUnit, selectedTypesArr, keyArr, fromRetrieve = false) {
+    static async deploy(businessUnit, selectedTypesArr, keyArr) {
+        console.time('Time'); // eslint-disable-line no-console
         Util.startLogger();
-        return Deployer.deploy(businessUnit, selectedTypesArr, keyArr, fromRetrieve);
+        const deployResult = await Deployer.deploy(businessUnit, selectedTypesArr, keyArr);
+        console.timeEnd('Time'); // eslint-disable-line no-console
+        return deployResult;
     }
 
     /**
@@ -701,56 +744,159 @@ class Mcdev {
         }
     }
     /**
-     * Start an item (query)
+     * Schedule an item (shortcut for execute --schedule)
+     *
+     * @param {string} businessUnit name of BU
+     * @param {TYPE.SupportedMetadataTypes} [selectedType] limit to given metadata types
+     * @param {string[]} [keys] customerkey of the metadata
+     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of scheduled item keys
+     */
+    static async schedule(businessUnit, selectedType, keys) {
+        this.setOptions({ schedule: true });
+        return this.#runMethod('execute', businessUnit, selectedType, keys);
+    }
+    /**
+     * Start/execute an item
+     *
+     * @param {string} businessUnit name of BU
+     * @param {TYPE.SupportedMetadataTypes} [selectedType] limit to given metadata types
+     * @param {string[]} [keys] customerkey of the metadata
+     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of executed item keys
+     */
+    static async execute(businessUnit, selectedType, keys) {
+        return this.#runMethod('execute', businessUnit, selectedType, keys);
+    }
+    /**
+     * pause an item
+     *
+     * @param {string} businessUnit name of BU
+     * @param {TYPE.SupportedMetadataTypes} [selectedType] limit to given metadata types
+     * @param {string[]} [keys] customerkey of the metadata
+     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of paused item keys
+     */
+    static async pause(businessUnit, selectedType, keys) {
+        return this.#runMethod('pause', businessUnit, selectedType, keys);
+    }
+    /**
+     * Updates the key to match the name field
+     *
+     * @param {string} businessUnit name of BU
+     * @param {TYPE.SupportedMetadataTypes} selectedType limit to given metadata types
+     * @param {string[]} [keys] customerkey of the metadata
+     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of paused item keys
+     */
+    static async fixKeys(businessUnit, selectedType, keys) {
+        return this.#runMethod('fixKeys', businessUnit, selectedType, keys);
+    }
+    /**
+     * run a method across BUs
      *
+     * @param {'execute'|'pause'|'fixKeys'} methodName what to run
      * @param {string} businessUnit name of BU
-     * @param {TYPE.SupportedMetadataTypes[]} [selectedTypesArr] limit to given metadata types
-     * @param {string[]} keys customerkey of the metadata
-     * @returns {Promise.<boolean>} true if all started successfully, false if not
+     * @param {TYPE.SupportedMetadataTypes} [selectedType] limit to given metadata types
+     * @param {string[]} [keys] customerkey of the metadata
+     * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of affected item keys
      */
-    static async execute(businessUnit, selectedTypesArr, keys) {
+    static async #runMethod(methodName, businessUnit, selectedType, keys) {
         Util.startLogger();
-        Util.logger.info('mcdev:: Execute');
+        let lang_past;
+        let lang_present;
+        let requireKeyOrLike;
+        let checkMetadataSupport;
+        const resultObj = {};
+
+        switch (methodName) {
+            case 'execute': {
+                lang_past = 'executed';
+                lang_present = 'executing';
+                requireKeyOrLike = true;
+                checkMetadataSupport = true;
+                break;
+            }
+            case 'pause': {
+                lang_past = 'paused';
+                lang_present = 'pausing';
+                requireKeyOrLike = true;
+                checkMetadataSupport = true;
+                break;
+            }
+            case 'fixKeys': {
+                lang_past = 'fixed keys';
+                lang_present = 'fixing keys';
+                requireKeyOrLike = false;
+                checkMetadataSupport = false;
+                break;
+            }
+        }
+
+        Util.logger.info(`mcdev:: ${methodName} ${selectedType}`);
         const properties = await config.getProperties();
         let counter_credBu = 0;
-        let counter_failed = 0;
+        let counter_credKeys = 0;
         if (!(await config.checkProperties(properties))) {
             // return null here to avoid seeing 2 error messages for the same issue
-            return null;
+            return resultObj;
         }
-        if (Array.isArray(selectedTypesArr)) {
-            // types and keys can be provided but for each type all provided keys are applied as filter
-            for (const selectedType of Array.isArray(selectedTypesArr)
-                ? selectedTypesArr
-                : Object.keys(selectedTypesArr)) {
-                if (!Util._isValidType(selectedType)) {
-                    return;
-                }
-            }
+        if (!Util._isValidType(selectedType)) {
+            return resultObj;
         }
+        if (
+            checkMetadataSupport &&
+            !Object.prototype.hasOwnProperty.call(MetadataTypeInfo[selectedType], methodName)
+        ) {
+            Util.logger.error(
+                ` ☇ skipping ${selectedType}: ${methodName} is not supported yet for ${selectedType}`
+            );
+            return resultObj;
+        }
+
+        if (
+            requireKeyOrLike &&
+            (!Array.isArray(keys) || !keys.length) &&
+            (!Util.OPTIONS.like || !Object.keys(Util.OPTIONS.like).length)
+        ) {
+            Util.logger.error('At least one key or a --like filter is required.');
+            return resultObj;
+        } else if (
+            Array.isArray(keys) &&
+            keys.length &&
+            Util.OPTIONS.like &&
+            Object.keys(Util.OPTIONS.like).length
+        ) {
+            Util.logger.error('You can either specify keys OR a --like filter.');
+            return resultObj;
+        }
+
         if (businessUnit === '*') {
+            Util.OPTIONS._multiBuExecution = true;
             Util.logger.info(
-                '\n               :: Executing the entity on all BUs for all credentials'
+                `:: ${lang_present} the ${selectedType} on all BUs for all credentials`
             );
             let counter_credTotal = 0;
             for (const cred in properties.credentials) {
-                Util.logger.info(`\n               :: Executing the entity on all BUs for ${cred}`);
-
+                Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
+                // reset counter per cred
+                counter_credKeys = 0;
+                counter_credBu = 0;
                 for (const bu in properties.credentials[cred].businessUnits) {
-                    if (await this._executeBU(cred, bu, selectedTypesArr, keys)) {
-                        counter_credBu++;
-                    } else {
-                        counter_failed++;
-                    }
+                    resultObj[cred + '/' + bu] = await this.#runOnBU(
+                        methodName,
+                        cred,
+                        bu,
+                        selectedType,
+                        keys
+                    );
+                    counter_credBu++;
+                    counter_credKeys += resultObj[cred + '/' + bu].length;
                     Util.startLogger(true);
                 }
                 counter_credTotal += counter_credBu;
                 Util.logger.info(
-                    `\n               :: Executed the entity on ${counter_credBu} BUs for ${cred}\n`
+                    `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
                 );
             }
             Util.logger.info(
-                `\n               :: Executed the entity on ${counter_credTotal} BUs in total\n`
+                `:: ${lang_past} ${selectedType} on ${counter_credTotal} BUs in total\n`
             );
         } else {
             let [cred, bu] = businessUnit ? businessUnit.split('/') : [null, null];
@@ -767,91 +913,248 @@ class Mcdev {
                     true
                 );
                 if (buObject === null) {
-                    return;
+                    return resultObj;
                 } else {
                     cred = buObject.credential;
                     bu = buObject.businessUnit;
                 }
             }
             if (bu === '*' && properties.credentials && properties.credentials[cred]) {
-                Util.logger.info(`\n               :: Executing the entity on all BUs for ${cred}`);
-                let counter_credBu = 0;
+                Util.OPTIONS._multiBuExecution = true;
+                Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
                 for (const bu in properties.credentials[cred].businessUnits) {
-                    if (await this._executeBU(cred, bu, selectedTypesArr, keys)) {
-                        counter_credBu++;
-                    } else {
-                        counter_failed++;
-                    }
+                    resultObj[cred + '/' + bu] = await this.#runOnBU(
+                        methodName,
+                        cred,
+                        bu,
+                        selectedType,
+                        keys
+                    );
+                    counter_credBu++;
+                    counter_credKeys += resultObj[cred + '/' + bu].length;
                     Util.startLogger(true);
                 }
                 Util.logger.info(
-                    `\n               :: Executed the entity on ${counter_credBu} BUs for ${cred}\n`
+                    `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
                 );
             } else {
-                // execute the entity on one BU only
-                if (await this._executeBU(cred, bu, selectedTypesArr, keys)) {
-                    counter_credBu++;
-                } else {
-                    counter_failed++;
-                }
-                Util.logger.info(`\n               :: Done\n`);
+                // execute runMethod for the entity on one BU only
+                resultObj[cred + '/' + bu] = await this.#runOnBU(
+                    methodName,
+                    cred,
+                    bu,
+                    selectedType,
+                    keys
+                );
+                Util.logger.info(`:: Done`);
             }
         }
-        if (counter_credBu !== 0) {
-            Util.logger.info(`\n               :: Executed query on ${counter_credBu} BUs\n`);
-        }
-        return counter_failed === 0 ? true : false;
+        return resultObj;
     }
     /**
-     * helper for {@link execute}
+     * helper for {@link Mcdev.#runMethod}
      *
+     * @param {'execute'|'pause'|'fixKeys'} methodName what to run
      * @param {string} cred name of Credential
      * @param {string} bu name of BU
-     * @param {TYPE.SupportedMetadataTypes[]} [selectedTypesArr] limit execution to given metadata type
+     * @param {TYPE.SupportedMetadataTypes} [type] limit execution to given metadata type
      * @param {string[]} keyArr customerkey of the metadata
-     * @returns {Promise.<boolean>} true if all items were executed, false otherwise
+     * @returns {Promise.<string[]>} list of keys that were affected
      */
-    static async _executeBU(cred, bu, selectedTypesArr, keyArr) {
+    static async #runOnBU(methodName, cred, bu, type, keyArr) {
         const properties = await config.getProperties();
-        let counter_failed = 0;
+        const resultArr = [];
         const buObject = await Cli.getCredentialObject(
             properties,
             cred === null ? null : cred + '/' + bu,
             null,
             true
         );
-        if (!keyArr || (Array.isArray(keyArr) && !keyArr.length)) {
-            throw new Error('No keys were provided');
+        try {
+            if (!type) {
+                throw new Error('No type was provided');
+            }
+            if (buObject !== null) {
+                cache.initCache(buObject);
+                cred = buObject.credential;
+                bu = buObject.businessUnit;
+            }
+            Util.logger.info(`:: ${methodName} ${type} on ${cred}/${bu}`);
+            MetadataTypeInfo[type].client = auth.getSDK(buObject);
+
+            MetadataTypeInfo[type].properties = properties;
+            MetadataTypeInfo[type].buObject = buObject;
+            switch (methodName) {
+                case 'fixKeys': {
+                    {
+                        resultArr.push(...(await this.#fixKeys(cred, bu, type, keyArr)));
+
+                        break;
+                    }
+                }
+                default: {
+                    if (Util.OPTIONS.like && Object.keys(Util.OPTIONS.like).length) {
+                        keyArr = await this.#retrieveKeysWithLike(type, buObject);
+                    }
+                    if (!keyArr || (Array.isArray(keyArr) && !keyArr.length)) {
+                        throw new Error('No keys were provided');
+                    } // result will be undefined (false) if methodName is not supported for the type
+                    resultArr.push(...(await MetadataTypeInfo[type][methodName](keyArr)));
+                }
+            }
+        } catch (ex) {
+            Util.logger.errorStack(ex, 'mcdev.' + methodName + ' failed');
         }
-        if (!selectedTypesArr || (Array.isArray(selectedTypesArr) && !selectedTypesArr.length)) {
-            throw new Error('No type was provided');
+
+        return resultArr;
+    }
+
+    /**
+     * helper for {@link Mcdev.#runOnBU}
+     *
+     * @param {TYPE.SupportedMetadataTypes} selectedType limit execution to given metadata type
+     * @param {TYPE.BuObject} buObject properties for auth
+     * @returns {string[]} keyArr
+     */
+    static async #retrieveKeysWithLike(selectedType, buObject) {
+        const properties = await config.getProperties();
+
+        // cache depenencies
+        const deployOrder = Util.getMetadataHierachy([selectedType]);
+        for (const type in deployOrder) {
+            const subTypeArr = deployOrder[type];
+            MetadataTypeInfo[type].client = auth.getSDK(buObject);
+            MetadataTypeInfo[type].properties = properties;
+            MetadataTypeInfo[type].buObject = buObject;
+            Util.logger.info(`Caching dependent Metadata: ${type}`);
+            Util.logSubtypes(subTypeArr);
+            const result = await MetadataTypeInfo[type].retrieveForCache(null, subTypeArr);
+            if (result) {
+                if (Array.isArray(result)) {
+                    for (const result_i of result) {
+                        if (result_i?.metadata && Object.keys(result_i.metadata).length) {
+                            cache.mergeMetadata(type, result_i.metadata);
+                        }
+                    }
+                } else {
+                    cache.setMetadata(type, result.metadata);
+                }
+            }
         }
-        if (buObject !== null) {
-            cache.initCache(buObject);
-            cred = buObject.credential;
-            bu = buObject.businessUnit;
+
+        // find all keys in chosen type that match the like-filter
+        const keyArr = [];
+        const metadataMap = cache.getCache()[selectedType];
+        if (!metadataMap) {
+            throw new Error(`Selected type ${selectedType} could not be cached`);
         }
         Util.logger.info(
-            `\n               :: Executing ${selectedTypesArr.join(', ')} on ${cred}/${bu}\n`
+            Util.getGrayMsg(`Found ${Object.keys(metadataMap).length} ${selectedType}s`)
+        );
+        for (const originalKey in metadataMap) {
+            // hide postRetrieveOutput
+            Util.setLoggingLevel({ silent: true });
+            metadataMap[originalKey] = MetadataTypeInfo[selectedType].postRetrieveTasks(
+                metadataMap[originalKey]
+            );
+            // reactivate logging
+            Util.setLoggingLevel({});
+            if (Util.fieldsLike(metadataMap[originalKey])) {
+                keyArr.push(originalKey);
+            }
+        }
+        Util.logger.info(
+            Util.getGrayMsg(
+                `Identified ${keyArr.length} ${selectedType}${
+                    keyArr.length === 1 ? '' : 's'
+                } that match${keyArr.length === 1 ? 'es' : ''} the like-filter`
+            )
+        );
+
+        return keyArr;
+    }
+    /**
+     * Updates the key to match the name field
+     *
+     * @param {string} cred name of Credential
+     * @param {string} bu name of BU
+     * @param {TYPE.SupportedMetadataTypes} type limit execution to given metadata type
+     * @param {string[]} [keyArr] customerkey of the metadata
+     * @returns {Promise.<string[]>} list of keys that were affected
+     */
+    static async #fixKeys(cred, bu, type, keyArr) {
+        const properties = await config.getProperties();
+        let actuallyFixedKeys = [];
+        const resultArr = [];
+
+        if (
+            MetadataTypeDefinitions[type].keyIsFixed === true ||
+            MetadataTypeDefinitions[type].keyField === MetadataTypeDefinitions[type].idField
+        ) {
+            Util.logger.error(`Key cannot be updated for this type`);
+            return resultArr;
+        }
+
+        const buObject = await Cli.getCredentialObject(
+            properties,
+            cred === null ? null : cred + '/' + bu,
+            null,
+            true
         );
         try {
-            // more than one type was provided, iterate types and execute items
-            for (const type of selectedTypesArr) {
-                try {
-                    MetadataTypeInfo[type].client = auth.getSDK(buObject);
-                } catch (ex) {
-                    Util.logger.error(ex.message);
-                    return;
-                }
-                // result will be undefined (false) if execute is not supported for the type
-                if (!(await MetadataTypeInfo[type].execute(keyArr))) {
-                    counter_failed++;
+            Util.logger.info(`Retrieving latest versions of ${type} from server`);
+            const retriever = new Retriever(properties, buObject);
+            const retrieved = await retriever.retrieve([type], keyArr, null, false);
+
+            const metadataMap = Object.values(retrieved)[0][0];
+            const keysForDeploy = MetadataTypeInfo[type].getKeysForFixing(metadataMap);
+            if (keysForDeploy.length < 1) {
+                Util.logger.warn(
+                    `No items found with a key-name mismatch that match your criteria.\n`
+                );
+                return resultArr;
+            }
+            this.setOptions({
+                changeKeyField: MetadataTypeDefinitions[type].nameField,
+                fromRetrieve: true,
+            });
+            const deployed = await Deployer.deploy(cred + '/' + bu, [type], keysForDeploy);
+            actuallyFixedKeys = Object.keys(Object.values(Object.values(deployed)[0])[0]);
+            resultArr.push(...actuallyFixedKeys);
+            const dependentTypes = await Util.getDependentMetadata(type);
+            if (actuallyFixedKeys && actuallyFixedKeys.length) {
+                Util.logger.info(
+                    `Successfully updated ${actuallyFixedKeys.length} key${
+                        actuallyFixedKeys.length === 1 ? '' : 's'
+                    } of type ${type}`
+                );
+                if (dependentTypes.length) {
+                    Util.logger.warn(
+                        `Please re-retrieve the following types as your local copies might now be outdated: ${Util.getGrayMsg(
+                            dependentTypes.join(', ')
+                        )}`
+                    );
+                    const reRetrieve = await Cli.postFixKeysReretrieve(type, dependentTypes);
+                    if (reRetrieve) {
+                        Util.logger.info(
+                            `Retrieving latest versions of ${dependentTypes.join(', ')} from server`
+                        );
+                        const retriever = new Retriever(properties, buObject);
+                        await retriever.retrieve(dependentTypes, null, null, false);
+                    }
+                } else {
+                    Util.logger.info(
+                        `No dependent types found that need to be re-retrieved after fixing keys of type ${type}.`
+                    );
                 }
+            } else {
+                Util.logger.warn(`No keys of type ${type} updated.`);
             }
         } catch (ex) {
-            Util.logger.errorStack(ex, 'mcdev.execute failed');
+            Util.logger.errorStack(ex, 'mcdev.fixKeys failed');
         }
-        return counter_failed === 0 ? true : false;
+        Util.logger.info(`:: Done\n`);
+        return resultArr;
     }
 }