mcdev 5.0.2 → 5.2.0

package/lib/metadataTypes/DataExtension.js

@@ -59,8 +59,8 @@ class DataExtension extends MetadataType {
                 // output error & remove from deploy list
                 Util.logger.error(
                     ` ☇ skipping ${this.definition.type} ${
-                        metadataMap[this.definition.keyField]
-                    } / ${metadataMap[this.definition.nameField]}: ${ex.message}`
+                        metadataMap[metadataKey][this.definition.keyField]
+                    } / ${metadataMap[metadataKey][this.definition.nameField]}: ${ex.message}`
                 );
                 delete metadataMap[metadataKey];
                 // skip rest of handling for this DE
@@ -203,7 +203,7 @@ class DataExtension extends MetadataType {
         }
     }
     /**
-     * helper for {@link upsert}
+     * helper for {@link DataExtension.upsert}
      *
      * @private
      * @param {object} res -
@@ -607,7 +607,7 @@ class DataExtension extends MetadataType {
         metadata[customerKey].Fields = fieldArr;
     }
     /**
-     * helper for {@link super.updateREST} and {@link super.updateSOAP} that removes old files after the key was changed
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
      *
      * @private
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
@@ -624,16 +624,16 @@ class DataExtension extends MetadataType {
      * @returns {Promise.<TYPE.DataExtensionItem>} Promise of updated single DE
      */
     static async preDeployTasks(metadata) {
-        if (metadata.Name.startsWith('_')) {
+        if (metadata.Name?.startsWith('_')) {
             throw new Error(`Cannot Upsert Strongly Typed Data Extensions`);
         }
         if (
             this.buObject.eid !== this.buObject.mid &&
-            metadata.r__folder_Path.startsWith('Shared Items')
+            metadata.r__folder_Path?.startsWith('Shared Items')
         ) {
             throw new Error(`Cannot Create/Update a Shared Data Extension from the Child BU`);
         }
-        if (metadata.r__folder_Path.startsWith('Synchronized Data Extensions')) {
+        if (metadata.r__folder_Path?.startsWith('Synchronized Data Extensions')) {
             throw new Error(
                 `Cannot Create/Update a Synchronized Data Extension. Please use Contact Builder to maintain these`
             );

package/lib/metadataTypes/DataExtensionField.js

@@ -31,7 +31,7 @@ class DataExtensionField extends MetadataType {
         return super.retrieveSOAP(null, requestParams, null, additionalFields);
     }
     /**
-     * helper for {@link DataExtension._retrieveFieldsForSingleDe} that sorts the fields into an array
+     * helper for DataExtension.retrieveFieldsForSingleDe that sorts the fields into an array
      *
      * @param {TYPE.DataExtensionFieldMap} fieldsObj customerKey-based list of fields for one dataExtension
      * @returns {TYPE.DataExtensionFieldItem[]} sorted array of field objects

package/lib/metadataTypes/Event.js

@@ -136,12 +136,11 @@ class Event extends MetadataType {
      * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
      * @param {string} retrieveDir directory where metadata after deploy should be saved
-     * @param {boolean} [isRefresh] optional flag - so far not used by eventDefinition
      * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of keyField => metadata map
      */
-    static async deploy(metadata, deployDir, retrieveDir, isRefresh) {
+    static async deploy(metadata, deployDir, retrieveDir) {
         Util.logBeta(this.definition.type);
-        return super.deploy(metadata, deployDir, retrieveDir, isRefresh);
+        return super.deploy(metadata, deployDir, retrieveDir);
     }
 
     /**

package/lib/metadataTypes/Folder.js

@@ -452,7 +452,7 @@ class Folder extends MetadataType {
      * Returns file contents mapped to their filename without '.json' ending
      *
      * @param {string} dir directory that contains '.json' files to be read
-     * @param {boolean} [listBadKeys=false] do not print errors, used for badKeys()
+     * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
      * @returns {TYPE.MetadataTypeMap} fileName => fileContent map
      */
     static getJsonFromFS(dir, listBadKeys) {

package/lib/metadataTypes/Journey.js

@@ -216,12 +216,11 @@ class Journey extends MetadataType {
      * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
      * @param {string} retrieveDir directory where metadata after deploy should be saved
-     * @param {boolean} [isRefresh] optional flag - so far not used by interaction
      * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of keyField => metadata map
      */
-    static async deploy(metadata, deployDir, retrieveDir, isRefresh) {
+    static async deploy(metadata, deployDir, retrieveDir) {
         Util.logBeta(this.definition.type);
-        return super.deploy(metadata, deployDir, retrieveDir, isRefresh);
+        return super.deploy(metadata, deployDir, retrieveDir);
     }
 
     /**
@@ -265,7 +264,7 @@ class Journey extends MetadataType {
     }
 
     /**
-     * helper for Journey's {@link saveResults}. Gets executed after retreive of metadata type and
+     * helper for Journey's {@link Journey.saveResults}. Gets executed after retreive of metadata type and
      *
      * @param {TYPE.MetadataTypeMap} metadataMap key=customer key, value=metadata
      */
@@ -478,7 +477,7 @@ class Journey extends MetadataType {
         return metadata;
     }
     /**
-     * helper for {@link postRetrieveTasks}
+     * helper for {@link Journey.postRetrieveTasks}
      *
      * @private
      * @param {TYPE.MetadataTypeItem} metadata a single item
@@ -800,7 +799,7 @@ class Journey extends MetadataType {
     }
 
     /**
-     * helper for {@link preDeployTasks}
+     * helper for {@link Journey.preDeployTasks}
      *
      * @private
      * @param {TYPE.MetadataTypeItem} metadata a single item

package/lib/metadataTypes/MetadataType.js

@@ -35,7 +35,7 @@ class MetadataType {
      * Returns file contents mapped to their filename without '.json' ending
      *
      * @param {string} dir directory that contains '.json' files to be read
-     * @param {boolean} [listBadKeys=false] do not print errors, used for badKeys()
+     * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
      * @returns {TYPE.MetadataTypeMap} fileName => fileContent map
      */
     static getJsonFromFS(dir, listBadKeys) {
@@ -58,15 +58,9 @@ class MetadataType {
                         if (key === fileNameWithoutEnding || listBadKeys) {
                             fileName2FileContent[fileNameWithoutEnding] = fileContent;
                         } else {
-                            Util.metadataLogger(
-                                'error',
-                                this.definition.type,
-                                'getJsonFromFS',
-                                'Name of the Metadata and the External Identifier must match',
-                                JSON.stringify({
-                                    Filename: fileNameWithoutEnding,
-                                    ExternalIdentifier: key,
-                                })
+                            Util.logger.error(
+                                ` ${this.definition.type} ${key}: Name of the metadata file and the JSON-key (${this.definition.keyField}) must match` +
+                                    Util.getGrayMsg(` - ${dir}/${fileName}`)
                             );
                         }
                     }
@@ -114,11 +108,10 @@ class MetadataType {
      * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
      * @param {string} retrieveDir directory where metadata after deploy should be saved
-     * @param {boolean} [isRefresh] optional flag to indicate that triggeredSend should be refreshed after deployment of assets
      * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of keyField => metadata map
      */
-    static async deploy(metadata, deployDir, retrieveDir, isRefresh) {
-        const upsertResults = await this.upsert(metadata, deployDir, isRefresh);
+    static async deploy(metadata, deployDir, retrieveDir) {
+        const upsertResults = await this.upsert(metadata, deployDir);
         const savedMetadata = await this.saveResults(upsertResults, retrieveDir, null);
         if (
             this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type) &&
@@ -137,13 +130,12 @@ class MetadataType {
      * @param {TYPE.MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
      * @param {TYPE.MetadataTypeMap} originalMetadata metadata to be updated (contains additioanl fields)
      * @param {{created: number, updated: number}} createdUpdated counter representing successful creates/updates
-     * @param {boolean} [isRefresh] optional flag to indicate that triggeredSend should be refreshed after deployment of assets
      * @returns {void}
      */
-    static postDeployTasks(upsertResults, originalMetadata, createdUpdated, isRefresh) {}
+    static postDeployTasks(upsertResults, originalMetadata, createdUpdated) {}
 
     /**
-     * helper for {@link createREST}
+     * helper for {@link MetadataType.createREST}
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
@@ -152,7 +144,7 @@ class MetadataType {
     static postCreateTasks(metadataEntry, apiResponse) {}
 
     /**
-     * helper for {@link updateREST}
+     * helper for {@link MetadataType.updateREST}
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
@@ -161,7 +153,7 @@ class MetadataType {
     static postUpdateTasks(metadataEntry, apiResponse) {}
 
     /**
-     * helper for {@link createREST} when legacy API endpoints as these do not return the created item but only their new id
+     * helper for {@link MetadataType.createREST} when legacy API endpoints as these do not return the created item but only their new id
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
@@ -460,6 +452,29 @@ class MetadataType {
         return;
     }
 
+    /**
+     * Abstract execute method that needs to be implemented in child metadata type
+     *
+     * @returns {void}
+     */
+    static execute() {
+        Util.logger.error(
+            ` ☇ skipping ${this.definition.type}: execute is not supported yet for ${this.definition.type}`
+        );
+        return [];
+    }
+    /**
+     * Abstract pause method that needs to be implemented in child metadata type
+     *
+     * @returns {void}
+     */
+    static pause() {
+        Util.logger.error(
+            ` ☇ skipping ${this.definition.type}: pause is not supported yet for ${this.definition.type}`
+        );
+        return [];
+    }
+
     /**
      * test if metadata was actually changed or not to potentially skip it during deployment
      *
@@ -531,10 +546,9 @@ class MetadataType {
      *
      * @param {TYPE.MetadataTypeMap} metadataMap metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
-     * @param {boolean} [isRefresh] optional flag to indicate that triggeredSend should be refreshed after deployment of assets
      * @returns {Promise.<TYPE.MetadataTypeMap>} keyField => metadata map
      */
-    static async upsert(metadataMap, deployDir, isRefresh) {
+    static async upsert(metadataMap, deployDir) {
         const orignalMetadataMap = JSON.parse(JSON.stringify(metadataMap));
         const metadataToUpdate = [];
         const metadataToCreate = [];
@@ -626,12 +640,10 @@ class MetadataType {
             const metadataResults = createResults.concat(updateResults).filter(Boolean);
             upsertResults = this.parseResponseBody(metadataResults);
         }
-        await this.postDeployTasks(
-            upsertResults,
-            orignalMetadataMap,
-            { created: createResults.length, updated: updateResults.length },
-            isRefresh
-        );
+        await this.postDeployTasks(upsertResults, orignalMetadataMap, {
+            created: createResults.length,
+            updated: updateResults.length,
+        });
         return upsertResults;
     }
 
@@ -650,6 +662,7 @@ class MetadataType {
             metadataMap[metadataKey][this.definition.keyField]
         );
         // Update if it already exists; Create it if not
+        const maxKeyLength = this.definition.maxKeyLength || 36;
         if (
             Util.logger.level === 'debug' &&
             metadataMap[metadataKey][this.definition.idField] &&
@@ -703,11 +716,11 @@ class MetadataType {
                     // NOTE: trim twice while getting the newKey value to remove leading spaces before limiting the length
                     const newKey = (metadataMap[metadataKey][Util.OPTIONS.changeKeyField] + '')
                         .trim()
-                        .slice(0, 36)
+                        .slice(0, maxKeyLength)
                         .trim();
-                    if (metadataMap[metadataKey][Util.OPTIONS.changeKeyField] + '' > 36) {
+                    if (metadataMap[metadataKey][Util.OPTIONS.changeKeyField] + '' > maxKeyLength) {
                         Util.logger.warn(
-                            `Customer Keys may not exceed 36 characters. Truncated the value in field ${Util.OPTIONS.changeKeyField} to ${newKey}`
+                            `${this.definition.type} ${this.definition.keyField} may not exceed ${maxKeyLength} characters. Truncated the value in field ${Util.OPTIONS.changeKeyField} to ${newKey}`
                         );
                     }
                     if (metadataKey == newKey) {
@@ -727,10 +740,10 @@ class MetadataType {
                 }
             } else if (Util.OPTIONS.changeKeyValue) {
                 // NOTE: trim twice while getting the newKey value to remove leading spaces before limiting the length
-                const newKey = Util.OPTIONS.changeKeyValue.trim().slice(0, 36).trim();
-                if (Util.OPTIONS.changeKeyValue.trim().length > 36) {
+                const newKey = Util.OPTIONS.changeKeyValue.trim().slice(0, maxKeyLength).trim();
+                if (Util.OPTIONS.changeKeyValue.trim().length > maxKeyLength) {
                     Util.logger.warn(
-                        `Customer Keys may not exceed 36 characters. Truncated your value to ${newKey}`
+                        `${this.definition.type} ${this.definition.keyField} may not exceed ${maxKeyLength} characters. Truncated your value to ${newKey}`
                     );
                 }
                 if (this.definition.keyField == this.definition.idField) {
@@ -808,7 +821,7 @@ class MetadataType {
             );
             return response;
         } catch (ex) {
-            const parsedErrors = this.checkForErrors(ex);
+            const parsedErrors = this.getErrorsREST(ex);
             Util.logger.error(
                 ` ☇ error creating ${this.definition.type} ${
                     metadataEntry[this.definition.keyField] ||
@@ -838,7 +851,7 @@ class MetadataType {
         this.removeNotCreateableFields(metadataEntry);
         try {
             const response = await this.client.soap.create(
-                soapType.charAt(0).toUpperCase() + soapType.slice(1),
+                Util.capitalizeFirstLetter(soapType),
                 metadataEntry,
                 null
             );
@@ -862,7 +875,7 @@ class MetadataType {
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {string} uri rest endpoint for PATCH
-     * @param {'patch'|'post'|'put'} [httpMethod='patch'] defaults to 'patch'; some update requests require PUT instead of PATCH
+     * @param {'patch'|'post'|'put'} [httpMethod] defaults to 'patch'; some update requests require PUT instead of PATCH
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async updateREST(metadataEntry, uri, httpMethod = 'patch') {
@@ -871,7 +884,7 @@ class MetadataType {
             // set to empty object in case API returned nothing to be able to update it in helper classes
             const response = (await this.client.rest[httpMethod](uri, metadataEntry)) || {};
             await this._postChangeKeyTasks(metadataEntry);
-            this.checkForErrors(response);
+            this.getErrorsREST(response);
             await this.postUpdateTasks(metadataEntry, response);
             // some times, e.g. automation dont return a key in their update response and hence we need to fall back to name
             Util.logger.info(
@@ -882,7 +895,7 @@ class MetadataType {
             );
             return response;
         } catch (ex) {
-            const parsedErrors = this.checkForErrors(ex);
+            const parsedErrors = this.getErrorsREST(ex);
             Util.logger.error(
                 ` ☇ error updating ${this.definition.type} ${
                     metadataEntry[this.definition.keyField] ||
@@ -897,7 +910,7 @@ class MetadataType {
     }
 
     /**
-     * helper for {@link updateREST} and {@link updateSOAP} that removes old files after the key was changed
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
      *
      * @private
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
@@ -943,7 +956,7 @@ class MetadataType {
         this.removeNotUpdateableFields(metadataEntry);
         try {
             const response = await this.client.soap.update(
-                soapType.charAt(0).toUpperCase() + soapType.slice(1),
+                Util.capitalizeFirstLetter(soapType),
                 metadataEntry,
                 null
             );
@@ -978,15 +991,20 @@ class MetadataType {
         }
     }
     /**
-     * helper for {@link _handleSOAPErrors}
+     * helper for {@link MetadataType._handleSOAPErrors}
      *
      * @param {Error} ex error that occured
      * @returns {string} error message
      */
     static getSOAPErrorMsg(ex) {
-        return ex?.json?.Results?.length
-            ? `${ex.json.Results[0].StatusMessage} (Code ${ex.json.Results[0].ErrorCode})`
-            : ex.message;
+        if (ex?.json?.Results?.length) {
+            if (ex?.json?.Results[0].StatusMessage) {
+                return `${ex.json.Results[0].StatusMessage} (Code ${ex.json.Results[0].ErrorCode})`;
+            } else if (ex?.json?.Results[0].Result.StatusMessage) {
+                return `${ex.json.Results[0].Result.StatusMessage} (Code ${ex.json.Results[0].Result.ErrorCode})`;
+            }
+        }
+        return ex.message;
     }
     /**
      * Retrieves SOAP via generic fuel-soap wrapper based metadata of metadata type into local filesystem. executes callback with retrieved metadata
@@ -1003,7 +1021,11 @@ class MetadataType {
         const soapType = this.definition.soapType || this.definition.type;
         let response;
         try {
-            response = await this.client.soap.retrieveBulk(soapType, fields, requestParams);
+            response = await this.client.soap.retrieveBulk(
+                Util.capitalizeFirstLetter(soapType),
+                fields,
+                requestParams
+            );
         } catch (ex) {
             this._handleSOAPErrors(ex, 'retrieving');
             return {};
@@ -1066,9 +1088,61 @@ class MetadataType {
             type: this.definition.type,
         };
     }
+    /**
+     * Used to execute a query/automation etc.
+     *
+     * @param {string} uri REST endpoint where the POST request should be sent
+     * @param {string} key item key
+     * @returns {Promise.<{key:string, response:string}>} metadata key and API response (OK or error)
+     */
+    static async executeREST(uri, key) {
+        try {
+            const response = await this.client.rest.post(uri, {}); // payload is empty for this request
+            if (response === 'OK') {
+                Util.logger.info(` - executed ${this.definition.type}: ${key}`);
+            } else {
+                throw new Error(response);
+            }
+            return { key, response };
+        } catch (ex) {
+            Util.logger.error(`Failed to execute ${this.definition.type} ${key}: ${ex.message}`);
+        }
+    }
 
     /**
-     * helper for {@link retrieveREST} and {@link retrieveSOAP}
+     * Used to execute a query/automation etc.
+     *
+     * @param {TYPE.MetadataTypeItem} [metadataEntry] single metadata entry
+     * @returns {Promise.<{key:string, response:object}>} metadata key and API response
+     */
+    static async executeSOAP(metadataEntry) {
+        const soapType = this.definition.soapType || this.definition.type;
+        try {
+            const response = await this.client.soap.perform(
+                Util.capitalizeFirstLetter(soapType),
+                'start',
+                {
+                    ObjectID: metadataEntry[this.definition.idField],
+                }
+            );
+            if (response?.OverallStatus === 'OK') {
+                Util.logger.info(
+                    ` - executed ${this.definition.type}: ${
+                        metadataEntry[this.definition.keyField]
+                    }`
+                );
+            } else {
+                throw new Error(response?.OverallStatus);
+            }
+            return { key: metadataEntry[this.definition.keyField], response };
+        } catch (ex) {
+            this._handleSOAPErrors(ex, 'executing', metadataEntry);
+            return null;
+        }
+    }
+
+    /**
+     * helper for {@link MetadataType.retrieveREST} and {@link MetadataType.retrieveSOAP}
      *
      * @param {string|number} [singleRetrieve] key of single item to filter by
      * @param {TYPE.MetadataTypeMap} metadataMap saved metadata
@@ -1271,7 +1345,7 @@ class MetadataType {
      *
      * @static
      * @param {TYPE.MetadataTypeItem} metadataEntry metadata entry
-     * @param {boolean} [include=false] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
+     * @param {boolean} [include] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
      * @returns {boolean} true: skip saving == filtered; false: continue with saving
      * @memberof MetadataType
      */
@@ -1316,7 +1390,7 @@ class MetadataType {
      *
      * @static
      * @param {object} metadataEntry metadata entry
-     * @param {boolean} [include=false] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
+     * @param {boolean} [include] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
      * @returns {boolean} true: filtered == do NOT save; false: not filtered == do save
      * @memberof MetadataType
      */
@@ -1548,6 +1622,10 @@ class MetadataType {
                     }
                 }
 
+                if (Util.OPTIONS.like && !Util.fieldsLike(results[originalKey])) {
+                    Util.logger.debug(`Filtered ${originalKey} because of --like option`);
+                    continue;
+                }
                 // we dont store Id on local disk, but we need it for caching logic,
                 // so its in retrieve but not in save. Here we put into the clone so that the original
                 // object used for caching doesnt have the Id removed.
@@ -1594,7 +1672,7 @@ class MetadataType {
         return savedResults;
     }
     /**
-     * helper for {@link buildDefinitionForNested}
+     * helper for {@link MetadataType.buildDefinitionForNested}
      * searches extracted file for template variable names and applies the market values
      *
      * @param {string} code code from extracted code
@@ -1606,7 +1684,7 @@ class MetadataType {
         return Mustache.render(code, templateVariables, {}, ['{{{', '}}}']);
     }
     /**
-     * helper for {@link buildTemplateForNested}
+     * helper for {@link MetadataType.buildTemplateForNested}
      * searches extracted file for template variable values and applies the market variable names
      *
      * @param {string} code code from extracted code
@@ -1618,7 +1696,7 @@ class MetadataType {
         return Util.replaceByObject(code, templateVariables);
     }
     /**
-     * helper for {@link buildDefinition}
+     * helper for {@link MetadataType.buildDefinition}
      * handles extracted code if any are found for complex types (e.g script, asset, query)
      *
      * @param {string} templateDir Directory where metadata templates are stored
@@ -1639,7 +1717,7 @@ class MetadataType {
         return null;
     }
     /**
-     * helper for {@link buildTemplate}
+     * helper for {@link MetadataType.buildTemplate}
      * handles extracted code if any are found for complex types
      *
      * @param {string} templateDir Directory where metadata templates are stored
@@ -1785,7 +1863,7 @@ class MetadataType {
      * @param {object} ex response payload from REST API
      * @returns {string[] | void} formatted Error Message
      */
-    static checkForErrors(ex) {
+    static getErrorsREST(ex) {
         const errors = [];
         if (ex?.response?.status >= 400 && ex?.response?.status < 600) {
             if (ex.response.data.errors) {
@@ -1808,11 +1886,13 @@ class MetadataType {
                 }
             } else if (ex.response.data.message) {
                 errors.push(ex.response.data.message);
-            } else {
+            } else if (ex.response.data) {
                 errors.push(`Undefined Errors: ${JSON.stringify(ex.response.data)}`);
+                Util.logger.debug(JSON.stringify(ex.response.data));
+            } else {
+                errors.push(`${ex.response.status} ${ex.response.statusText}`);
             }
             Util.logger.debug(JSON.stringify(ex.config));
-            Util.logger.debug(JSON.stringify(ex.response.data));
         }
         return errors;
     }
@@ -1875,11 +1955,7 @@ class MetadataType {
         metadata[overrideKeyField || this.definition.keyField] = customerKey;
         const soapType = this.definition.soapType || this.definition.type;
         try {
-            await this.client.soap.delete(
-                soapType.charAt(0).toUpperCase() + soapType.slice(1),
-                metadata,
-                null
-            );
+            await this.client.soap.delete(Util.capitalizeFirstLetter(soapType), metadata, null);
             if (!handleOutside) {
                 Util.logger.info(` - deleted ${this.definition.type}: ${customerKey}`);
             }
@@ -1932,7 +2008,7 @@ class MetadataType {
      * Returns metadata of a business unit that is saved locally
      *
      * @param {string} readDir root directory of metadata.
-     * @param {boolean} [listBadKeys=false] do not print errors, used for badKeys()
+     * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
      * @param {object} [buMetadata] Metadata of BU in local directory
      * @returns {object} Metadata of BU in local directory
      */
@@ -1970,6 +2046,57 @@ class MetadataType {
         const fileList = keyArr.map((key) => File.normalizePath([path, key + typeExtension]));
         return fileList;
     }
+
+    /**
+     *
+     * @param {TYPE.MetadataTypeMap} metadataMap metadata mapped by their keyField
+     * @returns {string[]} list of keys
+     */
+    static getKeysForFixing(metadataMap) {
+        const keysForDeploy = [];
+        if (Object.keys(metadataMap).length) {
+            Util.logger.info(
+                `Searching for ${this.definition.type} keys among downloaded items that need fixing:`
+            );
+            for (const item of Object.values(metadataMap)) {
+                if (item[this.definition.nameField].length > this.definition.maxKeyLength) {
+                    Util.logger.warn(
+                        `Name of the item ${
+                            item[this.definition.keyField]
+                        } is too long for a key. Consider renaming your item. Key will be equal first ${
+                            this.definition.maxKeyLength
+                        } characters of the name`
+                    );
+                    item[this.definition.nameField] = item[this.definition.nameField].slice(
+                        0,
+                        this.definition.maxKeyLength
+                    );
+                }
+
+                if (
+                    item[this.definition.nameField] != item[this.definition.keyField] &&
+                    !this.definition.keyIsFixed
+                ) {
+                    keysForDeploy.push(item[this.definition.keyField]);
+                    Util.logger.info(
+                        ` - added ${this.definition.type} to fixKey queue: ${
+                            item[this.definition.keyField]
+                        }`
+                    );
+                } else {
+                    Util.logger.info(
+                        Util.getGrayMsg(
+                            ` ☇ skipping ${this.definition.type} ${
+                                item[this.definition.keyField]
+                            }: key does not need to be updated`
+                        )
+                    );
+                }
+            }
+            Util.logger.info(`Found ${keysForDeploy.length} ${this.definition.type} keys to fix`);
+        }
+        return keysForDeploy;
+    }
 }
 
 MetadataType.definition = {