@scandipwa/magento-scripts 1.15.1 → 1.15.4

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

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

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

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

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

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

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

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

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

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

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

@@ -27,13 +27,13 @@ const adjustComposerJson = async ({
     const composerData = await getJsonFileData(path.join(baseConfig.magentoDir, 'composer.json'));
 
     // fix composer magento repository
-    if (!composerData.repositories
+    if (composerData && (!composerData.repositories
         || (Array.isArray(composerData.repositories)
             && !composerData.repositories.some((repo) => repo.type === 'composer' && repo.url.includes('repo.magento.com'))
         )
         || (typeof composerData.repositories === 'object'
             && !Object.values(composerData.repositories).some((repo) => repo.type === 'composer' && repo.url.includes('repo.magento.com')))
-    ) {
+    )) {
         task.output = 'No Magento repository is set in composer.json! Setting up...';
         await runComposerCommand('config repo.0 composer https://repo.magento.com', {
             magentoVersion,
@@ -44,7 +44,7 @@ const adjustComposerJson = async ({
     }
 
     // if composer-root-update-plugin is not installed in composer, install it.
-    if (!composerData.require['magento/composer-root-update-plugin']) {
+    if (composerData && !composerData.require['magento/composer-root-update-plugin']) {
         task.output = 'Installing magento/composer-root-update-plugin!';
         await runComposerCommand('require magento/composer-root-update-plugin:^1',
             {
@@ -56,8 +56,8 @@ const adjustComposerJson = async ({
     }
 
     // if for some reason both editions are installed, throw an error
-    if (
-        composerData.require[magentoProductCommunityEdition]
+    if (composerData
+        && composerData.require[magentoProductCommunityEdition]
         && composerData.require[magentoProductEnterpriseEdition]
     ) {
         throw new KnownError('Somehow, both Magento editions are installed!\nPlease choose only one edition an modify your composer.json manually!');
@@ -67,7 +67,7 @@ const adjustComposerJson = async ({
         .find((edition) => edition !== magentoProductSelectedEdition);
 
     // if opposite edition is installed than selected in config file, throw an error
-    if (composerData.require[oppositeEdition]) {
+    if (composerData && composerData.require[oppositeEdition]) {
         throw new KnownError(`You have installed ${oppositeEdition} but selected magento.edition as ${magentoEdition} in config file!
 
 Change magento edition in config file or manually reinstall correct magento edition!`);
@@ -75,7 +75,7 @@ Change magento edition in config file or manually reinstall correct magento edit
 
     // if magento package is not installed in composer, require it.
 
-    if (!composerData.require[magentoProductSelectedEdition]) {
+    if (composerData && !composerData.require[magentoProductSelectedEdition]) {
         task.output = `Installing ${magentoProductSelectedEdition}=${magentoPackageVersion}!`;
         await runComposerCommand(`require ${magentoProductSelectedEdition}:${magentoPackageVersion}`,
             {
@@ -170,7 +170,7 @@ const installMagento = () => ({
         task.title = `Installing Magento ${magentoPackageVersion}`;
         task.output = 'Creating Magento project';
 
-        if (!await pathExists(path.join(baseConfig.magentoDir, 'composer.json'))) {
+        if (!await pathExists(path.join(process.cwd(), 'composer.json'))) {
             await createMagentoProject({
                 magentoProject,
                 magentoPackageVersion,

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

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

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

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

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

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

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

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

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

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

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

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

package/lib/util/CSA-theme.js

@@ -6,7 +6,7 @@ const getCSAThemes = async ({ cwd = process.cwd() } = {}) => {
         path.join(cwd, 'composer.json')
     );
 
-    if (!composerData.repositories) {
+    if (!composerData || !composerData.repositories) {
         return [];
     }
 

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

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

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

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

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

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

package/lib/util/open-browser.js

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

package/package.json

@@ -3,7 +3,7 @@
     "description": "Scripts and configuration used by CMA.",
     "homepage": "https://docs.create-magento-app.com/",
     "repository": "github:scandipwa/create-magento-app",
-    "version": "1.15.1",
+    "version": "1.15.4",
     "main": "./index.js",
     "types": "./typings/index.d.ts",
     "license": "OSL-3.0",
@@ -53,5 +53,5 @@
         "mysql",
         "scandipwa"
     ],
-    "gitHead": "ba6f9e613e4448cf449c6e82f8d95ff546de2294"
+    "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
-};