mcdev 7.6.1 → 7.6.3

package/lib/metadataTypes/Journey.js

@@ -23,6 +23,7 @@ import yoctoSpinner from 'yocto-spinner';
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').TypeKeyCombo} TypeKeyCombo
  */
 
 /**
@@ -737,7 +738,10 @@ class Journey extends MetadataType {
                                     }
                                 }
                                 if (linkedTE.options) {
-                                    triggeredSend.isTrackingClicks = linkedTE.options.trackLinks;
+                                    triggeredSend.isTrackingClicks =
+                                        linkedTE.options.trackLinks || false;
+                                    triggeredSend.ccEmail = linkedTE.options.cc || '';
+                                    triggeredSend.bccEmail = linkedTE.options.bcc || '';
                                 }
 
                                 // send classification
@@ -1293,6 +1297,11 @@ class Journey extends MetadataType {
                 break;
             }
             case 'Transactional': {
+                const cachedVersion = cache.getByKey('journey', metadata.key);
+                if (cachedVersion.status === 'Published') {
+                    throw new Error(`Cannot update transactional-send journey in Published status`);
+                }
+
                 // Transactional Send Journey
                 // ~~~ TRIGGERS ~~~~
                 // ! journeys so far transactional EMAIL messages. SMS and Push do not create their own journey.
@@ -1319,13 +1328,16 @@ class Journey extends MetadataType {
                                 activity.configurationArguments.triggeredSendKey =
                                     activity.configurationArguments.r__transactionalEmail_key;
                             } catch (ex) {
-                                const isCreateMode = !cache.getByKey('journey', metadata.key);
-                                if (isCreateMode && !Util.OPTIONS.publish) {
+                                const isCreateMode = !cachedVersion;
+                                if (
+                                    (isCreateMode && !Util.OPTIONS.publish) ||
+                                    (!isCreateMode && cachedVersion.status === 'Draft')
+                                ) {
                                     // no need to add a log entry if the publish-option was provided
                                     Util.logger.info(
                                         ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
                                             metadata[this.definition.keyField]
-                                        }): To activate this transactional journey (and create the associated transactionalEmail record), please run 'mcdev publish ${this.buObject.credential}/${this.buObject.businessUnit} journey ${metadata.key}' or click on "Activate" in the GUI.`
+                                        }): To activate this transactional journey (and create the associated transactionalEmail record), please run 'mcdev publish ${this.buObject.credential}/${this.buObject.businessUnit} -m journey:"${metadata.key}" ' or click on "Activate" in the GUI.`
                                     );
                                 } else if (!isCreateMode) {
                                     // block deployment if we are in update mode
@@ -1357,9 +1369,7 @@ class Journey extends MetadataType {
                     default: {
                         // it is expected that we'll see 'sms' and 'push' here in the future
                         throw new Error(
-                            ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
-                                metadata[this.definition.keyField]
-                            }): channel ${
+                            `channel ${
                                 metadata.channel
                             } is not supported yet. Please open a ticket at https://github.com/Accenture/sfmc-devtools/issues/new/choose to request it`
                         );
@@ -1370,9 +1380,7 @@ class Journey extends MetadataType {
             }
             default: {
                 throw new Error(
-                    ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
-                        metadata[this.definition.keyField]
-                    }): definitionType ${
+                    `definitionType ${
                         metadata.definitionType
                     } is not supported yet. Please open a ticket at https://github.com/Accenture/sfmc-devtools/issues/new/choose to request it`
                 );
@@ -1834,15 +1842,31 @@ class Journey extends MetadataType {
      * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
      */
     static async postDeployTasks(upsertResults) {
+        if (!upsertResults || !Object.keys(upsertResults).length) {
+            // nothing to do. skip here to avoid unnecessary logs / api calls
+            return;
+        }
+        let postDeployFlags = 0;
+        if (Util.OPTIONS.publish) {
+            postDeployFlags++;
+        }
+        if (Util.OPTIONS.validate) {
+            postDeployFlags++;
+        }
+        if (postDeployFlags > 1) {
+            Util.logger.warn(
+                `Please provide only one of the following options (--publish, --validate). Flags are processed in this order and only the first one found is executed.`
+            );
+        }
+
         if (Util.OPTIONS.publish) {
             Util.logger.info(`Publishing: ${this.definition.type}`);
             // pubslih
             const idArr = Object.values(upsertResults).map(
                 (item) => 'id:' + item.id + '/' + item.version
             );
-            await this.publish(idArr);
-        }
-        if (Util.OPTIONS.validate) {
+            await this.publish(idArr, upsertResults);
+        } else if (Util.OPTIONS.validate) {
             Util.logger.info(`Validating: ${this.definition.type}`);
             // pubslih
             const idArr = Object.values(upsertResults).map(
@@ -1856,14 +1880,18 @@ class Journey extends MetadataType {
      * a function to publish the journey via API
      *
      * @param {string[]} keyArr keys or ids of the metadata
+     * @param {MetadataTypeMap} [upsertResults] metadata mapped by their keyField as returned by update/create
      * @returns {Promise.<string[]>} Returns list of updated keys/ids that were published. Success could only be seen with a delay in the UI because the publish-endpoint is async
      */
-    static async publish(keyArr) {
+    static async publish(keyArr, upsertResults) {
         const resultsTransactional = [];
         // works only with objectId
         const statusUrls = [];
         const executedKeyArr = [];
-        const metadataMap = await this.retrieveForCache();
+        const refreshTransactionalKeys = [];
+        const metadataMap = upsertResults
+            ? { metadata: upsertResults }
+            : await this.retrieveForCache();
         const spinnerTransactional = yoctoSpinner({
             text: `Publishing transactional journey…`,
         });
@@ -1927,11 +1955,20 @@ class Journey extends MetadataType {
             }
             if (journey.status === 'Published') {
                 // api would return error code 30000 and ask to open a support case when in fact we simply already have a transactionalEmail created based on this status
-                Util.logger.error(
-                    ` ☇ skipping ${this.definition.type} ${
-                        journey[this.definition.nameField]
-                    } (${journey[this.definition.keyField]}): already published`
-                );
+                if (journey.definitionType === 'Transactional') {
+                    Util.logger.info(
+                        ` ☇ skipping ${this.definition.type} ${
+                            journey[this.definition.nameField]
+                        } (${journey[this.definition.keyField]}): already published. Queueing for refresh.`
+                    );
+                    refreshTransactionalKeys.push(journey.key);
+                } else {
+                    Util.logger.warn(
+                        ` ☇ skipping ${this.definition.type} ${
+                            journey[this.definition.nameField]
+                        } (${journey[this.definition.keyField]}): already published.`
+                    );
+                }
                 continue;
             }
 
@@ -1957,7 +1994,7 @@ class Journey extends MetadataType {
                                     statusUrls.push({ key, statusUrl: response.statusUrl });
                                 }
                                 spinnerTransactional.start();
-                                return key;
+                                return journey[this.definition.keyField];
                             } catch (ex) {
                                 spinnerTransactional.stop();
                                 if (
@@ -2006,6 +2043,11 @@ class Journey extends MetadataType {
                         } else {
                             throw new Error(response);
                         }
+                        if (Util.OPTIONS.skipStatusCheck) {
+                            Util.logger.warn(
+                                ` - Skipping status check for publishing journey ${key} due to --skipStatusCheck flag`
+                            );
+                        }
                         if (!Util.OPTIONS.skipStatusCheck && statusUrl) {
                             const spinner = yoctoSpinner({
                                 text: `Publishing journey…`,
@@ -2064,6 +2106,10 @@ class Journey extends MetadataType {
             }
         } // for loop
 
+        const publishedJourneyCounter = {
+            multiStep: executedKeyArr.filter(Boolean).length,
+            transactional: 0,
+        };
         // Transactional Send Journeys
         if (resultsTransactional.length) {
             const transactionalKeyArr = (await Promise.all(resultsTransactional)).filter(Boolean);
@@ -2072,56 +2118,103 @@ class Journey extends MetadataType {
             // if all publish actions failed, we don't need to re-retrieve anything here
             if (transactionalKeyArr.length) {
                 executedKeyArr.push(...transactionalKeyArr);
+                publishedJourneyCounter.transactional = transactionalKeyArr.length;
+                // reset transactionalEmail cache to trigger re-caching it.
+                cache.clearCache(this.buObject.mid, 'transactionalEmail');
+            }
+        }
 
-                Util.logger.info('Retrieving relevant journeys');
-                const retriever = new Retriever(this.properties, this.buObject);
+        // reload published journeys including their events/transactionalEmails
+        await this._reRetrieve(
+            executedKeyArr,
+            publishedJourneyCounter.transactional,
+            publishedJourneyCounter.multiStep
+        );
 
-                try {
-                    const updatedJourneyRetrieve = await retriever.retrieve(
-                        ['journey'],
-                        transactionalKeyArr
+        Util.logger.info(
+            `Published ${executedKeyArr.filter(Boolean).length} of ${keyArr.length} items`
+        );
+
+        if (refreshTransactionalKeys.length) {
+            // in case we tried to publish a transactional journey that was already published we will instead run a refresh for those
+            executedKeyArr.push(...(await this.refresh(refreshTransactionalKeys)));
+        }
+        return executedKeyArr.filter(Boolean);
+    }
+
+    /**
+     *
+     * @param {string[]} executedKeyArr list of journey keys
+     * @param {number} transactionalCounter how many transactiona-send journeys did we expect to refresh
+     * @param {number} multiStepCounter how many multi-step journeys did we expect to refresh
+     * @returns {Promise.<void>} -
+     */
+    static async _reRetrieve(executedKeyArr, transactionalCounter, multiStepCounter) {
+        if (!executedKeyArr.filter(Boolean).length) {
+            return;
+        }
+        Util.logger.info('Re-retrieving published journeys');
+        const retriever = new Retriever(this.properties, this.buObject);
+        try {
+            // we need to retrieve the updated journeys and all dependencies
+            const updatedJourneyRetrieve = await retriever.retrieve(
+                ['journey'],
+                executedKeyArr.filter(Boolean)
+            );
+
+            /** @type {MetadataTypeItem[]} */
+            const updatedJourneys =
+                updatedJourneyRetrieve?.journey?.length > 1
+                    ? Object.values(
+                          updatedJourneyRetrieve?.journey.reduce(
+                              (previousValue, currentValue) =>
+                                  Object.assign(previousValue, currentValue),
+                              {}
+                          )
+                      )
+                    : Object.values(updatedJourneyRetrieve?.journey[0]);
+
+            if (updatedJourneys) {
+                // regardless of upsert vs publish-only mode, we need to retrieve the events/transactionalEmail and their dependencies
+                const updatedEvents = [];
+                const updatedTransactionalEmails = [];
+                for (const journey of updatedJourneys) {
+                    // multi-step journeys
+                    updatedEvents.push(journey.triggers?.[0]?.metaData?.r__event_key);
+                    // transactional-send journeys
+                    updatedTransactionalEmails.push(
+                        journey.activities?.[0]?.configurationArguments?.r__transactionalEmail_key
                     );
+                }
+                /** @type {TypeKeyCombo} */
+                const eventTransEmailCombo = {};
+                if (updatedEvents.filter(Boolean).length) {
+                    eventTransEmailCombo.event = updatedEvents.filter(Boolean);
+                } else if (multiStepCounter) {
+                    Util.logger.error(`Could not find events for the published journeys`);
+                }
+                if (updatedTransactionalEmails.filter(Boolean).length) {
+                    eventTransEmailCombo.transactionalEmail =
+                        updatedTransactionalEmails.filter(Boolean);
+                    Util.logger.info('Retrieving relevant transactionalEmails');
+                } else if (transactionalCounter) {
+                    Util.logger.error(
+                        `Could not find transactional Emails for the published journeys`
+                    );
+                }
 
-                    /** @type {MetadataTypeItem[]} */
-                    const updatedJourneys =
-                        updatedJourneyRetrieve?.journey?.length > 1
-                            ? Object.values(
-                                  updatedJourneyRetrieve?.journey.reduce(
-                                      (previousValue, currentValue) =>
-                                          Object.assign(previousValue, currentValue),
-                                      {}
-                                  )
-                              )
-                            : Object.values(updatedJourneyRetrieve?.journey[0]);
-                    if (updatedJourneys) {
-                        const updatedTransactionalEmails = [];
-                        for (const journey of updatedJourneys) {
-                            updatedTransactionalEmails.push(
-                                journey.activities?.[0]?.configurationArguments
-                                    ?.r__transactionalEmail_key
-                            );
-                        }
-                        if (updatedTransactionalEmails.filter(Boolean).length) {
-                            Util.logger.info('Retrieving relevant transactionalEmails');
-                            await retriever.retrieve(
-                                ['transactionalEmail'],
-                                updatedTransactionalEmails.filter(Boolean)
-                            );
-                        } else {
-                            Util.logger.error(
-                                `Could not find transactional Emails for the published journeys`
-                            );
-                        }
-                    }
-                } catch (ex) {
-                    Util.logger.errorStack(ex, 'retrieve failed');
+                const toBeRetrievedTypes = Object.keys(eventTransEmailCombo);
+                if (toBeRetrievedTypes.length) {
+                    Util.logger.info(
+                        'Retrieving relevant ' +
+                            toBeRetrievedTypes.map((item) => item + 's').join(', ')
+                    );
+                    await retriever.retrieve(toBeRetrievedTypes, eventTransEmailCombo);
                 }
             }
+        } catch (ex) {
+            Util.logger.errorStack(ex, 'retrieve failed');
         }
-        Util.logger.info(
-            `Published ${executedKeyArr.filter(Boolean).length} of ${keyArr.length} items`
-        );
-        return executedKeyArr.filter(Boolean);
     }
 
     /**
@@ -2675,31 +2768,28 @@ class Journey extends MetadataType {
      * TSD-specific refresh method that finds active TSDs and refreshes them
      *
      * @param {string[]} keyArr metadata keys
-     * @param {boolean} [checkKey] whether to check if the key is valid
      * @returns {Promise.<string[]>} Returns list of keys that were refreshed
      */
-    static async refresh(keyArr, checkKey = true) {
+    static async refresh(keyArr) {
         console.time('Time'); // eslint-disable-line no-console
-        if (!keyArr) {
+        if (!Array.isArray(keyArr) || !keyArr.length) {
             Util.logger.error('No refresh-keys provided');
             return [];
             // keyArr = await this.getKeysForValidTSDs((await this.findRefreshableItems()).metadata);
             // checkKey = false;
         }
-        let journeyCache;
-        if (checkKey) {
-            journeyCache = await this.retrieveForCache();
-        }
+        const journeyCache = await this.retrieveForCache();
         // then executes pause, publish, start on them.
         Util.logger.info(`Refreshing ${keyArr.length} ${this.definition.typeName}...`);
         Util.logger.debug(`Refreshing keys: ${keyArr.join(', ')}`);
         const refreshedKeyArr = [];
         const tsKeys = [];
         const rateLimit = pLimit(10);
+        const transactionalJourneyKeys = [];
         await Promise.all(
             keyArr.map((key) =>
                 rateLimit(async () => {
-                    if (checkKey && !journeyCache.metadata[key]) {
+                    if (!journeyCache.metadata[key]) {
                         Util.logger.error(
                             ` ☇ skipping refresh of ${this.definition.type} ${key}: not found on server`
                         );
@@ -2707,15 +2797,16 @@ class Journey extends MetadataType {
                     }
                     switch (journeyCache.metadata[key].definitionType) {
                         case 'Transactional': {
-                            if (checkKey && journeyCache.metadata[key]?.status !== 'Published') {
-                                Util.logger.error(
-                                    ` ☇ skipping refresh of ${this.definition.type} ${key}: Can only refresh journeys with status 'Published'. Found status: ${journeyCache.metadata[key]?.status}`
-                                );
-                            } else {
+                            if (journeyCache.metadata[key]?.status === 'Published') {
                                 const result = await this._refreshItem(key, journeyCache);
                                 if (result) {
                                     refreshedKeyArr.push(key);
+                                    transactionalJourneyKeys.push(key);
                                 }
+                            } else {
+                                Util.logger.error(
+                                    ` ☇ skipping refresh of ${this.definition.type} ${key}: Can only refresh journeys with status 'Published'. Found status: ${journeyCache.metadata[key]?.status}`
+                                );
                             }
                             break;
                         }
@@ -2804,6 +2895,14 @@ class Journey extends MetadataType {
             Util.logger.info(Util.getGrayMsg('No triggeredSends found to refresh'));
         }
 
+        // reload refreshed transactional journeys including their transactionalEmails
+        if (transactionalJourneyKeys.length) {
+            // reset transactionalEmail cache to trigger re-caching it.
+            cache.clearCache(this.buObject.mid, 'transactionalEmail');
+
+            await this._reRetrieve(transactionalJourneyKeys, transactionalJourneyKeys.length, 0);
+        }
+
         Util.logger.info(
             `Refreshed ${refreshedKeyArr.length} of ${keyArr.length} ${this.definition.type}`
         );

package/lib/metadataTypes/MetadataType.js

@@ -69,21 +69,34 @@ class MetadataType {
                 try {
                     if (fileName.endsWith('.json')) {
                         const fileContent = await File.readJSONFile(dir, fileName, false);
-                        const fileNameWithoutEnding = File.reverseFilterIllegalFilenames(
-                            fileName.split(/\.(\w|-)+-meta.json/)[0]
-                        );
-                        // We always store the filename using the External Key (CustomerKey or key) to avoid duplicate names.
-                        // to ensure any changes are done to both the filename and external key do a check here
                         // ! convert numbers to string to allow numeric keys to be checked properly
                         const key = Number.isInteger(fileContent[this.definition.keyField])
                             ? fileContent[this.definition.keyField].toString()
                             : fileContent[this.definition.keyField];
-                        if (key === fileNameWithoutEnding || listBadKeys) {
-                            fileName2FileContent[fileNameWithoutEnding] = fileContent;
+
+                        // ensure filename includes extended metadata extension
+                        const regex = new RegExp(/\.(\w|-)+-meta.json/);
+                        const errorDir = dir.split('\\').join('/');
+                        if (regex.test(fileName)) {
+                            const fileNameWithoutEnding = File.reverseFilterIllegalFilenames(
+                                fileName.split(regex)[0]
+                            );
+                            // We always store the filename using the External Key (CustomerKey or key) to avoid duplicate names.
+                            // to ensure any changes are done to both the filename and external key do a check here
+                            if (key === fileNameWithoutEnding || listBadKeys) {
+                                fileName2FileContent[fileNameWithoutEnding] = fileContent;
+                            } else {
+                                Util.logger.error(
+                                    ` ☇ skipping ${this.definition.type} ${key}: Name of the metadata file and the JSON-key (${this.definition.keyField}) must match. Expected: ${key}.${this.definition.type}-meta.json. Actual: ` +
+                                        Util.getGrayMsg(`${errorDir}/`) +
+                                        fileName
+                                );
+                            }
                         } else {
                             Util.logger.error(
-                                ` ${this.definition.type} ${key}: Name of the metadata file and the JSON-key (${this.definition.keyField}) must match` +
-                                    Util.getGrayMsg(` - ${dir}/${fileName}`)
+                                ` ☇ skipping ${this.definition.type} ${key}: Name of the metadata file must end on the extended metadata suffix. Expected: ${key}.${this.definition.type}-meta.json. Actual: ` +
+                                    Util.getGrayMsg(`${errorDir}/`) +
+                                    fileName
                             );
                         }
                     }

package/lib/metadataTypes/SendClassification.js

@@ -131,6 +131,26 @@ class SendClassification extends MetadataType {
         return metadata;
     }
 
+    /**
+     * Gets executed after deployment of metadata type
+     *
+     * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
+     * @returns {Promise.<void>} -
+     */
+    static async postDeployTasks(upsertResults) {
+        // re-retrieve all upserted items to ensure we have all fields (createdDate and modifiedDate are otherwise not present)
+        Util.logger.debug(
+            `Caching all ${this.definition.type} post-deploy to ensure we have all fields`
+        );
+        const typeCache = await this.retrieveForCache();
+        // update values in upsertResults with retrieved values before saving to disk
+        for (const key of Object.keys(upsertResults)) {
+            if (typeCache.metadata[key]) {
+                upsertResults[key] = typeCache.metadata[key];
+            }
+        }
+    }
+
     /**
      * manages post retrieve steps
      *

package/lib/metadataTypes/SenderProfile.js

@@ -162,6 +162,26 @@ class SenderProfile extends MetadataType {
         return metadata;
     }
 
+    /**
+     * Gets executed after deployment of metadata type
+     *
+     * @param {MetadataTypeMap} upsertResults metadata mapped by their keyField as returned by update/create
+     * @returns {Promise.<void>} -
+     */
+    static async postDeployTasks(upsertResults) {
+        // re-retrieve all upserted items to ensure we have all fields (createdDate and modifiedDate are otherwise not present)
+        Util.logger.debug(
+            `Caching all ${this.definition.type} post-deploy to ensure we have all fields`
+        );
+        const typeCache = await this.retrieveForCache();
+        // update values in upsertResults with retrieved values before saving to disk
+        for (const key of Object.keys(upsertResults)) {
+            if (typeCache.metadata[key]) {
+                upsertResults[key] = typeCache.metadata[key];
+            }
+        }
+    }
+
     /**
      *
      * @param {MetadataTypeItem} item single metadata item

package/lib/metadataTypes/definitions/Automation.definition.js

@@ -78,6 +78,12 @@ export default {
         Scheduled: 6,
         Stopped: 5,
     },
+    fileNameOperatorMapping: {
+        Equals: 4,
+        Contains: 1,
+        'Begins with': 2,
+        'Ends with': 3,
+    },
     timeZoneMapping: {
         // bugs in SFMC timezones:
         // * Yerevan GMT+4 always is changing to 'Caucasus Standard Time' GMT+4, so no id 29

package/lib/metadataTypes/definitions/FileLocation.definition.js

@@ -17,6 +17,20 @@ export default {
         'Used for export or import of files to/from Marketing Cloud. Previously this was labeled ftpLocation.',
     typeRetrieveByDefault: true,
     typeName: 'File Location',
+    locationTypeMapping: {
+        'Enhanced FTP Site Import Directory': 0,
+        'External FTP Site': 1,
+        'External SFTP Site': 2,
+        'External FTPS Site': 3,
+        'Salesforce Objects and Reports': 4,
+        Safehouse: 5,
+        'Enhanced FTP Site Export Directory': 6,
+        'Legacy Import Directory': 8,
+        'Relative location under FTP Site': 9,
+        'Amazon Simple Storage Service': 13,
+        'Azure Blob Storage': 15,
+        'Google Cloud Storage': 16,
+    },
     fields: {
         id: {
             isCreateable: false,
@@ -34,13 +48,13 @@ export default {
             isCreateable: false,
             isUpdateable: false,
             retrieving: true,
-            template: false,
+            template: true,
         },
         name: {
             isCreateable: false,
             isUpdateable: false,
             retrieving: true,
-            template: false,
+            template: true,
         },
         relPath: {
             isCreateable: true,
@@ -48,5 +62,11 @@ export default {
             retrieving: true,
             template: true,
         },
+        c__locationType: {
+            isCreateable: false,
+            isUpdateable: false,
+            retrieving: true,
+            template: true,
+        },
     },
 };

package/lib/util/cache.js

@@ -60,12 +60,17 @@ export default {
     /**
      * clean cache for one BU if mid provided, otherwise whole cache
      *
-     * @param {number} [mid] of business unit
+     * @param {number} [mid] limit clearing to provided business unit MID
+     * @param {string} [type] optionally limit clearing to specific metadata type; only used if mid is provided
      * @returns {void}
      */
-    clearCache: (mid) =>
+    clearCache: (mid, type) =>
         mid
-            ? Object.keys(dataStore[mid]).forEach((key) => delete dataStore[mid][key])
+            ? Object.keys(dataStore[mid]).forEach((key) => {
+                  if (!type || type === key) {
+                      delete dataStore[mid][key];
+                  }
+              })
             : Object.keys(dataStore).forEach((key) => delete dataStore[key]),
     /* eslint-enable unicorn/no-array-for-each */
 

package/lib/util/config.js

@@ -127,6 +127,10 @@ const config = {
                 `Your Accenture SFMC DevTools version ${Util.packageJsonMcdev.version} is lower than your project's config version ${properties.version}`
             );
             if (Util.skipInteraction) {
+                // print guidance for extension users
+                Util.logger.error(
+                    `Run 'npm update -g mcdev@${properties.version}' now to fix this.`
+                );
                 return false;
             }
 
@@ -277,6 +281,8 @@ const config = {
                     ].join('\n- ')
                 );
                 if (Util.skipInteraction) {
+                    // print guidance for extension users
+                    Util.logger.error(`Run 'mcdev upgrade' now to fix this.`);
                     return false;
                 }
                 const runUpgradeNow = await confirm({

package/lib/util/file.js

@@ -270,6 +270,7 @@ const File = {
      * @returns {Promise.<string>} original string on error; formatted string on success
      */
     _beautify_prettier: async function (directory, filename, filetype, content) {
+        const properties = await config.getProperties();
         let formatted = '';
         try {
             if (!FileFs.prettierConfig) {
@@ -337,20 +338,22 @@ const File = {
 
             formatted = await prettier.format(content, FileFs.prettierConfig);
         } catch (ex) {
-            // save prettier errror into log file
-            // Note: we have to filter color codes from prettier's error message before saving it to file
-            /* eslint-disable no-control-regex */
-            this.writeToFile(
-                directory,
-                filename + '.error',
-                'log',
-                `Error Log\nParser: ${FileFs.prettierConfig.parser}\n${ex.message.replaceAll(
-                    /[\u001B\u009B][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
-
-                    ''
-                )}`
-            );
-            /* eslint-enable no-control-regex */
+            if (properties.options.formatErrorLog) {
+                // save prettier errror into log file
+                // Note: we have to filter color codes from prettier's error message before saving it to file
+                /* eslint-disable no-control-regex */
+                this.writeToFile(
+                    directory,
+                    filename + '.error',
+                    'log',
+                    `Error Log\nParser: ${FileFs.prettierConfig.parser}\n${ex.message.replaceAll(
+                        /[\u001B\u009B][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+
+                        ''
+                    )}`
+                );
+                /* eslint-enable no-control-regex */
+            }
 
             formatted = content;
         }