@scandipwa/magento-scripts 1.14.1-alpha.0 → 1.14.1-alpha.1

package/lib/config/xml-parser.js

@@ -0,0 +1,61 @@
+const { XMLParser, XMLBuilder } = require('fast-xml-parser');
+const fs = require('fs');
+const path = require('path');
+const pathExists = require('../util/path-exists');
+
+/**
+ * @type {import('fast-xml-parser').X2jOptions}
+ */
+const xmlParserConfig = {
+    ignoreAttributes: false,
+    parseAttributeValue: false,
+    trimValues: true,
+    allowBooleanAttributes: true
+};
+
+/**
+ * @type {Partial<import('fast-xml-parser').XmlBuilderOptions>}
+ */
+const xmlBuilderConfig = {
+    ...xmlParserConfig,
+    format: true,
+    suppressEmptyNode: true,
+    suppressBooleanAttributes: false
+};
+
+const parser = new XMLParser(xmlParserConfig);
+const builder = new XMLBuilder(xmlBuilderConfig);
+
+/**
+ * Load xml file to js object
+ * @param {String} filePath
+ */
+const loadXmlFile = async (filePath) => {
+    const fileData = await fs.promises.readFile(filePath, 'utf-8');
+
+    return parser.parse(fileData);
+};
+
+/**
+ * Build xml from js object and write it to file
+ * @param {String} filePath
+ * @param {String} fileData
+ */
+const buildXmlFile = async (filePath, fileData) => {
+    const xmlFileData = builder.build(fileData);
+
+    const { dir } = path.parse(filePath);
+
+    if (!await pathExists(dir)) {
+        await fs.promises.mkdir(dir, {
+            recursive: true
+        });
+    }
+
+    await fs.promises.writeFile(filePath, xmlFileData, 'utf-8');
+};
+
+module.exports = {
+    loadXmlFile,
+    buildXmlFile
+};

package/lib/tasks/file-system/create-phpstorm-config/database-config.js

@@ -0,0 +1,248 @@
+/* eslint-disable no-param-reassign */
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
+const pathExists = require('../../../util/path-exists');
+const setConfigFile = require('../../../util/set-config');
+
+/**
+ * Get link to data-source field, create fields if necessary
+ *
+ * @param {Object} data
+ * @param {Object} defaultData Default data structure that will be used if original data is missing
+ */
+const getToDataSource = (data, defaultData) => {
+    if (!data.project) {
+        data.project = defaultData.project;
+    }
+
+    if (!data.project.component) {
+        data.project.component = defaultData.project.component;
+    }
+
+    if (!data.project.component['data-source']) {
+        data.project.component['data-source'] = defaultData.project.component['data-source'];
+    }
+
+    return data.project.component['data-source'];
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupDataSourceLocalConfig = () => ({
+    title: 'Set up datasource local configuration',
+    task: async (ctx, task) => {
+        const {
+            config: {
+                phpStorm,
+                phpStorm: {
+                    database
+                }
+            }
+        } = ctx;
+
+        if (await pathExists(database.dataSourcesLocal.path)) {
+            let hasChanges = false;
+            const dataSourcesLocalData = await loadXmlFile(database.dataSourcesLocal.path);
+            const dataSource = getToDataSource(
+                dataSourcesLocalData,
+                {
+                    project: {
+                        '@_version': '4',
+                        component: {
+                            '@_name': 'dataSourceStorageLocal',
+                            '@_created-in': 'PS-212.5284.49',
+                            'data-source': {
+                                '@_uuid': 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
+                            }
+                        }
+                    }
+                }
+            );
+
+            if (dataSource['@_name'] !== database.dataSourceManagerName) {
+                hasChanges = true;
+                dataSource['@_name'] = database.dataSourceManagerName;
+            }
+
+            if (dataSource['@_uuid'] === undefined) {
+                hasChanges = true;
+                dataSource['@_uuid'] = 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f';
+            }
+
+            const defaultDatabaseInfoConfig = {
+                '@_product': '',
+                '@_version': '',
+                '@_jdbc-version': '',
+                '@_driver-name': '',
+                '@_driver-version': '',
+                '@_dbms': 'MYSQL',
+                '@_exact-version': '0'
+            };
+            const isDatabaseInfoChangeNeeded = dataSource['database-info']
+                ? Object.entries(defaultDatabaseInfoConfig)
+                    .some(([key]) => !(key in dataSource['database-info']))
+                : true;
+
+            if (isDatabaseInfoChangeNeeded) {
+                hasChanges = true;
+                if (!dataSource['database-info']) {
+                    dataSource['database-info'] = defaultDatabaseInfoConfig;
+                } else {
+                    Object.entries(defaultDatabaseInfoConfig).forEach(([key, value]) => {
+                        if (!(key in dataSource['database-info'])) {
+                            dataSource['database-info'][key] = value;
+                        }
+                        // ^^^ only set missing properties, only ones should be in place
+                    });
+                }
+            }
+
+            const dataSourceDefaultData = {
+                'secret-storage': 'master_key',
+                'user-name': 'magento'
+            };
+
+            const isDataSourceDataChangeNeeded = dataSource
+                ? Object.entries(dataSourceDefaultData)
+                    .some(([key, value]) => dataSource[key] !== value)
+                : true;
+
+            if (isDataSourceDataChangeNeeded) {
+                hasChanges = true;
+                Object.entries(dataSourceDefaultData).forEach(([key, value]) => {
+                    dataSource[key] = value;
+                });
+            }
+
+            if (!('schema-mapping' in dataSource)) {
+                hasChanges = true;
+                dataSource['schema-mapping'] = '';
+            }
+
+            if (hasChanges) {
+                await buildXmlFile(database.dataSourcesLocal.path, dataSourcesLocalData);
+            } else {
+                task.skip();
+            }
+        } else {
+            try {
+                await setConfigFile({
+                    configPathname: phpStorm.database.dataSourcesLocal.path,
+                    template: phpStorm.database.dataSourcesLocal.templatePath,
+                    overwrite: true,
+                    templateArgs: {
+                        phpStorm
+                    }
+                });
+            } catch (e) {
+                throw new Error(`Unexpected error accrued during dataSources.local.xml config creation\n\n${e}`);
+            }
+        }
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupDataSourceConfig = () => ({
+    task: async (ctx, task) => {
+        const {
+            config: {
+                phpStorm,
+                phpStorm: {
+                    database
+                }
+            },
+            ports
+        } = ctx;
+        const jdbcUrl = `jdbc:mysql://localhost:${ports.mysql}/magento`;
+
+        if (await pathExists(database.dataSources.path)) {
+            let hasChanges = false;
+            const dataSourcesData = await loadXmlFile(database.dataSources.path);
+            const dataSource = getToDataSource(
+                dataSourcesData,
+                {
+                    project: {
+                        '@_version': '4',
+                        component: {
+                            '@_name': 'DataSourceManagerImpl',
+                            '@_format': 'xml',
+                            '@_multifile-model': true,
+                            'data-source': {
+                                '@_source': 'LOCAL',
+                                '@_uuid': 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
+                            }
+                        }
+                    }
+                }
+            );
+
+            if (dataSource['@_uuid'] === undefined) {
+                hasChanges = true;
+                dataSource['@_uuid'] = 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f';
+            }
+
+            const expectedDataSourceData = {
+                '@_name': database.dataSourceManagerName,
+                'driver-ref': 'mysql.8',
+                synchronize: true,
+                'jdbc-driver': 'com.mysql.cj.jdbc.Driver',
+                'jdbc-url': jdbcUrl,
+                'working-dir': '$ProjectFileDir$',
+                '@_source': 'LOCAL'
+            };
+
+            const isDataSourceNeedChanges = dataSource
+                ? Object.entries(expectedDataSourceData)
+                    .some(([key]) => !(key in dataSource))
+                : true;
+
+            if (isDataSourceNeedChanges) {
+                hasChanges = true;
+                if (!dataSource) {
+                    dataSourcesData.project.component['data-source'] = expectedDataSourceData;
+                } else {
+                    Object.entries(expectedDataSourceData).forEach(([key, value]) => {
+                        if (!(key in dataSource)) {
+                            dataSource[key] = value;
+                        }
+                    });
+                }
+            }
+
+            if (hasChanges) {
+                await buildXmlFile(database.dataSources.path, dataSourcesData);
+            } else {
+                task.skip();
+            }
+        } else {
+            try {
+                await setConfigFile({
+                    configPathname: phpStorm.database.dataSources.path,
+                    template: phpStorm.database.dataSources.templatePath,
+                    overwrite: true,
+                    templateArgs: {
+                        phpStorm,
+                        jdbcUrl
+                    }
+                });
+            } catch (e) {
+                throw new Error(`Unexpected error accrued during dataSources.xml config creation\n\n${e}`);
+            }
+        }
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupDatabaseConfig = () => ({
+    title: 'Set up database configuration',
+    task: (ctx, task) => task.newListr([
+        setupDataSourceLocalConfig(),
+        setupDataSourceConfig()
+    ])
+});
+
+module.exports = setupDatabaseConfig;

package/lib/tasks/file-system/create-phpstorm-config/eslint-config.js

@@ -0,0 +1,83 @@
+const path = require('path');
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
+const pathExists = require('../../../util/path-exists');
+const { valueKey, nameKey } = require('./keys');
+const { getCSAThemes } = require('../../../util/CSA-theme');
+const { formatPathForPHPStormConfig } = require('./xml-utils');
+
+const ESLINT_COMPONENT_NAME = 'EslintConfiguration';
+
+const pathToESLintConfig = path.join(process.cwd(), '.idea', 'jsLinters', 'eslint.xml');
+
+const defaultESLintComponentConfiguration = {
+    [nameKey]: ESLINT_COMPONENT_NAME,
+    option: {
+        [nameKey]: 'fix-on-save',
+        [valueKey]: 'true'
+    }
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupESLintConfig = () => ({
+    title: 'Set up ESLint configuration',
+    task: async (ctx, task) => {
+        if (await pathExists(pathToESLintConfig)) {
+            let hasChanges = false;
+            const esLintConfigurationData = await loadXmlFile(pathToESLintConfig);
+
+            if (esLintConfigurationData.project.component && !Array.isArray(esLintConfigurationData.project.component)) {
+                hasChanges = true;
+                esLintConfigurationData.project.component = [esLintConfigurationData.project.component];
+            }
+
+            const esLintConfigurationComponent = esLintConfigurationData.project.component.find(
+                (config) => config[nameKey] === ESLINT_COMPONENT_NAME
+            );
+
+            if (!esLintConfigurationComponent) {
+                hasChanges = true;
+                esLintConfigurationData.project.component.push(defaultESLintComponentConfiguration);
+            }
+
+            if (hasChanges) {
+                await buildXmlFile(pathToESLintConfig, esLintConfigurationData);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const styleLintConfigurationData = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            },
+            project: {
+                '@_version': '4',
+                component: defaultESLintComponentConfiguration
+            }
+        };
+        const themes = await getCSAThemes();
+        const theme = themes[0];
+
+        if (await pathExists(theme.themePath)) {
+            styleLintConfigurationData.project.component['work-dir-pattern'] = {
+                [valueKey]: formatPathForPHPStormConfig(theme.themePath)
+            };
+            const packageJsonPath = path.join(theme.themePath, 'package.json');
+            if (await pathExists(packageJsonPath)) {
+                styleLintConfigurationData.project.component['custom-configuration-file'] = {
+                    '@_used': 'true',
+                    '@_path': formatPathForPHPStormConfig(packageJsonPath)
+                };
+            }
+        }
+
+        await buildXmlFile(pathToESLintConfig, styleLintConfigurationData);
+    }
+});
+
+module.exports = setupESLintConfig;

package/lib/tasks/file-system/create-phpstorm-config/exclude-folder-config.js

@@ -0,0 +1,154 @@
+const path = require('path');
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
+const pathExists = require('../../../util/path-exists');
+const { formatPathForPHPStormConfig } = require('./xml-utils');
+
+const pathToModulesConfig = path.join(process.cwd(), '.idea', 'modules.xml');
+const excludeFoldersPaths = [
+    'bin',
+    'dev',
+    'pub',
+    'setup',
+    'var/cache',
+    'var/page_cache',
+    'var/log'
+].map((p) => `file://$MODULE_DIR$/${p}`);
+
+/**
+ * Will retrieve project config file path from module.xml
+ *
+ * @returns {Promise<String>}
+ */
+const getProjectConfigFilePath = async () => {
+    const modulesConfigData = await loadXmlFile(pathToModulesConfig);
+    return modulesConfigData.project.component.modules.module['@_filepath'].replace('$PROJECT_DIR$', process.cwd());
+};
+
+/**
+ * @returns {Array<{'@_url': string}>}
+ */
+const getExcludedFoldersConfig = (projectConfigData) => {
+    if (!projectConfigData.module) {
+        projectConfigData.module = {
+            '@_type': 'WEB_MODULE',
+            '@_version': '4'
+        };
+    }
+
+    if (!projectConfigData.module.component) {
+        projectConfigData.module.component = {
+            '@_name': 'NewModuleRootManager',
+            orderEntry: [
+                {
+                    '@_type': 'inheritedJdk'
+                },
+                {
+                    '@_type': 'sourceFolder',
+                    '@_forTest': 'false'
+                }
+            ]
+        };
+    }
+
+    if (!projectConfigData.module.component.content) {
+        projectConfigData.module.component.content = {
+            '@_url': 'file://$MODULE_DIR$'
+        };
+    }
+
+    if (!projectConfigData.module.component.content.excludeFolder) {
+        projectConfigData.module.component.content.excludeFolder = [];
+    }
+
+    return projectConfigData
+        .module.component.content.excludeFolder;
+};
+
+const setupExcludedFolders = (excludedFoldersConfig) => {
+    let hasChanges = false;
+    // filter excluded folders to get ones that needs to be added to excluded folders list
+    const missingExcludedFolders = excludeFoldersPaths
+        .filter(
+            (excludeFoldersPath) => !excludedFoldersConfig.some(
+                (config) => config['@_url'] === excludeFoldersPath
+            )
+        );
+
+    if (missingExcludedFolders.length > 0) {
+        hasChanges = true;
+        missingExcludedFolders.forEach((missingExcludedFolder) => {
+            excludedFoldersConfig.unshift({
+                '@_url': missingExcludedFolder
+            });
+        });
+    }
+
+    return hasChanges;
+};
+
+const createModulesXML = async () => {
+    const filePath = path.join(process.cwd(), '.idea', `${path.parse(process.cwd()).base}.iml`);
+    const fileFormattedPath = formatPathForPHPStormConfig(filePath);
+    const fileFormattedUrl = `file://${fileFormattedPath}`;
+
+    const modulesConfig = {
+        '?xml': {
+            '@_version': '1.0',
+            '@_encoding': 'UTF-8'
+        },
+        project: {
+            '@_version': '4',
+            component: {
+                '@_name': 'ProjectModuleManager',
+                modules: [
+                    {
+                        module: {
+                            '@_fileurl': fileFormattedUrl,
+                            '@_filepath': fileFormattedPath
+                        }
+                    }
+                ]
+            }
+        }
+    };
+
+    await buildXmlFile(pathToModulesConfig, modulesConfig);
+
+    return filePath;
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupExcludedFoldersConfig = () => ({
+    title: 'Set up excluded folders configuration',
+    task: async (ctx, task) => {
+        if (await pathExists(pathToModulesConfig)) {
+            const projectFilePath = await getProjectConfigFilePath();
+            const projectConfigData = await loadXmlFile(projectFilePath);
+            const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
+            const hasChanges = setupExcludedFolders(excludedFoldersConfig);
+            if (hasChanges) {
+                await buildXmlFile(projectFilePath, projectConfigData);
+            } else {
+                task.skip();
+            }
+
+            return;
+        }
+
+        const projectFilePath = await createModulesXML();
+        const projectConfigData = {
+            '?xml': {
+                '@_version': '1.0',
+                '@_encoding': 'UTF-8'
+            }
+        };
+        const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
+        setupExcludedFolders(excludedFoldersConfig);
+
+        await buildXmlFile(projectFilePath, projectConfigData);
+    }
+});
+
+module.exports = setupExcludedFoldersConfig;

package/lib/tasks/file-system/create-phpstorm-config/index.js

@@ -0,0 +1,27 @@
+const setupWorkspaceConfig = require('./workspace-config');
+const setupPhpConfig = require('./php-config');
+const setupDatabaseConfig = require('./database-config');
+const setupInspectionToolsConfig = require('./inspection-tools-config');
+const setupExcludedFoldersConfig = require('./exclude-folder-config');
+const setupStylelintConfig = require('./stylelint-config');
+const setupESLintConfig = require('./eslint-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const createPhpStormConfig = () => ({
+    title: 'Setting PHPStorm config',
+    task: (ctx, task) => task.newListr([
+        setupWorkspaceConfig(),
+        setupPhpConfig(),
+        setupDatabaseConfig(),
+        setupInspectionToolsConfig(),
+        setupExcludedFoldersConfig(),
+        setupStylelintConfig(),
+        setupESLintConfig()
+    ], {
+        concurrent: true
+    })
+});
+
+module.exports = createPhpStormConfig;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/coding-standard-config.js

@@ -0,0 +1,29 @@
+const { nameKey, valueKey } = require('../keys');
+const {
+    options: {
+        CODING_STANDARD_OPTION_NAME,
+        CUSTOM_CODING_STANDARD_OPTION_VALUE
+    }
+} = require('./config');
+
+const setupCodingStandardOption = async (config) => {
+    let hasChanges = false;
+    const codingStandardOption = config.option.find(
+        (option) => option[nameKey] === CODING_STANDARD_OPTION_NAME
+    );
+
+    if (!codingStandardOption) {
+        hasChanges = true;
+        config.option.push({
+            [nameKey]: CODING_STANDARD_OPTION_NAME,
+            [valueKey]: CUSTOM_CODING_STANDARD_OPTION_VALUE
+        });
+    } else if (codingStandardOption[valueKey] !== CUSTOM_CODING_STANDARD_OPTION_VALUE) {
+        hasChanges = true;
+        codingStandardOption[valueKey] = CUSTOM_CODING_STANDARD_OPTION_VALUE;
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupCodingStandardOption;

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/config.js

@@ -0,0 +1,54 @@
+// inspection tool classes
+const PHP_CS_FIXER_VALIDATION_INSPECTION = 'PhpCSFixerValidationInspection';
+const PHP_CS_VALIDATION_INSPECTION = 'PhpCSValidationInspection';
+const STYLELINT_INSPECTION = 'Stylelint';
+const ESLINT_INSPECTION = 'Eslint';
+const MESS_DETECTOR_VALIDATION_INSPECTION = 'MessDetectorValidationInspection';
+
+// options
+const CODING_STANDARD_OPTION_NAME = 'CODING_STANDARD';
+const CUSTOM_CODING_STANDARD_OPTION_VALUE = 'Custom';
+const CUSTOM_RULE_SET_PATH_OPTION_NAME = 'CUSTOM_RULESET_PATH';
+const MAGENTO2_CODING_STANDARD_OPTION_VALUE = 'Magento2';
+const EXTENSIONS_OPTION_NAME = 'EXTENSIONS';
+const WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME = 'WARNING_HIGHLIGHT_LEVEL_NAME';
+const WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE = 'ERROR';
+const SHOW_SNIFF_NAMES_OPTION_NAME = 'SHOW_SNIFF_NAMES';
+const USE_INSTALLED_PATHS_OPTION_NAME = 'USE_INSTALLED_PATHS';
+const INSTALLED_PATHS_OPTION_NAME = 'INSTALLED_PATHS';
+const CODESIZE_OPTION_NAME = 'CODESIZE';
+const CONTROVERSIAL_OPTION_NAME = 'CONTROVERSIAL';
+const DESIGN_OPTION_NAME = 'DESIGN';
+const UNUSED_CODE_OPTION_NAME = 'UNUSEDCODE';
+const NAMING_OPTION_NAME = 'NAMING';
+const CUSTOM_RULESETS_OPTION_NAME = 'customRulesets';
+const PHP_MD_RULESET_OPTION_VALUE = 'Magento PHPMD rule set';
+
+module.exports = {
+    options: {
+        CODESIZE_OPTION_NAME,
+        CONTROVERSIAL_OPTION_NAME,
+        DESIGN_OPTION_NAME,
+        UNUSED_CODE_OPTION_NAME,
+        NAMING_OPTION_NAME,
+        CUSTOM_RULESETS_OPTION_NAME,
+        PHP_MD_RULESET_OPTION_VALUE,
+        CODING_STANDARD_OPTION_NAME,
+        CUSTOM_CODING_STANDARD_OPTION_VALUE,
+        CUSTOM_RULE_SET_PATH_OPTION_NAME,
+        MAGENTO2_CODING_STANDARD_OPTION_VALUE,
+        EXTENSIONS_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_NAME,
+        WARNING_HIGHLIGHT_LEVEL_NAME_OPTION_VALUE,
+        SHOW_SNIFF_NAMES_OPTION_NAME,
+        USE_INSTALLED_PATHS_OPTION_NAME,
+        INSTALLED_PATHS_OPTION_NAME
+    },
+    classes: {
+        PHP_CS_FIXER_VALIDATION_INSPECTION,
+        PHP_CS_VALIDATION_INSPECTION,
+        STYLELINT_INSPECTION,
+        ESLINT_INSPECTION,
+        MESS_DETECTOR_VALIDATION_INSPECTION
+    }
+};

package/lib/tasks/file-system/create-phpstorm-config/inspection-tools-config/custom-ruleset-path-config.js

@@ -0,0 +1,31 @@
+const pathExists = require('../../../../util/path-exists');
+const { phpCSConfigurationPath, phpCSConfigFormattedPath } = require('./paths');
+const { nameKey, valueKey } = require('../keys');
+const {
+    options: {
+        CUSTOM_RULE_SET_PATH_OPTION_NAME
+    }
+} = require('./config');
+
+const setupCustomRuleSetPathOption = async (config) => {
+    let hasChanges = false;
+    const customRuleSetPathOption = config.option.find(
+        (option) => option[nameKey] === CUSTOM_RULE_SET_PATH_OPTION_NAME
+    );
+    const phpCSConfigExists = await pathExists(phpCSConfigurationPath);
+
+    if (!customRuleSetPathOption && phpCSConfigExists) {
+        hasChanges = true;
+        config.option.push({
+            [nameKey]: CUSTOM_RULE_SET_PATH_OPTION_NAME,
+            [valueKey]: phpCSConfigFormattedPath
+        });
+    } else if (customRuleSetPathOption && customRuleSetPathOption[valueKey] !== phpCSConfigFormattedPath) {
+        hasChanges = true;
+        customRuleSetPathOption[valueKey] = phpCSConfigFormattedPath;
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupCustomRuleSetPathOption;