mcdev 5.0.2 → 5.2.0

package/lib/index.js

@@ -51,13 +51,18 @@ class Mcdev {
     static setOptions(argv) {
         const knownOptions = [
             'api',
-            'commitHistory',
             'changeKeyField',
             'changeKeyValue',
+            'commitHistory',
+            'execute',
             'filter',
             'fromRetrieve',
             'json',
+            'like',
+            'noLogColors',
+            'noLogFile',
             'refresh',
+            'schedule',
             'skipInteraction',
         ];
         for (const option of knownOptions) {
@@ -89,6 +94,7 @@ class Mcdev {
      * @returns {Promise.<TYPE.DeltaPkgItem[]>} list of changed items
      */
     static async createDeltaPkg(argv) {
+        Util.startLogger();
         Util.logger.info('Create Delta Package ::');
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
@@ -111,6 +117,7 @@ class Mcdev {
      * @returns {Promise} .
      */
     static async selectTypes() {
+        Util.startLogger();
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
@@ -127,6 +134,7 @@ class Mcdev {
      * @returns {Promise.<boolean>} success flag
      */
     static async upgrade() {
+        Util.startLogger();
         const properties = await config.getProperties();
         if (!properties) {
             Util.logger.error('No config found. Please run mcdev init');
@@ -149,6 +157,8 @@ 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();
         if (!(await config.checkProperties(properties))) {
@@ -166,22 +176,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.restartLogger();
+                    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
@@ -205,17 +225,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.restartLogger();
+                    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,
@@ -223,14 +248,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
@@ -240,7 +284,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;
@@ -258,6 +302,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',
@@ -265,7 +310,7 @@ class Mcdev {
                 triggeredSend: 'triggeredSendDefinition',
                 user: 'accountUser',
             };
-            Util.logger.info(`\n               :: Retrieving ${cred}/${bu}\n`);
+            Util.logger.info(`:: Retrieving ${cred}/${bu}\n`);
             const retrieveTypesArr = [];
             if (selectedTypesArr) {
                 for (const selectedType of Array.isArray(selectedTypesArr)
@@ -332,9 +377,7 @@ class Mcdev {
                     null,
                     changelogOnly
                 );
-                if (changelogOnly) {
-                    return retrieveChangelog;
-                }
+                return retrieveChangelog;
             } catch (ex) {
                 Util.logger.errorStack(ex, 'mcdev.retrieve failed');
             }
@@ -347,11 +390,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) {
-        return Deployer.deploy(businessUnit, selectedTypesArr, keyArr, fromRetrieve);
+    static async deploy(businessUnit, selectedTypesArr, keyArr) {
+        console.time('Time'); // eslint-disable-line no-console
+        Util.startLogger();
+        const deployResult = await Deployer.deploy(businessUnit, selectedTypesArr, keyArr);
+        console.timeEnd('Time'); // eslint-disable-line no-console
+        return deployResult;
     }
 
     /**
@@ -361,6 +407,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async initProject(credentialsName) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Setting up project');
         const properties = await config.getProperties(!!credentialsName, true);
         await Init.initProject(properties, credentialsName);
@@ -371,6 +418,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async joinProject() {
+        Util.startLogger();
         Util.logger.info('mcdev:: Joining an existing project');
         await Init.joinProject();
     }
@@ -382,6 +430,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async findBUs(credentialsName) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Load BUs');
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
@@ -401,6 +450,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async document(businessUnit, type) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Document');
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
@@ -440,6 +490,7 @@ class Mcdev {
      * @returns {Promise.<boolean>} true if successful, false otherwise
      */
     static async deleteByKey(businessUnit, type, customerKey) {
+        Util.startLogger();
         Util.logger.info('mcdev:: delete');
         if (!Util._isValidType(type)) {
             return;
@@ -477,6 +528,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async refresh(businessUnit, type, keyArr) {
+        Util.startLogger();
         Util.logger.info('mcdev:: refresh');
         if (!type || !Util._isValidType(type, true)) {
             type = 'triggeredSend';
@@ -512,6 +564,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async badKeys(businessUnit) {
+        Util.startLogger();
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
             return null;
@@ -585,6 +638,7 @@ class Mcdev {
      * @returns {Promise.<TYPE.MultiMetadataTypeList>} -
      */
     static async retrieveAsTemplate(businessUnit, selectedType, name, market) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Retrieve as Template');
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
@@ -626,6 +680,7 @@ class Mcdev {
      * @returns {Promise.<TYPE.MultiMetadataTypeList>} -
      */
     static async buildTemplate(businessUnit, selectedType, keyArr, market) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Build Template from retrieved files');
         return Builder.buildTemplate(businessUnit, selectedType, keyArr, market);
     }
@@ -639,6 +694,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async buildDefinition(businessUnit, selectedType, name, market) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Build Definition from Template');
         return Builder.buildDefinition(businessUnit, selectedType, name, market);
     }
@@ -652,6 +708,7 @@ class Mcdev {
      * @returns {Promise.<void>} -
      */
     static async buildDefinitionBulk(listName, type, name) {
+        Util.startLogger();
         Util.logger.info('mcdev:: Build Definition from Template Bulk');
         return Builder.buildDefinitionBulk(listName, type, name);
     }
@@ -663,6 +720,7 @@ class Mcdev {
      * @returns {Promise.<string[]>} list of all files that need to be committed in a flat array ['path/file1.ext', 'path/file2.ext']
      */
     static async getFilesToCommit(businessUnit, selectedType, keyArr) {
+        Util.startLogger();
         Util.logger.info('mcdev:: getFilesToCommit');
         const properties = await config.getProperties();
         if (!(await config.checkProperties(properties))) {
@@ -682,6 +740,419 @@ class Mcdev {
             return DevOps.getFilesToCommit(properties, buObject, selectedType, keyArr);
         }
     }
+    /**
+     * 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} [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 #runMethod(methodName, businessUnit, selectedType, keys) {
+        Util.startLogger();
+        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_credKeys = 0;
+        if (!(await config.checkProperties(properties))) {
+            // return null here to avoid seeing 2 error messages for the same issue
+            return resultObj;
+        }
+        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(
+                `:: ${lang_present} the ${selectedType} on all BUs for all credentials`
+            );
+            let counter_credTotal = 0;
+            for (const cred in properties.credentials) {
+                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) {
+                    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(
+                    `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
+                );
+            }
+            Util.logger.info(
+                `:: ${lang_past} ${selectedType} on ${counter_credTotal} BUs 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
+            if (
+                properties.credentials &&
+                (!properties.credentials[cred] ||
+                    (bu !== '*' && !properties.credentials[cred].businessUnits[bu]))
+            ) {
+                const buObject = await Cli.getCredentialObject(
+                    properties,
+                    cred === null ? null : cred + '/' + bu,
+                    null,
+                    true
+                );
+                if (buObject === null) {
+                    return resultObj;
+                } else {
+                    cred = buObject.credential;
+                    bu = buObject.businessUnit;
+                }
+            }
+            if (bu === '*' && properties.credentials && properties.credentials[cred]) {
+                Util.OPTIONS._multiBuExecution = true;
+                Util.logger.info(`:: ${lang_present} ${selectedType} on all BUs for ${cred}`);
+                for (const bu in properties.credentials[cred].businessUnits) {
+                    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(
+                    `:: ${lang_past} for ${counter_credKeys} ${selectedType}s on ${counter_credBu} BUs for ${cred}`
+                );
+            } else {
+                // execute runMethod for the entity on one BU only
+                resultObj[cred + '/' + bu] = await this.#runOnBU(
+                    methodName,
+                    cred,
+                    bu,
+                    selectedType,
+                    keys
+                );
+                Util.logger.info(`:: Done`);
+            }
+        }
+        return resultObj;
+    }
+    /**
+     * 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} [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 #runOnBU(methodName, cred, bu, type, keyArr) {
+        const properties = await config.getProperties();
+        const resultArr = [];
+        const buObject = await Cli.getCredentialObject(
+            properties,
+            cred === null ? null : cred + '/' + bu,
+            null,
+            true
+        );
+        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');
+        }
+
+        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);
+                }
+            }
+        }
+
+        // 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(
+            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 {
+            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.fixKeys failed');
+        }
+        Util.logger.info(`:: Done\n`);
+        return resultArr;
+    }
 }
 
 module.exports = Mcdev;