mcdev 9.0.2 → 10.0.0

package/lib/util/file.js

@@ -2,10 +2,7 @@
 import fs from 'fs-extra';
 
 import path from 'node:path';
-import prettier from 'prettier';
-import beautyAmp from 'beauty-amp-core2';
 import { Util } from './util.js';
-import updateNotifier from 'update-notifier';
 import config from './config.js';
 
 /**
@@ -24,24 +21,105 @@ import config from './config.js';
  * @typedef {import('../../types/mcdev.d.js').MultiMetadataTypeList} MultiMetadataTypeList
  * @typedef {import('../../types/mcdev.d.js').MultiMetadataTypeMap} MultiMetadataTypeMap
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
- * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
  * @typedef {import('../../types/mcdev.d.js').TypeKeyCombo} TypeKeyCombo
  */
 
-// inform user when there is an update
-const notifier = updateNotifier({
-    pkg: Util.packageJsonMcdev,
-    updateCheckInterval: 1000 * 3600 * 24, // once per day
-});
-// Notify using the built-in convenience method
-notifier.notify();
-
 /**
  * File extends fs-extra. It adds logger and util methods for file handling
  */
+let prettierModulesPromise;
+
 const File = {
+    // Deprecated compatibility fields. Formatting uses immutable per-filetype entries below.
     prettierConfig: null,
     prettierConfigFileType: null,
+    prettierConfigCache: new Map(),
+
+    /**
+     * Loads and caches formatting packages after formatting has been confirmed enabled.
+     *
+     * @returns {Promise.<{prettier: import('prettier'), prettierPluginSfmc: object}>} formatter modules
+     */
+    async _loadPrettierModules() {
+        if (!prettierModulesPromise) {
+            prettierModulesPromise = (async () => {
+                const [prettierModule, prettierPluginSfmc] = await Promise.all([
+                    import('prettier'),
+                    import('prettier-plugin-sfmc'),
+                ]);
+                return { prettier: prettierModule.default, prettierPluginSfmc };
+            })();
+        }
+        return prettierModulesPromise;
+    },
+
+    /**
+     * Maps mcdev file extensions to Prettier parser names.
+     *
+     * @param {string} filetype file extension without dot
+     * @returns {string | undefined} parser name when mcdev has an explicit mapping
+     */
+    _getPrettierParser(filetype) {
+        switch (filetype.toLowerCase()) {
+            case 'amp':
+            case 'ampscript':
+            case 'html':
+            case 'htm':
+            case 'hbs': {
+                return 'ampscript-parse';
+            }
+            case 'ssjs':
+            case 'js': {
+                return 'babel';
+            }
+            case 'sql': {
+                return 'sql';
+            }
+            case 'json': {
+                return 'json';
+            }
+            case 'jsonc': {
+                return 'jsonc';
+            }
+            case 'yaml':
+            case 'yml': {
+                return 'yaml';
+            }
+            case 'ts': {
+                return 'babel-ts';
+            }
+            case 'css': {
+                return 'css';
+            }
+            case 'less': {
+                return 'less';
+            }
+            case 'scss': {
+                return 'scss';
+            }
+            case 'md': {
+                return 'markdown';
+            }
+            default: {
+                // Unknown and intentionally unsupported text types (csv, rss, sass, txt, xml)
+                // rely on filepath inference; absent inference means safe pass-through.
+                return;
+            }
+        }
+    },
+
+    /**
+     * Checks whether formatting is enabled by CLI or project configuration.
+     *
+     * @param {Mcdevrc} properties project configuration
+     * @returns {boolean} whether formatting should run
+     */
+    _isFormattingEnabled(properties) {
+        return Boolean(
+            (properties?.options?.formatOnSave && Util.OPTIONS.format === undefined) ||
+            Util.OPTIONS.format
+        );
+    },
 
     /**
      * copies a file from one path to another
@@ -75,7 +153,7 @@ const File = {
     filterIllegalPathChars(path) {
         return (
             encodeURIComponent(path)
-                .replaceAll(/[*]/g, '_STAR_')
+                .replaceAll('*', '_STAR_')
                 // convert space back
                 .split('%20')
                 .join(' ')
@@ -112,7 +190,7 @@ const File = {
     filterIllegalFilenames(filename) {
         return (
             encodeURIComponent(filename)
-                .replaceAll(/[*]/g, '_STAR_')
+                .replaceAll('*', '_STAR_')
                 // convert space back
                 .split('%20')
                 .join(' ')
@@ -141,7 +219,7 @@ const File = {
      * @returns {string} - corrected string
      */
     reverseFilterIllegalFilenames(filename) {
-        return decodeURIComponent(filename).split('_STAR_').join('*');
+        return decodeURIComponent(filename).replaceAll('_STAR_', '*');
     },
 
     /**
@@ -151,7 +229,6 @@ const File = {
      * @returns {string} Path strings
      */
     normalizePath: function (denormalizedPath) {
-        /* eslint-disable unicorn/prefer-ternary */
         if (Array.isArray(denormalizedPath)) {
             // if the value is undefined set to empty string to allow parsing
             return path.join(...denormalizedPath.map((val) => val || ''));
@@ -159,7 +236,6 @@ const File = {
             // if directory is empty put . as otherwill will write to c://
             return path.join(denormalizedPath || '.');
         }
-        /* eslint-enable unicorn/prefer-ternary */
     },
 
     /**
@@ -173,11 +249,13 @@ const File = {
     writeJSONToFile: async function (directory, filename, content) {
         directory = this.filterIllegalPathChars(this.normalizePath(directory));
         filename = this.filterIllegalFilenames(filename);
-        await fs.ensureDir(directory);
         try {
-            return fs.writeJSON(path.join(directory, filename + '.json'), content, { spaces: 4 });
+            await fs.ensureDir(directory);
+            await fs.writeJSON(path.join(directory, filename + '.json'), content, { spaces: 4 });
+            return true;
         } catch (ex) {
             Util.logger.error('File.writeJSONToFile:: error | ' + ex.message);
+            return false;
         }
     },
 
@@ -189,74 +267,28 @@ const File = {
      * @param {string} filename name of the file without suffix
      * @param {string} filetype filetype ie. JSON or SSJS
      * @param {string} content filecontent
-     * @param {TemplateMap} [templateVariables] templating variables to be replaced in the metadata
      * @returns {Promise.<boolean>} Promise
      */
-    writePrettyToFile: async function (directory, filename, filetype, content, templateVariables) {
-        let formatted;
+    writePrettyToFile: async function (directory, filename, filetype, content) {
         const properties = await config.getProperties();
-        if (
-            (properties?.options?.formatOnSave && Util.OPTIONS.format === undefined) ||
-            Util.OPTIONS.format
-        ) {
-            formatted =
-                filetype === 'amp'
-                    ? await this.beautify_beautyAmp(content, false)
-                    : await this._beautify_prettier(directory, filename, filetype, content);
-        } else {
-            // skip formatting
-            formatted = content;
-        }
-        if (templateVariables) {
-            formatted = Util.replaceByObject(formatted, templateVariables);
-        }
+        const formatted = this._isFormattingEnabled(properties)
+            ? await this._beautify_prettier(directory, filename, filetype, content)
+            : content;
         return this.writeToFile(directory, filename, filetype, formatted);
     },
 
     /**
-     * helper that applies beautyAmp onto given stringified content; strongly typed for strings only
-     *
-     * @param {string} content code
-     * @param {boolean} [formatHTML] applies formatting to html and ampscript if true
-     * @returns {Promise.<string>} formatted code
-     */
-    _beautify_beautyAmp_beautify: async function (content, formatHTML = true) {
-        const response = await beautyAmp.beautify(content, formatHTML);
-        if (typeof response == 'string') {
-            return response.trim() + '\n';
-        } else {
-            throw new TypeError('beautyAmp failed to beautify the content');
-        }
-    },
-
-    /**
-     * helper for {@link File.writePrettyToFile}, applying beautyAmp onto given stringified content
+     * Formats extracted Transactional SMS content when formatting is enabled.
      *
-     * @param {string} content filecontent
-     * @param {boolean} formatHTML should we format HTML or not via prettier included in beautyAmp
-     * @returns {Promise.<string>} original string on error; formatted string on success
+     * @param {string} content extracted AMPscript content
+     * @returns {Promise.<string>} original string when disabled or on error; formatted string on success
      */
-    beautify_beautyAmp: async function (content, formatHTML = true) {
+    _formatTransactionalSmsContent: async function (content) {
         const properties = await config.getProperties();
-        if (
-            (properties?.options?.formatOnSave && Util.OPTIONS.format === undefined) ||
-            Util.OPTIONS.format
-        ) {
-            // logs trough console only for the moment.
-            const logs = {
-                loggerOn: false, // <= disable logging
-            };
-            try {
-                beautyAmp.setup(null, null, logs);
-                // Note: we need to trim the result as beautyAmp adds a leading new line; but we also want to ensure there is a single new line at the end to comply with standard linting rules
-                return await this._beautify_beautyAmp_beautify(content, formatHTML);
-            } catch {
-                return content;
-            }
-        } else {
-            // skip formatting
+        if (!this._isFormattingEnabled(properties)) {
             return content;
         }
+        return this._beautify_prettier('', '', 'amp', content);
     },
 
     /**
@@ -271,85 +303,48 @@ const File = {
      */
     _beautify_prettier: async function (directory, filename, filetype, content) {
         const properties = await config.getProperties();
+        const normalizedFiletype = filetype.toLowerCase();
+        const filepath = path.resolve(
+            this.normalizePath(directory),
+            `${filename || 'index'}.${normalizedFiletype}`
+        );
+        const mappedParser = this._getPrettierParser(normalizedFiletype);
+        let effectiveParser;
         /** @type {string} */
         let formatted;
         try {
-            if (!FileFs.prettierConfig) {
-                // either no prettier config in project directory or initPrettier was not run before this
+            await this.initPrettier(normalizedFiletype);
+            const resolvedConfig = FileFs.prettierConfigCache.get(normalizedFiletype);
+            if (!resolvedConfig) {
                 return content;
-            } else if (content.includes('%%[') || content.includes('%%=')) {
-                // in case we find AMPScript we need to abort beautifying as prettier
-                // will throw an error falsely assuming bad syntax
-                return await this.beautify_beautyAmp(content, true);
             }
-
-            if (!FileFs.prettierConfig.parser) {
-                // load the right prettier config relative to our file
-                switch (filetype) {
-                    case 'htm':
-                    case 'html': {
-                        FileFs.prettierConfig.parser = 'html';
-                        break;
-                    }
-                    case 'ssjs':
-                    case 'js': {
-                        FileFs.prettierConfig.parser = 'babel';
-                        break;
-                    }
-                    case 'json': {
-                        FileFs.prettierConfig.parser = 'json';
-                        break;
-                    }
-                    case 'yaml':
-                    case 'yml': {
-                        FileFs.prettierConfig.parser = 'yaml';
-                        break;
-                    }
-                    case 'ts': {
-                        FileFs.prettierConfig.parser = 'babel-ts';
-                        break;
-                    }
-                    case 'css': {
-                        FileFs.prettierConfig.parser = 'css';
-                        break;
-                    }
-                    case 'less': {
-                        FileFs.prettierConfig.parser = 'less';
-                        break;
-                    }
-                    case 'sass':
-                    case 'scss': {
-                        FileFs.prettierConfig.parser = 'scss';
-                        break;
-                    }
-                    case 'md': {
-                        FileFs.prettierConfig.parser = 'markdown';
-                        break;
-                    }
-                    case 'sql': {
-                        FileFs.prettierConfig.parser = 'sql';
-                        FileFs.prettierConfig.plugins = ['prettier-plugin-sql'];
-                        break;
-                    }
-                    default: {
-                        FileFs.prettierConfig.parser = 'babel';
-                    }
-                }
+            const { prettier, prettierPluginSfmc } = await this._loadPrettierModules();
+            effectiveParser = resolvedConfig.parser || mappedParser;
+            if (!effectiveParser && !(await prettier.getFileInfo(filepath)).inferredParser) {
+                return content;
             }
 
-            formatted = await prettier.format(content, FileFs.prettierConfig);
+            const formatOptions = {
+                ...resolvedConfig,
+                filepath,
+                plugins: [...(resolvedConfig.plugins || []), prettierPluginSfmc],
+            };
+            if (effectiveParser) {
+                formatOptions.parser = effectiveParser;
+            }
+            formatted = await prettier.format(content, formatOptions);
         } catch (ex) {
             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
+                // save prettier error into log file
+                // Note: filter color codes from Prettier's error message before saving it
                 /* eslint-disable no-control-regex */
-                this.writeToFile(
+                const parserContext = effectiveParser ? `Parser: ${effectiveParser}\n` : '';
+                await this.writeToFile(
                     directory,
                     filename + '.error',
                     'log',
-                    `Error Log\nParser: ${FileFs.prettierConfig.parser}\n${ex.message.replaceAll(
+                    `Error Log\nFile: ${filepath}\n${parserContext}${ex.message.replaceAll(
                         /[\u001B\u009B][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
-
                         ''
                     )}`
                 );
@@ -465,29 +460,30 @@ const File = {
             for (const dirent of raw) {
                 const direntPath = path.join(directory, dirent.name);
                 if (
-                    (await fs.pathExists(direntPath)) &&
-                    (await fs.lstat(direntPath)).isDirectory() &&
-                    depth > 0
+                    !(await fs.pathExists(direntPath)) ||
+                    !(await fs.lstat(direntPath)).isDirectory() ||
+                    depth <= 0
                 ) {
-                    const nestedChildren = await this.readDirectories(
-                        direntPath,
-                        depth - 1,
-                        includeStem,
-                        _stemLength
-                    );
-                    children = children.concat(nestedChildren);
+                    continue;
                 }
+                const nestedChildren = await this.readDirectories(
+                    direntPath,
+                    depth - 1,
+                    includeStem,
+                    _stemLength
+                );
+                children = children.concat(nestedChildren);
             }
             if (children.length === 0) {
                 // if not includeStem then remove base directory and leading slahes and backslashes
-                return includeStem
-                    ? [directory]
-                    : [
-                          directory
+                return [
+                    includeStem
+                        ? directory
+                        : directory
                               .slice(Math.max(0, _stemLength))
                               .replace(/^\\+/, '')
                               .replace(/^\/+/, ''),
-                      ];
+                ];
             } else {
                 return children;
             }
@@ -532,16 +528,18 @@ const File = {
             // loop through children of current directory (if not then this is skipped)
             for (const dirent of raw) {
                 // if directory found and should get children then recursively call
-                if (dirent.isDirectory() && depth > 0) {
-                    const nestedChildren = this.readDirectoriesSync(
-                        path.join(directory, dirent.name),
-                        depth - 1,
-                        includeStem,
-                        _stemLength
-                    );
-                    if (Array.isArray(nestedChildren) && nestedChildren.length > 0) {
-                        children.push(...nestedChildren);
-                    }
+                if (!(dirent.isDirectory() && depth > 0)) {
+                    continue;
+                }
+
+                const nestedChildren = this.readDirectoriesSync(
+                    path.join(directory, dirent.name),
+                    depth - 1,
+                    includeStem,
+                    _stemLength
+                );
+                if (Array.isArray(nestedChildren) && nestedChildren.length > 0) {
+                    children.push(...nestedChildren);
                 }
             }
             return children;
@@ -555,14 +553,25 @@ const File = {
      * helper that splits the config back into auth & config parts to save them separately
      *
      * @param {Mcdevrc} properties central properties object
-     * @returns {Promise.<void>} -
+     * @param {string} [version] version to persist; defaults to the current mcdev version
+     * @returns {Promise.<boolean>} whether the config file was saved successfully
      */
-    async saveConfigFile(properties) {
-        // we want to save to save the full version here to allow us to upgrade configs properly in the future
-        properties.version = Util.packageJsonMcdev.version;
-
-        await this.writeJSONToFile('', Util.configFileName.split('.json')[0], properties);
+    async saveConfigFile(properties, version = Util.packageJsonMcdev.version) {
+        const previousVersion = properties.version;
+        // save the full version to allow us to upgrade configs properly in the future
+        properties.version = version;
+
+        const success = await this.writeJSONToFile(
+            '',
+            Util.configFileName.split('.json', 1)[0],
+            properties
+        );
+        if (!success) {
+            properties.version = previousVersion;
+            return false;
+        }
         Util.logger.info(`✔️  ${Util.configFileName} and ${Util.authFileName} saved successfully`);
+        return true;
     },
 
     /**
@@ -572,39 +581,44 @@ 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
+        if (!this._isFormattingEnabled(properties)) {
             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;
-            try {
-                // pass in project dir with fake index.html to avoid "no parser" error
-                // by using process.cwd we are limiting ourselves to a config in the project root
-                // note: overrides will be ignored unless they are for *.html if hand in an html file here. This method includes the overrides corresponding to the file we pass in
-                FileFs.prettierConfig = await prettier.resolveConfig(
-                    path.join(process.cwd(), 'index.' + filetype)
-                );
-                if (FileFs.prettierConfig === null) {
-                    // set to false to avoid re-running this after an initial failure
-                    throw new Error(
-                        `No .prettierrc found in your project directory. Please run 'mcdev upgrade' to create it`
-                    );
-                }
 
-                return true;
-            } catch (ex) {
-                FileFs.prettierConfig = false;
-                Util.logger.error('Cannot apply auto-formatting to your code: ' + ex.message);
-                return false;
+        const effectiveFiletype = filetype.toLowerCase();
+        if (FileFs.prettierConfigCache.has(effectiveFiletype)) {
+            return false;
+        }
+
+        try {
+            const { prettier } = await this._loadPrettierModules();
+            // Resolve against a synthetic project-root file so matching overrides are applied.
+            // Clear Prettier's internal cache because mcdev tests and long-running API users can update config.
+            prettier.clearConfigCache();
+            const resolvedConfig = await prettier.resolveConfig(
+                path.join(process.cwd(), 'index.' + effectiveFiletype)
+            );
+            if (resolvedConfig === null) {
+                throw new Error(
+                    `No .prettierrc found in your project directory. Please run 'mcdev upgrade' to create it`
+                );
             }
-        } else {
+
+            const immutableConfig = Object.freeze({
+                ...resolvedConfig,
+                plugins: Object.freeze([...(resolvedConfig.plugins || [])]),
+            });
+            FileFs.prettierConfigCache.set(effectiveFiletype, immutableConfig);
+            // Maintain public compatibility fields without using them for formatting decisions.
+            FileFs.prettierConfig = immutableConfig;
+            FileFs.prettierConfigFileType = effectiveFiletype;
+            return true;
+        } catch (ex) {
+            FileFs.prettierConfigCache.set(effectiveFiletype, false);
+            FileFs.prettierConfig = false;
+            FileFs.prettierConfigFileType = effectiveFiletype;
+            Util.logger.error('Cannot apply auto-formatting to your code: ' + ex.message);
             return false;
         }
     },