@scandipwa/magento-scripts 1.14.1-alpha.0 → 1.14.1-alpha.1

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

@@ -0,0 +1,60 @@
+const { nameKey } = require('../keys');
+
+const PHP_SERVERS_COMPONENT_NAME = 'PhpServers';
+
+const hostKey = '@_host';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @returns {Promise<Boolean>}
+ */
+const setupPHPServers = async (workspaceConfigs, phpStormConfiguration) => {
+    const { xdebug } = phpStormConfiguration;
+    let hasChanges = false;
+    const phpServersComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PHP_SERVERS_COMPONENT_NAME
+    );
+
+    const defaultServerConfig = {
+        [hostKey]: xdebug.debugServerAddress,
+        id: '7e16e907-9ce3-4559-9d26-a30a5650d11f',
+        [nameKey]: xdebug.serverName
+    };
+
+    if (phpServersComponent) {
+        if (phpServersComponent.servers && !Array.isArray(phpServersComponent.servers)) {
+            hasChanges = true;
+            phpServersComponent.servers = [phpServersComponent.servers];
+        } else if (!phpServersComponent.servers) {
+            hasChanges = true;
+            phpServersComponent.servers = [];
+        }
+
+        const serverConfiguration = phpServersComponent.servers.find((server) => server.server[nameKey] === xdebug.serverName);
+
+        if (serverConfiguration && serverConfiguration.server[hostKey] !== xdebug.debugServerAddress) {
+            hasChanges = true;
+            serverConfiguration.server[hostKey] = xdebug.debugServerAddress;
+        } else if (!serverConfiguration) {
+            hasChanges = true;
+            phpServersComponent.servers.push({
+                server: defaultServerConfig
+            });
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: PHP_SERVERS_COMPONENT_NAME,
+            servers: [
+                {
+                    server: defaultServerConfig
+                }
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPHPServers;

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

@@ -0,0 +1,51 @@
+const path = require('path');
+// const { baseConfig } = require('../../../../config');
+const { getCSAThemes } = require('../../../../util/CSA-theme');
+const pathExists = require('../../../../util/path-exists');
+const { nameKey } = require('../keys');
+// const { formatPathForPHPStormConfig } = require('../xml-utils');
+
+const PROPERTIES_COMPONENT_NAME = 'PropertiesComponent';
+
+const defaultProperties = {
+    keyToString: {
+        'RunOnceActivity.OpenProjectViewOnStart': 'true',
+        'RunOnceActivity.ShowReadmeOnStart': 'true'
+    }
+};
+
+/**
+ * @param {Array} workspaceConfigs
+ * @returns {Promise<Boolean>}
+ */
+const setupPropertiesComponent = async (workspaceConfigs) => {
+    let hasChanges = false;
+    const propertiesComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === PROPERTIES_COMPONENT_NAME
+    );
+
+    if (propertiesComponent) {
+        // check later
+    } else {
+        hasChanges = true;
+        const themes = await getCSAThemes();
+        if (themes.length > 0) {
+            const theme = themes[0];
+            const themeESLintPath = path.join(process.cwd(), theme.themePath, 'node_modules', 'eslint');
+            if (await pathExists(themeESLintPath)) {
+                defaultProperties.keyToString['node.js.selected.package.eslint'] = themeESLintPath;
+                defaultProperties.keyToString['js.linters.configure.manually.selectedeslint'] = 'true';
+                defaultProperties.keyToString['node.js.detected.package.eslint'] = 'true';
+                defaultProperties.keyToString['settings.editor.selected.configurable'] = 'settings.javascript.linters.eslint';
+            }
+        }
+        workspaceConfigs.push({
+            [nameKey]: PROPERTIES_COMPONENT_NAME,
+            '#text': JSON.stringify(defaultProperties)
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupPropertiesComponent;

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

@@ -0,0 +1,74 @@
+const { nameKey } = require('../keys');
+
+const RUN_MANAGER_COMPONENT_NAME = 'RunManager';
+
+const PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE = 'PhpRemoteDebugRunConfigurationType';
+
+const serverNameKey = '@_server_name';
+const sessionIdKey = '@_session_id';
+
+/**
+ * @param {Array} workspaceConfigs
+ * @param {import('../../../../../typings/phpstorm').PHPStormConfig} phpStormConfiguration
+ * @returns {Promise<Boolean>}
+ */
+const setupRunManager = async (workspaceConfigs, phpStormConfiguration) => {
+    const { xdebug } = phpStormConfiguration;
+    let hasChanges = false;
+    const runManagerComponent = workspaceConfigs.find(
+        (workspaceConfig) => workspaceConfig[nameKey] === RUN_MANAGER_COMPONENT_NAME
+    );
+
+    const defaultRunManagerConfiguration = {
+        [nameKey]: xdebug.runManagerName,
+        '@_type': PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE,
+        '@_factoryName': 'PHP Remote Debug',
+        '@_filter_connections': 'FILTER',
+        [serverNameKey]: xdebug.serverName,
+        [sessionIdKey]: xdebug.sessionId,
+        method: {
+            '@_v': '2'
+        }
+    };
+
+    if (runManagerComponent) {
+        if (runManagerComponent.configuration && !Array.isArray(runManagerComponent.configuration)) {
+            hasChanges = true;
+            runManagerComponent.configuration = [runManagerComponent.configuration];
+        } else if (!runManagerComponent.configuration) {
+            hasChanges = true;
+            runManagerComponent.configuration = [];
+        }
+
+        const phpRemoteDebugRunConfiguration = runManagerComponent.configuration.find(
+            (configuration) => configuration['@_type'] === PHP_REMOTE_DEBUG_RUN_CONFIGURATION_TYPE && configuration[nameKey] === xdebug.runManagerName
+        );
+
+        if (phpRemoteDebugRunConfiguration) {
+            if (phpRemoteDebugRunConfiguration[serverNameKey] !== xdebug.serverName) {
+                hasChanges = true;
+                phpRemoteDebugRunConfiguration[serverNameKey] = xdebug.serverName;
+            }
+
+            if (phpRemoteDebugRunConfiguration[sessionIdKey] !== xdebug.sessionId) {
+                hasChanges = true;
+                phpRemoteDebugRunConfiguration[sessionIdKey] = xdebug.sessionId;
+            }
+        } else {
+            hasChanges = true;
+            runManagerComponent.configuration.push(defaultRunManagerConfiguration);
+        }
+    } else {
+        hasChanges = true;
+        workspaceConfigs.push({
+            [nameKey]: RUN_MANAGER_COMPONENT_NAME,
+            configuration: [
+                defaultRunManagerConfiguration
+            ]
+        });
+    }
+
+    return hasChanges;
+};
+
+module.exports = setupRunManager;

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

@@ -0,0 +1,5 @@
+const formatPathForPHPStormConfig = (p) => p.replace(process.cwd(), '$PROJECT_DIR$');
+
+module.exports = {
+    formatPathForPHPStormConfig
+};

package/lib/tasks/file-system/index.js

@@ -1,7 +1,7 @@
 const createNginxConfig = require('./create-nginx-config');
 const createPhpConfig = require('./create-php-config');
 const createPhpFpmConfig = require('./create-php-fpm-config');
-const createPhpStormConfig = require('./create-php-storm-config');
+const createPhpStormConfig = require('./create-phpstorm-config');
 const createVSCodeConfig = require('./create-vscode-config');
 
 /**

package/lib/tasks/start.js

@@ -29,6 +29,7 @@ const convertLegacyVolumes = require('./docker/convert-legacy-volumes');
 const enableMagentoComposerPlugins = require('./magento/enable-magento-composer-plugins');
 const getIsWsl = require('../util/is-wsl');
 const checkForXDGOpen = require('../util/xdg-open-exists');
+const { getInstanceMetadata, constants: { WEB_LOCATION_TITLE } } = require('../util/instance-metadata');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
@@ -189,8 +190,11 @@ const start = () => ({
 
                     return false;
                 },
-                task: ({ ports, config: { overridenConfiguration: { host, ssl } } }) => {
-                    openBrowser(`${ssl.enabled ? 'https' : 'http'}://${host}${ssl.enabled || ports.app === 80 ? '' : `:${ports.app}`}/`);
+                task: (ctx) => {
+                    const instanceMetadata = getInstanceMetadata(ctx);
+                    const locationOnTheWeb = instanceMetadata.frontend.find(({ title }) => title === WEB_LOCATION_TITLE);
+
+                    openBrowser(locationOnTheWeb.text);
                 },
                 options: {
                     showTimer: false

package/lib/util/instance-metadata.js

@@ -70,5 +70,11 @@ const getInstanceMetadata = (ctx) => {
 };
 
 module.exports = {
-    getInstanceMetadata
+    getInstanceMetadata,
+    constants: {
+        WEB_LOCAL_LOCATION_TITLE,
+        WEB_LOCATION_TITLE,
+        WEB_ADMIN_LOCATION_TITLE,
+        WEB_ADMIN_CREDENTIALS_TITLE
+    }
 };

package/package.json

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

package/typings/context.d.ts

@@ -1,6 +1,7 @@
 import mysql2 from 'mysql2';
 
 import { CMAConfiguration, PHPExtensions } from './index';
+import { PHPStormConfig } from './phpstorm';
 
 export interface ListrContext {
     magentoVersion: string
@@ -82,6 +83,7 @@ export interface ListrContext {
         overridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
         userConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
         nonOverridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
+        phpStorm: PHPStormConfig
     }
     systemConfiguration: {
         analytics: boolean

package/typings/phpstorm.d.ts

@@ -0,0 +1,33 @@
+export interface PHPStormConfig {
+    xdebug: {
+        v2Port: string;
+        v3Port: string;
+        debugServerAddress: string;
+        serverName: string;
+        runManagerName: string;
+        sessionId: string;
+        path: string;
+        templatePath: string;
+    }
+    php: {
+        phpLanguageLevel: string;
+        path: string;
+        templatePath: string;
+    }
+    database: {
+        driver: string;
+        dataSourceManagerName: string;
+        dataSourcesLocal: {
+            path: string;
+            templatePath: string;
+        }
+        dataSources: {
+            path: string;
+            templatePath: string;
+        }
+    }
+    inspectionTools: {
+        path: string;
+        templatePath: string;
+    }
+}

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

@@ -1,82 +0,0 @@
-const setConfigFile = require('../../util/set-config');
-const pathExists = require('../../util/path-exists');
-const path = require('path');
-const fs = require('fs');
-
-const createPhpStormConfig = () => ({
-    title: 'Setting PHPStorm config',
-    task: async ({ config: { phpStorm }, ports }) => {
-        const { phpLanguageLevel } = phpStorm.php;
-        const jdbcUrl = `jdbc:mysql://localhost:${ports.mysql}/magento`;
-
-        try {
-            await setConfigFile({
-                configPathname: phpStorm.xdebug.path,
-                template: phpStorm.xdebug.templatePath,
-                overwrite: true,
-                templateArgs: {
-                    phpStorm
-                }
-            });
-        } catch (e) {
-            throw new Error(`Unexpected error accrued during workspace.xml config creation\n\n${e}`);
-        }
-
-        try {
-            await setConfigFile({
-                configPathname: phpStorm.php.path,
-                template: phpStorm.php.templatePath,
-                overwrite: true,
-                templateArgs: {
-                    phpLanguageLevel
-                }
-            });
-        } catch (e) {
-            throw new Error(`Unexpected error accrued during php.xml config creation\n\n${e}`);
-        }
-
-        try {
-            await setConfigFile({
-                configPathname: phpStorm.database.dataSourcesLocal.path,
-                template: phpStorm.database.dataSourcesLocal.templatePath,
-                overwrite: true,
-                templateArgs: {
-                    phpStorm
-                }
-            });
-        } catch (e) {
-            throw new Error(`Unexpected error accrued during dataSources.local.xml config creation\n\n${e}`);
-        }
-
-        try {
-            await setConfigFile({
-                configPathname: phpStorm.database.dataSources.path,
-                template: phpStorm.database.dataSources.templatePath,
-                overwrite: true,
-                templateArgs: {
-                    phpStorm,
-                    jdbcUrl
-                }
-            });
-        } catch (e) {
-            throw new Error(`Unexpected error accrued during dataSources.xml config creation\n\n${e}`);
-        }
-
-        if (!await pathExists(path.resolve('./.idea/dataSources'))) {
-            await fs.promises.mkdir(path.resolve('./.idea/dataSources'));
-        }
-
-        try {
-            await setConfigFile({
-                configPathname: phpStorm.inspectionTools.path,
-                template: phpStorm.inspectionTools.templatePath,
-                overwrite: true,
-                templateArgs: {}
-            });
-        } catch (e) {
-            throw new Error(`Unexpected error accrued during Project_Default.xml config creation\n\n${e}`);
-        }
-    }
-});
-
-module.exports = createPhpStormConfig;