mcdev 4.2.1 → 4.3.0

package/lib/metadataTypes/MetadataType.js

@@ -15,6 +15,15 @@ const cache = require('../util/cache');
 const deepEqual = require('deep-equal');
 const pLimit = require('p-limit');
 const Mustache = require('mustache');
+/**
+ * ensure that Mustache does not escape any characters
+ *
+ * @param {string} text -
+ * @returns {string} text
+ */
+Mustache.escape = function (text) {
+    return text;
+};
 
 /**
  * MetadataType class that gets extended by their specific metadata type class.
@@ -103,11 +112,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 {TYPE.BuObject} buObject properties for auth
      * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of keyField => metadata map
      */
-    static async deploy(metadata, deployDir, retrieveDir, buObject) {
-        const upsertResults = await this.upsert(metadata, deployDir, buObject);
+    static async deploy(metadata, deployDir, retrieveDir) {
+        const upsertResults = await this.upsert(metadata, deployDir);
         await this.postDeployTasks(upsertResults, metadata);
         const savedMetadata = await this.saveResults(upsertResults, retrieveDir, null);
         if (
@@ -116,7 +124,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(buObject, savedMetadata, true);
+            this.document(savedMetadata, true);
         }
         return upsertResults;
     }
@@ -144,7 +152,7 @@ class MetadataType {
     /**
      * generic script that retrieves the folder path from cache and updates the given metadata with it after retrieve
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
+     * @param {TYPE.MetadataTypeItem} metadata a single item
      */
     static setFolderPath(metadata) {
         if (!this.definition.folderIdField) {
@@ -166,18 +174,34 @@ class MetadataType {
             );
         }
     }
+    /**
+     * generic script that retrieves the folder ID from cache and updates the given metadata with it before deploy
+     *
+     * @param {TYPE.MetadataTypeItem} metadata a single item
+     */
+    static setFolderId(metadata) {
+        if (!this.definition.folderIdField) {
+            return;
+        }
+        metadata[this.definition.folderIdField] = cache.searchForField(
+            'folder',
+            metadata.r__folder_Path,
+            'Path',
+            'ID'
+        );
+        delete metadata.r__folder_Path;
+    }
 
     /**
      * Gets metadata from Marketing Cloud
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
-     * @param {TYPE.BuObject} buObject properties for auth
-     * @param {string} [subType] optionally limit to a single subtype
+     * @param {string[]} [subTypeArr] optionally limit to a single subtype
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} metadata
      */
-    static retrieve(retrieveDir, additionalFields, buObject, subType, key) {
+    static retrieve(retrieveDir, additionalFields, subTypeArr, key) {
         Util.metadataLogger('error', this.definition.type, 'retrieve', `Not Supported`);
         const metadata = {};
         return { metadata: null, type: this.definition.type };
@@ -185,24 +209,23 @@ class MetadataType {
     /**
      * Gets metadata from Marketing Cloud
      *
-     * @param {TYPE.BuObject} [buObject] properties for auth
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
-     * @param {string} [subType] optionally limit to a single subtype
+     * @param {string[]} [subTypeArr] optionally limit to a single subtype
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} metadata
      */
-    static retrieveChangelog(buObject, additionalFields, subType) {
-        return this.retrieveForCache(buObject, subType);
+    static retrieveChangelog(additionalFields, subTypeArr) {
+        return this.retrieveForCache(additionalFields, subTypeArr);
     }
 
     /**
      * Gets metadata cache with limited fields and does not store value to disk
      *
-     * @param {TYPE.BuObject} buObject properties for auth
-     * @param {string} [subType] optionally limit to a single subtype
+     * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
+     * @param {string[]} [subTypeArr] optionally limit to a single subtype
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} metadata
      */
-    static async retrieveForCache(buObject, subType) {
-        return this.retrieve(null, null, buObject, subType);
+    static async retrieveForCache(additionalFields, subTypeArr) {
+        return this.retrieve(null, additionalFields, subTypeArr);
     }
     /**
      * Gets metadata cache with limited fields and does not store value to disk
@@ -303,10 +326,9 @@ class MetadataType {
      *
      * @param {TYPE.MetadataTypeItem} metadata a single metadata item
      * @param {string} deployDir folder where files for deployment are stored
-     * @param {TYPE.BuObject} buObject buObject properties for auth
      * @returns {Promise.<TYPE.MetadataTypeItem>} Promise of a single metadata item
      */
-    static async preDeployTasks(metadata, deployDir, buObject) {
+    static async preDeployTasks(metadata, deployDir) {
         return metadata;
     }
 
@@ -341,6 +363,17 @@ class MetadataType {
         );
         return;
     }
+    /**
+     * Abstract refresh method that needs to be implemented in child metadata type
+     *
+     * @returns {void}
+     */
+    static refresh() {
+        Util.logger.error(
+            ` ☇ skipping ${this.definition.type}: refresh is not supported yet for ${this.definition.type}`
+        );
+        return;
+    }
 
     /**
      * test if metadata was actually changed or not to potentially skip it during deployment
@@ -413,10 +446,9 @@ class MetadataType {
      *
      * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
-     * @param {TYPE.BuObject} [buObject] properties for auth
      * @returns {Promise.<TYPE.MetadataTypeMap>} keyField => metadata map
      */
-    static async upsert(metadata, deployDir, buObject) {
+    static async upsert(metadata, deployDir) {
         const metadataToUpdate = [];
         const metadataToCreate = [];
         let filteredByPreDeploy = 0;
@@ -428,8 +460,7 @@ class MetadataType {
                 try {
                     deployableMetadata = await this.preDeployTasks(
                         metadata[metadataKey],
-                        deployDir,
-                        buObject
+                        deployDir
                     );
                 } catch (ex) {
                     // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
@@ -445,57 +476,13 @@ class MetadataType {
                 if (deployableMetadata) {
                     metadata[metadataKey] = deployableMetadata;
                     // create normalizedKey off of whats in the json rather than from "metadataKey" because preDeployTasks might have altered something (type asset)
-                    const normalizedKey = File.reverseFilterIllegalFilenames(
-                        deployableMetadata[this.definition.keyField]
+                    this.createOrUpdate(
+                        metadata,
+                        metadataKey,
+                        hasError,
+                        metadataToUpdate,
+                        metadataToCreate
                     );
-                    // Update if it already exists; Create it if not
-                    if (
-                        Util.logger.level === 'debug' &&
-                        metadata[metadataKey][this.definition.idField]
-                    ) {
-                        // TODO: re-evaluate in future releases if & when we managed to solve folder dependencies once and for all
-                        // only used if resource is excluded from cache and we still want to update it
-                        // needed e.g. to rewire lost folders
-                        Util.logger.warn(
-                            ' - Hotfix for non-cachable resource found in deploy folder. Trying update:'
-                        );
-                        Util.logger.warn(JSON.stringify(metadata[metadataKey]));
-                        if (hasError) {
-                            metadataToUpdate.push(null);
-                        } else {
-                            metadataToUpdate.push({
-                                before: {},
-                                after: metadata[metadataKey],
-                            });
-                        }
-                    } else if (cache.getByKey(this.definition.type, normalizedKey)) {
-                        // normal way of processing update files
-                        const cachedVersion = cache.getByKey(this.definition.type, normalizedKey);
-                        if (!this.hasChanged(cachedVersion, metadata[metadataKey])) {
-                            hasError = true;
-                        }
-
-                        if (hasError) {
-                            // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
-                            metadataToUpdate.push(null);
-                        } else {
-                            // add ObjectId to allow actual update
-                            metadata[metadataKey][this.definition.idField] =
-                                cachedVersion[this.definition.idField];
-
-                            metadataToUpdate.push({
-                                before: cache.getByKey(this.definition.type, normalizedKey),
-                                after: metadata[metadataKey],
-                            });
-                        }
-                    } else {
-                        if (hasError) {
-                            // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
-                            metadataToCreate.push(null);
-                        } else {
-                            metadataToCreate.push(metadata[metadataKey]);
-                        }
-                    }
                 } else {
                     filteredByPreDeploy++;
                 }
@@ -554,12 +541,72 @@ class MetadataType {
         }
     }
 
+    /**
+     *
+     * @param {TYPE.MetadataTypeItem} metadata single metadata itme
+     * @param {string} metadataKey key of item we are looking at
+     * @param {boolean} hasError error flag from previous code
+     * @param {TYPE.MetadataTypeItemDiff[]} metadataToUpdate list of items to update
+     * @param {TYPE.MetadataTypeItem[]} metadataToCreate list of items to create
+     * @returns {void}
+     */
+    static createOrUpdate(metadata, metadataKey, hasError, metadataToUpdate, metadataToCreate) {
+        const normalizedKey = File.reverseFilterIllegalFilenames(
+            metadata[metadataKey][this.definition.keyField]
+        );
+        // Update if it already exists; Create it if not
+        if (Util.logger.level === 'debug' && metadata[metadataKey][this.definition.idField]) {
+            // TODO: re-evaluate in future releases if & when we managed to solve folder dependencies once and for all
+            // only used if resource is excluded from cache and we still want to update it
+            // needed e.g. to rewire lost folders
+            Util.logger.warn(
+                ' - Hotfix for non-cachable resource found in deploy folder. Trying update:'
+            );
+            Util.logger.warn(JSON.stringify(metadata[metadataKey]));
+            if (hasError) {
+                metadataToUpdate.push(null);
+            } else {
+                metadataToUpdate.push({
+                    before: {},
+                    after: metadata[metadataKey],
+                });
+            }
+        } else if (cache.getByKey(this.definition.type, normalizedKey)) {
+            // normal way of processing update files
+            const cachedVersion = cache.getByKey(this.definition.type, normalizedKey);
+            if (!this.hasChanged(cachedVersion, metadata[metadataKey])) {
+                hasError = true;
+            }
+
+            if (hasError) {
+                // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
+                metadataToUpdate.push(null);
+            } else {
+                // add ObjectId to allow actual update
+                metadata[metadataKey][this.definition.idField] =
+                    cachedVersion[this.definition.idField];
+
+                metadataToUpdate.push({
+                    before: cache.getByKey(this.definition.type, normalizedKey),
+                    after: metadata[metadataKey],
+                });
+            }
+        } else {
+            if (hasError) {
+                // do this in case something went wrong during pre-deploy steps to ensure the total counter is correct
+                metadataToCreate.push(null);
+            } else {
+                metadataToCreate.push(metadata[metadataKey]);
+            }
+        }
+    }
+
     /**
      * Creates a single metadata entry via REST
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {string} uri rest endpoint for POST
-     * @returns {Promise} Promise
+     * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async createREST(metadataEntry, uri) {
         this.removeNotCreateableFields(metadataEntry);
@@ -593,7 +640,7 @@ class MetadataType {
      * @param {TYPE.MetadataTypeItem} metadataEntry single metadata entry
      * @param {string} [overrideType] can be used if the API type differs from the otherwise used type identifier
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
-     * @returns {Promise} Promise
+     * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async createSOAP(metadataEntry, overrideType, handleOutside) {
         try {
@@ -615,7 +662,7 @@ class MetadataType {
             return response;
         } catch (ex) {
             this._handleSOAPErrors(ex, 'creating', metadataEntry, handleOutside);
-            return {};
+            return null;
         }
     }
 
@@ -624,12 +671,15 @@ class MetadataType {
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {string} uri rest endpoint for PATCH
-     * @returns {Promise} Promise
+     * @param {boolean} [usePut] 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) {
+    static async updateREST(metadataEntry, uri, usePut) {
         this.removeNotUpdateableFields(metadataEntry);
         try {
-            const response = await this.client.rest.patch(uri, metadataEntry);
+            const response = usePut
+                ? await this.client.rest.put(uri, metadataEntry)
+                : await this.client.rest.patch(uri, metadataEntry);
             this.checkForErrors(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(
@@ -660,7 +710,7 @@ class MetadataType {
      * @param {TYPE.MetadataTypeItem} metadataEntry single metadata entry
      * @param {string} [overrideType] can be used if the API type differs from the otherwise used type identifier
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
-     * @returns {Promise} Promise
+     * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async updateSOAP(metadataEntry, overrideType, handleOutside) {
         try {
@@ -681,7 +731,7 @@ class MetadataType {
             return response;
         } catch (ex) {
             this._handleSOAPErrors(ex, 'updating', metadataEntry, handleOutside);
-            return {};
+            return null;
         }
     }
     /**
@@ -695,23 +745,31 @@ class MetadataType {
         if (handleOutside) {
             throw ex;
         } else {
-            const errorMsg = ex?.json?.Results?.length
-                ? `${ex.json.Results[0].StatusMessage} (Code ${ex.json.Results[0].ErrorCode})`
-                : ex.message;
+            const errorMsg = this.getSOAPErrorMsg(ex);
             const name = metadataEntry ? ` '${metadataEntry[this.definition.keyField]}'` : '';
             Util.logger.error(` ☇ error ${msg} ${this.definition.type}${name}: ${errorMsg}`);
         }
     }
+    /**
+     * helper for {@link _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;
+    }
     /**
      * Retrieves SOAP via generic fuel-soap wrapper based metadata of metadata type into local filesystem. executes callback with retrieved metadata
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {TYPE.BuObject} buObject properties for auth
      * @param {TYPE.SoapRequestParams} [requestParams] required for the specific request (filter for example)
      * @param {string[]} [additionalFields] Returns specified fields even if their retrieve definition is not set to true
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of item map
      */
-    static async retrieveSOAP(retrieveDir, buObject, requestParams, additionalFields) {
+    static async retrieveSOAP(retrieveDir, requestParams, additionalFields) {
         requestParams = requestParams || {};
         const fields = this.getFieldNamesToRetrieve(additionalFields);
         let response;
@@ -733,10 +791,10 @@ class MetadataType {
                 `Downloaded: ${this.definition.type} (${Object.keys(savedMetadata).length})`
             );
             if (
-                buObject &&
+                this.buObject &&
                 this.properties.metaDataTypes.documentOnRetrieve.includes(this.definition.type)
             ) {
-                await this.document(buObject, savedMetadata);
+                await this.document(savedMetadata);
             }
         }
         return { metadata: metadata, type: this.definition.type };
@@ -755,7 +813,7 @@ class MetadataType {
     static async retrieveREST(retrieveDir, uri, overrideType, templateVariables, singleRetrieve) {
         const response =
             this.definition.restPagination && !singleRetrieve
-                ? await this.client.rest.getBulk(uri)
+                ? await this.client.rest.getBulk(uri, this.definition.restPageSize || 500)
                 : await this.client.rest.get(uri);
         const results = this.parseResponseBody(response, singleRetrieve);
         // get extended metadata if applicable
@@ -770,11 +828,6 @@ class MetadataType {
         }
 
         if (retrieveDir) {
-            // defined colors for optionally printing the keys we filtered by
-            const color = {
-                reset: '\x1B[0m',
-                dim: '\x1B[2m',
-            };
             const savedMetadata = await this.saveResults(
                 results,
                 retrieveDir,
@@ -784,10 +837,7 @@ class MetadataType {
             Util.logger.info(
                 `Downloaded: ${overrideType || this.definition.type} (${
                     Object.keys(savedMetadata).length
-                })` +
-                    (singleRetrieve === null
-                        ? ''
-                        : ` ${color.dim}(Key: ${singleRetrieve})${color.reset}`)
+                })` + Util.getKeysString(singleRetrieve)
             );
         }
 
@@ -822,6 +872,10 @@ class MetadataType {
                 }
             } else if (singleRetrieve) {
                 // some types will return a single item intead of an array if the key is supported by their api
+                // ! currently, the id: prefix is only supported by journey (interaction)
+                if (singleRetrieve.startsWith('id:')) {
+                    singleRetrieve = body[keyField];
+                }
                 metadataStructure[singleRetrieve] = body;
                 return metadataStructure;
             }
@@ -865,8 +919,8 @@ class MetadataType {
         // revert back placeholder to dots
         const originHelper = origin ? origin + '.' + fieldPath : fieldPath;
 
-        if (this.definition.fields[originHelper]?.skipValidation) {
-            // skip if current field should not be validated
+        if (this.definition.fields[originHelper]?.skipValidation || originHelper === '@_xsi:type') {
+            // skip if current field should not be validated OR if field is internal helper field xsi:type
             return;
         } else if (
             Array.isArray(fieldContent) &&
@@ -1062,7 +1116,7 @@ class MetadataType {
                 metadataEntry.r__folder_Path
             );
             if (excludeByDefinition) {
-                Util.logger.debug(errorMsg + ' (project config)');
+                Util.logger.debug(errorMsg + ' (Accenture SFMC DevTools default)');
                 return true;
             }
 
@@ -1071,7 +1125,7 @@ class MetadataType {
                 metadataEntry.r__folder_Path
             );
             if (excludeByConfig) {
-                Util.logger.debug(errorMsg + ' (Accenture SFMC DevTools default)');
+                Util.logger.debug(errorMsg + ' (project config)');
                 return true;
             }
         }
@@ -1298,7 +1352,7 @@ class MetadataType {
      */
     static applyTemplateValues(code, templateVariables) {
         // replace template variables with their values
-        return Mustache.render(code, templateVariables);
+        return Mustache.render(code, templateVariables, {}, ['{{{', '}}}']);
     }
     /**
      * helper for {@link buildTemplateForNested}
@@ -1431,8 +1485,8 @@ class MetadataType {
         let metadata;
         try {
             // update all initial variables & create metadata object
-            metadata = JSON.parse(Mustache.render(metadataStr, variables));
-            typeDirArr = typeDirArr.map((el) => Mustache.render(el, variables));
+            metadata = JSON.parse(Mustache.render(metadataStr, variables, {}, ['{{{', '}}}']));
+            typeDirArr = typeDirArr.map((el) => Mustache.render(el, variables, {}, ['{{{', '}}}']));
         } catch {
             throw new Error(
                 `${this.definition.type}:: Error applying template variables on ${
@@ -1478,7 +1532,7 @@ class MetadataType {
      *  Standardizes a check for multiple messages
      *
      * @param {object} ex response payload from REST API
-     * @returns {string[]} formatted Error Message
+     * @returns {string[] | void} formatted Error Message
      */
     static checkForErrors(ex) {
         if (ex?.response?.status >= 400 && ex?.response?.status < 600) {
@@ -1515,12 +1569,11 @@ class MetadataType {
     /**
      * Gets metadata cache with limited fields and does not store value to disk
      *
-     * @param {TYPE.BuObject} [buObject] properties for auth
      * @param {TYPE.MetadataTypeMap} [metadata] a list of type definitions
      * @param {boolean} [isDeploy] used to skip non-supported message during deploy
      * @returns {void}
      */
-    static document(buObject, metadata, isDeploy) {
+    static document(metadata, isDeploy) {
         if (!isDeploy) {
             Util.logger.error(`Documenting type ${this.definition.type} is not supported.`);
         }
@@ -1529,27 +1582,25 @@ class MetadataType {
     /**
      * Delete a metadata item from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of data extension
      * @returns {boolean} deletion success status
      */
-    static deleteByKey(buObject, customerKey) {
+    static deleteByKey(customerKey) {
         Util.logger.error(`Deletion is not yet supported for ${this.definition.typeName}!`);
         return false;
     }
     /**
      * clean up after deleting a metadata item
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of metadata item
      * @returns {void}
      */
-    static async postDeleteTasks(buObject, customerKey) {
+    static async postDeleteTasks(customerKey) {
         // delete local copy: retrieve/cred/bu/type/...json
         const jsonFile = File.normalizePath([
             this.properties.directories.retrieve,
-            buObject.credential,
-            buObject.businessUnit,
+            this.buObject.credential,
+            this.buObject.businessUnit,
             this.definition.type,
             `${customerKey}.${this.definition.type}-meta.json`,
         ]);
@@ -1559,12 +1610,11 @@ class MetadataType {
     /**
      * Delete a data extension from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} customerKey Identifier of metadata
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {boolean} deletion success flag
      */
-    static async deleteByKeySOAP(buObject, customerKey, handleOutside) {
+    static async deleteByKeySOAP(customerKey, handleOutside) {
         const keyObj = {};
         keyObj[this.definition.keyField] = customerKey;
         try {
@@ -1576,7 +1626,7 @@ class MetadataType {
             if (!handleOutside) {
                 Util.logger.info(`- deleted ${this.definition.type}: ${customerKey}`);
             }
-            this.postDeleteTasks(buObject, customerKey);
+            this.postDeleteTasks(customerKey);
 
             return true;
         } catch (ex) {
@@ -1597,31 +1647,27 @@ class MetadataType {
     /**
      * Delete a data extension from the specified business unit
      *
-     * @param {TYPE.BuObject} buObject references credentials
      * @param {string} url endpoint
      * @param {string} key Identifier of metadata
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
      * @returns {boolean} deletion success flag
      */
-    static async deleteByKeyREST(buObject, url, key, handleOutside) {
+    static async deleteByKeyREST(url, key, handleOutside) {
         const keyObj = {};
         keyObj[this.definition.keyField] = key;
         try {
-            this.client.rest.delete(url);
+            await this.client.rest.delete(url);
             if (!handleOutside) {
                 Util.logger.info(`- deleted ${this.definition.type}: ${key}`);
             }
-            this.postDeleteTasks(buObject, key);
+            this.postDeleteTasks(key);
 
             return true;
         } catch (ex) {
             if (handleOutside) {
                 throw ex;
             } else {
-                const errorMsg = ex?.results?.length
-                    ? `${ex.results[0].StatusMessage} (Code ${ex.results[0].ErrorCode})`
-                    : ex.message;
-                Util.logger.error(`- error deleting ${this.definition.type} '${key}': ${errorMsg}`);
+                Util.logger.errorStack(ex, ` - Deleting ${this.definition.type} '${key}' failed`);
             }
 
             return false;

package/lib/metadataTypes/MobileCode.js

@@ -16,11 +16,10 @@ class MobileCode extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(
             retrieveDir,
             '/legacy/v1/beta/mobile/code/' + (key ? `?$where=keyword%20eq%20%27${key}%27%20` : ''),

package/lib/metadataTypes/MobileKeyword.js

@@ -19,11 +19,10 @@ class MobileKeyword extends MetadataType {
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
      * @param {void} [_] unused parameter
      * @param {void} [__] unused parameter
-     * @param {void} [___] unused parameter
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
      */
-    static retrieve(retrieveDir, _, __, ___, key) {
+    static retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(
             retrieveDir,
             '/legacy/v1/beta/mobile/keyword/?view=simple' +