mcdev 7.10.0 → 7.10.1

package/lib/metadataTypes/DataExtension.js

@@ -1476,7 +1476,7 @@ class DataExtension extends MetadataType {
      * @returns {Promise.<boolean>} deletion success status
      */
     static deleteByKey(customerKey) {
-        return super.deleteByKeySOAP(customerKey);
+        return super.deleteByKeySOAP(customerKey, undefined, 310007);
     }
 
     /**

package/lib/metadataTypes/DataExtract.js

@@ -129,6 +129,21 @@ class DataExtract extends MetadataType {
      * @returns {MetadataTypeItem} metadata object
      */
     static preDeployTasks(metadata) {
+        // dataExtension
+        if (metadata.r__dataExtension_key) {
+            const deField = metadata.dataFields.find((field) => field.name === 'DECustomerKey');
+            if (deField) {
+                deField.value = cache.searchForField(
+                    'dataExtension',
+                    metadata.r__dataExtension_key,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                delete metadata.r__dataExtension_key;
+            }
+        }
+
+        // dataExtractType
         metadata.dataExtractTypeId = cache.searchForField(
             'dataExtractType',
             metadata.r__dataExtractType_name,
@@ -166,6 +181,7 @@ class DataExtract extends MetadataType {
      * @returns {MetadataTypeItem} metadata
      */
     static postRetrieveTasks(metadata) {
+        // user
         try {
             metadata.createdBy = cache.searchForField(
                 'user',
@@ -195,6 +211,25 @@ class DataExtract extends MetadataType {
                 }): ${ex.message}.`
             );
         }
+        // dataExtension
+        const deField = metadata.dataFields.find((field) => field.name === 'DECustomerKey');
+        if (deField && deField.value) {
+            try {
+                metadata.r__dataExtension_key = cache.searchForField(
+                    'dataExtension',
+                    deField.value,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                delete deField.value;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata[this.definition.keyField]}: ${ex.message}`
+                );
+            }
+        }
+
+        // dataExtractType
         try {
             metadata.r__dataExtractType_name = cache.searchForField(
                 'dataExtractType',
@@ -208,7 +243,7 @@ class DataExtract extends MetadataType {
                 ` - ${this.definition.type} ${metadata[this.definition.keyField]}: ${ex.message}`
             );
         }
-        return structuredClone(metadata);
+        return metadata;
     }
 
     /**
@@ -232,17 +267,17 @@ class DataExtract extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {string} customerKey Identifier of data extension
+     * @param {string} key Identifier of data extension
      * @returns {Promise.<boolean>} deletion success flag
      */
-    static async deleteByKey(customerKey) {
+    static async deleteByKey(key) {
         // delete only works with the query's object id
-        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        const objectId = key ? await this._getObjectIdForSingleRetrieve(key) : null;
         if (!objectId) {
-            Util.logger.error(` - dataExtract ${customerKey} not found`);
+            await this.deleteNotFound(key);
             return false;
         }
-        return super.deleteByKeyREST('/automation/v1/dataextracts/' + objectId, customerKey);
+        return super.deleteByKeyREST('/automation/v1/dataextracts/' + objectId, key);
     }
 }
 

package/lib/metadataTypes/DomainVerification.js

@@ -262,7 +262,7 @@ class DomainVerification extends MetadataType {
     static async deleteByKey(key) {
         const metadataItem = cache.getByKey(this.definition.type, key);
         if (!metadataItem) {
-            Util.logger.error(` - ${this.definition.type} ${key} not found`);
+            await this.deleteNotFound(key);
             return false;
         }
         if (metadataItem.domainType !== 'UserDomain') {

package/lib/metadataTypes/EmailSend.js

@@ -90,11 +90,11 @@ class EmailSend extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {string} customerKey Identifier of data extension
+     * @param {string} key Identifier of data extension
      * @returns {Promise.<boolean>} deletion success status
      */
-    static deleteByKey(customerKey) {
-        return super.deleteByKeySOAP(customerKey);
+    static deleteByKey(key) {
+        return super.deleteByKeySOAP(key, undefined, 42002);
     }
 
     /**

package/lib/metadataTypes/Event.js

@@ -141,26 +141,11 @@ class Event extends MetadataType {
      * @returns {Promise.<boolean>} deletion success status
      */
     static async deleteByKey(key) {
-        let response = false;
-        try {
-            response = await super.deleteByKeyREST(
-                '/interaction/v1/eventDefinitions/key:' + encodeURIComponent(key),
-                key,
-                true
-            );
-            Util.logger.info(` - deleted ${this.definition.type}: ${key}`);
-        } catch (ex) {
-            if (ex.code === 30000) {
-                Util.logger.warn(
-                    ` ☇ skipping deletion of ${this.definition.type} ${key}: not found on server`
-                );
-            } else {
-                Util.logger.errorStack(ex, ` - Deleting ${this.definition.type} '${key}' failed`);
-            }
-
-            return false;
-        }
-        return response;
+        return await super.deleteByKeyREST(
+            '/interaction/v1/eventDefinitions/key:' + encodeURIComponent(key),
+            key,
+            30000
+        );
     }
 
     /**
@@ -369,8 +354,20 @@ class Event extends MetadataType {
             }
             if (!deFound) {
                 if (metadataItem.r__dataExtension_key) {
+                    if (!metadataItem.schema) {
+                        // make sure we skip this item
+                        this.removeFromDeployment(metadataKey, metadataToUpdate, metadataToCreate);
+                        throw new Error(
+                            `related dataExtension ${metadataItem.r__dataExtension_key} not found`
+                        );
+                    }
                     metadataItem.schema.name = metadataItem.r__dataExtension_key;
                 }
+                if (!metadataItem.schema) {
+                    this.removeFromDeployment(metadataKey, metadataToUpdate, metadataToCreate);
+                    throw new Error(`no related dataExtension and no schema found`);
+                }
+
                 Util.logger.warn(
                     `Data Extension ${metadataItem.schema.name || metadataItem[this.definition.keyField]} not found on BU. Creating it automatically based on schema-definition.`
                 );
@@ -384,6 +381,28 @@ class Event extends MetadataType {
         return createOrUpdateAction;
     }
 
+    /**
+     * helper for {@link createOrUpdate}
+     *
+     * @param {string} metadataKey key of item we are looking at
+     * @param {MetadataTypeItemDiff[]} metadataToUpdate list of items to update
+     * @param {MetadataTypeItem[]} metadataToCreate list of items to create
+     */
+    static removeFromDeployment(metadataKey, metadataToUpdate, metadataToCreate) {
+        const removeUpdate = metadataToUpdate.findIndex(
+            (el) => el.after[this.definition.keyField] === metadataKey
+        );
+        if (removeUpdate !== -1) {
+            metadataToUpdate.splice(removeUpdate, 1);
+        }
+        const removeCreate = metadataToCreate.findIndex(
+            (el) => el[this.definition.keyField] === metadataKey
+        );
+        if (removeCreate !== -1) {
+            metadataToCreate.splice(removeCreate, 1);
+        }
+    }
+
     /**
      * Gets executed after deployment of metadata type
      *

package/lib/metadataTypes/FileTransfer.js

@@ -187,17 +187,17 @@ class FileTransfer extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {string} customerKey Identifier of data extension
+     * @param {string} key Identifier of data extension
      * @returns {Promise.<boolean>} deletion success flag
      */
-    static async deleteByKey(customerKey) {
+    static async deleteByKey(key) {
         // delete only works with the query's object id
-        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        const objectId = key ? await this._getObjectIdForSingleRetrieve(key) : null;
         if (!objectId) {
-            Util.logger.error(` - fileTransfer ${customerKey} not found`);
+            await this.deleteNotFound(key);
             return false;
         }
-        return super.deleteByKeyREST('/automation/v1/filetransfers/' + objectId, customerKey);
+        return super.deleteByKeyREST('/automation/v1/filetransfers/' + objectId, key);
     }
 }
 

package/lib/metadataTypes/ImportFile.js

@@ -228,9 +228,11 @@ class ImportFile extends MetadataType {
      * @returns {Promise.<MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
-        const fileLocation = cache.getByKey('fileLocation', metadata.source.r__fileLocation_name);
+        const fileLocation = cache.getByKey('fileLocation', metadata.source?.r__fileLocation_name);
         if (!fileLocation) {
-            throw new Error(`fileLocation ${metadata.r__fileLocation_name} not found in cache`);
+            throw new Error(
+                `fileLocation ${metadata.source?.r__fileLocation_name} not found in cache`
+            );
         }
 
         metadata.fileTransferLocationId = fileLocation.id;
@@ -512,17 +514,17 @@ class ImportFile extends MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {string} customerKey Identifier of data extension
+     * @param {string} key Identifier of data extension
      * @returns {Promise.<boolean>} deletion success flag
      */
-    static async deleteByKey(customerKey) {
+    static async deleteByKey(key) {
         // delete only works with the query's object id
-        const objectId = customerKey ? await this._getObjectIdForSingleRetrieve(customerKey) : null;
+        const objectId = key ? await this._getObjectIdForSingleRetrieve(key) : null;
         if (!objectId) {
-            Util.logger.error(` - importFile ${customerKey} not found`);
+            await this.deleteNotFound(key);
             return false;
         }
-        return super.deleteByKeyREST('/automation/v1/imports/' + objectId, customerKey);
+        return super.deleteByKeyREST('/automation/v1/imports/' + objectId, key);
     }
 }
 

package/lib/metadataTypes/Journey.js

@@ -256,9 +256,7 @@ class Journey extends MetadataType {
             }
         }
         if (!cachedJourney?.key) {
-            Util.logger.warn(
-                ` ☇ skipping deletion of ${this.definition.type} ${key}: not found on server`
-            );
+            await this.deleteNotFound(key);
             return false;
         }
         switch (cachedJourney.definitionType) {
@@ -287,8 +285,7 @@ class Journey extends MetadataType {
                     '/interaction/v1/interactions/' +
                         id +
                         (version === '*' ? '' : `?versionNumber=${version}`),
-                    key,
-                    false
+                    key
                 );
                 // break;
             }
@@ -296,8 +293,7 @@ class Journey extends MetadataType {
                 // Quicksend doesnt have versions
                 const isDeleted = await super.deleteByKeyREST(
                     '/interaction/v1/interactions/' + id,
-                    key,
-                    false
+                    key
                 );
                 return isDeleted;
             }
@@ -305,8 +301,7 @@ class Journey extends MetadataType {
                 //  Transactional dont have versions
                 const isDeleted = await super.deleteByKeyREST(
                     '/interaction/v1/interactions/' + id,
-                    key,
-                    false
+                    key
                 );
                 const transactionalEmailKey =
                     cachedJourney.activities[0]?.configurationArguments?.triggeredSendKey;

package/lib/metadataTypes/MetadataType.js

@@ -157,7 +157,7 @@ class MetadataType {
             ) {
                 // * do not await here as this might take a while and has no impact on the deploy
                 // * this should only be run if documentation is on a per metadata record level. Types that document an overview into a single file will need a full retrieve to work instead
-                this.document(savedMetadataMap, true);
+                await this.document(savedMetadataMap, true);
             }
         }
         return upsertedMetadataMap;
@@ -299,8 +299,7 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} metadata
      */
     static async retrieve(retrieveDir, additionalFields, subTypeArr, key) {
-        Util.metadataLogger('error', this.definition.type, 'retrieve', `Not Supported`);
-        const metadata = {};
+        Util.notSupportedError(this.definition, 'retrieve');
         return { metadata: {}, type: this.definition.type };
     }
 
@@ -337,13 +336,7 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeItemObj>} metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables, subType) {
-        Util.logger.error('retrieveAsTemplate is not supported yet for ' + this.definition.type);
-        Util.metadataLogger(
-            'debug',
-            this.definition.type,
-            'retrieveAsTemplate',
-            `(${templateDir}, ${name}, ${templateVariables}) no templating function`
-        );
+        Util.notSupportedError(this.definition, 'retrieveAsTemplate');
         return { metadata: null, type: this.definition.type };
     }
 
@@ -506,9 +499,7 @@ class MetadataType {
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async create(metadata, deployDir) {
-        Util.logger.error(
-            ` ☇ skipping ${Util.getTypeKeyName(this.definition, metadata)}: create is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'retrieveAsTemplate', metadata);
         return;
     }
 
@@ -520,9 +511,7 @@ class MetadataType {
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async update(metadata, metadataBefore) {
-        Util.logger.error(
-            ` ☇ skipping ${Util.getTypeKeyName(this.definition, metadata)}: update is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'retrieveAsTemplate', metadata);
         return;
     }
 
@@ -535,9 +524,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were refreshed
      */
     static async refresh(keyArr, checkKey = true, upsertResults) {
-        Util.logger.error(
-            ` ☇ skipping ${this.definition.type}: refresh is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'refresh');
         return [];
     }
 
@@ -643,9 +630,7 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeItem | CodeExtractItem>} key of the item that was updated
      */
     static async replaceCbReference(item, retrieveDir, findAssetKeys) {
-        Util.logger.error(
-            ` ☇ skipping ${this.definition.type}: replaceCbReference is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'replaceCbReference');
         return [];
     }
 
@@ -657,9 +642,19 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were executed
      */
     static async execute(keyArr, cache) {
-        Util.logger.error(
-            ` ☇ skipping ${this.definition.type}: execute is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'execute');
+        return [];
+    }
+
+    /**
+     * Abstract schedule method that needs to be implemented in child metadata type
+     *
+     * @param {string[]} keyArr customerkey of the metadata
+     * @param {MetadataTypeMapObj} [cache] metadata cache used by refresh to avoid recaching
+     * @returns {Promise.<string[]>} Returns list of keys that were executed
+     */
+    static async schedule(keyArr, cache) {
+        Util.notSupportedError(this.definition, 'schedule');
         return [];
     }
 
@@ -671,9 +666,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were paused
      */
     static async pause(keyArr, cache) {
-        Util.logger.error(
-            ` ☇ skipping ${this.definition.type}: pause is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'pause');
         return [];
     }
 
@@ -684,9 +677,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were stopped
      */
     static async stop(keyArr) {
-        Util.logger.error(
-            ` ☇ skipping ${this.definition.type}: stop is not supported yet for ${this.definition.type}`
-        );
+        Util.notSupportedError(this.definition, 'stop');
         return [];
     }
 
@@ -1493,7 +1484,7 @@ class MetadataType {
      */
     static async retrieveRESTcollection(urlArray, concurrentRequests = 10, logAmountOfUrls = true) {
         if (logAmountOfUrls) {
-            Util.logger.info(
+            Util.logger.debug(
                 Util.getGrayMsg(
                     ` - ${urlArray?.length} ${this.definition.type}${
                         urlArray?.length === 1 ? '' : 's'
@@ -2341,6 +2332,17 @@ class MetadataType {
             );
         }
 
+        // run validations before buildDefinitionForNested because that method writes extracted code to disk
+        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;
+        }
+
         // handle extracted code
         // run after metadata was templated and converted into JS-object
         // templating to extracted content is applied inside of buildDefinitionForNested()
@@ -2353,16 +2355,6 @@ class MetadataType {
         );
 
         try {
-            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) {
@@ -2446,7 +2438,7 @@ class MetadataType {
      */
     static document(metadata, isDeploy) {
         if (!isDeploy) {
-            Util.logger.error(`Documenting type ${this.definition.type} is not supported.`);
+            Util.notSupportedError(this.definition, 'document');
         }
     }
 
@@ -2457,7 +2449,7 @@ class MetadataType {
      * @returns {Promise.<{key:string, name:string}>} key, name and path of metadata; null if not found
      */
     static async resolveId(id) {
-        Util.logger.error(`resolveId type ${this.definition.type} is not supported.`);
+        Util.notSupportedError(this.definition, 'resolveId');
         return;
     }
 
@@ -2468,7 +2460,7 @@ class MetadataType {
      * @returns {Promise.<boolean>} deletion success status
      */
     static async deleteByKey(customerKey) {
-        Util.logger.error(`Deletion is not yet supported for ${this.definition.typeName}!`);
+        Util.notSupportedError(this.definition, 'delete');
         return false;
     }
 
@@ -2497,26 +2489,33 @@ class MetadataType {
     /**
      * Delete a data extension from the specified business unit
      *
-     * @param {string} customerKey Identifier of metadata
+     * @param {string} key Identifier of metadata
      * @param {string} [overrideKeyField] optionally change the name of the key field if the api uses a different name
+     * @param {number} [codeNotFound] error code that is responded with if the item was not found
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {Promise.<boolean>} deletion success flag
      */
-    static async deleteByKeySOAP(customerKey, overrideKeyField, handleOutside) {
+    static async deleteByKeySOAP(key, overrideKeyField, codeNotFound, handleOutside) {
         const metadata = {};
-        metadata[overrideKeyField || this.definition.keyField] = customerKey;
+        metadata[overrideKeyField || this.definition.keyField] = key;
         const soapType = this.definition.soapType || this.definition.type;
         try {
             await this.client.soap.delete(Util.capitalizeFirstLetter(soapType), metadata, null);
             if (!handleOutside) {
-                Util.logger.info(` - deleted ${this.definition.type}: ${customerKey}`);
+                Util.logger.info(` - deleted ${this.definition.type}: ${key}`);
             }
-            this.postDeleteTasks(customerKey);
+            await this.postDeleteTasks(key);
 
             return true;
         } catch (ex) {
             if (handleOutside) {
                 throw ex;
+            } else if (
+                codeNotFound &&
+                (ex.results?.[0]?.ErrorCode == codeNotFound ||
+                    ex.json?.Results?.[0]?.ErrorCode == codeNotFound)
+            ) {
+                await this.deleteNotFound(key);
             } else {
                 const errorMsg = ex?.results?.length
                     ? `${ex.results[0].StatusMessage} (Code ${ex.results[0].ErrorCode})`
@@ -2524,7 +2523,7 @@ class MetadataType {
                       ? `${ex.json.Results[0].StatusMessage} (Code ${ex.json.Results[0].ErrorCode})`
                       : ex.message;
                 Util.logger.error(
-                    ` - Deleting ${this.definition.type} '${customerKey}' failed: ${errorMsg}`
+                    ` - Deleting ${this.definition.type} '${key}' failed: ${errorMsg}`
                 );
             }
 
@@ -2537,21 +2536,27 @@ class MetadataType {
      *
      * @param {string} url endpoint
      * @param {string} key Identifier of metadata
+     * @param {number} [codeNotFound] error code that is responded with if the item was not found
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {Promise.<boolean>} deletion success flag
      */
-    static async deleteByKeyREST(url, key, handleOutside) {
+    static async deleteByKeyREST(url, key, codeNotFound, handleOutside) {
         try {
             await this.client.rest.delete(url);
             if (!handleOutside) {
                 Util.logger.info(` - deleted ${this.definition.type}: ${key}`);
             }
-            this.postDeleteTasks(key);
+            await this.postDeleteTasks(key);
 
             return true;
         } catch (ex) {
             if (handleOutside) {
                 throw ex;
+            } else if (
+                codeNotFound &&
+                (ex.code === codeNotFound || ex.response?.status === codeNotFound)
+            ) {
+                await this.deleteNotFound(key);
             } else {
                 Util.logger.errorStack(ex, ` - Deleting ${this.definition.type} '${key}' failed`);
             }
@@ -2560,6 +2565,18 @@ class MetadataType {
         }
     }
 
+    /**
+     * helper for {@link deleteByKey}, {@link deleteByKeyREST}, {@link deleteByKeySOAP}
+     *
+     * @param {string} key Identifier of metadata
+     */
+    static async deleteNotFound(key) {
+        Util.logger.error(
+            ` ☇ skipping deletion of ${this.definition.type} ${key}: not found on server`
+        );
+        await this.postDeleteTasks(key);
+    }
+
     /**
      * Returns metadata of a business unit that is saved locally
      *
@@ -2600,7 +2617,9 @@ class MetadataType {
             this.definition.type,
         ]);
 
-        const fileList = keyArr.map((key) => File.normalizePath([path, key + typeExtension]));
+        const fileList = keyArr.map((key) =>
+            File.normalizePath([path, File.filterIllegalFilenames(key) + typeExtension])
+        );
         return fileList;
     }
 
@@ -2641,7 +2660,10 @@ class MetadataType {
                     // make sure we don't retry components that we have already searched without result
                     !notFoundList[this.definition.type].includes(key) &&
                     // make sure we don't search for components that we have already found
-                    !multiTypeKeyList[this.definition.type].includes(key)
+                    !multiTypeKeyList[this.definition.type].includes(key) &&
+                    // filter out ampscript code that was used instead of actual keys; relevant e.g. for domainVerifications mentioned in senderProfiles
+                    !key.startsWith('%%') &&
+                    !key.endsWith('%%')
             );
         if (!keyArr.length) {
             return;
@@ -2943,7 +2965,7 @@ class MetadataType {
                 let passed;
 
                 try {
-                    passed = await (mode === 'fix'
+                    passed = await (!Util.OPTIONS.skipValidation && mode === 'fix'
                         ? validationRules[rule].fix()
                         : validationRules[rule].passed());
                 } catch (ex) {
@@ -2958,7 +2980,7 @@ class MetadataType {
                     fixed = true;
                 }
                 if (!passed) {
-                    if (mode === 'fix') {
+                    if (!Util.OPTIONS.skipValidation && mode === 'fix') {
                         if (passed === false) {
                             info.push('😎 auto-fixed: ' + validationRules[rule].failedMsg);
                         } else if (passed === null) {
@@ -3000,7 +3022,7 @@ class MetadataType {
             );
         }
         // only return "fixed" item if --fix is set, otherwise return the original item
-        return Util.OPTIONS.fix || fixed ? item : originalItem;
+        return !Util.OPTIONS.skipValidation && (Util.OPTIONS.fix || fixed) ? item : originalItem;
     }
 }
 

package/lib/metadataTypes/MobileKeyword.js

@@ -491,7 +491,7 @@ class MobileKeyword extends MetadataType {
         // get id from cache
         const { metadata } = await this.retrieveForCache(undefined, undefined, key);
         if (!metadata[key]) {
-            Util.logger.error(` - mobileKeyword ${key} not found`);
+            await this.deleteNotFound(key);
             return false;
         }
         const id = metadata[key][this.definition.idField];
@@ -499,7 +499,7 @@ class MobileKeyword extends MetadataType {
         Util.logger.info(
             ' - Note: As long as the provided API key once existed, you will not see an error even if the mobileKeyword is already deleted.'
         );
-        return super.deleteByKeyREST('/legacy/v1/beta/mobile/keyword/' + id, key, false);
+        return super.deleteByKeyREST('/legacy/v1/beta/mobile/keyword/' + id, key);
     }
 
     /**

package/lib/metadataTypes/MobileMessage.js

@@ -491,9 +491,11 @@ class MobileMessage extends MetadataType {
      */
     static deleteByKey(id) {
         Util.logger.info(
-            ' - Note: As long as the provided API key once existed, you will not see an error even if the mobileMessage is already deleted.'
+            Util.getGrayMsg(
+                ' - Note: As long as the provided API key once existed, you will not see an error even if the mobileMessage is already deleted.'
+            )
         );
-        return super.deleteByKeyREST('/legacy/v1/beta/mobile/message/' + id, id, false);
+        return super.deleteByKeyREST('/legacy/v1/beta/mobile/message/' + id, id, 400);
     }
 }