mcdev 5.1.0 → 5.3.0

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) {
@@ -108,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) &&
@@ -131,22 +130,22 @@ 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
+     * @param {TYPE.MetadataTypeItem} metadataEntryWithAllFields like metadataEntry but before non-creatable fields were stripped
      * @returns {void}
      */
-    static postCreateTasks(metadataEntry, apiResponse) {}
+    static postCreateTasks(metadataEntry, apiResponse, metadataEntryWithAllFields) {}
 
     /**
-     * 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
@@ -155,7 +154,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
@@ -267,11 +266,10 @@ class MetadataType {
      *
      * @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
-     * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<TYPE.MetadataTypeMapObj>} metadata
      */
-    static async retrieveForCache(additionalFields, subTypeArr, key) {
-        return this.retrieve(null, additionalFields, subTypeArr, key);
+    static async retrieveForCache(additionalFields, subTypeArr) {
+        return this.retrieve(null, additionalFields, subTypeArr);
     }
     /**
      * Gets metadata cache with limited fields and does not store value to disk
@@ -463,7 +461,18 @@ class MetadataType {
         Util.logger.error(
             ` ☇ skipping ${this.definition.type}: execute is not supported yet for ${this.definition.type}`
         );
-        return;
+        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 [];
     }
 
     /**
@@ -537,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 = [];
@@ -632,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;
     }
 
@@ -802,11 +808,12 @@ class MetadataType {
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async createREST(metadataEntry, uri) {
+        const metadataClone = JSON.parse(JSON.stringify(metadataEntry));
         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);
+            await this.postCreateTasks(metadataEntry, response, metadataClone);
             Util.logger.info(
                 ` - created ${this.definition.type}: ${
                     metadataEntry[this.definition.keyField] ||
@@ -815,7 +822,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] ||
@@ -845,7 +852,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
             );
@@ -869,7 +876,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') {
@@ -878,7 +885,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(
@@ -889,7 +896,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] ||
@@ -904,7 +911,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
@@ -950,7 +957,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
             );
@@ -985,15 +992,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
@@ -1010,7 +1022,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 {};
@@ -1045,6 +1061,7 @@ class MetadataType {
         const results = this.parseResponseBody(response, singleRetrieve);
         // get extended metadata if applicable
         if (this.definition.hasExtended) {
+            Util.logger.debug(' - retrieving extended metadata');
             const extended = await this.client.rest.getCollection(
                 Object.keys(results).map((key) => uri + results[key][this.definition.idField])
             );
@@ -1073,29 +1090,117 @@ class MetadataType {
             type: this.definition.type,
         };
     }
+    /**
+     *
+     * @param {object[]} urlArray {uri: string, id: string} combo of URL and ID/key of metadata
+     * @param {number} [concurrentRequests] optionally set a different amount of concurrent requests
+     * @param {boolean} [logAmountOfUrls] if true, prints an info message about to-be loaded amount of metadata
+     * @returns {Promise.<{metadata: (TYPE.MetadataTypeMap | TYPE.MetadataTypeItem), type: string}>} Promise of item map (single item for templated result)
+     */
+    static async retrieveRESTcollection(urlArray, concurrentRequests = 10, logAmountOfUrls = true) {
+        if (logAmountOfUrls) {
+            Util.logger.info(
+                Util.getGrayMsg(
+                    ` - ${urlArray?.length} ${this.definition.type}${
+                        urlArray?.length === 1 ? '' : 's'
+                    } found. Retrieving details...`
+                )
+            );
+        }
+        const rateLimit = pLimit(concurrentRequests);
+
+        const metadataArr = urlArray.length
+            ? await Promise.all(
+                  urlArray.map(async (item) =>
+                      rateLimit(async () => {
+                          try {
+                              return await this.client.rest.get(item.uri);
+                          } catch (ex) {
+                              return this.handleRESTErrors(ex, item.id);
+                          }
+                      })
+                  )
+              )
+            : [];
+        const results = {};
+        for (const item of metadataArr) {
+            const key = item[this.definition.keyField];
+            results[key] = item;
+        }
+        return {
+            metadata: results,
+            type: this.definition.type,
+        };
+    }
+
+    /**
+     * helper for {@link this.retrieveRESTcollection}
+     *
+     * @param {Error} ex exception
+     * @param {string} id id or key of item
+     * @returns {null} -
+     */
+    static handleRESTErrors(ex, id) {
+        // if the ID is too short, the system will throw the 400 error
+        Util.logger.debug(` ☇ skipping ${this.definition.type} ${id}: ${ex.message} ${ex.code}`);
+
+        return null;
+    }
     /**
      * 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.<string>} 'OK' if started execution successfully, otherwise - 'Error'
+     * @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}`);
+                Util.logger.info(` - executed ${this.definition.type}: ${key}`);
             } else {
                 throw new Error(response);
             }
-            return 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
@@ -1298,7 +1403,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
      */
@@ -1343,7 +1448,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
      */
@@ -1575,6 +1680,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.
@@ -1621,7 +1730,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
@@ -1633,7 +1742,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
@@ -1645,7 +1754,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
@@ -1666,7 +1775,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
@@ -1812,7 +1921,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) {
@@ -1835,11 +1944,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;
     }
@@ -1902,11 +2013,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}`);
             }
@@ -1959,7 +2066,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
      */
@@ -1997,6 +2104,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 = {

package/lib/metadataTypes/MobileKeyword.js

@@ -96,7 +96,7 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * helper for {@link parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
+     * helper for {@link MobileKeyword.parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
      *
      * @private
      * @param {TYPE.MetadataType} metadata single item
@@ -106,7 +106,7 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * helper for {@link preDeployTasks} and {@link createOrUpdate} to ensure we have code & keyword properly set
+     * helper for {@link MobileKeyword.preDeployTasks} and {@link MobileKeyword.createOrUpdate} to ensure we have code & keyword properly set
      *
      * @private
      * @param {TYPE.MetadataType} metadata single item
@@ -192,7 +192,7 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * helper for {@link retrieve} and {@link retrieveAsTemplate}
+     * helper for {@link MobileKeyword.retrieve} and {@link MobileKeyword.retrieveAsTemplate}
      *
      * @private
      * @param {string} key customer key of single item to retrieve / name of the metadata file
@@ -281,7 +281,7 @@ class MobileKeyword extends MetadataType {
         }
     }
     /**
-     * helper for {@link parseMetadata} and {@link _buildForNested}
+     * helper for {@link MobileKeyword.postRetrieveTasks} and {@link MobileKeyword._buildForNested}
      *
      * @param {string} metadataScript the code of the file
      * @returns {{fileExt:string,code:string}} returns found extension and file content
@@ -349,7 +349,7 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * helper for {@link buildTemplateForNested} / {@link buildDefinitionForNested}
+     * helper for {@link MobileKeyword.buildTemplateForNested} / {@link MobileKeyword.buildDefinitionForNested}
      * handles extracted code if any are found for complex types
      *
      * @param {string} templateDir Directory where metadata templates are stored
@@ -445,7 +445,7 @@ class MobileKeyword extends MetadataType {
         return metadata;
     }
     /**
-     * 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
@@ -455,7 +455,7 @@ class MobileKeyword extends MetadataType {
         await super.postDeployTasks_legacyApi(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
@@ -466,7 +466,7 @@ class MobileKeyword extends MetadataType {
     }
 
     /**
-     * helper for {@link preDeployTasks} that loads extracted code content back into JSON
+     * helper for {@link MobileKeyword.preDeployTasks} that loads extracted code content back into JSON
      *
      * @param {TYPE.MetadataTypeItem} metadata a single definition
      * @param {string} deployDir directory of deploy files
@@ -501,7 +501,7 @@ class MobileKeyword extends MetadataType {
      */
     static async deleteByKey(key) {
         // get id from cache
-        const { metadata } = await this.retrieveForCache(key);
+        const { metadata } = await this.retrieveForCache(undefined, undefined, key);
         if (!metadata[key]) {
             Util.logger.error(`Could not find ${this.definition.type} with key ${key}.`);
             return false;

package/lib/metadataTypes/MobileMessage.js

@@ -83,7 +83,7 @@ class MobileMessage extends MetadataType {
         return super.createREST(metadata, '/legacy/v1/beta/mobile/message/');
     }
     /**
-     * helper for {@link preDeployTasks} that loads extracted code content back into JSON
+     * helper for {@link MobileMessage.preDeployTasks} that loads extracted code content back into JSON
      *
      * @param {TYPE.MetadataTypeItem} metadata a single definition
      * @param {string} deployDir directory of deploy files
@@ -110,7 +110,7 @@ class MobileMessage extends MetadataType {
         }
     }
     /**
-     * helper for {@link parseMetadata} and {@link _buildForNested}
+     * helper for {@link MobileMessage.postRetrieveTasks} and {@link MobileMessage._buildForNested}
      *
      * @param {string} code the code of the file
      * @returns {{fileExt:string,code:string}} returns found extension and file content
@@ -304,7 +304,7 @@ class MobileMessage extends MetadataType {
         return metadata;
     }
     /**
-     * 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
@@ -314,7 +314,7 @@ class MobileMessage extends MetadataType {
         await super.postDeployTasks_legacyApi(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
@@ -380,7 +380,7 @@ class MobileMessage extends MetadataType {
     }
 
     /**
-     * helper for {@link buildTemplateForNested} / {@link buildDefinitionForNested}
+     * helper for {@link MobileMessage.buildTemplateForNested} / {@link MobileMessage.buildDefinitionForNested}
      * handles extracted code if any are found for complex types
      *
      * @param {string} templateDir Directory where metadata templates are stored