mcdev 7.6.3 → 7.7.1

package/lib/metadataTypes/MetadataType.js

@@ -142,8 +142,8 @@ class MetadataType {
      * Deploys metadata
      *
      * @param {MetadataTypeMap} metadataMap 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 {string} deployDir directory where deploy metadata are saved, ending on cred/bu
+     * @param {string} retrieveDir directory where metadata after deploy should be saved, ending on cred/bu
      * @returns {Promise.<MetadataTypeMap>} Promise of keyField => metadata map
      */
     static async deploy(metadataMap, deployDir, retrieveDir) {
@@ -173,24 +173,36 @@ class MetadataType {
      */
     static async postDeployTasks(upsertResults, originalMetadata, createdUpdated) {}
 
+    /**
+     * Gets executed before deleting a list of keys for the current type
+     *
+     * @param {string} keyArr metadata keys
+     * @returns {Promise.<void>} -
+     */
+    static async preDeleteTasks(keyArr) {}
+
     /**
      * helper for {@link MetadataType.createREST}
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
      * @param {MetadataTypeItem} metadataEntryWithAllFields like metadataEntry but before non-creatable fields were stripped
-     * @returns {void}
+     * @returns {Promise.<object>} apiResponse, potentially modified
      */
-    static postCreateTasks(metadataEntry, apiResponse, metadataEntryWithAllFields) {}
+    static async postCreateTasks(metadataEntry, apiResponse, metadataEntryWithAllFields) {
+        return apiResponse;
+    }
 
     /**
      * helper for {@link MetadataType.updateREST}
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
-     * @returns {void}
+     * @returns {Promise.<object>} apiResponse, potentially modified
      */
-    static postUpdateTasks(metadataEntry, apiResponse) {}
+    static postUpdateTasks(metadataEntry, apiResponse) {
+        return apiResponse;
+    }
 
     /**
      * helper for {@link MetadataType.createREST} when legacy API endpoints as these do not return the created item but only their new id
@@ -252,9 +264,8 @@ class MetadataType {
             delete metadata[this.definition.folderIdField];
         } catch (ex) {
             Util.logger.warn(
-                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${
-                    metadata[this.definition.keyField]
-                }): Could not find folder (${ex.message})`
+                Util.getMsgPrefix(this.definition, metadata) +
+                    `: Could not find folder (${ex.message})`
             );
         }
     }
@@ -437,7 +448,7 @@ class MetadataType {
             // write to file
             await File.writeJSONToFile([templateDir, ...typeDirArr], fileName, metadata);
             Util.logger.info(
-                `- templated ${this.definition.type}: ${key} (${
+                ` - templated ${this.definition.type}: ${key} (${
                     metadata[this.definition.nameField]
                 })`
             );
@@ -495,9 +506,7 @@ class MetadataType {
      */
     static async create(metadata, deployDir) {
         Util.logger.error(
-            ` ☇ skipping ${this.definition.type} ${metadata[this.definition.keyField]} / ${
-                metadata[this.definition.nameField]
-            }: create is not supported yet for ${this.definition.type}`
+            ` ☇ skipping ${Util.getTypeKeyName(this.definition, metadata)}: create is not supported yet for ${this.definition.type}`
         );
         return;
     }
@@ -511,9 +520,7 @@ class MetadataType {
      */
     static async update(metadata, metadataBefore) {
         Util.logger.error(
-            ` ☇ skipping ${this.definition.type} ${metadata[this.definition.keyField]} / ${
-                metadata[this.definition.nameField]
-            }: update is not supported yet for ${this.definition.type}`
+            ` ☇ skipping ${Util.getTypeKeyName(this.definition, metadata)}: update is not supported yet for ${this.definition.type}`
         );
         return;
     }
@@ -523,9 +530,10 @@ class MetadataType {
      *
      * @param {string[]} [keyArr] metadata keys
      * @param {boolean} [checkKey] whether to check if the key is valid
+     * @param {MetadataTypeMap} [upsertResults] metadata mapped by their keyField as returned by update/create; needs to be refreshed after publish
      * @returns {Promise.<string[]>} Returns list of keys that were refreshed
      */
-    static async refresh(keyArr, checkKey = true) {
+    static async refresh(keyArr, checkKey = true, upsertResults) {
         Util.logger.error(
             ` ☇ skipping ${this.definition.type}: refresh is not supported yet for ${this.definition.type}`
         );
@@ -610,9 +618,7 @@ class MetadataType {
                     if (!findAssetKeys) {
                         Util.logger.info(
                             Util.getGrayMsg(
-                                ` ☇ skipping ${this.definition.type} ${
-                                    item[this.definition.keyField]
-                                }: no ${fromDescription} found`
+                                ` ☇ skipping ${Util.getTypeKeyName(this.definition, item)}: no ${fromDescription} found`
                             )
                         );
                     }
@@ -774,24 +780,38 @@ class MetadataType {
                 // preDeployTasks parsing
                 let deployableMetadata;
                 try {
-                    await this.validation('deploy', metadataMap[metadataKey], deployDir);
-                    deployableMetadata = await this.preDeployTasks(
+                    metadataMap[metadataKey] = await this.validation(
+                        'deploy',
                         metadataMap[metadataKey],
                         deployDir
                     );
+                    if (metadataMap[metadataKey]) {
+                        // only run unless we encountered a situation in our validation that made us want to filter this record
+                        deployableMetadata = await this.preDeployTasks(
+                            metadataMap[metadataKey],
+                            deployDir
+                        );
+                    }
                 } catch (ex) {
                     // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
                     hasError = true;
                     deployableMetadata = metadataMap[metadataKey];
-
-                    // * include ": ${ex.message}" in the error if this is ever turned back into Util.logger.error()
-                    Util.logger.errorStack(
-                        ex,
-                        ` ☇ skipping ${this.definition.type} ${
-                            deployableMetadata[this.definition.keyField]
-                        } / ${deployableMetadata[this.definition.nameField]}`
-                    );
+                    if (deployableMetadata) {
+                        // * include ": ${ex.message}" in the error if this is ever turned back into Util.logger.error()
+                        Util.logger.errorStack(
+                            ex,
+                            ` ☇ skipping ${this.definition.type} ${
+                                deployableMetadata[this.definition.keyField]
+                            } / ${deployableMetadata[this.definition.nameField]}`
+                        );
+                    } else {
+                        Util.logger.errorStack(
+                            ex,
+                            ` ☇ skipping ${this.definition.type} ${metadataKey}`
+                        );
+                    }
                 }
+
                 // if preDeploy returns nothing then it cannot be deployed so skip deployment
                 if (deployableMetadata) {
                     metadataMap[metadataKey] = deployableMetadata;
@@ -809,8 +829,14 @@ class MetadataType {
                             const result = await this.create(metadataMap[metadataKey], deployDir);
                             if (result) {
                                 createResults.push(result);
+                                if (result[this.definition.idField]) {
+                                    // ensure we have the ID in the cache
+                                    metadataMap[metadataKey][this.definition.idField] =
+                                        result[this.definition.idField];
+                                }
 
                                 // make this newly created item available in cache for other itmes that might reference it
+                                /** @type {MetadataTypeMap} */
                                 const newObject = {};
                                 newObject[metadataKey] = metadataMap[metadataKey];
                                 cache.mergeMetadata(this.definition.type, newObject);
@@ -1174,24 +1200,18 @@ class MetadataType {
         this.removeNotCreateableFields(metadataEntry);
         try {
             // set to empty object in case API returned nothing to be able to update it in helper classes
-            const response = (await this.client.rest.post(uri, metadataEntry)) || {};
-            await this.postCreateTasks(metadataEntry, response, metadataClone);
+            let response = (await this.client.rest.post(uri, metadataEntry)) || {};
+            response = await this.postCreateTasks(metadataEntry, response, metadataClone);
             if (!handleOutside) {
                 Util.logger.info(
-                    ` - created ${this.definition.type}: ${
-                        metadataEntry[this.definition.keyField] ||
-                        metadataEntry[this.definition.nameField]
-                    } / ${metadataEntry[this.definition.nameField]}`
+                    ` - created ${Util.getTypeKeyName(this.definition, metadataEntry)}`
                 );
             }
             return response;
         } catch (ex) {
             const parsedErrors = this.getErrorsREST(ex);
             Util.logger.error(
-                ` ☇ error creating ${this.definition.type} ${
-                    metadataEntry[this.definition.keyField] ||
-                    metadataEntry[this.definition.nameField]
-                } / ${metadataEntry[this.definition.nameField]}:`
+                ` ☇ error creating ${Util.getTypeKeyName(this.definition, metadataEntry)}:`
             );
             if (parsedErrors.length) {
                 for (const msg of parsedErrors) {
@@ -1223,9 +1243,7 @@ class MetadataType {
 
             if (!handleOutside) {
                 Util.logger.info(
-                    ` - created ${this.definition.type}: ${
-                        metadataEntry[this.definition.keyField]
-                    } / ${metadataEntry[this.definition.nameField]}`
+                    ` - created ${Util.getTypeKeyName(this.definition, metadataEntry)}`
                 );
             }
             return response;
@@ -1247,25 +1265,17 @@ class MetadataType {
         this.removeNotUpdateableFields(metadataEntry);
         try {
             // 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)) || {};
+            let response = (await this.client.rest[httpMethod](uri, metadataEntry)) || {};
             await this._postChangeKeyTasks(metadataEntry);
             this.getErrorsREST(response);
-            await this.postUpdateTasks(metadataEntry, response);
+            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(
-                ` - updated ${this.definition.type}: ${
-                    metadataEntry[this.definition.keyField] ||
-                    metadataEntry[this.definition.nameField]
-                } / ${metadataEntry[this.definition.nameField]}`
-            );
+            Util.logger.info(` - updated ${Util.getTypeKeyName(this.definition, metadataEntry)}`);
             return response;
         } catch (ex) {
             const parsedErrors = this.getErrorsREST(ex);
             Util.logger.error(
-                ` ☇ error updating ${this.definition.type} ${
-                    metadataEntry[this.definition.keyField] ||
-                    metadataEntry[this.definition.nameField]
-                } / ${metadataEntry[this.definition.nameField]}:`
+                ` ☇ error updating ${Util.getTypeKeyName(this.definition, metadataEntry)}:`
             );
             for (const msg of parsedErrors) {
                 Util.logger.error('   • ' + msg);
@@ -1326,9 +1336,7 @@ class MetadataType {
             );
             if (!handleOutside) {
                 Util.logger.info(
-                    ` - updated ${this.definition.type}: ${
-                        metadataEntry[this.definition.keyField]
-                    } / ${metadataEntry[this.definition.nameField]}`
+                    ` - updated ${Util.getTypeKeyName(this.definition, metadataEntry)}`
                 );
             }
             await this._postChangeKeyTasks(metadataEntry);
@@ -1559,9 +1567,7 @@ class MetadataType {
             );
             if (response?.OverallStatus === 'OK') {
                 Util.logger.info(
-                    ` - executed ${this.definition.type}: ${
-                        metadataEntry[this.definition.keyField]
-                    }`
+                    ` - executed ${Util.getTypeKeyName(this.definition, metadataEntry)}`
                 );
             } else {
                 throw new Error(response?.OverallStatus);
@@ -1799,9 +1805,7 @@ class MetadataType {
             );
             if (includeByDefinition === false || includeByConfig === false) {
                 Util.logger.debug(
-                    `Filtered ${this.definition.type} '${
-                        metadataEntry[this.definition.nameField]
-                    }' (${metadataEntry[this.definition.keyField]}): not matching include filter`
+                    `Filtered ${Util.getTypeKeyName(this.definition, metadataEntry)}: not matching include filter`
                 );
 
                 return true;
@@ -1815,9 +1819,7 @@ class MetadataType {
             );
             if (excludeByDefinition || excludeByConfig) {
                 Util.logger.debug(
-                    `Filtered ${this.definition.type} '${
-                        metadataEntry[this.definition.nameField]
-                    }' (${metadataEntry[this.definition.keyField]}): matching exclude filter`
+                    `Filtered ${Util.getTypeKeyName(this.definition, metadataEntry)}: matching exclude filter`
                 );
                 return true;
             }
@@ -1846,11 +1848,10 @@ class MetadataType {
         // r__folder_Path found
 
         if (include) {
-            const errorMsg = `Filtered ${this.definition.type} '${
-                metadataEntry[this.definition.nameField]
-            }' (${
-                metadataEntry[this.definition.keyField]
-            }): not matching include filter for folder`;
+            const errorMsg = `Filtered ${Util.getTypeKeyName(
+                this.definition,
+                metadataEntry
+            )}: not matching include filter for folder`;
             // check include-only filters (== discard rest)
             const includeByDefinition = this._filterFolder(
                 this.definition.include,
@@ -1870,9 +1871,7 @@ class MetadataType {
                 return true;
             }
         } else {
-            const errorMsg = `Filtered ${this.definition.type} '${
-                metadataEntry[this.definition.nameField]
-            }' (${metadataEntry[this.definition.keyField]}): matching exclude filter for folder`;
+            const errorMsg = `Filtered ${Util.getTypeKeyName(this.definition, metadataEntry)}: matching exclude filter for folder`;
             // check exclude-only filters (== keep rest)
             const excludeByDefinition = this._filterFolder(
                 this.definition.filter,
@@ -2017,8 +2016,17 @@ class MetadataType {
                     filterCounter++;
                     continue;
                 }
-                await this.validation('retrieve', results[originalKey], retrieveDir);
-
+                results[originalKey] = await this.validation(
+                    'retrieve',
+                    results[originalKey],
+                    retrieveDir
+                );
+                if (!results[originalKey]) {
+                    // we encountered a situation in our validation that made us want to filter this record
+                    delete results[originalKey];
+                    filterCounter++;
+                    continue;
+                }
                 savedResults[originalKey] = await this.saveToDisk(
                     results,
                     originalKey,
@@ -2321,11 +2329,16 @@ class MetadataType {
         );
 
         try {
-            await this.validation(
+            metadata = await this.validation(
                 'buildDefinition',
                 metadata,
                 Array.isArray(targetDir) ? targetDir[0] : targetDir
             );
+            if (!metadata) {
+                // we encountered a situation in our validation that made us want to filter this record
+                return;
+            }
+
             // write to file
             const targetDirArr = Array.isArray(targetDir) ? targetDir : [targetDir];
             for (const targetDir of targetDirArr) {
@@ -2336,9 +2349,10 @@ class MetadataType {
                 );
             }
             Util.logger.info(
-                `- prepared deployment definition of ${this.definition.type}: ${
-                    metadata[this.definition.keyField]
-                }`
+                ` - prepared deployment definition of ${Util.getTypeKeyName(
+                    this.definition,
+                    metadata
+                )}`
             );
             if (
                 metadata.r__folder_Path &&
@@ -2346,16 +2360,15 @@ class MetadataType {
                     metadata.r__folder_Path.startsWith('Shared Items/'))
             ) {
                 Util.logger.warn(
-                    `- ${this.definition.type} ${
-                        metadata[this.definition.keyField]
-                    } is in a shared folder: ${metadata.r__folder_Path}`
+                    Util.getMsgPrefix(this.definition, metadata) +
+                        ` is in a shared folder: ${metadata.r__folder_Path}`
                 );
             }
 
             return { metadata: metadata, type: this.definition.type };
         } catch (ex) {
             Util.logger.error(
-                ` ☇ skipped ${this.definition.type} ${metadata[this.definition.keyField]}${metadata[this.definition.nameField] ? ' / ' + metadata[this.definition.nameField] : ''}: ${ex.message}`
+                ` ☇ skipped ${Util.getTypeKeyName(this.definition, metadata)}: ${ex.message}`
             );
         }
     }
@@ -2775,9 +2788,10 @@ class MetadataType {
                             maxKeyLength)
                 ) {
                     Util.logger.warn(
-                        `Name of the item ${item[this.definition.keyField]} (${
-                            item[this.definition.nameField]
-                        }) is too long for a key${Util.OPTIONS.keySuffix.length ? ' (including the suffix ' + Util.OPTIONS.keySuffix + ')' : ''}. Consider renaming your item. Key will be equal first ${maxKeyLength} characters of the name`
+                        `Name of the item ${Util.getKeyName(
+                            this.definition,
+                            item
+                        )} is too long for a key${Util.OPTIONS.keySuffix.length ? ' (including the suffix ' + Util.OPTIONS.keySuffix + ')' : ''}. Consider renaming your item. Key will be equal first ${maxKeyLength} characters of the name`
                     );
                 }
                 const newKey = this.getNewKey(this.definition.nameField, item, maxKeyLength);
@@ -2785,16 +2799,18 @@ class MetadataType {
                     // add key but make sure to turn it into string or else numeric keys will be filtered later
                     keysForDeploy.push(item[this.definition.keyField] + '');
                     Util.logger.info(
-                        ` - added ${this.definition.type} to fixKey queue: ${
-                            item[this.definition.keyField]
-                        } >> ${newKey}`
+                        ` - added ${this.definition.type} to fixKey queue: ${Util.getKeyName(
+                            this.definition,
+                            item
+                        )} >> ${newKey}`
                     );
                 } else {
                     Util.logger.info(
                         Util.getGrayMsg(
-                            ` ☇ skipping ${this.definition.type} ${
-                                item[this.definition.keyField]
-                            }: key does not need to be updated`
+                            ` ☇ skipping ${Util.getTypeKeyName(
+                                this.definition,
+                                item
+                            )}: key does not need to be updated`
                         )
                     );
                 }
@@ -2841,15 +2857,17 @@ class MetadataType {
      * Gets executed before deploying metadata
      *
      * @param {'retrieve'|'buildDefinition'|'deploy'} method used to select the right config
-     * @param {MetadataTypeItem | CodeExtractItem} item a single metadata item
+     * @param {MetadataTypeItem | CodeExtractItem} originalItem a single metadata item
      * @param {string} targetDir folder where files for deployment are stored
      * @returns {Promise.<MetadataTypeItem | CodeExtractItem>} Promise of a single metadata item
      */
-    static async validation(method, item, targetDir) {
-        item = structuredClone(item);
+    static async validation(method, originalItem, targetDir) {
         if (!this.properties.options?.validation?.[method]) {
-            return item;
+            return originalItem;
         }
+        // if the fix parameter was set, allow validation rules to override the metadata
+        /** @type {MetadataTypeItem | CodeExtractItem} */
+        let item = Util.OPTIONS.fix ? originalItem : structuredClone(originalItem);
         /** @type {MetadataTypeItem} */
         const metadataItem = item.json && item.codeArr ? item.json : item;
         const codeArr = item.codeArr || null;
@@ -2884,26 +2902,55 @@ class MetadataType {
 
         // run validation rules
         const warnings = [];
+        let fixed = false;
         for (const rule of Object.keys(validationRules)) {
             if (
                 validationConfig[rule] &&
                 validationConfig[rule] !== 'off' &&
-                !this.definition.skipValidation?.[rule] &&
-                !(await validationRules[rule].passed())
+                !this.definition.skipValidation?.[rule]
             ) {
-                if (!Util.OPTIONS.skipValidation && validationConfig[rule] === 'error') {
-                    throw new Error(validationRules[rule].failedMsg);
-                } else if (Util.OPTIONS.skipValidation || validationConfig[rule] === 'warn') {
-                    warnings.push(validationRules[rule].failedMsg);
+                const mode = Util.OPTIONS.fix ? 'fix' : validationConfig[rule];
+                const passed = await validationRules[rule].passed(mode);
+                if (mode === 'fix') {
+                    // potentially fixed really
+                    fixed = true;
+                }
+                if (!passed) {
+                    if (mode === 'fix') {
+                        if (passed === false) {
+                            warnings.push(validationRules[rule].failedMsg);
+                        } else if (passed === null) {
+                            // ensure this item no longer exists outside of the validation rule
+                            item = null;
+                            warnings.push(
+                                ` ☇ filtered item via validation rule fix: ` +
+                                    validationRules[rule].failedMsg
+                            );
+                            break;
+                        }
+                    } else if (
+                        !Util.OPTIONS.skipValidation &&
+                        validationConfig[rule] === 'error' &&
+                        passed === false
+                    ) {
+                        throw new Error(validationRules[rule].failedMsg);
+                    } else if (
+                        (Util.OPTIONS.skipValidation || validationConfig[rule] === 'warn') &&
+                        passed === false
+                    ) {
+                        warnings.push(validationRules[rule].failedMsg);
+                    }
                 }
             }
         }
         if (warnings.length) {
             Util.logger.warn(
-                ` - ${this.definition.type} ${metadataItem[this.definition.keyField]} / ${metadataItem[this.definition.nameField]}:${warnings.length > 1 ? '\n        ·' : ''} ${warnings.join('\n        · ')}`
+                Util.getMsgPrefix(this.definition, metadataItem) +
+                    `:${warnings.length > 1 ? '\n        ·' : ''} ${warnings.join('\n        · ')}`
             );
         }
-        return item;
+        // only return "fixed" item if --fix is set, otherwise return the original item
+        return Util.OPTIONS.fix || fixed ? item : originalItem;
     }
 }
 

package/lib/metadataTypes/MobileKeyword.js

@@ -481,10 +481,12 @@ class MobileKeyword extends MetadataType {
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
-     * @returns {Promise.<void>} -
+     * @returns {Promise.<object>} apiResponse
      */
     static async postCreateTasks(metadataEntry, apiResponse) {
         await super.postDeployTasks_legacyApi(metadataEntry, apiResponse);
+
+        return apiResponse;
     }
 
     /**
@@ -492,10 +494,11 @@ class MobileKeyword extends MetadataType {
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
-     * @returns {Promise.<void>} -
+     * @returns {Promise.<object>} apiResponse, potentially modified
      */
     static async postUpdateTasks(metadataEntry, apiResponse) {
         await super.postDeployTasks_legacyApi(metadataEntry, apiResponse);
+        return apiResponse;
     }
 
     /**

package/lib/metadataTypes/MobileMessage.js

@@ -338,10 +338,12 @@ class MobileMessage extends MetadataType {
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
-     * @returns {Promise.<void>} -
+     * @returns {Promise.<object>} apiResponse
      */
     static async postCreateTasks(metadataEntry, apiResponse) {
         await super.postDeployTasks_legacyApi(metadataEntry, apiResponse);
+
+        return apiResponse;
     }
 
     /**
@@ -349,10 +351,11 @@ class MobileMessage extends MetadataType {
      *
      * @param {MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
-     * @returns {Promise.<void>} -
+     * @returns {Promise.<object>} apiResponse, potentially modified
      */
     static async postUpdateTasks(metadataEntry, apiResponse) {
         await super.postDeployTasks_legacyApi(metadataEntry, apiResponse);
+        return apiResponse;
     }
 
     /**

package/lib/metadataTypes/SendClassification.js

@@ -1,6 +1,7 @@
 'use strict';
 
 import MetadataType from './MetadataType.js';
+import SenderProfile from './SenderProfile.js';
 import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
 
@@ -110,6 +111,8 @@ class SendClassification extends MetadataType {
             'CustomerKey',
             'ObjectID'
         );
+        const sp = cache.getByKey('senderProfile', metadata.r__senderProfile_key);
+        SenderProfile.verifySenderEmailAddresses(sp, metadata, this.definition);
         metadata.SenderProfile = {
             ObjectID: spId,
             CustomerKey: metadata.r__senderProfile_key,
@@ -173,6 +176,8 @@ class SendClassification extends MetadataType {
                 'CustomerKey'
             );
             delete metadata.SenderProfile;
+            const sp = cache.getByKey('senderProfile', metadata.r__senderProfile_key);
+            SenderProfile.verifySenderEmailAddresses(sp, metadata, this.definition);
         } catch (ex) {
             Util.logger.warn(` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`);
         }