@scandipwa/magento-scripts 1.15.3 → 1.15.4

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/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/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,6 +6,7 @@ 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');
@@ -35,17 +36,12 @@ const inspectionProfileDefaults = {
 /**
  * @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
-            }
-        } = ctx;
-
-        if (await pathExists(phpStorm.inspectionTools.path)) {
-            const inspectionToolsData = await loadXmlFile(phpStorm.inspectionTools.path);
+        const inspectionToolsConfig = getInspectionToolsConfig();
+        if (await pathExists(inspectionToolsConfig.path)) {
+            const inspectionToolsData = await loadXmlFile(inspectionToolsConfig.path);
 
             if (!inspectionToolsData.component) {
                 inspectionToolsData.component = inspectionProfileDefaults.component;
@@ -75,7 +71,7 @@ const setupInspectionToolsConfig = () => ({
             ]);
 
             if (hasChanges.includes(true)) {
-                await buildXmlFile(phpStorm.inspectionTools.path, inspectionToolsData);
+                await buildXmlFile(inspectionToolsConfig.path, inspectionToolsData);
             } else {
                 task.skip();
             }
@@ -114,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

@@ -3,6 +3,7 @@ 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');
 
@@ -12,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 = setupXMLStructure(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();
             }
@@ -49,10 +41,10 @@ const setupPhpConfig = () => ({
             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

@@ -9,19 +9,20 @@ const xmlConfiguration = {
     }
 };
 
-const setupXMLStructure = (data = {}) => {
+const setupXMLStructure = (data) => {
     if (!data) {
         data = xmlConfiguration;
     }
-    if (!('?xml' in data['?xml'])) {
+
+    if (data['?xml'] === undefined) {
         data['?xml'] = xmlConfiguration['?xml'];
     }
 
-    if (!('project' in data)) {
+    if (data.project === undefined) {
         data.project = xmlConfiguration.project;
     }
 
-    if (!('component' in data.project)) {
+    if (data.project.component === undefined) {
         data.project.component = xmlConfiguration.project.component;
     }
 

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;

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

@@ -1,5 +1,6 @@
 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');
@@ -7,6 +8,7 @@ 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>}
@@ -14,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 = setupXMLStructure(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();
             }
@@ -43,15 +41,15 @@ const setupWorkspaceConfig = () => ({
         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/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/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/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.3",
+    "version": "1.15.4",
     "main": "./index.js",
     "types": "./typings/index.d.ts",
     "license": "OSL-3.0",
@@ -53,5 +53,5 @@
         "mysql",
         "scandipwa"
     ],
-    "gitHead": "b3a98d7f1ad13d8566f07cf3896a0ba0d64eb005"
+    "gitHead": "dca735e563dd90fd22fbb8bf706c122f2002bda8"
 }

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
-};