@scandipwa/magento-scripts 1.15.2 → 1.15.5

package/lib/config/index.js

@@ -7,7 +7,6 @@ const {
 const getPhpConfig = require('./php-config');
 const getComposerConfig = require('./composer');
 const { getMagentoConfig } = require('./magento-config');
-const { getPhpStormConfig } = require('./phpstorm/debug-config');
 const resolveConfigurationWithOverrides = require('../util/resolve-configuration-with-overrides');
 const { getPrefix, folderName } = require('../util/prefix');
 const UnknownError = require('../errors/unknown-error');
@@ -59,8 +58,7 @@ module.exports = {
             baseConfig: newBaseConfig,
             overridenConfiguration,
             userConfiguration,
-            nonOverridenConfiguration: configurations[magentoVersion],
-            phpStorm: getPhpStormConfig(overridenConfiguration, newBaseConfig)
+            nonOverridenConfiguration: configurations[magentoVersion]
         };
     },
     baseConfig,

package/lib/config/templates/dataSources.local.template.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="dataSourceStorageLocal" created-in="PS-212.5284.49">
-    <data-source name="<%~ it.phpStorm.database.dataSourceManagerName %>" uuid="a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f">
+    <data-source name="<%~ it.databaseConfiguration.dataSourceManagerName %>" uuid="a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f">
       <database-info product="" version="" jdbc-version="" driver-name="" driver-version="" dbms="MYSQL" exact-version="0" />
       <secret-storage>master_key</secret-storage>
       <user-name>magento</user-name>

package/lib/config/templates/dataSources.template.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
-    <data-source source="LOCAL" name="<%~ it.phpStorm.database.dataSourceManagerName %>" uuid="a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f">
+    <data-source source="LOCAL" name="<%~ it.databaseConfiguration.dataSourceManagerName %>" uuid="a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f">
       <driver-ref>mysql.8</driver-ref>
       <synchronize>true</synchronize>
       <jdbc-driver>com.mysql.cj.jdbc.Driver</jdbc-driver>

package/lib/config/templates/magentorc.template

@@ -1,5 +1,10 @@
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+NC='\033[0m' # No Color
+
 alias php="$HOME/.phpbrew/php/php-<%= it.php.version %>/bin/php -c $PWD/node_modules/.create-magento-app-cache/php.ini"
 alias magento="php $PWD/bin/magento"
+alias magneto="echo -e 'Not ${RED}magneto${NC} but ${GREEN}magento${NC} please! or at least ${GREEN}m${NC}!' && magento"
 alias m="magento"
 alias composer="php $PWD/node_modules/.create-magento-app-cache/composer/composer.phar"
 alias c="composer"

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

@@ -1,9 +1,24 @@
 /* eslint-disable no-param-reassign */
+const path = require('path');
+const { baseConfig } = require('../../../config');
 const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
 const UnknownError = require('../../../errors/unknown-error');
 const pathExists = require('../../../util/path-exists');
 const setConfigFile = require('../../../util/set-config');
 
+const databaseConfiguration = {
+    driver: 'mysql',
+    dataSourceManagerName: 'mysql 8.0',
+    dataSourcesLocal: {
+        path: path.join(process.cwd(), '.idea', 'dataSources.local.xml'),
+        templatePath: path.join(baseConfig.templateDir, 'dataSources.local.template.xml')
+    },
+    dataSources: {
+        path: path.join(process.cwd(), '.idea', 'dataSources.xml'),
+        templatePath: path.join(baseConfig.templateDir, 'dataSources.template.xml')
+    }
+};
+
 /**
  * Get link to data-source field, create fields if necessary
  *
@@ -32,18 +47,9 @@ const getToDataSource = (data, defaultData) => {
 const setupDataSourceLocalConfig = () => ({
     title: 'Set up datasource local configuration',
     task: async (ctx, task) => {
-        const {
-            config: {
-                phpStorm,
-                phpStorm: {
-                    database
-                }
-            }
-        } = ctx;
-
-        if (await pathExists(database.dataSourcesLocal.path)) {
+        if (await pathExists(databaseConfiguration.dataSourcesLocal.path)) {
             let hasChanges = false;
-            const dataSourcesLocalData = await loadXmlFile(database.dataSourcesLocal.path);
+            const dataSourcesLocalData = await loadXmlFile(databaseConfiguration.dataSourcesLocal.path);
             const dataSource = getToDataSource(
                 dataSourcesLocalData,
                 {
@@ -62,7 +68,7 @@ const setupDataSourceLocalConfig = () => ({
 
             if (!dataSource['@_name']) {
                 hasChanges = true;
-                dataSource['@_name'] = database.dataSourceManagerName;
+                dataSource['@_name'] = databaseConfiguration.dataSourceManagerName;
             }
 
             if (!dataSource['@_uuid']) {
@@ -115,24 +121,24 @@ const setupDataSourceLocalConfig = () => ({
                 });
             }
 
-            if (!('schema-mapping' in dataSource)) {
+            if (dataSource && dataSource['schema-mapping'] === undefined) {
                 hasChanges = true;
                 dataSource['schema-mapping'] = '';
             }
 
             if (hasChanges) {
-                await buildXmlFile(database.dataSourcesLocal.path, dataSourcesLocalData);
+                await buildXmlFile(databaseConfiguration.dataSourcesLocal.path, dataSourcesLocalData);
             } else {
                 task.skip();
             }
         } else {
             try {
                 await setConfigFile({
-                    configPathname: phpStorm.database.dataSourcesLocal.path,
-                    template: phpStorm.database.dataSourcesLocal.templatePath,
+                    configPathname: databaseConfiguration.dataSourcesLocal.path,
+                    template: databaseConfiguration.dataSourcesLocal.templatePath,
                     overwrite: true,
                     templateArgs: {
-                        phpStorm
+                        databaseConfiguration
                     }
                 });
             } catch (e) {
@@ -147,20 +153,11 @@ const setupDataSourceLocalConfig = () => ({
  */
 const setupDataSourceConfig = () => ({
     task: async (ctx, task) => {
-        const {
-            config: {
-                phpStorm,
-                phpStorm: {
-                    database
-                }
-            },
-            ports
-        } = ctx;
-        const jdbcUrl = `jdbc:mysql://localhost:${ports.mysql}/magento`;
+        const jdbcUrl = `jdbc:mysql://localhost:${ctx.ports.mysql}/magento`;
 
-        if (await pathExists(database.dataSources.path)) {
+        if (await pathExists(databaseConfiguration.dataSources.path)) {
             let hasChanges = false;
-            const dataSourcesData = await loadXmlFile(database.dataSources.path);
+            const dataSourcesData = await loadXmlFile(databaseConfiguration.dataSources.path);
             const dataSource = getToDataSource(
                 dataSourcesData,
                 {
@@ -185,7 +182,7 @@ const setupDataSourceConfig = () => ({
             }
 
             const expectedDataSourceData = {
-                '@_name': database.dataSourceManagerName,
+                '@_name': databaseConfiguration.dataSourceManagerName,
                 'driver-ref': 'mysql.8',
                 synchronize: true,
                 'jdbc-driver': 'com.mysql.cj.jdbc.Driver',
@@ -213,18 +210,18 @@ const setupDataSourceConfig = () => ({
             }
 
             if (hasChanges) {
-                await buildXmlFile(database.dataSources.path, dataSourcesData);
+                await buildXmlFile(databaseConfiguration.dataSources.path, dataSourcesData);
             } else {
                 task.skip();
             }
         } else {
             try {
                 await setConfigFile({
-                    configPathname: phpStorm.database.dataSources.path,
-                    template: phpStorm.database.dataSources.templatePath,
+                    configPathname: databaseConfiguration.dataSources.path,
+                    template: databaseConfiguration.dataSources.templatePath,
                     overwrite: true,
                     templateArgs: {
-                        phpStorm,
+                        databaseConfiguration,
                         jdbcUrl
                     }
                 });

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

@@ -17,10 +17,39 @@ const defaultESLintComponentConfiguration = {
     }
 };
 
+const setupESlintConfig = async (esLintConfigurationData) => {
+    let hasChanges = false;
+    const themes = await getCSAThemes();
+
+    if (themes.length > 0) {
+        const theme = themes[0];
+        if (await pathExists(theme.themePath)) {
+            if (esLintConfigurationData['work-dir-pattern'] === undefined) {
+                hasChanges = true;
+                esLintConfigurationData['work-dir-pattern'] = {
+                    [valueKey]: formatPathForPHPStormConfig(theme.themePath)
+                };
+            }
+            const packageJsonPath = path.join(process.cwd(), theme.themePath, 'package.json');
+            if (await pathExists(packageJsonPath)) {
+                if (esLintConfigurationData['custom-configuration-file'] === undefined) {
+                    hasChanges = true;
+                    esLintConfigurationData['custom-configuration-file'] = {
+                        '@_used': 'true',
+                        '@_path': formatPathForPHPStormConfig(packageJsonPath)
+                    };
+                }
+            }
+        }
+    }
+
+    return hasChanges;
+};
+
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
-const setupESLintConfig = () => ({
+const setupESLintConfigTask = () => ({
     title: 'Set up ESLint configuration',
     task: async (ctx, task) => {
         if (await pathExists(pathToESLintConfig)) {
@@ -41,6 +70,11 @@ const setupESLintConfig = () => ({
                 esLintConfigurationData.project.component.push(defaultESLintComponentConfiguration);
             }
 
+            const hasThemeEslintChanges = await setupESlintConfig(esLintConfigurationComponent);
+            if (hasThemeEslintChanges) {
+                hasChanges = hasThemeEslintChanges;
+            }
+
             if (hasChanges) {
                 await buildXmlFile(pathToESLintConfig, esLintConfigurationData);
             } else {
@@ -50,7 +84,7 @@ const setupESLintConfig = () => ({
             return;
         }
 
-        const styleLintConfigurationData = {
+        const esLintConfigurationData = {
             '?xml': {
                 '@_version': '1.0',
                 '@_encoding': 'UTF-8'
@@ -60,26 +94,11 @@ const setupESLintConfig = () => ({
                 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(process.cwd(), theme.themePath, 'package.json');
-                if (await pathExists(packageJsonPath)) {
-                    styleLintConfigurationData.project.component['custom-configuration-file'] = {
-                        '@_used': 'true',
-                        '@_path': formatPathForPHPStormConfig(packageJsonPath)
-                    };
-                }
-            }
-        }
+        await setupESlintConfig(esLintConfigurationData);
 
-        await buildXmlFile(pathToESLintConfig, styleLintConfigurationData);
+        await buildXmlFile(pathToESLintConfig, esLintConfigurationData);
     }
 });
 
-module.exports = setupESLintConfig;
+module.exports = setupESLintConfigTask;

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

@@ -86,33 +86,35 @@ const setupExcludedFolders = (excludedFoldersConfig) => {
     return hasChanges;
 };
 
-const createModulesXML = async () => {
+const getIMLFilePath = 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
+    if (!await pathExists(pathToModulesConfig)) {
+        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);
+        await buildXmlFile(pathToModulesConfig, modulesConfig);
+    }
 
     return filePath;
 };
@@ -125,19 +127,21 @@ const setupExcludedFoldersConfig = () => ({
     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();
-            }
+            if (await pathExists(projectFilePath)) {
+                const projectConfigData = await loadXmlFile(projectFilePath);
+                const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
+                const hasChanges = setupExcludedFolders(excludedFoldersConfig);
+                if (hasChanges) {
+                    await buildXmlFile(projectFilePath, projectConfigData);
+                } else {
+                    task.skip();
+                }
 
-            return;
+                return;
+            }
         }
 
-        const projectFilePath = await createModulesXML();
+        const projectFilePath = await getIMLFilePath();
         const projectConfigData = {
             '?xml': {
                 '@_version': '1.0',

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

@@ -16,17 +16,17 @@ const properties = {
  */
 const setupDefaultProperties = (inspectionTool, defaultProperties = properties) => {
     let hasChanges = false;
-    if (!inspectionTool['@_enabled']) {
+    if (inspectionTool['@_enabled'] === undefined) {
         hasChanges = true;
         inspectionTool['@_enabled'] = defaultProperties.enabled;
     }
 
-    if (!inspectionTool['@_enabled_by_default']) {
+    if (inspectionTool['@_enabled_by_default'] === undefined) {
         hasChanges = true;
         inspectionTool['@_enabled_by_default'] = defaultProperties.enabled_by_default;
     }
 
-    if (!inspectionTool['@_level']) {
+    if (inspectionTool['@_level'] === undefined) {
         hasChanges = true;
         inspectionTool['@_level'] = defaultProperties.level;
     }

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

@@ -6,25 +6,62 @@ const {
     classKey
 } = require('../keys');
 const setupESLintInspection = require('./eslint-inspection-config');
+const { getInspectionToolsConfig } = require('./inspection-tools-config');
 const setupMessDetectorValidationInspection = require('./mess-detector-validation-inspection-config');
 const setupPhpCSFixerValidationInspection = require('./php-cs-fixer-validation-inspection-config');
 const setupPhpCSValidationInspection = require('./php-cs-validation-inspection-config');
 const setupStyleLintInspection = require('./stylelint-inspection-config');
 
+const inspectionProfileDefaults = {
+    component: {
+        [nameKey]: 'InspectionProjectProfileManager',
+        profile: {
+            '@_version': '1.0',
+            option: {
+                [nameKey]: 'myName',
+                [valueKey]: 'Project Default'
+            },
+            inspection_tool: [
+                {
+                    [classKey]: 'PhpStanGlobal',
+                    '@_enabled': 'true',
+                    '@_level': 'ERROR',
+                    '@_enabled_by_default': 'true'
+                }
+            ]
+        }
+    }
+};
+
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
  */
-const setupInspectionToolsConfig = () => ({
+const setupInspectionToolsConfigTask = () => ({
     title: 'Set up inspection tools configuration',
     task: async (ctx, task) => {
-        const {
-            config: {
-                phpStorm
+        const inspectionToolsConfig = getInspectionToolsConfig();
+        if (await pathExists(inspectionToolsConfig.path)) {
+            const inspectionToolsData = await loadXmlFile(inspectionToolsConfig.path);
+
+            if (!inspectionToolsData.component) {
+                inspectionToolsData.component = inspectionProfileDefaults.component;
+            }
+
+            if (!inspectionToolsData.component.profile) {
+                inspectionToolsData.component.profile = inspectionProfileDefaults.component.profile;
+            }
+
+            if (!inspectionToolsData.component.profile.inspection_tool) {
+                inspectionToolsData.component.profile.inspection_tool = [];
+            }
+
+            // eslint-disable-next-line max-len
+            if (!Array.isArray(inspectionToolsData.component.profile.inspection_tool) && Boolean(inspectionToolsData.component.profile.inspection_tool)) {
+                inspectionToolsData.component.profile.inspection_tool = [
+                    inspectionToolsData.component.profile.inspection_tool
+                ];
             }
-        } = ctx;
 
-        if (await pathExists(phpStorm.inspectionTools.path)) {
-            const inspectionToolsData = await loadXmlFile(phpStorm.inspectionTools.path);
             const inspectionTools = inspectionToolsData.component.profile.inspection_tool;
             const hasChanges = await Promise.all([
                 setupPhpCSFixerValidationInspection(inspectionTools),
@@ -34,7 +71,7 @@ const setupInspectionToolsConfig = () => ({
             ]);
 
             if (hasChanges.includes(true)) {
-                await buildXmlFile(phpStorm.inspectionTools.path, inspectionToolsData);
+                await buildXmlFile(inspectionToolsConfig.path, inspectionToolsData);
             } else {
                 task.skip();
             }
@@ -73,8 +110,8 @@ const setupInspectionToolsConfig = () => ({
             setupESLintInspection(inspectionTools)
         ]);
 
-        await buildXmlFile(phpStorm.inspectionTools.path, inspectionToolsData);
+        await buildXmlFile(inspectionToolsConfig.path, inspectionToolsData);
     }
 });
 
-module.exports = setupInspectionToolsConfig;
+module.exports = setupInspectionToolsConfigTask;

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

@@ -0,0 +1,11 @@
+const path = require('path');
+const { baseConfig } = require('../../../../config');
+
+const getInspectionToolsConfig = () => ({
+    path: path.join(process.cwd(), '.idea', 'inspectionProfiles', 'Project_Default.xml'),
+    templatePath: path.join(baseConfig.templateDir, 'Project_Default.template.xml')
+});
+
+module.exports = {
+    getInspectionToolsConfig
+};

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

@@ -1,7 +1,9 @@
 const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
 const pathExists = require('../../../../util/path-exists');
+const { setupXMLStructure } = require('../setup-xml-structure');
 const setupMessDetector = require('./mess-detector-config');
 const setupPHPCodeSniffer = require('./php-code-sniffer-config');
+const { getPhpConfig } = require('./php-config');
 const setupPHPCSFixer = require('./php-cs-fixer-config');
 const setupPHPProjectSharedConfiguration = require('./php-project-shared-configuration-config');
 
@@ -11,29 +13,20 @@ const setupPHPProjectSharedConfiguration = require('./php-project-shared-configu
 const setupPhpConfig = () => ({
     title: 'Set up PHP configuration',
     task: async (ctx, task) => {
-        const {
-            config: {
-                phpStorm,
-                phpStorm: {
-                    php: {
-                        phpLanguageLevel
-                    }
-                }
-            }
-        } = ctx;
+        const phpConfig = getPhpConfig(ctx.config.overridenConfiguration);
 
-        if (await pathExists(phpStorm.php.path)) {
-            const phpConfigContent = await loadXmlFile(phpStorm.php.path);
+        if (await pathExists(phpConfig.path)) {
+            const phpConfigContent = setupXMLStructure(await loadXmlFile(phpConfig.path));
             const phpConfigs = phpConfigContent.project.component;
             const hasChanges = await Promise.all([
                 setupMessDetector(phpConfigs),
                 setupPHPCodeSniffer(phpConfigs),
                 setupPHPCSFixer(phpConfigs),
-                setupPHPProjectSharedConfiguration(phpConfigs, phpLanguageLevel)
+                setupPHPProjectSharedConfiguration(phpConfigs, phpConfig.phpLanguageLevel)
             ]);
 
             if (hasChanges.includes(true)) {
-                await buildXmlFile(phpStorm.php.path, phpConfigContent);
+                await buildXmlFile(phpConfig.path, phpConfigContent);
             } else {
                 task.skip();
             }
@@ -41,26 +34,17 @@ const setupPhpConfig = () => ({
             return;
         }
 
-        const phpConfigContent = {
-            '?xml': {
-                '@_version': '1.0',
-                '@_encoding': 'UTF-8'
-            },
-            project: {
-                '@_version': '4',
-                component: []
-            }
-        };
+        const phpConfigContent = setupXMLStructure();
         const phpConfigs = phpConfigContent.project.component;
 
         await Promise.all([
             setupMessDetector(phpConfigs),
             setupPHPCodeSniffer(phpConfigs),
             setupPHPCSFixer(phpConfigs),
-            setupPHPProjectSharedConfiguration(phpConfigs, phpLanguageLevel)
+            setupPHPProjectSharedConfiguration(phpConfigs, phpConfig.phpLanguageLevel)
         ]);
 
-        await buildXmlFile(phpStorm.php.path, phpConfigContent);
+        await buildXmlFile(phpConfig.path, phpConfigContent);
     }
 });
 

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

@@ -0,0 +1,20 @@
+const path = require('path');
+const { baseConfig } = require('../../../../config');
+
+/**
+ * @param {import('../../../../../typings/index').CMAConfiguration} app
+ */
+const getPhpConfig = (app) => {
+    const [majorPHPVersion, minorPHPVersion] = app.configuration.php.version.split('.');
+    const phpLanguageLevel = `${ majorPHPVersion }.${ minorPHPVersion }`;
+
+    return {
+        phpLanguageLevel,
+        path: path.join(process.cwd(), '.idea', 'php.xml'),
+        templatePath: path.join(baseConfig.templateDir, 'php.template.xml')
+    };
+};
+
+module.exports = {
+    getPhpConfig
+};

package/lib/tasks/file-system/create-phpstorm-config/setup-xml-structure.js

@@ -0,0 +1,40 @@
+const xmlConfiguration = {
+    '?xml': {
+        '@_version': '1.0',
+        '@_encoding': 'UTF-8'
+    },
+    project: {
+        '@_version': '4',
+        component: []
+    }
+};
+
+const setupXMLStructure = (data) => {
+    if (!data) {
+        data = xmlConfiguration;
+    }
+
+    if (data['?xml'] === undefined) {
+        data['?xml'] = xmlConfiguration['?xml'];
+    }
+
+    if (data.project === undefined) {
+        data.project = xmlConfiguration.project;
+    }
+
+    if (data.project.component === undefined) {
+        data.project.component = xmlConfiguration.project.component;
+    }
+
+    if (!Array.isArray(data.project.component) && Boolean(data.project.component)) {
+        data.project.component = [
+            data.project.component
+        ];
+    }
+
+    return data;
+};
+
+module.exports = {
+    setupXMLStructure
+};

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/composer-settings-config.js

@@ -48,7 +48,7 @@ const setupComposerSettings = async (workspaceConfigs) => {
 
     if (composerSettingsComponent) {
         if (
-            !('pharConfigPath' in composerSettingsComponent)
+            composerSettingsComponent.pharConfigPath === undefined
             && isComposerJsonExists
         ) {
             hasChanges = true;
@@ -67,16 +67,6 @@ const setupComposerSettings = async (workspaceConfigs) => {
                 [pharPathKey]: composerPharFormattedPath
             };
         }
-
-        const composerSettingsMissingProperties = Object.entries(defaultComposerSettingsProperties)
-            .filter(([key]) => !(key in composerSettingsComponent));
-
-        if (composerSettingsMissingProperties.length > 0) {
-            hasChanges = true;
-            composerSettingsMissingProperties.forEach(([key, value]) => {
-                composerSettingsComponent[key] = value;
-            });
-        }
     } else {
         hasChanges = true;
         workspaceConfigs.push({

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

@@ -1,11 +1,14 @@
 const { loadXmlFile, buildXmlFile } = require('../../../../config/xml-parser');
 const pathExists = require('../../../../util/path-exists');
+const { getPhpConfig } = require('../php-config/php-config');
+const { setupXMLStructure } = require('../setup-xml-structure');
 const setupComposerSettings = require('./composer-settings-config');
 const setupFormatOnSave = require('./format-setting-config');
 const setupPHPDebugGeneral = require('./php-debug-general-config');
 const setupPHPServers = require('./php-server-config');
 const setupPropertiesComponent = require('./properties-component-config');
 const setupRunManager = require('./run-manager-config');
+const { getWorkspaceConfig } = require('./workspace-config');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
@@ -13,24 +16,20 @@ const setupRunManager = require('./run-manager-config');
 const setupWorkspaceConfig = () => ({
     title: 'Set up Workspace configuration',
     task: async (ctx, task) => {
-        const {
-            config: {
-                phpStorm
-            }
-        } = ctx;
-
-        if (await pathExists(phpStorm.xdebug.path)) {
-            const workspaceConfiguration = await loadXmlFile(phpStorm.xdebug.path);
+        const workspaceConfig = getWorkspaceConfig(ctx.config.overridenConfiguration);
+        const phpConfig = getPhpConfig(ctx.config.overridenConfiguration);
+        if (await pathExists(workspaceConfig.path)) {
+            const workspaceConfiguration = setupXMLStructure(await loadXmlFile(workspaceConfig.path));
             const workspaceConfigs = workspaceConfiguration.project.component;
             const hasChanges = await Promise.all([
-                setupPHPDebugGeneral(workspaceConfigs, phpStorm),
-                setupPHPServers(workspaceConfigs, phpStorm),
-                setupRunManager(workspaceConfigs, phpStorm),
+                setupPHPDebugGeneral(workspaceConfigs, workspaceConfig),
+                setupPHPServers(workspaceConfigs, workspaceConfig),
+                setupRunManager(workspaceConfigs, workspaceConfig),
                 setupPropertiesComponent(workspaceConfigs)
             ]);
 
             if (hasChanges.includes(true)) {
-                await buildXmlFile(phpStorm.php.path, workspaceConfiguration);
+                await buildXmlFile(phpConfig.path, workspaceConfiguration);
             } else {
                 task.skip();
             }
@@ -38,28 +37,19 @@ const setupWorkspaceConfig = () => ({
             return;
         }
 
-        const workspaceConfiguration = {
-            '?xml': {
-                '@_version': '1.0',
-                '@_encoding': 'UTF-8'
-            },
-            project: {
-                '@_version': '4',
-                component: []
-            }
-        };
+        const workspaceConfiguration = setupXMLStructure();
         const workspaceConfigs = workspaceConfiguration.project.component;
 
         await Promise.all([
-            setupPHPDebugGeneral(workspaceConfigs, phpStorm),
-            setupPHPServers(workspaceConfigs, phpStorm),
-            setupRunManager(workspaceConfigs, phpStorm),
+            setupPHPDebugGeneral(workspaceConfigs, workspaceConfig),
+            setupPHPServers(workspaceConfigs, workspaceConfig),
+            setupRunManager(workspaceConfigs, workspaceConfig),
             setupPropertiesComponent(workspaceConfigs),
             setupComposerSettings(workspaceConfigs),
             setupFormatOnSave(workspaceConfigs)
         ]);
 
-        await buildXmlFile(phpStorm.xdebug.path, workspaceConfiguration);
+        await buildXmlFile(workspaceConfig.path, workspaceConfiguration);
     }
 });
 

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-debug-general-config.js

@@ -10,11 +10,10 @@ const ignoreConnectionsThroughUnregisteredServersKey = '@_ignore_connections_thr
 
 /**
  * @param {Array} workspaceConfigs
- * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
  * @returns {Promise<Boolean>}
  */
-const setupPHPDebugGeneral = async (workspaceConfigs, phpStormConfiguration) => {
-    const { xdebug } = phpStormConfiguration;
+const setupPHPDebugGeneral = async (workspaceConfigs, workspaceConfig) => {
     let hasChanges = false;
     const phpDebugGeneralComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === PHP_DEBUG_GENERAL_COMPONENT_NAME
@@ -31,10 +30,10 @@ const setupPHPDebugGeneral = async (workspaceConfigs, phpStormConfiguration) =>
 
         if (!(xdebugDebugPortKey in phpDebugGeneralComponent)) {
             hasChanges = true;
-            phpDebugGeneralComponent[xdebugDebugPortKey] = xdebug.v3Port;
+            phpDebugGeneralComponent[xdebugDebugPortKey] = workspaceConfig.v3Port;
         }
 
-        const missingXDebugPorts = [xdebug.v3Port, xdebug.v2Port].filter(
+        const missingXDebugPorts = [workspaceConfig.v3Port, workspaceConfig.v2Port].filter(
             (port) => !phpDebugGeneralComponent.xdebug_debug_ports.some((xPort) => xPort[portKey] === port)
         );
 
@@ -50,9 +49,9 @@ const setupPHPDebugGeneral = async (workspaceConfigs, phpStormConfiguration) =>
         hasChanges = true;
         workspaceConfigs.push({
             [nameKey]: PHP_DEBUG_GENERAL_COMPONENT_NAME,
-            [xdebugDebugPortKey]: xdebug.v3Port,
+            [xdebugDebugPortKey]: workspaceConfig.v3Port,
             [ignoreConnectionsThroughUnregisteredServersKey]: 'true',
-            xdebug_debug_ports: [xdebug.v3Port, xdebug.v2Port].map((port) => ({
+            xdebug_debug_ports: [workspaceConfig.v3Port, workspaceConfig.v2Port].map((port) => ({
                 [portKey]: port
             }))
         });

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-server-config.js

@@ -6,20 +6,19 @@ const hostKey = '@_host';
 
 /**
  * @param {Array} workspaceConfigs
- * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
  * @returns {Promise<Boolean>}
  */
-const setupPHPServers = async (workspaceConfigs, phpStormConfiguration) => {
-    const { xdebug } = phpStormConfiguration;
+const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
     let hasChanges = false;
     const phpServersComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === PHP_SERVERS_COMPONENT_NAME
     );
 
     const defaultServerConfig = {
-        [hostKey]: xdebug.debugServerAddress,
+        [hostKey]: workspaceConfig.debugServerAddress,
         id: '7e16e907-9ce3-4559-9d26-a30a5650d11f',
-        [nameKey]: xdebug.serverName
+        [nameKey]: workspaceConfig.serverName
     };
 
     if (phpServersComponent) {
@@ -31,7 +30,7 @@ const setupPHPServers = async (workspaceConfigs, phpStormConfiguration) => {
             phpServersComponent.servers = [];
         }
 
-        const serverConfiguration = phpServersComponent.servers.find((server) => server.server[nameKey] === xdebug.serverName);
+        const serverConfiguration = phpServersComponent.servers.find((server) => server.server[nameKey] === workspaceConfig.serverName);
 
         if (!serverConfiguration) {
             hasChanges = true;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/run-manager-config.js

@@ -9,23 +9,22 @@ const sessionIdKey = '@_session_id';
 
 /**
  * @param {Array} workspaceConfigs
- * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
  * @returns {Promise<Boolean>}
  */
-const setupRunManager = async (workspaceConfigs, phpStormConfiguration) => {
-    const { xdebug } = phpStormConfiguration;
+const setupRunManager = async (workspaceConfigs, workspaceConfig) => {
     let hasChanges = false;
     const runManagerComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === RUN_MANAGER_COMPONENT_NAME
     );
 
     const defaultRunManagerConfiguration = {
-        [nameKey]: xdebug.runManagerName,
+        [nameKey]: workspaceConfig.runManagerName,
         '@_type': PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE,
         '@_factoryName': 'PHP Remote Debug',
         '@_filter_connections': 'FILTER',
-        [serverNameKey]: xdebug.serverName,
-        [sessionIdKey]: xdebug.sessionId,
+        [serverNameKey]: workspaceConfig.serverName,
+        [sessionIdKey]: workspaceConfig.sessionId,
         method: {
             '@_v': '2'
         }
@@ -41,7 +40,8 @@ const setupRunManager = async (workspaceConfigs, phpStormConfiguration) => {
         }
 
         const phpRemoteDebugRunConfiguration = runManagerComponent.configuration.find(
-            (configuration) => configuration['@_type'] === PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE && configuration[nameKey] === xdebug.runManagerName
+            // eslint-disable-next-line max-len
+            (configuration) => configuration['@_type'] === PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE && configuration[nameKey] === workspaceConfig.runManagerName
         );
 
         if (!phpRemoteDebugRunConfiguration) {

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

@@ -0,0 +1,20 @@
+const path = require('path');
+const { baseConfig } = require('../../../../config');
+
+/**
+ * @param {import('../../../../../typings/index').CMAConfiguration} app
+ */
+const getWorkspaceConfig = (app) => ({
+    v2Port: '9111',
+    v3Port: '9003',
+    debugServerAddress: `http://${ app.host }`,
+    serverName: 'create-magento-app',
+    runManagerName: 'create-magento-app',
+    sessionId: 'PHPSTORM',
+    path: path.join(process.cwd(), '.idea', 'workspace.xml'),
+    templatePath: path.join(baseConfig.templateDir, 'workspace.template.xml')
+});
+
+module.exports = {
+    getWorkspaceConfig
+};

package/lib/tasks/magento/setup-magento/disable-2fa.js

@@ -9,7 +9,7 @@ module.exports = () => ({
     task: async ({ magentoVersion }, task) => {
         const { modules } = await configPhpToJson(process.cwd(), { magentoVersion });
 
-        if (modules.Magento_TwoFactorAuth !== 0) {
+        if (modules.Magento_TwoFactorAuth !== undefined && modules.Magento_TwoFactorAuth !== 0) {
             await runMagentoCommand('module:disable Magento_TwoFactorAuth', {
                 magentoVersion
             });

package/lib/tasks/magento/setup-magento/install-magento.js

@@ -1,6 +1,10 @@
+const fs = require('fs');
+const path = require('path');
 const semver = require('semver');
 const UnknownError = require('../../../errors/unknown-error');
 const runMagentoCommand = require('../../../util/run-magento');
+const envPhpToJson = require('../../../util/env-php-json');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
 
 /**
  * @type {({ isDbEmpty }: { isDbEmpty: boolean }) => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -20,6 +24,21 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
             ports
         } = ctx;
         const { mysql: { env } } = docker.getContainers(ports);
+        const envPhpData = await envPhpToJson(process.cwd(), {
+            magentoVersion: ctx.magentoVersion
+        });
+
+        const envPhpHaveEncryptionKey = envPhpData && envPhpData.crypt && envPhpData.crypt.key && envPhpData.crypt.key;
+
+        let encryptionKeyOption = null;
+
+        if (ctx.encryptionKey) {
+            encryptionKeyOption = `--key='${ctx.encryptionKey}'`;
+        }
+
+        if (envPhpHaveEncryptionKey && !encryptionKeyOption) {
+            encryptionKeyOption = `--key='${envPhpData.crypt.key}'`;
+        }
 
         let installed = false;
 
@@ -46,6 +65,7 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
                 --admin-user='${ magentoConfiguration.user }' \
                 --admin-password='${ magentoConfiguration.password }' \
                 ${ !isMagento23 ? elasticsearchConfiguration : '' } \
+                ${encryptionKeyOption || ''} \
                 --session-save=redis \
                 --session-save-redis-host='127.0.0.1' \
                 --session-save-redis-port='${ ports.redis }' \
@@ -85,6 +105,34 @@ const installMagento = ({ isDbEmpty = false } = {}) => ({
             }
         }
 
+        if (errors.length > 0) {
+            if (envPhpHaveEncryptionKey && errors.some(
+                (e) => e.message.includes('The default website isn\'t defined. Set the website and try again.')
+            )
+            ) {
+                const confirmToWipeEnvPhp = await task.prompt({
+                    type: 'Confirm',
+                    message: `We detected that your encryption key in ${logger.style.file('app/etc/env.php')} file is not accepted by Magento installer.
+To fix this issue we will need to ${logger.style.misc('DELETE')} ${logger.style.file('app/etc/env.php')} file. It will be recreated but existing encryption key but if you any custom configuration in it will be lost.
+
+Without this you will not be able to install Magento at this moment.
+
+Do you want to continue?`
+                });
+
+                if (confirmToWipeEnvPhp) {
+                    try {
+                        await fs.promises.unlink(path.join(process.cwd(), 'app', 'etc', 'env.php'));
+                    } catch (e) {
+                        throw new UnknownError(`Unexpected error occurred during deleting of app/etc/env.php file!\n\n${e}`);
+                    }
+                    ctx.encryptionKey = envPhpData.crypt.key;
+
+                    return task.run(ctx);
+                }
+            }
+        }
+
         if (!installed) {
             const errorMessages = errors.map((e) => e.message).join('\n\n');
             throw new UnknownError(`Unable to install Magento!\n${errorMessages}`);

package/lib/tasks/magento/setup-magento/upgrade-magento.js

@@ -7,7 +7,7 @@ const KnownError = require('../../../errors/known-error');
  */
 const upgradeMagento = () => ({
     skip: (ctx) => {
-        if ('isSetupUpgradeNeeded' in ctx) {
+        if (ctx.isSetupUpgradeNeeded !== undefined) {
             return !ctx.isSetupUpgradeNeeded;
         }
 

package/lib/tasks/mysql/connect-to-mysql.js

@@ -2,31 +2,57 @@ const mysql = require('mysql2/promise');
 const UnknownError = require('../../errors/unknown-error');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const sleep = require('../../util/sleep');
+const { createMagentoDatabase } = require('./create-magento-database');
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const connectToMySQL = () => ({
-    title: 'Connecting to MySQL server...',
-    skip: (ctx) => ctx.skipSetup,
+const waitForMySQLInitialization = () => ({
+    title: 'Waiting for MySQL to initialize',
+    task: async (ctx, task) => {
+        const { mysql: { name } } = ctx.config.docker.getContainers();
+        let mysqlReadyForConnections = false;
+        while (!mysqlReadyForConnections) {
+            const mysqlOutput = await execAsyncSpawn(`docker logs ${name}`);
+            if (mysqlOutput.includes('ready for connections')) {
+                mysqlReadyForConnections = true;
+                break;
+            } else if (mysqlOutput.includes('Initializing database files')) {
+                task.output = `MySQL is initializing database files!
+Please wait, this will take some time and do not restart the MySQL container until initialization is finished!`;
+
+                let mysqlFinishedInitialization = false;
+                while (!mysqlFinishedInitialization) {
+                    const mysqlOutput = await execAsyncSpawn(`docker logs ${name}`);
+                    if (mysqlOutput.includes('MySQL init process done.') && !mysqlFinishedInitialization) {
+                        mysqlFinishedInitialization = true;
+                        break;
+                    }
+                    await sleep(2000);
+                }
+            }
+
+            await sleep(2000);
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const gettingMySQLConnection = () => ({
+    title: 'Getting MySQL connection',
     task: async (ctx, task) => {
         const { config: { docker }, ports } = ctx;
-        const { mysql: { env, name } } = docker.getContainers();
+        const { mysql: { env } } = docker.getContainers();
         let tries = 0;
-        let maxTries = 20;
+        const maxTries = 20;
         const errors = [];
         while (tries < maxTries) {
             tries++;
-
-            if (maxTries !== 120) {
-                const mysqlOutput = await execAsyncSpawn(`docker logs ${name}`);
-                if (mysqlOutput.includes('Initializing database files')) {
-                    maxTries = 120;
-                    task.output = `MySQL is initializing database files!
-Please wait, this will take some time and do not restart the MySQL container until initialization is finished!`;
-                }
-                await sleep(2000);
-            }
             try {
                 const connection = await mysql.createConnection({
                     host: '127.0.0.1',
@@ -49,7 +75,25 @@ Please wait, this will take some time and do not restart the MySQL container unt
         }
 
         task.title = 'MySQL server connected!';
-    },
+    }
+});
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const connectToMySQL = () => ({
+    title: 'Connecting to MySQL server',
+    skip: (ctx) => ctx.skipSetup,
+    task: (ctx, task) => task.newListr([
+        waitForMySQLInitialization(),
+        createMagentoDatabase(),
+        gettingMySQLConnection()
+    ], {
+        concurrent: false,
+        rendererOptions: {
+            collapse: true
+        }
+    }),
     options: {
         bottomBar: 10
     }

package/lib/tasks/mysql/create-magento-database.js

@@ -0,0 +1,18 @@
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+
+/**
+ * Will create database 'magento' in MySQL if it does not exist for some reason
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createMagentoDatabase = () => ({
+    title: 'Creating Magento database in MySQL',
+    task: async (ctx) => {
+        const { mysql } = ctx.config.docker.getContainers();
+
+        await execAsyncSpawn(`docker exec ${mysql.name} mysql -umagento -pmagento -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`);
+    }
+});
+
+module.exports = {
+    createMagentoDatabase
+};

package/lib/tasks/php/install-sodium.js

@@ -33,7 +33,7 @@ const installSodiumExtension = () => ({
         const extractedArchivePath = path.join(tempDir, 'libsodium-stable');
         const enabledExtensions = await getEnabledExtensions(ctx.config);
 
-        if ('sodium' in enabledExtensions) {
+        if (enabledExtensions.sodium !== undefined) {
             cmaGlobalConfig.set(HAS_LIBSODIUM_BEEN_INSTALLED, true);
             task.skip();
             return;

package/lib/tasks/requirements/phpbrew/install.js

@@ -17,7 +17,7 @@ const installPHPBrewDependencies = () => ({
         if (process.platform === 'darwin') {
             const installedDependencies = (await execAsyncSpawn(`${await getBrewCommand({ native: true })} list`)).split('\n');
 
-            const dependenciesToInstall = ['php', 'autoconf', 'pkg-config'].filter((dep) => !installedDependencies.includes(dep));
+            const dependenciesToInstall = ['php', 'autoconf', 'pkg-config', 'gd'].filter((dep) => !installedDependencies.includes(dep));
 
             if (dependenciesToInstall.length === 0) {
                 task.skip();

package/lib/util/env-php-json.js

@@ -1,9 +1,14 @@
 const path = require('path');
 const UnknownError = require('../errors/unknown-error');
+const pathExists = require('./path-exists');
 const runPhpCode = require('./run-php');
 
 const envPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) => {
-    const { code, result } = await runPhpCode(`-r "echo json_encode(require '${path.join(projectPath, 'app', 'etc', 'env.php')}');"`, {
+    const envPhpPath = path.join(projectPath, 'app', 'etc', 'env.php');
+    if (!await pathExists(envPhpPath)) {
+        return null;
+    }
+    const { code, result } = await runPhpCode(`-r "echo json_encode(require '${envPhpPath}');"`, {
         magentoVersion
     });
 

package/lib/util/exec-async-command.d.ts

@@ -25,16 +25,6 @@ export function execAsyncSpawn (
     options?: ExecAsyncSpawnOptions<true>
 ): Promise<{ code: number, result: string }>;
 
-/**
- * Execute bash command
- * @param command Bash command
- * @param options Child process exec options ([docs](https://nodejs.org/dist/latest-v14.x/docs/api/child_process.html#child_process_child_process_exec_command_options_callback))
- */
-export function execAsync(
-    command: string,
-    options?: { encoding: BufferEncoding } & ExecOptions
-): Promise<string>
-
 export function execCommandTask(
     command: string,
     options?: Omit<ExecAsyncSpawnOptions<false>, 'callback'>

package/lib/util/exec-async.d.ts

@@ -0,0 +1,10 @@
+/* eslint-disable max-len */
+/**
+ * Execute bash command
+ * @param command Bash command
+ * @param options Child process exec options ([docs](https://nodejs.org/dist/latest-v14.x/docs/api/child_process.html#child_process_child_process_exec_command_options_callback))
+ */
+export function execAsync(
+    command: string,
+    options?: { encoding: BufferEncoding } & ExecOptions
+): Promise<string>

package/lib/util/open-browser.js

@@ -1,4 +1,4 @@
-const { execAsync } = require('./exec-async-command');
+const { execAsync } = require('./exec-async');
 
 const openBrowser = async (url) => {
     const start = process.platform === 'darwin' ? 'open' : 'xdg-open';

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.15.2",
+    "version": "1.15.5",
     "main": "./index.js",
     "types": "./typings/index.d.ts",
     "license": "OSL-3.0",
@@ -53,5 +53,5 @@
         "mysql",
         "scandipwa"
     ],
-    "gitHead": "6ddbd68e15d1868386f559f7edd6610dbc80a8e4"
+    "gitHead": "b90809f36891441aa93a685b69cc3d5e8e922c15"
 }

package/lib/config/phpstorm/debug-config.js

@@ -1,46 +0,0 @@
-const path = require('path');
-
-const getPhpStormConfig = (app, config) => {
-    const [majorPHPVersion, minorPHPVersion] = app.configuration.php.version.split('.');
-    const phpLanguageLevel = `${ majorPHPVersion }.${ minorPHPVersion }`;
-    const { templateDir } = config;
-    const phpStormConfiguration = {
-        xdebug: {
-            v2Port: '9111',
-            v3Port: '9003',
-            debugServerAddress: `http://${ app.host }`,
-            serverName: 'create-magento-app',
-            runManagerName: 'create-magento-app',
-            sessionId: 'PHPSTORM',
-            path: path.join(process.cwd(), '.idea', 'workspace.xml'),
-            templatePath: path.join(templateDir, 'workspace.template.xml')
-        },
-        php: {
-            phpLanguageLevel,
-            path: path.join(process.cwd(), '.idea', 'php.xml'),
-            templatePath: path.join(templateDir, 'php.template.xml')
-        },
-        database: {
-            driver: 'mysql',
-            dataSourceManagerName: 'mysql 8.0',
-            dataSourcesLocal: {
-                path: path.join(process.cwd(), '.idea', 'dataSources.local.xml'),
-                templatePath: path.join(templateDir, 'dataSources.local.template.xml')
-            },
-            dataSources: {
-                path: path.join(process.cwd(), '.idea', 'dataSources.xml'),
-                templatePath: path.join(templateDir, 'dataSources.template.xml')
-            }
-        },
-        inspectionTools: {
-            path: path.join(process.cwd(), '.idea', 'inspectionProfiles', 'Project_Default.xml'),
-            templatePath: path.join(templateDir, 'Project_Default.template.xml')
-        }
-    };
-
-    return phpStormConfiguration;
-};
-
-module.exports = {
-    getPhpStormConfig
-};