@scandipwa/magento-scripts 1.16.0 → 2.0.0-alpha.1

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

@@ -1,50 +1,39 @@
 const path = require('path');
-const { baseConfig } = require('../../../../config');
 const pathExists = require('../../../../util/path-exists');
 const { nameKey } = require('../keys');
 const { formatPathForPHPStormConfig } = require('../xml-utils');
 
 const COMPOSER_SETTINGS_COMPONENT_NAME = 'ComposerSettings';
 
-const pharPathKey = '@_pharPath';
+const composerKey = '@_composer';
 const doNotAskKey = '@_doNotAsk';
 const synchronizationStateKey = '@_synchronizationState';
 
 const composerJsonPath = path.join(process.cwd(), 'composer.json');
 const composerJsonFormattedPath = formatPathForPHPStormConfig(composerJsonPath);
-const composerPharPath = path.join(baseConfig.cacheDir, 'composer', 'composer.phar');
-const composerPharFormattedPath = formatPathForPHPStormConfig(composerPharPath);
 
 const defaultComposerSettingsProperties = {
     [doNotAskKey]: 'true',
     [synchronizationStateKey]: 'SYNCHRONIZE'
 };
 
-// TODO Ideally, we want to setup interpreter for compose.phar
-
-// It should look like this:
-// <component name="ComposerSettings" synchronizationState="DONT_SYNCHRONIZE">
-//     <pharConfigPath>$PROJECT_DIR$/composer.json</pharConfigPath>
-//     <execution>
-//         <phar
-//             pharPath="$PROJECT_DIR$/node_modules/.create-magento-app-cache/composer/composer.phar"
-//             interpreterId="f19b09e2-16e7-491f-9056-3299df58e578"
-//         />
-//     </execution>
-// </component>
-
 /**
  * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
-const setupComposerSettings = async (workspaceConfigs) => {
+const setupComposerSettings = async (workspaceConfigs, ctx) => {
     let hasChanges = false;
     const composerSettingsComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === COMPOSER_SETTINGS_COMPONENT_NAME
     );
 
     const isComposerJsonExists = await pathExists(composerJsonPath);
-    const isComposerPharExists = await pathExists(composerPharPath);
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const defaultInterpreterConfig = {
+        [nameKey]: ctx.debug ? php.debugImage : php.image,
+        [composerKey]: 'composer'
+    };
 
     if (composerSettingsComponent) {
         if (
@@ -55,17 +44,15 @@ const setupComposerSettings = async (workspaceConfigs) => {
             composerSettingsComponent.pharConfigPath = composerJsonFormattedPath;
         }
 
-        const pharConfig = composerSettingsComponent.execution && composerSettingsComponent.execution.phar;
+        const interpreterConfig = composerSettingsComponent.execution && composerSettingsComponent.execution.interpreter;
 
-        if (pharConfig && isComposerPharExists && !(pharPathKey in pharConfig)) {
-            hasChanges = true;
-            pharConfig[pharPathKey] = composerPharFormattedPath;
-        } else if (!pharConfig && isComposerPharExists) {
+        if (!interpreterConfig) {
             hasChanges = true;
             composerSettingsComponent.execution = composerSettingsComponent.execution || {};
-            composerSettingsComponent.execution.phar = {
-                [pharPathKey]: composerPharFormattedPath
-            };
+            composerSettingsComponent.execution.interpreter = defaultInterpreterConfig;
+        } else if (interpreterConfig[nameKey] !== defaultInterpreterConfig[nameKey]) {
+            hasChanges = true;
+            composerSettingsComponent.execution.interpreter[nameKey] = defaultInterpreterConfig[nameKey];
         }
     } else {
         hasChanges = true;
@@ -74,9 +61,7 @@ const setupComposerSettings = async (workspaceConfigs) => {
             ...defaultComposerSettingsProperties,
             pharConfigPath: composerJsonFormattedPath,
             execution: {
-                phar: {
-                    [pharPathKey]: composerPharFormattedPath
-                }
+                interpreter: defaultInterpreterConfig
             }
         });
     }

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

@@ -3,9 +3,15 @@ const pathExists = require('../../../../util/path-exists');
 const { setupXMLStructure } = require('../setup-xml-structure');
 const setupComposerSettings = require('./composer-settings-config');
 const setupFormatOnSave = require('./format-setting-config');
+const setupMessDetectorProjectConfiguration = require('./mess-detector-project-configuration-config');
+const setupPHPCodeSnifferProjectConfiguration = require('./php-code-sniffer-project-configuration-config');
+const setupPHPCSFixerProjectConfiguration = require('./php-cs-fixer-project-configuration-config');
 const setupPHPDebugGeneral = require('./php-debug-general-config');
 const setupPHPServers = require('./php-server-config');
+const setupPHPStanProjectConfiguration = require('./php-stan-project-configuration-config.js');
+const setupPHPWorkspaceProjectConfiguration = require('./php-workspace-project-configuration-config');
 const setupPropertiesComponent = require('./properties-component-config');
+const setupPSalmProjectConfiguration = require('./psalm-project-configuration-config.js');
 const setupRunManager = require('./run-manager-config');
 const { getWorkspaceConfig } = require('./workspace-config');
 
@@ -20,8 +26,15 @@ const setupWorkspaceConfig = () => ({
             const workspaceConfiguration = setupXMLStructure(await loadXmlFile(workspaceConfig.path));
             const workspaceConfigs = workspaceConfiguration.project.component;
             const hasChanges = await Promise.all([
-                setupPHPDebugGeneral(workspaceConfigs, workspaceConfig),
-                setupPHPServers(workspaceConfigs, workspaceConfig),
+                setupMessDetectorProjectConfiguration(workspaceConfigs),
+                setupPHPCSFixerProjectConfiguration(workspaceConfigs),
+                setupPHPCodeSnifferProjectConfiguration(workspaceConfigs),
+                setupPHPStanProjectConfiguration(workspaceConfigs),
+                setupPSalmProjectConfiguration(workspaceConfigs),
+                setupPHPWorkspaceProjectConfiguration(workspaceConfigs, ctx),
+                setupPHPDebugGeneral(workspaceConfigs),
+                setupPHPServers(workspaceConfigs, workspaceConfig, ctx),
+                setupComposerSettings(workspaceConfigs, ctx),
                 setupRunManager(workspaceConfigs, workspaceConfig),
                 setupPropertiesComponent(workspaceConfigs)
             ]);
@@ -39,11 +52,17 @@ const setupWorkspaceConfig = () => ({
         const workspaceConfigs = workspaceConfiguration.project.component;
 
         await Promise.all([
-            setupPHPDebugGeneral(workspaceConfigs, workspaceConfig),
-            setupPHPServers(workspaceConfigs, workspaceConfig),
+            setupMessDetectorProjectConfiguration(workspaceConfigs),
+            setupPHPCSFixerProjectConfiguration(workspaceConfigs),
+            setupPHPCodeSnifferProjectConfiguration(workspaceConfigs),
+            setupPHPStanProjectConfiguration(workspaceConfigs),
+            setupPSalmProjectConfiguration(workspaceConfigs),
+            setupPHPDebugGeneral(workspaceConfigs),
+            setupPHPServers(workspaceConfigs, workspaceConfig, ctx),
+            setupPHPWorkspaceProjectConfiguration(workspaceConfigs, ctx),
             setupRunManager(workspaceConfigs, workspaceConfig),
             setupPropertiesComponent(workspaceConfigs),
-            setupComposerSettings(workspaceConfigs),
+            setupComposerSettings(workspaceConfigs, ctx),
             setupFormatOnSave(workspaceConfigs)
         ]);
 

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/mess-detector-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME = 'MessDetectorProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupMessDetectorProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const messDetectorProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (messDetectorProjectConfigurationComponent) {
+        if (messDetectorProjectConfigurationComponent.option && !Array.isArray(messDetectorProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            messDetectorProjectConfigurationComponent.option = [messDetectorProjectConfigurationComponent.option];
+        } else if (!messDetectorProjectConfigurationComponent.option) {
+            hasChanges = true;
+            messDetectorProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            messDetectorProjectConfigurationComponent.option.length > 0
+            && !messDetectorProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            messDetectorProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: MESS_DETECTOR_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupMessDetectorProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-code-sniffer-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PHPCodeSnifferProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCodeSnifferProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpCodeSnifferProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpCodeSnifferProjectConfigurationComponent) {
+        if (phpCodeSnifferProjectConfigurationComponent.option && !Array.isArray(phpCodeSnifferProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpCodeSnifferProjectConfigurationComponent.option = [phpCodeSnifferProjectConfigurationComponent.option];
+        } else if (!phpCodeSnifferProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpCodeSnifferProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpCodeSnifferProjectConfigurationComponent.option.length > 0
+            && !phpCodeSnifferProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpCodeSnifferProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_CODE_SNIFFER_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCodeSnifferProjectConfiguration;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-cs-fixer-project-configuration-config.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PHPCSFixerProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPCSFixerProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpCSFixeProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpCSFixeProjectConfigurationComponent) {
+        if (phpCSFixeProjectConfigurationComponent.option && !Array.isArray(phpCSFixeProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpCSFixeProjectConfigurationComponent.option = [phpCSFixeProjectConfigurationComponent.option];
+        } else if (!phpCSFixeProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpCSFixeProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpCSFixeProjectConfigurationComponent.option.length > 0
+            && !phpCSFixeProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpCSFixeProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_CS_FIXER_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPCSFixerProjectConfiguration;

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

@@ -8,12 +8,13 @@ const portKey = '@_port';
 const xdebugDebugPortKey = '@_xdebug_debug_port';
 const ignoreConnectionsThroughUnregisteredServersKey = '@_ignore_connections_through_unregistered_servers';
 
+const xdebugPort = '9003';
+
 /**
  * @param {Array} workspaceConfigs
- * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
  * @returns {Promise<Boolean>}
  */
-const setupPHPDebugGeneral = async (workspaceConfigs, workspaceConfig) => {
+const setupPHPDebugGeneral = async (workspaceConfigs) => {
     let hasChanges = false;
     const phpDebugGeneralComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === PHP_DEBUG_GENERAL_COMPONENT_NAME
@@ -30,30 +31,29 @@ const setupPHPDebugGeneral = async (workspaceConfigs, workspaceConfig) => {
 
         if (!(xdebugDebugPortKey in phpDebugGeneralComponent)) {
             hasChanges = true;
-            phpDebugGeneralComponent[xdebugDebugPortKey] = workspaceConfig.v3Port;
+            phpDebugGeneralComponent[xdebugDebugPortKey] = xdebugPort;
         }
 
-        const missingXDebugPorts = [workspaceConfig.v3Port, workspaceConfig.v2Port].filter(
-            (port) => !phpDebugGeneralComponent.xdebug_debug_ports.some((xPort) => xPort[portKey] === port)
-        );
+        if (phpDebugGeneralComponent[xdebugDebugPortKey] !== xdebugPort) {
+            hasChanges = true;
+            phpDebugGeneralComponent[xdebugDebugPortKey] = xdebugPort;
+        }
 
-        if (missingXDebugPorts.length > 0) {
+        if (!phpDebugGeneralComponent.xdebug_debug_ports.some((xPort) => xPort[portKey] === xdebugPort)) {
             hasChanges = true;
-            missingXDebugPorts.forEach((port) => {
-                phpDebugGeneralComponent.xdebug_debug_ports.push({
-                    [portKey]: port
-                });
+            phpDebugGeneralComponent.xdebug_debug_ports.push({
+                [portKey]: xdebugPort
             });
         }
     } else {
         hasChanges = true;
         workspaceConfigs.push({
             [nameKey]: PHP_DEBUG_GENERAL_COMPONENT_NAME,
-            [xdebugDebugPortKey]: workspaceConfig.v3Port,
+            [xdebugDebugPortKey]: xdebugPort,
             [ignoreConnectionsThroughUnregisteredServersKey]: 'true',
-            xdebug_debug_ports: [workspaceConfig.v3Port, workspaceConfig.v2Port].map((port) => ({
-                [portKey]: port
-            }))
+            xdebug_debug_ports: [{
+                [portKey]: xdebugPort
+            }]
         });
     }
 

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

@@ -3,13 +3,17 @@ const { nameKey } = require('../keys');
 const PHP_SERVERS_COMPONENT_NAME = 'PhpServers';
 
 const hostKey = '@_host';
+const usePathMappingsKey = '@_use_path_mappings';
+const localRootKey = '@_local-root';
+const remoteRootKey = '@_remote-root';
 
 /**
  * @param {Array} workspaceConfigs
  * @param {ReturnType<typeof import('./workspace-config').getWorkspaceConfig>} workspaceConfig
+ * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
-const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
+const setupPHPServers = async (workspaceConfigs, workspaceConfig, ctx) => {
     let hasChanges = false;
     const phpServersComponent = workspaceConfigs.find(
         (workspaceConfig) => workspaceConfig[nameKey] === PHP_SERVERS_COMPONENT_NAME
@@ -18,7 +22,14 @@ const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
     const defaultServerConfig = {
         [hostKey]: workspaceConfig.debugServerAddress,
         id: '7e16e907-9ce3-4559-9d26-a30a5650d11f',
-        [nameKey]: workspaceConfig.serverName
+        [nameKey]: workspaceConfig.serverName,
+        [usePathMappingsKey]: true,
+        path_mappings: {
+            mapping: {
+                [localRootKey]: '$PROJECT_DIR$',
+                [remoteRootKey]: ctx.config.baseConfig.containerMagentoDir
+            }
+        }
     };
 
     if (phpServersComponent) {
@@ -32,11 +43,26 @@ const setupPHPServers = async (workspaceConfigs, workspaceConfig) => {
 
         const serverConfiguration = phpServersComponent.servers.find((server) => server.server[nameKey] === workspaceConfig.serverName);
 
-        if (!serverConfiguration) {
+        if (!serverConfiguration || !serverConfiguration.server) {
             hasChanges = true;
             phpServersComponent.servers.push({
                 server: defaultServerConfig
             });
+        } else if (serverConfiguration.server) {
+            if (!serverConfiguration.server[usePathMappingsKey]) {
+                hasChanges = true;
+                serverConfiguration.server[usePathMappingsKey] = true;
+            }
+            if (!serverConfiguration.server.path_mappings
+                || (
+                    serverConfiguration.server.path_mappings.mapping
+                    && serverConfiguration.server.path_mappings.mapping[remoteRootKey] !== defaultServerConfig.path_mappings.mapping[remoteRootKey]
+                )
+            ) {
+                hasChanges = true;
+                serverConfiguration.server.path_mappings = serverConfiguration.server.path_mappings || {};
+                serverConfiguration.server.path_mappings.mapping = defaultServerConfig.path_mappings.mapping;
+            }
         }
     } else {
         hasChanges = true;

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/php-stan-project-configuration-config.js.js

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PHP_STAN_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PhpStanProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPStanProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const phpStanProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_STAN_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (phpStanProjectConfigurationComponent) {
+        if (phpStanProjectConfigurationComponent.option && !Array.isArray(phpStanProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            phpStanProjectConfigurationComponent.option = [phpStanProjectConfigurationComponent.option];
+        } else if (!phpStanProjectConfigurationComponent.option) {
+            hasChanges = true;
+            phpStanProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            phpStanProjectConfigurationComponent.option.length > 0
+            && !phpStanProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            phpStanProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_STAN_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPStanProjectConfiguration;

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

@@ -0,0 +1,42 @@
+const { nameKey } = require('../keys');
+
+const PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PhpWorkspaceProjectConfiguration';
+
+const interpreterNameKey = '@_interpreter_name';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/context').ListrContext} ctx
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPWorkspaceProjectConfiguration = async (workspaceConfigs, ctx) => {
+    let hasChanges = false;
+    const phpWorkspaceProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const currentInterpreterImage = ctx.debug ? php.debugImage : php.image;
+
+    if (phpWorkspaceProjectConfigurationComponent) {
+        if (
+            !phpWorkspaceProjectConfigurationComponent[interpreterNameKey]
+            || (
+                phpWorkspaceProjectConfigurationComponent[interpreterNameKey] !== currentInterpreterImage
+            )
+        ) {
+            hasChanges = true;
+            phpWorkspaceProjectConfigurationComponent[interpreterNameKey] = currentInterpreterImage;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            [currentInterpreterImage]: currentInterpreterImage,
+            include_path: []
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPWorkspaceProjectConfiguration;

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

@@ -0,0 +1,50 @@
+const { nameKey, valueKey } = require('../keys');
+
+const PSALM_PROJECT_CONFIGURATION_COMPONENT_NAME = 'PsalmProjectConfiguration';
+
+const selectedConfigurationIdName = 'selectedConfigurationId';
+const value = 'DEFAULT_INTERPRETER';
+
+const defaultOption = {
+    [nameKey]: selectedConfigurationIdName,
+    [valueKey]: value
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPSalmProjectConfiguration = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const psalmProjectConfigurationComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PSALM_PROJECT_CONFIGURATION_COMPONENT_NAME
+    );
+
+    if (psalmProjectConfigurationComponent) {
+        if (psalmProjectConfigurationComponent.option && !Array.isArray(psalmProjectConfigurationComponent.option)) {
+            hasChanges = true;
+            psalmProjectConfigurationComponent.option = [psalmProjectConfigurationComponent.option];
+        } else if (!psalmProjectConfigurationComponent.option) {
+            hasChanges = true;
+            psalmProjectConfigurationComponent.option = [];
+        }
+
+        if (
+            psalmProjectConfigurationComponent.option.length > 0
+            && !psalmProjectConfigurationComponent.option.some((option) => option[nameKey] === selectedConfigurationIdName)
+        ) {
+            psalmProjectConfigurationComponent.option = [defaultOption];
+            hasChanges = true;
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PSALM_PROJECT_CONFIGURATION_COMPONENT_NAME,
+            option: [defaultOption]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPSalmProjectConfiguration;

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

@@ -5,8 +5,6 @@ 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',

package/lib/tasks/file-system/create-ssl-terminator-config.js

@@ -19,7 +19,8 @@ const createSSLTerminatorConfig = () => ({
                 overridenConfiguration,
                 baseConfig
             },
-            isWsl
+            isWsl,
+            debug
         } = ctx;
 
         const {
@@ -84,7 +85,8 @@ const createSSLTerminatorConfig = () => ({
                     hostMachine,
                     hostPort,
                     config: overridenConfiguration,
-                    networkToBindTo
+                    networkToBindTo,
+                    debug
                 }
             });
         } catch (e) {