mcdev 9.0.2 → 10.0.0

package/lib/util/init.npm.js

@@ -4,163 +4,146 @@ import File from './file.js';
 import path from 'node:path';
 import { Util } from './util.js';
 import semver from 'semver';
-import { fileURLToPath } from 'node:url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-/**
- * CLI helper class
- */
+const retiredDependencies = ['eslint-config-ssjs', 'eslint-plugin-prettier', 'prettier-plugin-sql'];
+const retiredScripts = {
+    build: 'sfmc-build all',
+    'build-cp': 'sfmc-build cloudPages',
+    'build-email': 'sfmc-build emails',
+    'eslint-check': 'eslint',
+};
+const scripts = {
+    lint: 'eslint .',
+    'lint:fix': 'eslint . --fix',
+    format: 'prettier . --write',
+    'format:check': 'prettier . --check',
+};
 
+/** CLI helper for project tooling dependencies. */
 const Init = {
     /**
-     * initiates npm project and then
-     * takes care of loading the pre-configured dependency list
-     * from the boilerplate directory to them as dev-dependencies
+     * Update project tooling defaults and install dependencies.
      *
-     * @param {string} [repoName] if git URL was provided earlier, the repo name was extracted to use it for npm init
-     * @returns {Promise.<boolean>} install successful or error occured
+     * @param {string} [repoName] optional initial project name
+     * @param {string} [versionBeforeUpgrade] original project version for retirement gating
+     * @returns {Promise.<boolean>} whether installation succeeded
      */
-    async installDependencies(repoName) {
-        let fileContent;
-        let projectPackageJson;
-        if (await File.pathExists('package.json')) {
-            try {
-                fileContent = await File.readFile('package.json', 'utf8');
-            } catch (ex) {
-                Util.logger.error(
-                    'Your package.json was found but seems to be corrupted: ' + ex.message
-                );
-            }
-            if (fileContent) {
-                projectPackageJson = JSON.parse(fileContent);
-                this._getDefaultPackageJson(projectPackageJson);
-                await File.writeJSON('./package.json', projectPackageJson, { spaces: 2 });
-                Util.logger.info('✔️  package.json found');
-            }
-        } else {
-            Util.logger.warn('No package.json found. Initializing node project:');
-            // make sure the npm project name is compliant with npm rules
-            const currentFolderName = path.basename(path.resolve());
-            const standardNpmName =
-                repoName ||
-                currentFolderName
-                    .toLowerCase()
-                    .replaceAll(/[^a-z0-9 ]/gi, '')
-                    .replaceAll(/ /gi, '-');
-            projectPackageJson = { name: standardNpmName };
-            this._getDefaultPackageJson(projectPackageJson);
-            await File.writeToFile('./', 'package', 'json', JSON.stringify(projectPackageJson));
-            // execute "no questions asked" npm init
-            Util.execSync('npm', ['init', '--yes'], true);
-            try {
-                fileContent = await File.readFile('package.json', 'utf8');
-                if (fileContent) {
-                    projectPackageJson = JSON.parse(fileContent);
-                }
-                // type="module" is solely required for the new flat configs of ESLint >=9
-                Util.execSync('npm', ['pkg', 'set', 'type="module"'], true);
-                Util.logger.info('✔️  package.json created');
-            } catch {
-                Util.logger.error('No package.json found. Please run "npm init" manually');
-                return false;
-            }
+    async installDependencies(repoName, versionBeforeUpgrade) {
+        const exists = await File.pathExists('package.json');
+        const current = exists ? await File.readJSON('package.json') : {};
+        let project = structuredClone(current);
+        if (!exists) {
+            const selected = repoName?.trim().toLowerCase();
+            const validName = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+            const directoryName = path
+                .basename(path.resolve())
+                .toLowerCase()
+                .replaceAll(/[^a-z0-9 ]/g, '')
+                .trim()
+                .replaceAll(/ +/g, '-');
+            const name = selected && validName.test(selected) ? selected : directoryName;
+            project.name =
+                name && name.length <= 214 && !['node_modules', 'favicon.ico'].includes(name)
+                    ? name
+                    : 'mcdev-project';
         }
-
-        // ensure npm dependencies are loaded
-        const dependencyFile = path.resolve(
-            __dirname,
-            Util.boilerplateDirectory,
-            'npm-dependencies.json'
-        );
-        if (!(await File.pathExists(dependencyFile))) {
-            Util.logger.debug(`Dependency file not found in ${dependencyFile}`);
-            return false;
+        this._getDefaultPackageJson(project);
+        const manifest = await File.readJSON(Util.getBoilerplatePath('npm-dependencies.json'));
+        if (!Array.isArray(manifest)) {
+            throw new TypeError('The tooling dependency manifest must be an array.');
         }
-        const defaultDependencies = await File.readJSON(dependencyFile);
         const versionsDefault = {};
-        for (const name of defaultDependencies) {
-            // check mcdev.devDependencies first
-            versionsDefault[name] = Object.keys(Util.packageJsonMcdev.dependencies).includes(name)
-                ? Util.packageJsonMcdev.dependencies[name]
-                : // then check mcdev.devDependencies
-                  Object.keys(Util.packageJsonMcdev.devDependencies).includes(name)
-                  ? Util.packageJsonMcdev.devDependencies[name]
-                  : // fallback to using latest version if not found
-                    'latest';
+        for (const name of manifest) {
+            versionsDefault[name] =
+                Util.packageJsonMcdev.dependencies?.[name] ||
+                Util.packageJsonMcdev.devDependencies?.[name] ||
+                'latest';
         }
-
         const versionsProject = {};
-        if (projectPackageJson.devDependencies) {
-            for (const name of defaultDependencies) {
-                // check project.devDependencies
-                versionsProject[name] = Object.keys(projectPackageJson.devDependencies).includes(
-                    name
-                )
-                    ? projectPackageJson.devDependencies[name].replace(/^[\^~]/, '')
-                    : // fallback to invalid version if not found
-                      '0.0.0';
-            }
+        for (const name of manifest) {
+            versionsProject[name] =
+                project.devDependencies?.[name]?.replace(/^[\^~]/, '') || '0.0.0';
         }
-        const loadDependencies = defaultDependencies.filter(
+        const loadDependencies = manifest.filter(
             (name) =>
-                !projectPackageJson ||
-                !projectPackageJson.devDependencies ||
-                !projectPackageJson.devDependencies[name] ||
-                versionsDefault[name] == 'latest' ||
-                // filters out file:.. references instead of versions that would otherwise lead to an error in semver.gt()
+                !project.devDependencies?.[name] ||
+                versionsDefault[name] === 'latest' ||
                 !semver.valid(versionsProject[name]) ||
                 semver.gt(versionsDefault[name], versionsProject[name])
         );
+        const retired = semver.lt(semver.valid(versionBeforeUpgrade) || '0.0.0', '10.0.0')
+            ? retiredDependencies.filter(
+                  (name) =>
+                      current.dependencies?.[name] !== undefined ||
+                      current.devDependencies?.[name] !== undefined
+              )
+            : [];
+        if (!exists) {
+            // Seed the project name before npm validates the directory-derived default.
+            await File.writeJSON('package.json', { name: project.name }, { spaces: 2 });
+            if (
+                Util.execSync('npm', ['init', '--yes'], true) === null ||
+                !(await File.pathExists('package.json'))
+            ) {
+                Util.logger.error('Could not initialize package.json. Migration incomplete.');
+                return false;
+            }
+            const generated = await File.readJSON('package.json');
+            project = {
+                ...generated,
+                ...project,
+                scripts: { ...generated.scripts, ...project.scripts },
+            };
+        }
+        await File.writeJSON('package.json', project, { spaces: 2 });
+        if (retired.length && Util.execSync('npm', ['uninstall', ...retired], true) === null) {
+            Util.logger.error('Could not uninstall retired dependencies. Migration incomplete.');
+            return false;
+        }
         if (loadDependencies.length) {
             Util.logger.info('Installing/Updating Dependencies:');
             const args = ['install', '--save-dev'].concat(
                 loadDependencies.map((name) => `${name}@${versionsDefault[name]}`)
             );
-
-            Util.execSync('npm', args);
+            if (Util.execSync('npm', args, true) === null) {
+                Util.logger.error('Could not install/update dependencies. Migration incomplete.');
+                return false;
+            }
             Util.logger.info('✔️  Dependencies installed.');
         } else {
             Util.logger.info(
                 `✔️  All default dependencies are already installed: ` +
-                    defaultDependencies.map((name) => `${name}@${versionsProject[name]}`).join(', ')
+                    manifest.map((name) => `${name}@${versionsProject[name]}`).join(', ')
             );
         }
         return true;
     },
 
     /**
-     * ensure we have certain default values in our config
+     * Apply owned defaults while retaining unrelated project settings.
      *
-     * @param {object} [currentContent] what was read from existing package.json file
-     * @returns {Promise.<{script: object, author: string, license: string}>} extended currentContent
+     * @param {object} currentContent existing package contents
+     * @returns {object} updated package contents
      */
-    async _getDefaultPackageJson(currentContent) {
-        currentContent ||= {};
-        // #1 scripts
-        const predefinedCommandList = {
-            build: 'sfmc-build all',
-            'build-cp': 'sfmc-build cloudPages',
-            'build-email': 'sfmc-build emails',
-            'eslint-check': 'eslint',
-        };
-        if (!currentContent.scripts) {
-            currentContent.scripts = {};
-        }
-        for (const key in predefinedCommandList) {
-            currentContent.scripts[key] = predefinedCommandList[key];
-        }
-        // #2 Author
-        if (!currentContent.author || currentContent.author === '') {
-            currentContent.author = 'Accenture';
+    _getDefaultPackageJson(currentContent) {
+        currentContent.scripts ||= {};
+        for (const [name, command] of Object.entries(retiredScripts)) {
+            if (currentContent.scripts[name] === command) {
+                delete currentContent.scripts[name];
+            }
         }
-        // #3 License
+        Object.assign(currentContent.scripts, scripts);
+        currentContent.author ||= 'Accenture';
         if (!currentContent.license || currentContent.license === 'ISC') {
             currentContent.license = 'UNLICENSED';
         }
-        if (!currentContent.type || currentContent.type !== 'module') {
-            // type="module" is solely required for the new flat configs of ESLint >=9
-            currentContent.type = 'module';
+        currentContent.engines ||= {};
+        if (
+            !semver.validRange(currentContent.engines.node) ||
+            !semver.subset(currentContent.engines.node, Util.packageJsonMcdev.engines.node)
+        ) {
+            currentContent.engines.node = Util.packageJsonMcdev.engines.node;
         }
+        currentContent.type = 'module';
         return currentContent;
     },
 };

package/lib/util/isDeepEqual.js

@@ -0,0 +1,48 @@
+'use strict';
+
+/**
+ * Compares arrays and plain objects recursively while allowing scalar type coercion.
+ *
+ * @param {unknown} left first value
+ * @param {unknown} right second value
+ * @returns {boolean} whether both values are equivalent
+ */
+export function isDeepEqual(left, right) {
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (
+            Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => isDeepEqual(value, right[index]))
+        );
+    }
+
+    if (isPlainObject(left) || isPlainObject(right)) {
+        if (!isPlainObject(left) || !isPlainObject(right)) {
+            return false;
+        }
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        return (
+            leftKeys.length === rightKeys.length &&
+            leftKeys.every((key) => Object.hasOwn(right, key) && isDeepEqual(left[key], right[key]))
+        );
+    }
+
+    // Match the loose scalar comparison previously provided by deep-equal.
+    return left == right;
+}
+
+/**
+ * Checks whether a value is a plain object.
+ *
+ * @param {unknown} value value to inspect
+ * @returns {value is Record<string, unknown>} whether the value is a plain object
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/lib/util/jsonToTable.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/**
+ * Converts one object or an array of objects into rows with flattened headers.
+ * Empty input produces a table containing one empty header row.
+ *
+ * @param {object | object[]} input object or objects to tabulate
+ * @returns {unknown[][]} header row followed by value rows
+ */
+export default function jsonToTable(input) {
+    const records = Array.isArray(input) ? input : input ? [input] : [];
+    if (records.length === 0) {
+        return [[]];
+    }
+
+    const flattenedRecords = records.map((record) => flatten(record));
+    const headers = [];
+    const knownHeaders = new Set();
+
+    for (const record of flattenedRecords) {
+        for (const header of Object.keys(record)) {
+            if (knownHeaders.has(header)) {
+                continue;
+            }
+            knownHeaders.add(header);
+            headers.push(header);
+        }
+    }
+
+    if (headers.length === 0) {
+        return [[]];
+    }
+
+    return [
+        headers,
+        ...flattenedRecords.map((record) =>
+            headers.map((header) =>
+                Object.prototype.hasOwnProperty.call(record, header) ? record[header] : ''
+            )
+        ),
+    ];
+}
+
+/**
+ * Flattens nested values into dotted leaf paths without changing the source object.
+ *
+ * @param {object} input object to flatten
+ * @returns {Record<string, unknown>} flattened path/value map
+ */
+function flatten(input) {
+    /** @type {Record<string, unknown>} */
+    const result = {};
+
+    /**
+     * Visits one value and records its leaf path.
+     *
+     * @param {unknown} value current value
+     * @param {string} path current dotted path
+     * @returns {void}
+     */
+    function visit(value, path) {
+        if (value !== null && typeof value === 'object' && Object.keys(value).length > 0) {
+            for (const [key, nestedValue] of Object.entries(value)) {
+                visit(nestedValue, path ? `${path}.${key}` : key);
+            }
+            return;
+        }
+
+        if (path) {
+            result[path] = value;
+        }
+    }
+
+    visit(input, '');
+    return result;
+}