mcdev 5.1.0 → 5.2.0

package/lib/metadataTypes/DataExtension.js

@@ -203,7 +203,7 @@ class DataExtension extends MetadataType {
         }
     }
     /**
-     * helper for {@link upsert}
+     * helper for {@link DataExtension.upsert}
      *
      * @private
      * @param {object} res -
@@ -607,7 +607,7 @@ class DataExtension extends MetadataType {
         metadata[customerKey].Fields = fieldArr;
     }
     /**
-     * helper for {@link super.updateREST} and {@link super.updateSOAP} that removes old files after the key was changed
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
      *
      * @private
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry

package/lib/metadataTypes/DataExtensionField.js

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

package/lib/metadataTypes/Event.js

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

package/lib/metadataTypes/Folder.js

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

package/lib/metadataTypes/Journey.js

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

package/lib/metadataTypes/MetadataType.js

@@ -35,7 +35,7 @@ class MetadataType {
      * Returns file contents mapped to their filename without '.json' ending
      *
      * @param {string} dir directory that contains '.json' files to be read
-     * @param {boolean} [listBadKeys=false] do not print errors, used for badKeys()
+     * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
      * @returns {TYPE.MetadataTypeMap} fileName => fileContent map
      */
     static getJsonFromFS(dir, listBadKeys) {
@@ -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,13 +130,12 @@ class MetadataType {
      * @param {TYPE.MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
      * @param {TYPE.MetadataTypeMap} originalMetadata metadata to be updated (contains additioanl fields)
      * @param {{created: number, updated: number}} createdUpdated counter representing successful creates/updates
-     * @param {boolean} [isRefresh] optional flag to indicate that triggeredSend should be refreshed after deployment of assets
      * @returns {void}
      */
-    static postDeployTasks(upsertResults, originalMetadata, createdUpdated, isRefresh) {}
+    static postDeployTasks(upsertResults, originalMetadata, createdUpdated) {}
 
     /**
-     * helper for {@link createREST}
+     * helper for {@link MetadataType.createREST}
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
@@ -146,7 +144,7 @@ class MetadataType {
     static postCreateTasks(metadataEntry, apiResponse) {}
 
     /**
-     * helper for {@link updateREST}
+     * helper for {@link MetadataType.updateREST}
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
@@ -155,7 +153,7 @@ class MetadataType {
     static postUpdateTasks(metadataEntry, apiResponse) {}
 
     /**
-     * helper for {@link createREST} when legacy API endpoints as these do not return the created item but only their new id
+     * helper for {@link MetadataType.createREST} when legacy API endpoints as these do not return the created item but only their new id
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {object} apiResponse varies depending on the API call
@@ -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;
     }
 
@@ -815,7 +821,7 @@ class MetadataType {
             );
             return response;
         } catch (ex) {
-            const parsedErrors = this.checkForErrors(ex);
+            const parsedErrors = this.getErrorsREST(ex);
             Util.logger.error(
                 ` ☇ error creating ${this.definition.type} ${
                     metadataEntry[this.definition.keyField] ||
@@ -845,7 +851,7 @@ class MetadataType {
         this.removeNotCreateableFields(metadataEntry);
         try {
             const response = await this.client.soap.create(
-                soapType.charAt(0).toUpperCase() + soapType.slice(1),
+                Util.capitalizeFirstLetter(soapType),
                 metadataEntry,
                 null
             );
@@ -869,7 +875,7 @@ class MetadataType {
      *
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
      * @param {string} uri rest endpoint for PATCH
-     * @param {'patch'|'post'|'put'} [httpMethod='patch'] defaults to 'patch'; some update requests require PUT instead of PATCH
+     * @param {'patch'|'post'|'put'} [httpMethod] defaults to 'patch'; some update requests require PUT instead of PATCH
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async updateREST(metadataEntry, uri, httpMethod = 'patch') {
@@ -878,7 +884,7 @@ class MetadataType {
             // set to empty object in case API returned nothing to be able to update it in helper classes
             const response = (await this.client.rest[httpMethod](uri, metadataEntry)) || {};
             await this._postChangeKeyTasks(metadataEntry);
-            this.checkForErrors(response);
+            this.getErrorsREST(response);
             await this.postUpdateTasks(metadataEntry, response);
             // some times, e.g. automation dont return a key in their update response and hence we need to fall back to name
             Util.logger.info(
@@ -889,7 +895,7 @@ class MetadataType {
             );
             return response;
         } catch (ex) {
-            const parsedErrors = this.checkForErrors(ex);
+            const parsedErrors = this.getErrorsREST(ex);
             Util.logger.error(
                 ` ☇ error updating ${this.definition.type} ${
                     metadataEntry[this.definition.keyField] ||
@@ -904,7 +910,7 @@ class MetadataType {
     }
 
     /**
-     * helper for {@link updateREST} and {@link updateSOAP} that removes old files after the key was changed
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP} that removes old files after the key was changed
      *
      * @private
      * @param {TYPE.MetadataTypeItem} metadataEntry a single metadata Entry
@@ -950,7 +956,7 @@ class MetadataType {
         this.removeNotUpdateableFields(metadataEntry);
         try {
             const response = await this.client.soap.update(
-                soapType.charAt(0).toUpperCase() + soapType.slice(1),
+                Util.capitalizeFirstLetter(soapType),
                 metadataEntry,
                 null
             );
@@ -985,15 +991,20 @@ class MetadataType {
         }
     }
     /**
-     * helper for {@link _handleSOAPErrors}
+     * helper for {@link MetadataType._handleSOAPErrors}
      *
      * @param {Error} ex error that occured
      * @returns {string} error message
      */
     static getSOAPErrorMsg(ex) {
-        return ex?.json?.Results?.length
-            ? `${ex.json.Results[0].StatusMessage} (Code ${ex.json.Results[0].ErrorCode})`
-            : ex.message;
+        if (ex?.json?.Results?.length) {
+            if (ex?.json?.Results[0].StatusMessage) {
+                return `${ex.json.Results[0].StatusMessage} (Code ${ex.json.Results[0].ErrorCode})`;
+            } else if (ex?.json?.Results[0].Result.StatusMessage) {
+                return `${ex.json.Results[0].Result.StatusMessage} (Code ${ex.json.Results[0].Result.ErrorCode})`;
+            }
+        }
+        return ex.message;
     }
     /**
      * Retrieves SOAP via generic fuel-soap wrapper based metadata of metadata type into local filesystem. executes callback with retrieved metadata
@@ -1010,7 +1021,11 @@ class MetadataType {
         const soapType = this.definition.soapType || this.definition.type;
         let response;
         try {
-            response = await this.client.soap.retrieveBulk(soapType, fields, requestParams);
+            response = await this.client.soap.retrieveBulk(
+                Util.capitalizeFirstLetter(soapType),
+                fields,
+                requestParams
+            );
         } catch (ex) {
             this._handleSOAPErrors(ex, 'retrieving');
             return {};
@@ -1078,24 +1093,56 @@ class MetadataType {
      *
      * @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 +1345,7 @@ class MetadataType {
      *
      * @static
      * @param {TYPE.MetadataTypeItem} metadataEntry metadata entry
-     * @param {boolean} [include=false] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
+     * @param {boolean} [include] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
      * @returns {boolean} true: skip saving == filtered; false: continue with saving
      * @memberof MetadataType
      */
@@ -1343,7 +1390,7 @@ class MetadataType {
      *
      * @static
      * @param {object} metadataEntry metadata entry
-     * @param {boolean} [include=false] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
+     * @param {boolean} [include] true: use definition.include / options.include; false=exclude: use definition.filter / options.exclude
      * @returns {boolean} true: filtered == do NOT save; false: not filtered == do save
      * @memberof MetadataType
      */
@@ -1575,6 +1622,10 @@ class MetadataType {
                     }
                 }
 
+                if (Util.OPTIONS.like && !Util.fieldsLike(results[originalKey])) {
+                    Util.logger.debug(`Filtered ${originalKey} because of --like option`);
+                    continue;
+                }
                 // we dont store Id on local disk, but we need it for caching logic,
                 // so its in retrieve but not in save. Here we put into the clone so that the original
                 // object used for caching doesnt have the Id removed.
@@ -1621,7 +1672,7 @@ class MetadataType {
         return savedResults;
     }
     /**
-     * helper for {@link buildDefinitionForNested}
+     * helper for {@link MetadataType.buildDefinitionForNested}
      * searches extracted file for template variable names and applies the market values
      *
      * @param {string} code code from extracted code
@@ -1633,7 +1684,7 @@ class MetadataType {
         return Mustache.render(code, templateVariables, {}, ['{{{', '}}}']);
     }
     /**
-     * helper for {@link buildTemplateForNested}
+     * helper for {@link MetadataType.buildTemplateForNested}
      * searches extracted file for template variable values and applies the market variable names
      *
      * @param {string} code code from extracted code
@@ -1645,7 +1696,7 @@ class MetadataType {
         return Util.replaceByObject(code, templateVariables);
     }
     /**
-     * helper for {@link buildDefinition}
+     * helper for {@link MetadataType.buildDefinition}
      * handles extracted code if any are found for complex types (e.g script, asset, query)
      *
      * @param {string} templateDir Directory where metadata templates are stored
@@ -1666,7 +1717,7 @@ class MetadataType {
         return null;
     }
     /**
-     * helper for {@link buildTemplate}
+     * helper for {@link MetadataType.buildTemplate}
      * handles extracted code if any are found for complex types
      *
      * @param {string} templateDir Directory where metadata templates are stored
@@ -1812,7 +1863,7 @@ class MetadataType {
      * @param {object} ex response payload from REST API
      * @returns {string[] | void} formatted Error Message
      */
-    static checkForErrors(ex) {
+    static getErrorsREST(ex) {
         const errors = [];
         if (ex?.response?.status >= 400 && ex?.response?.status < 600) {
             if (ex.response.data.errors) {
@@ -1835,11 +1886,13 @@ class MetadataType {
                 }
             } else if (ex.response.data.message) {
                 errors.push(ex.response.data.message);
-            } else {
+            } else if (ex.response.data) {
                 errors.push(`Undefined Errors: ${JSON.stringify(ex.response.data)}`);
+                Util.logger.debug(JSON.stringify(ex.response.data));
+            } else {
+                errors.push(`${ex.response.status} ${ex.response.statusText}`);
             }
             Util.logger.debug(JSON.stringify(ex.config));
-            Util.logger.debug(JSON.stringify(ex.response.data));
         }
         return errors;
     }
@@ -1902,11 +1955,7 @@ class MetadataType {
         metadata[overrideKeyField || this.definition.keyField] = customerKey;
         const soapType = this.definition.soapType || this.definition.type;
         try {
-            await this.client.soap.delete(
-                soapType.charAt(0).toUpperCase() + soapType.slice(1),
-                metadata,
-                null
-            );
+            await this.client.soap.delete(Util.capitalizeFirstLetter(soapType), metadata, null);
             if (!handleOutside) {
                 Util.logger.info(` - deleted ${this.definition.type}: ${customerKey}`);
             }
@@ -1959,7 +2008,7 @@ class MetadataType {
      * Returns metadata of a business unit that is saved locally
      *
      * @param {string} readDir root directory of metadata.
-     * @param {boolean} [listBadKeys=false] do not print errors, used for badKeys()
+     * @param {boolean} [listBadKeys] do not print errors, used for badKeys()
      * @param {object} [buMetadata] Metadata of BU in local directory
      * @returns {object} Metadata of BU in local directory
      */
@@ -1997,6 +2046,57 @@ class MetadataType {
         const fileList = keyArr.map((key) => File.normalizePath([path, key + typeExtension]));
         return fileList;
     }
+
+    /**
+     *
+     * @param {TYPE.MetadataTypeMap} metadataMap metadata mapped by their keyField
+     * @returns {string[]} list of keys
+     */
+    static getKeysForFixing(metadataMap) {
+        const keysForDeploy = [];
+        if (Object.keys(metadataMap).length) {
+            Util.logger.info(
+                `Searching for ${this.definition.type} keys among downloaded items that need fixing:`
+            );
+            for (const item of Object.values(metadataMap)) {
+                if (item[this.definition.nameField].length > this.definition.maxKeyLength) {
+                    Util.logger.warn(
+                        `Name of the item ${
+                            item[this.definition.keyField]
+                        } is too long for a key. Consider renaming your item. Key will be equal first ${
+                            this.definition.maxKeyLength
+                        } characters of the name`
+                    );
+                    item[this.definition.nameField] = item[this.definition.nameField].slice(
+                        0,
+                        this.definition.maxKeyLength
+                    );
+                }
+
+                if (
+                    item[this.definition.nameField] != item[this.definition.keyField] &&
+                    !this.definition.keyIsFixed
+                ) {
+                    keysForDeploy.push(item[this.definition.keyField]);
+                    Util.logger.info(
+                        ` - added ${this.definition.type} to fixKey queue: ${
+                            item[this.definition.keyField]
+                        }`
+                    );
+                } else {
+                    Util.logger.info(
+                        Util.getGrayMsg(
+                            ` ☇ skipping ${this.definition.type} ${
+                                item[this.definition.keyField]
+                            }: key does not need to be updated`
+                        )
+                    );
+                }
+            }
+            Util.logger.info(`Found ${keysForDeploy.length} ${this.definition.type} keys to fix`);
+        }
+        return keysForDeploy;
+    }
 }
 
 MetadataType.definition = {

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

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