@scandipwa/magento-scripts 1.15.1 → 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/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({