@scandipwa/magento-scripts 1.14.1-alpha.2 → 1.14.1-alpha.5

package/package.json

@@ -3,7 +3,7 @@
     "description": "Scripts and configuration used by CMA.",
     "homepage": "https://docs.create-magento-app.com/",
     "repository": "github:scandipwa/create-magento-app",
-    "version": "1.14.1-alpha.2",
+    "version": "1.14.1-alpha.5",
     "main": "./index.js",
     "types": "./typings/index.d.ts",
     "license": "OSL-3.0",
@@ -26,7 +26,6 @@
         "conf": "10.1.1",
         "enquirer": "2.3.6",
         "eta": "1.12.3",
-        "fast-xml-parser": "^4.0.7",
         "hjson": "^3.2.2",
         "is-installed-globally": "0.4.0",
         "joi": "17.6.0",
@@ -52,5 +51,5 @@
         "mysql",
         "scandipwa"
     ],
-    "gitHead": "8f43ab3d68af6442bbd618efd785654ac62e54b8"
+    "gitHead": "91adc2e400b0b00e9160680d04d8c1588d41fae7"
 }

package/typings/context.d.ts

@@ -1,7 +1,6 @@
 import mysql2 from 'mysql2';
 
 import { CMAConfiguration, PHPExtensions } from './index';
-import { PHPStormConfig } from './phpstorm';
 
 export interface ListrContext {
     magentoVersion: string
@@ -13,6 +12,7 @@ export interface ListrContext {
         mysql: number
         redis: number
         elasticsearch: number
+        varnish: number
     }
     arch: 'arm64' | 'x64'
     isArm: boolean
@@ -83,11 +83,11 @@ export interface ListrContext {
         overridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
         userConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
         nonOverridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
-        phpStorm: PHPStormConfig
     }
     systemConfiguration: {
         analytics: boolean
         useNonOverlappingPorts: boolean
     }
     mysqlConnection: mysql2.Connection
+    isSetupUpgradeNeeded?: boolean
 }

package/typings/index.d.ts

@@ -21,6 +21,20 @@ export interface NginxConfiguration extends ServiceWithVersion {
     configTemplate: string
 }
 
+export interface VarnishConfiguration extends ServiceWithVersion {
+    /**
+     * Enable or disable Varnish in the project
+     */
+    enabled: boolean
+
+    /**
+     * Configuration file location
+     *
+     * @example ./my-varnish-config.vcl
+     */
+    configTemplate: string
+}
+
 export interface PHPExtension extends Record<string, unknown> {
     version?: string
     /**
@@ -175,6 +189,11 @@ export interface CMAConfiguration {
          * Composer configuration
          */
         composer: ServiceWithVersion
+
+        /**
+         * Varnish configuration
+         */
+        varnish: VarnishConfiguration
     }
     /**
      * Magento configuration

package/lib/config/xml-parser.js

@@ -1,61 +0,0 @@
-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

@@ -1,248 +0,0 @@
-/* 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

@@ -1,85 +0,0 @@
-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();
-
-        if (themes.length > 0) {
-            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

@@ -1,154 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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;