mcdev 8.0.0 → 8.0.2

package/lib/metadataTypes/DataExtension.js

@@ -1493,12 +1493,14 @@ class DataExtension extends MetadataType {
     /**
      * Retrieves dataExtension metadata in template format.
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata item
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<{metadata: DataExtensionItem, type: string}>} Promise of items
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         /** @type {SoapRequestParams} */
         const options = {
             filter: {

package/lib/metadataTypes/DataExtract.js

@@ -50,12 +50,14 @@ class DataExtract extends MetadataType {
     /**
      * Retrieve a specific dataExtract Definition by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         const res = await this.client.rest.get(
             '/automation/v1/dataextracts/?$filter=name%20eq%20' + encodeURIComponent(name)
         );

package/lib/metadataTypes/Event.js

@@ -33,6 +33,7 @@ import pLimit from 'p-limit';
  */
 class Event extends MetadataType {
     static reCacheDataExtensions = [];
+    static createdKeys = [];
 
     /**
      * Retrieves Metadata of Event Definition.
@@ -81,12 +82,14 @@ class Event extends MetadataType {
     /**
      * Retrieve a specific Event Definition by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         const res = await this.client.rest.get(
             '/interaction/v1/eventDefinitions?name=' + encodeURIComponent(name)
         );
@@ -158,7 +161,10 @@ class Event extends MetadataType {
      */
     static async deploy(metadata, deployDir, retrieveDir) {
         Util.logBeta(this.definition.type);
-        return super.deploy(metadata, deployDir, retrieveDir);
+        const metadataMap = await super.deploy(metadata, deployDir, retrieveDir);
+
+        this.createdKeys.length = 0; // reset createdKeys after deploy to ensure it's not used in future retrieves
+        return metadataMap;
     }
 
     /**
@@ -168,6 +174,7 @@ class Event extends MetadataType {
      * @returns {Promise} Promise
      */
     static create(metadata) {
+        this.createdKeys.push(metadata[this.definition.keyField]);
         return super.createREST(metadata, '/interaction/v1/eventDefinitions/');
     }
 
@@ -215,8 +222,7 @@ class Event extends MetadataType {
                 break;
             }
             case 'SalesforceObjectTriggerV2': {
-                metadata.iconUrl ||=
-                    '/events/js/salesforce-event/events/NetworkMember/images/SF-Event-Icon.svg';
+                metadata.iconUrl ||= '/events/js/salesforce-event/images/SF-Event-Icon.svg';
                 break;
             }
             case 'AutomationAudience': {
@@ -601,16 +607,18 @@ class Event extends MetadataType {
         if (metadata.mode === 'Production') {
             delete metadata.mode;
         }
-        if (metadata.interactionCount === 0 && metadata.publishedInteractionCount === 0) {
-            Util.logger.warn(
-                ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is no longer used and could therefore be deleted. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
-            );
-        } else if (metadata.publishedInteractionCount === 0) {
-            Util.logger.info(
-                Util.getGrayMsg(
-                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is currently inactive. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
-                )
-            );
+        if (!this.createdKeys.includes(metadata[this.definition.keyField])) {
+            if (metadata.interactionCount === 0 && metadata.publishedInteractionCount === 0) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is not used and could therefore be deleted. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
+                );
+            } else if (metadata.publishedInteractionCount === 0) {
+                Util.logger.info(
+                    Util.getGrayMsg(
+                        ` - ${this.definition.type} '${metadata[this.definition.nameField]}' (${metadata[this.definition.keyField]}): is currently inactive. Associated Journeys: ${metadata.interactionCount}. Active Journeys: ${metadata.publishedInteractionCount}.`
+                    )
+                );
+            }
         }
 
         try {

package/lib/metadataTypes/FileTransfer.js

@@ -50,12 +50,14 @@ class FileTransfer extends MetadataType {
     /**
      * Retrieve a specific File Transfer Definition by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeItemObj>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         const res = await this.client.rest.get(
             '/automation/v1/filetransfers/?$filter=name%20eq%20' + encodeURIComponent(name)
         );

package/lib/metadataTypes/Folder.js

@@ -101,17 +101,21 @@ class Folder extends MetadataType {
                         idMap[id].Path = idMap[id].Name;
                     }
                 } else {
-                    Util.logger.warn(
-                        ` - Skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Cannot find parent folder (${idMap[id].ParentFolder.ID})`
+                    Util.logger.info(
+                        Util.getGrayMsg(
+                            ` ☇ skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Cannot find parent folder (${idMap[id].ParentFolder.ID})`
+                        )
                     );
+                    delete idMap[id];
                 }
             }
             // All folders except the artificial root have ParentFolder attribute. If they dont something else is wrong
             else if (idMap[id].Name !== '<ROOT>') {
                 idMap[id].Path = '';
                 Util.logger.warn(
-                    ` - Skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Does not have a parent folder`
+                    ` ☇ skipping folder ${idMap[id].Name} (${id}, type: ${idMap[id].ContentType}): Does not have a parent folder`
                 );
+                delete idMap[id];
             }
         }
 
@@ -220,25 +224,11 @@ class Folder extends MetadataType {
                             let existingId;
                             try {
                                 // perform a secondary check based on path
-                                existingId = cache.searchForField(
-                                    'folder',
-                                    deployableMetadata.Path,
-                                    'Path',
-                                    'ID',
-                                    undefined,
-                                    true
-                                );
-                                const cachedVersion = cache.getByKey(
-                                    'folder',
-                                    cache.searchForField(
-                                        'folder',
-                                        deployableMetadata.Path,
-                                        'Path',
-                                        this.definition.keyField,
-                                        undefined,
-                                        true
-                                    )
+
+                                const cachedVersion = cache.getFolderByPath(
+                                    deployableMetadata.Path
                                 );
+                                existingId = cachedVersion?.ID;
                                 if (
                                     existingId &&
                                     !this.hasChangedGeneric(
@@ -374,6 +364,7 @@ class Folder extends MetadataType {
             return {};
         }
         const path = metadataEntry.Path;
+        let apiTypeSoap = false;
         try {
             if (this.definition.deployFolderTypesEmailRest.includes(metadataEntry.ContentType)) {
                 // * The SOAP endpoint for creating folders does not support folders for automations nor journeys. The Rest endpoint on the other hand errors out on certain characters in the folder names that are actually valid. We therefore only use Rest for the folder types that are not supported by SOAP.
@@ -448,6 +439,7 @@ class Folder extends MetadataType {
                     throw new Error(JSON.stringify(response));
                 }
             } else {
+                apiTypeSoap = true;
                 const response = await super.createSOAP(metadataEntry, true);
                 if (response) {
                     // set the client ID to ensure we can find the newly created folders as parents for folders created afterwards inside of it
@@ -464,14 +456,18 @@ class Folder extends MetadataType {
                 }
             }
         } catch (ex) {
-            if (ex?.results) {
-                Util.logger.error(
-                    `${this.definition.type}-${metadataEntry.ContentType}.create:: error creating: '${path}'. ${ex.results[0].StatusMessage}`
-                );
-            } else if (ex) {
-                Util.logger.error(
-                    `${this.definition.type}-${metadataEntry.ContentType}.create:: error creating: '${path}'. ${ex.message}`
-                );
+            if (apiTypeSoap) {
+                this._handleSOAPErrors(ex, 'creating', metadataEntry, false, 'Name');
+            } else {
+                if (ex?.results) {
+                    Util.logger.error(
+                        `${this.definition.type}-${metadataEntry.ContentType}.create:: error creating: '${path}'. ${ex.results[0].StatusMessage}`
+                    );
+                } else if (ex) {
+                    Util.logger.error(
+                        `${this.definition.type}-${metadataEntry.ContentType}.create:: error creating: '${path}'. ${ex.message}`
+                    );
+                }
             }
         }
     }
@@ -490,6 +486,7 @@ class Folder extends MetadataType {
             return {};
         }
         const path = metadataEntry.Path;
+        let apiTypeSoap = false;
         try {
             let response;
             if (this.definition.deployFolderTypesAssetRest.includes(metadataEntry.ContentType)) {
@@ -531,6 +528,7 @@ class Folder extends MetadataType {
                     throw new Error(JSON.stringify(response));
                 }
             } else {
+                apiTypeSoap = true;
                 response = await super.updateSOAP(metadataEntry, true);
                 if (response.Results?.[0]?.StatusCode === 'OK') {
                     response.Results[0].Object = metadataEntry;
@@ -541,14 +539,18 @@ class Folder extends MetadataType {
                 }
             }
         } catch (ex) {
-            if (ex?.results) {
-                Util.logger.error(
-                    `${this.definition.type}-${metadataEntry.ContentType}.update:: error updating: '${path}'. ${ex.results[0].StatusMessage}`
-                );
-            } else if (ex) {
-                Util.logger.error(
-                    `${this.definition.type}-${metadataEntry.ContentType}.update:: error updating: '${path}'. ${ex.message}`
-                );
+            if (apiTypeSoap) {
+                this._handleSOAPErrors(ex, 'updating', metadataEntry, false, 'Name');
+            } else {
+                if (ex?.results) {
+                    Util.logger.error(
+                        `${this.definition.type}-${metadataEntry.ContentType}.update:: error updating: '${path}'. ${ex.results[0].StatusMessage}`
+                    );
+                } else if (ex) {
+                    Util.logger.error(
+                        `${this.definition.type}-${metadataEntry.ContentType}.update:: error updating: '${path}'. ${ex.message}`
+                    );
+                }
             }
         }
     }

package/lib/metadataTypes/ImportFile.js

@@ -133,12 +133,14 @@ class ImportFile extends MetadataType {
     /**
      * Retrieve a specific Import Definition by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeItemObj>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         // using '?$filter=name%20eq%20' + encodeURIComponent(name) would also work but that just retrieves more data for no reason
         const cache = await this.retrieveForCache(null, null, 'name:' + name);
         const metadataArr = Object.values(cache?.metadata);

package/lib/metadataTypes/Journey.js

@@ -182,7 +182,8 @@ class Journey extends MetadataType {
             // if the interaction does not exist, the API returns an error code which would otherwise bring execution to a hold
             if (
                 [
-                    'Interaction matching key not found.',
+                    'Interaction matching key not found.', // might be outdated
+                    'Interaction matching criteria not found.', // seen in 2025-05
                     'Must provide a valid ID or Key parameter',
                 ].includes(ex.message) ||
                 (key && ex.code === 'ERR_BAD_REQUEST')

package/lib/metadataTypes/MetadataType.js

@@ -299,7 +299,7 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} metadata
      */
     static async retrieve(retrieveDir, additionalFields, subTypeArr, key) {
-        Util.notSupportedError(this.definition, 'retrieve');
+        Util.logNotSupported(this.definition, 'retrieve');
         return { metadata: {}, type: this.definition.type };
     }
 
@@ -329,6 +329,7 @@ class MetadataType {
     /**
      * Gets metadata cache with limited fields and does not store value to disk
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
@@ -336,7 +337,8 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeItemObj>} metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables, subType) {
-        Util.notSupportedError(this.definition, 'retrieveAsTemplate');
+        Util.logNotSupported(this.definition, 'retrieveAsTemplate');
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         return { metadata: null, type: this.definition.type };
     }
 
@@ -499,7 +501,7 @@ class MetadataType {
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async create(metadata, deployDir) {
-        Util.notSupportedError(this.definition, 'retrieveAsTemplate', metadata);
+        Util.logNotSupported(this.definition, 'create', metadata);
         return;
     }
 
@@ -511,7 +513,7 @@ class MetadataType {
      * @returns {Promise.<object> | null} Promise of API response or null in case of an error
      */
     static async update(metadata, metadataBefore) {
-        Util.notSupportedError(this.definition, 'retrieveAsTemplate', metadata);
+        Util.logNotSupported(this.definition, 'update', metadata);
         return;
     }
 
@@ -524,7 +526,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were refreshed
      */
     static async refresh(keyArr, checkKey = true, upsertResults) {
-        Util.notSupportedError(this.definition, 'refresh');
+        Util.logNotSupported(this.definition, 'refresh');
         return [];
     }
 
@@ -630,7 +632,7 @@ class MetadataType {
      * @returns {Promise.<MetadataTypeItem | CodeExtractItem>} key of the item that was updated
      */
     static async replaceCbReference(item, retrieveDir, findAssetKeys) {
-        Util.notSupportedError(this.definition, 'replaceCbReference');
+        Util.logNotSupported(this.definition, 'replaceCbReference');
         return [];
     }
 
@@ -642,7 +644,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were executed
      */
     static async execute(keyArr, cache) {
-        Util.notSupportedError(this.definition, 'execute');
+        Util.logNotSupported(this.definition, 'execute');
         return [];
     }
 
@@ -654,7 +656,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were executed
      */
     static async schedule(keyArr, cache) {
-        Util.notSupportedError(this.definition, 'schedule');
+        Util.logNotSupported(this.definition, 'schedule');
         return [];
     }
 
@@ -666,7 +668,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were paused
      */
     static async pause(keyArr, cache) {
-        Util.notSupportedError(this.definition, 'pause');
+        Util.logNotSupported(this.definition, 'pause');
         return [];
     }
 
@@ -677,7 +679,7 @@ class MetadataType {
      * @returns {Promise.<string[]>} Returns list of keys that were stopped
      */
     static async stop(keyArr) {
-        Util.notSupportedError(this.definition, 'stop');
+        Util.logNotSupported(this.definition, 'stop');
         return [];
     }
 
@@ -1354,13 +1356,16 @@ class MetadataType {
      * @param {'creating'|'updating'|'retrieving'|'executing'|'pausing'} msg what to print in the log
      * @param {MetadataTypeItem} [metadataEntry] single metadata entry
      * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
+     * @param {string} [nameAttribute] name attribute to use in the error message instead of keyField
      */
-    static _handleSOAPErrors(ex, msg, metadataEntry, handleOutside) {
+    static _handleSOAPErrors(ex, msg, metadataEntry, handleOutside, nameAttribute) {
         if (handleOutside) {
             throw ex;
         } else {
             const errorMsg = this.getSOAPErrorMsg(ex);
-            const name = metadataEntry ? ` '${metadataEntry[this.definition.keyField]}'` : '';
+            const name = metadataEntry
+                ? ` '${metadataEntry[nameAttribute || this.definition.keyField]}'`
+                : '';
             Util.logger.error(` ☇ error ${msg} ${this.definition.type}${name}: ${errorMsg}`);
         }
     }
@@ -2464,7 +2469,7 @@ class MetadataType {
      */
     static document(metadata, isDeploy) {
         if (!isDeploy) {
-            Util.notSupportedError(this.definition, 'document');
+            Util.logNotSupported(this.definition, 'document');
         }
     }
 
@@ -2475,7 +2480,7 @@ class MetadataType {
      * @returns {Promise.<{key:string, name:string}>} key, name and path of metadata; null if not found
      */
     static async resolveId(id) {
-        Util.notSupportedError(this.definition, 'resolveId');
+        Util.logNotSupported(this.definition, 'resolveId');
         return;
     }
 
@@ -2486,7 +2491,7 @@ class MetadataType {
      * @returns {Promise.<boolean>} deletion success status
      */
     static async deleteByKey(customerKey) {
-        Util.notSupportedError(this.definition, 'delete');
+        Util.logNotSupported(this.definition, 'delete');
         return false;
     }
 

package/lib/metadataTypes/MobileKeyword.js

@@ -137,12 +137,14 @@ class MobileKeyword extends MetadataType {
     /**
      * retrieve an item and create a template from it
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} key name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, key, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         try {
             let queryParams;
             [key, queryParams] = this.#getRetrieveKeyAndUrl(key);

package/lib/metadataTypes/Query.js

@@ -127,12 +127,14 @@ class Query extends MetadataType {
     /**
      * Retrieve a specific Query by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<{metadata: Query, type: string}>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         await File.initPrettier('sql');
         return super.retrieveREST(
             templateDir,

package/lib/metadataTypes/Script.js

@@ -57,12 +57,14 @@ class Script extends MetadataType {
     /**
      * Retrieve a specific Script by Name
      *
+     * @deprecated Use `retrieve` followed by `build` instead. `retrieveAsTemplate` will be removed in a future version.
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
      * @param {TemplateMap} templateVariables variables to be replaced in the metadata
      * @returns {Promise.<{metadata: ScriptItem, type: string}>} Promise
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
+        Util.logDeprecated('retrieveAsTemplate', `'retrieve' followed by 'build'`);
         await File.initPrettier('ssjs');
         return super.retrieveREST(
             templateDir,

package/lib/util/cache.js

@@ -186,26 +186,45 @@ export default {
      * @returns {number} folder ID
      */
     getFolderId(r__folder_Path, overrideMID, allowOtherBu = true) {
+        const folder = this.getFolderByPath(r__folder_Path, overrideMID, allowOtherBu);
+        return folder?.ID;
+    },
+
+    /**
+     * helper for setFolderId
+     *
+     * @param {string} r__folder_Path folder path value
+     * @param {number} [overrideMID] ignore currentMID and use alternative (for example parent MID)
+     * @param {boolean} allowOtherBu getting folder from other BU; FALSE for folder parent search
+     * @returns {object} folder item
+     */
+    getFolderByPath(r__folder_Path, overrideMID, allowOtherBu = true) {
         if (!r__folder_Path) {
             throw new Error('r__folder_Path not set');
         }
+
         /** @type {ListMap} */
         const folderMap = dataStore[overrideMID || currentMID]?.['folder'];
         if (!folderMap) {
             throw new Error('No folders found in cache');
         }
+        const folderPath_lower = r__folder_Path.toLowerCase();
         const potentialFolders = [];
         for (const folder of Object.values(folderMap)) {
-            if (folder.Path === r__folder_Path) {
+            if (!folder?.Path) {
+                continue; // skip folders without Path
+            }
+            if (folder.Path.toLowerCase() === folderPath_lower) {
                 if (folder?.Client?.ID === (overrideMID || currentMID)) {
-                    return folder.ID;
+                    return folder;
                 } else if (allowOtherBu) {
                     potentialFolders.push(folder);
                 }
             }
         }
+
         if (potentialFolders.length >= 1) {
-            return potentialFolders[0].ID;
+            return potentialFolders[0];
         } else {
             throw new Error(`No folders found with path ${r__folder_Path}`);
         }

package/lib/util/file.js

@@ -571,6 +571,15 @@ const File = {
      * @returns {Promise.<boolean>} success of config load
      */
     async initPrettier(filetype = 'html') {
+        if (Util.OPTIONS.format === false) {
+            // auto-formatting was disabled via CLI option
+            return;
+        }
+        const properties = await config.getProperties();
+        if (Util.OPTIONS.format !== true && properties.options.formatOnSave === false) {
+            // auto-formatting was disabled via config file
+            return;
+        }
         if (FileFs.prettierConfig === null || FileFs.prettierConfigFileType !== filetype) {
             // run this if no config was yet found or if the filetype previously used to initialize it differs (because it results in a potentially different config!)
             FileFs.prettierConfigFileType = filetype;
@@ -591,7 +600,7 @@ const File = {
                 return true;
             } catch (ex) {
                 FileFs.prettierConfig = false;
-                Util.logger.error('Cannot apply auto-formatting to your code:' + ex.message);
+                Util.logger.error('Cannot apply auto-formatting to your code: ' + ex.message);
                 return false;
             }
         } else {

package/lib/util/util.js

@@ -904,6 +904,32 @@ export const Util = {
             ` - 🚧 ${type} support is currently still in beta. Please report any issues here: https://github.com/Accenture/sfmc-devtools/issues/new/choose`
         );
     },
+
+    /**
+     * outputs a warning that the given method is deprecated
+     *
+     * @param {string} method name of the method
+     * @param {string} [useInstead] optionally specify which method to use instead
+     */
+    logDeprecated(method, useInstead = '') {
+        Util.logger.warn(
+            ` 💥 '${method}' is deprecated and will be sunset in a future version. ${useInstead ? `Please use ${useInstead} instead.` : ''}`
+        );
+    },
+
+    /**
+     * helper for MetadataType class to issue a similar error message for unsupported methods
+     *
+     * @param {any} definition type definition object
+     * @param {string} method name of the method thats not supported
+     * @param {MetadataTypeItem} [item] metadata item
+     */
+    logNotSupported: function (definition, method, item) {
+        Util.logger.error(
+            ` ☇ skipping ${item ? Util.getTypeKeyName(definition, item) : definition.type}: ${method} is not supported for ${definition.type}`
+        );
+    },
+
     // defined colors for logging things in different colors
     color: {
         reset: '\x1B[0m',
@@ -1317,18 +1343,6 @@ export const Util = {
                 return acc;
             }, {});
     },
-    /**
-     * helper for MetadataType class to issue a similar error message for unsupported methods
-     *
-     * @param {any} definition type definition object
-     * @param {string} method name of the method thats not supported
-     * @param {MetadataTypeItem} [item] metadata item
-     */
-    notSupportedError: function (definition, method, item) {
-        Util.logger.error(
-            ` ☇ skipping ${item ? Util.getTypeKeyName(definition, item) : definition.type}: ${method} is not supported yet for ${definition.type}`
-        );
-    },
 };
 
 Util.startLogger(false, true);