@scandipwa/magento-scripts 1.11.2 → 1.12.0

package/lib/tasks/docker/network.js

@@ -5,7 +5,7 @@ const { execAsyncSpawn } = require('../../util/exec-async-command');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const createNetwork = () => ({
-    title: 'Deploying docker network',
+    title: 'Deploying Docker network',
     task: async ({ config: { docker } }, task) => {
         const networkList = (await execAsyncSpawn("docker network ls --format '{{.Name}}'")).split('\n');
 
@@ -41,7 +41,7 @@ Use command ${logger.style.command('docker network prune')}`);
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const removeNetwork = () => ({
-    title: 'Removing docker network',
+    title: 'Removing Docker network',
     task: async ({ config: { docker } }, task) => {
         const networkList = (await execAsyncSpawn("docker network ls --format '{{.Name}}'")).split('\n');
 

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

@@ -0,0 +1,82 @@
+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;

package/lib/tasks/file-system/create-vscode-config.js

@@ -0,0 +1,111 @@
+const path = require('path');
+const semver = require('semver');
+const fs = require('fs');
+const os = require('os');
+const hjson = require('hjson');
+const pathExists = require('../../util/path-exists');
+const setConfigFile = require('../../util/set-config');
+
+const phpXDebug2port = 9111;
+const phpXDebug3port = 9003;
+const listenForXDebugConfigName = 'Listen for XDebug';
+
+const vscodeLaunchConfigPath = path.join(process.cwd(), '.vscode', 'launch.json');
+
+/**
+ * @param {import('../../../typings/context').ListrContext['config']['php']} php
+ */
+const getCurrentXDebugPort = (php) => (semver.satisfies(php.extensions.xdebug.version, '>=3')
+    ? phpXDebug3port
+    : phpXDebug2port);
+
+/**
+ * @param {import('../../../typings/context').ListrContext['config']['php']} php
+ */
+const getPHPBinPathWithHomeVariable = (php) => php.binPath.replace(os.homedir(), '$HOME');
+/**
+ * @param {import('../../../typings/context').ListrContext['config']['php']} php
+ */
+const addPHPDebugConfig = (vscodeLaunchConfig, php) => {
+    const phpXDebugConfig = vscodeLaunchConfig.configurations.find(
+        ({ name }) => name === listenForXDebugConfigName
+    );
+
+    const phpXDebugPort = getCurrentXDebugPort(php);
+    const phpBingPath = getPHPBinPathWithHomeVariable(php);
+
+    if (!phpXDebugConfig) {
+        vscodeLaunchConfig.configurations.push({
+            name: listenForXDebugConfigName,
+            type: 'php',
+            request: 'launch',
+            port: phpXDebugPort,
+            runtimeExecutable: phpBingPath
+        });
+
+        return true;
+    }
+
+    if (
+        phpXDebugConfig.port !== phpXDebugPort
+        && phpXDebugConfig.runtimeExecutable !== phpBingPath
+    ) {
+        phpXDebugConfig.port = phpXDebugPort;
+        phpXDebugConfig.runtimeExecutable = phpBingPath;
+
+        return true;
+    }
+
+    return false;
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createPhpFpmConfig = () => ({
+    title: 'Setting VSCode config',
+    task: async ({ config: { php, baseConfig } }, task) => {
+        if (await pathExists(vscodeLaunchConfigPath)) {
+            const vscodeLaunchConfig = hjson.parse(await fs.promises.readFile(vscodeLaunchConfigPath, 'utf-8'), {
+                keepWsc: true
+            });
+
+            const vscodeConfigEdited = addPHPDebugConfig(vscodeLaunchConfig, php);
+
+            // if vscode config is up-to-date, skip task
+            if (!vscodeConfigEdited) {
+                task.skip();
+                return;
+            }
+
+            await fs.promises.writeFile(vscodeLaunchConfigPath, hjson.stringify(vscodeLaunchConfig));
+
+            return;
+        }
+
+        if (!await pathExists(path.join(process.cwd(), '.vscode'))) {
+            try {
+                await fs.promises.mkdir(path.join(process.cwd(), '.vscode'));
+            } catch (e) {
+                throw new Error(`Unable to creade .vscode directory in your project!\n\n${e}`);
+            }
+        }
+
+        try {
+            const phpXDebugPort = getCurrentXDebugPort(php);
+            const vscodeLaunchConfigTemplatePath = path.join(baseConfig.templateDir, 'vscode-launch.template.json');
+            await setConfigFile({
+                template: vscodeLaunchConfigTemplatePath,
+                configPathname: vscodeLaunchConfigPath,
+                templateArgs: {
+                    XDebugPort: phpXDebugPort,
+                    PHPBinPath: getPHPBinPathWithHomeVariable(php)
+                }
+            });
+        } catch (e) {
+            throw new Error(`Unexpected error accrued during launch.json config creation!\n\n${e}`);
+        }
+    }
+});
+
+module.exports = createPhpFpmConfig;

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

@@ -1,6 +1,8 @@
 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 createVSCodeConfig = require('./create-vscode-config');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -10,7 +12,9 @@ const prepareFileSystem = () => ({
     task: (ctx, task) => task.newListr([
         createNginxConfig(),
         createPhpFpmConfig(),
-        createPhpConfig()
+        createPhpConfig(),
+        createPhpStormConfig(),
+        createVSCodeConfig()
     ], {
         concurrent: true
     })

package/lib/tasks/magento/setup-magento/set-deployment-mode.js

@@ -5,7 +5,7 @@ const runMagentoCommand = require('../../../util/run-magento');
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 module.exports = () => ({
-    title: 'Switching magento mode',
+    title: 'Switching Magento mode',
     task: async ({ magentoVersion, config: { magentoConfiguration: { mode } } }, task) => {
         const { result } = await runMagentoCommand('deploy:mode:show', {
             throwNonZeroCode: false,

package/lib/tasks/magento/setup-magento/waiting-for-redis.js

@@ -4,7 +4,7 @@ const waitForIt = require('../../../util/wait-for-it');
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 module.exports = () => ({
-    title: 'Waiting for redis',
+    title: 'Waiting for Redis',
     task: async ({ ports }, task) => {
         await waitForIt({
             name: 'redis',

package/lib/tasks/php/compile.js

@@ -17,8 +17,8 @@ const compile = () => ({
                 platformCompileOptions.extraOptions.push('--with-libdir=lib64');
             }
         }
-        const exportEnv = Object.entries(platformCompileOptions.env || {}).map(([key, value]) => `export ${key}="${value}"`).join(' && ');
-        const phpCompileCommand = `${exportEnv ? `${exportEnv} && ` : ''} \
+        const commandEnv = Object.entries(platformCompileOptions.env || {}).map(([key, value]) => `${key}="${value}"`).join(' && ');
+        const phpCompileCommand = `${commandEnv ? `${commandEnv} && ` : ''} \
         phpbrew install -j ${platformCompileOptions.cpuCount} ${php.version} ${platformCompileOptions.variants.join(' ')} \
         -- ${platformCompileOptions.extraOptions.join(' ')}`;
 

package/lib/tasks/php/configure.js

@@ -1,14 +1,18 @@
 /* eslint-disable max-len */
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
-const macosVersion = require('macos-version');
+const enableExtension = require('./extensions/enable');
+const installExtension = require('./extensions/install');
+const disableExtension = require('./extensions/disable');
 
 /**
- * Get installed modules list with versions
- * @param {Object} param0
- * @param {import('../../../typings/context').ListrContext['config']['php']} param0.php
+ * Get enabled extensions list with versions
+ * @param {import('../../../typings/context').ListrContext['config']} param0
  * @returns {Promise<{[key: string]: string}}>}
  */
-const getInstalledModules = async ({ php }) => {
+const getEnabledExtensions = async ({ php }) => {
     const output = await execAsyncSpawn(
         `${ php.binPath } -c ${php.iniPath} -r 'foreach (get_loaded_extensions() as $extension) echo "$extension:" . phpversion($extension) . "\n";'`
     );
@@ -25,44 +29,35 @@ const getInstalledModules = async ({ php }) => {
 };
 
 /**
- * @type {(extensions: string[]) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * Get installed extensions
+ * @param {import('../../../typings/context').ListrContext['config']} param0
+ * @returns {Promise<string[]>}
  */
-const disablingExtensions = (extensions) => ({
-    title: `Disabling extensions ${extensions.join(', ')}`,
-    task: async ({ config: { overridenConfiguration: { configuration: { php } } } }, task) => {
-        try {
-            for (const extension of extensions) {
-                await execAsyncSpawn(`
-                source ~/.phpbrew/bashrc && \
-                phpbrew use ${ php.version } && \
-                phpbrew ext disable ${extension}`, {
-                    callback: (t) => {
-                        task.output = t;
-                    }
-                });
-            }
-        } catch (e) {
-            throw new Error(`Something went wrong during extension disabling.\n\n${e}`);
-        }
-    },
-    options: {
-        bottomBar: 10
-    }
-});
+const getInstalledExtensions = async ({ php }) => {
+    const extensionDirectory = path.join(os.homedir(), '.phpbrew', 'build', `php-${php.version}`, 'ext');
+
+    const availableExtensions = await fs.promises.readdir(extensionDirectory, {
+        encoding: 'utf-8'
+    });
+
+    return availableExtensions;
+};
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const configure = () => ({
     title: 'Configuring PHP extensions',
     task: async ({ config, debug }, task) => {
-        const { php, overridenConfiguration: { configuration: { php: { disabledExtensions = [] } } } } = config;
-        const loadedModules = await getInstalledModules({ php });
+        const { php, php: { disabledExtensions = [] } } = config;
+        const enabledExtensions = await getEnabledExtensions(config);
+        const installedExtensions = await getInstalledExtensions(config);
 
-        if (!debug && loadedModules.xdebug && !disabledExtensions.includes('xdebug')) {
+        if (!debug && enabledExtensions.xdebug && !disabledExtensions.includes('xdebug')) {
             disabledExtensions.push('xdebug');
         }
 
+        /** @type {[string, import('../../../typings/index').PHPExtension][]} */
         const missingExtensions = Object.entries(php.extensions)
             .filter(([name, options]) => {
                 const extensionName = options.extensionName || name;
@@ -75,49 +70,50 @@ const configure = () => ({
                 if (extensionName === 'xdebug' && !debug) {
                     return false;
                 }
-                if (!loadedModules[extensionName]) {
+                if (!enabledExtensions[extensionName]) {
                     return true;
                 }
 
-                if (options && options.version && loadedModules[extensionName] !== options.version) {
+                if (options && options.version && enabledExtensions[extensionName] !== options.version) {
                     return true;
                 }
 
                 return false;
             });
 
+        /** @type {import('listr2').ListrTask[]} */
+        const extensionTasks = [];
+
         if (missingExtensions.length > 0) {
-            try {
-                for (const [extensionName, extensionOptions] of missingExtensions) {
-                    const options = macosVersion.isMacOS ? extensionOptions.macOptions : extensionOptions.options;
-                    const { hooks = {} } = extensionOptions;
-
-                    if (hooks.preInstall) {
-                        await Promise.resolve(hooks.preInstall(config));
-                    }
-                    await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
-                phpbrew use ${ php.version } && \
-                phpbrew ext install ${ extensionName }${ extensionOptions.version ? ` ${extensionOptions.version}` : ''}${ options ? ` -- ${ options }` : ''}`,
-                    {
-                        callback: (t) => {
-                            task.output = t;
-                        }
-                    });
-
-                    if (hooks.postInstall) {
-                        await Promise.resolve(hooks.postInstall(config));
-                    }
+            missingExtensions.forEach(([extensionName, extensionOptions]) => {
+                if (installedExtensions.includes(extensionName)) {
+                    extensionTasks.push(enableExtension(extensionName, extensionOptions));
+                } else {
+                    extensionTasks.push(installExtension(extensionName, extensionOptions));
                 }
-            } catch (e) {
-                throw new Error(`Something went wrong during the extension installation.\n\n${e}`);
-            }
+            });
         }
 
         if (disabledExtensions.length > 0) {
-            return task.newListr(
-                disablingExtensions(disabledExtensions)
-            );
+            disabledExtensions.forEach((extensionName) => {
+                extensionTasks.push(disableExtension(extensionName));
+            });
         }
+
+        if (extensionTasks.length === 0) {
+            task.skip();
+            return;
+        }
+
+        return task.newListr(
+            extensionTasks,
+            {
+                concurrent: false,
+                rendererOptions: {
+                    collapse: false
+                }
+            }
+        );
     },
     options: {
         bottomBar: 10

package/lib/tasks/php/extensions/disable.js

@@ -0,0 +1,41 @@
+/* eslint-disable max-len */
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {String} extensionName
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const disableExtension = (extensionName) => ({
+    title: `Disabling ${extensionName} extension`,
+    task: async (ctx, task) => {
+        const {
+            config,
+            config: { php }
+        } = ctx;
+        const extensionOptions = php.extensions[extensionName] || {};
+        const { hooks } = extensionOptions;
+        if (extensionOptions.disable) {
+            await Promise.resolve(extensionOptions.disable(ctx, task));
+        } else {
+            if (hooks && hooks.preDisable) {
+                await Promise.resolve(hooks.preDisable(config));
+            }
+            await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
+            phpbrew use ${ php.version } && \
+            phpbrew ext disable ${ extensionName }`,
+            {
+                callback: (t) => {
+                    task.output = t;
+                }
+            });
+            if (hooks && hooks.postDisable) {
+                await Promise.resolve(hooks.postDisable(config));
+            }
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = disableExtension;

package/lib/tasks/php/extensions/enable.js

@@ -0,0 +1,44 @@
+/* eslint-disable max-len */
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {String} extensionName
+ * @param {import('../../../../typings/index').PHPExtension} extensionOptions
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const enableExtension = (extensionName, extensionOptions) => ({
+    title: `Enabling ${extensionName} extension`,
+    task: async (ctx, task) => {
+        const {
+            config,
+            config: { php }
+        } = ctx;
+        const { hooks } = extensionOptions;
+
+        if (extensionOptions.enable) {
+            await Promise.resolve(extensionOptions.enable(ctx, task));
+        } else {
+            if (hooks && hooks.postEnable) {
+                await Promise.resolve(hooks.postEnable(config));
+            }
+
+            await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
+            phpbrew use ${ php.version } && \
+            phpbrew ext enable ${ extensionName }`,
+            {
+                callback: (t) => {
+                    task.output = t;
+                }
+            });
+
+            if (hooks && hooks.postEnable) {
+                await Promise.resolve(hooks.postEnable(config));
+            }
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = enableExtension;

package/lib/tasks/php/extensions/install.js

@@ -0,0 +1,47 @@
+/* eslint-disable max-len */
+const macosVersion = require('macos-version');
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {String} extensionName
+ * @param {import('../../../../typings/index').PHPExtension} extensionOptions
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const installExtension = (extensionName, extensionOptions) => ({
+    title: `Installing ${extensionName} extension`,
+    task: async (ctx, task) => {
+        const {
+            config,
+            config: { php }
+        } = ctx;
+        const { hooks } = extensionOptions;
+
+        if (extensionOptions.install) {
+            await Promise.resolve(extensionOptions.install(ctx, task));
+        } else {
+            const options = macosVersion.isMacOS ? extensionOptions.macosOptions : extensionOptions.linuxOptions;
+
+            if (hooks && hooks.preInstall) {
+                await Promise.resolve(hooks.preInstall(config));
+            }
+
+            await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
+                phpbrew use ${ php.version } && \
+                phpbrew ext install ${ extensionName }${ extensionOptions.version ? ` ${extensionOptions.version}` : ''}${ options ? ` -- ${ options }` : ''}`,
+            {
+                callback: (t) => {
+                    task.output = t;
+                }
+            });
+
+            if (hooks && hooks.postInstall) {
+                await Promise.resolve(hooks.postInstall(config));
+            }
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = installExtension;

package/lib/tasks/php-fpm/start-php-fpm.js

@@ -1,5 +1,5 @@
 const { execAsyncSpawn } = require('../../util/exec-async-command');
-const getPhpConfig = require('../../config/php');
+const getPhpConfig = require('../../config/php-config');
 const { getBaseConfig } = require('../../config/index');
 const getProcessId = require('./get-process-id');
 
@@ -7,7 +7,7 @@ const getProcessId = require('./get-process-id');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const startPhpFpm = () => ({
-    title: 'Starting php-fpm',
+    title: 'Starting PHP-FPM',
     task: async ({ config: { overridenConfiguration }, projectPath }, task) => {
         const php = getPhpConfig(overridenConfiguration.configuration, getBaseConfig(projectPath));
         const processId = await getProcessId(php.fpmPidFilePath);
@@ -35,7 +35,7 @@ const startPhpFpm = () => ({
                 }
             );
         } catch (e) {
-            throw new Error(`Error during php-fpm start\n\n${e}`);
+            throw new Error(`Error during PHP-FPM start\n\n${e}`);
         }
     },
     options: {

package/lib/tasks/php-fpm/stop-php-fpm.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const pathExists = require('../../util/path-exists');
-const getPhpConfig = require('../../config/php');
+const getPhpConfig = require('../../config/php-config');
 const { getBaseConfig } = require('../../config/index');
 const getProcessId = require('./get-process-id');
 
@@ -9,7 +9,7 @@ const getProcessId = require('./get-process-id');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const stopPhpFpmTask = () => ({
-    title: 'Stopping php-fpm',
+    title: 'Stopping PHP-FPM',
     task: async ({ config: { overridenConfiguration }, projectPath }, task) => {
         const php = getPhpConfig(overridenConfiguration.configuration, getBaseConfig(projectPath));
         const processId = await getProcessId(php.fpmPidFilePath);

package/lib/tasks/requirements/composer.js

@@ -4,7 +4,7 @@ const logger = require('@scandipwa/scandipwa-dev-utils/logger');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const checkComposer = () => ({
-    title: 'Checking composer environmental variables',
+    title: 'Checking Composer environmental variables',
     task: () => {
         try {
             if (!process.env.COMPOSER_AUTH) {

package/lib/tasks/requirements/docker/index.js

@@ -9,7 +9,7 @@ const getDockerVersion = require('./version');
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDocker = () => ({
-    title: 'Checking docker',
+    title: 'Checking Docker',
     task: async (ctx, task) => {
         const { code } = await execAsyncSpawn('docker -v', {
             withCode: true
@@ -63,7 +63,7 @@ ${ logger.style.link('https://docs.create-magento-app.com/getting-started/prereq
             getDockerVersion(),
             {
                 task: (ctx) => {
-                    task.title = `Using docker version ${ctx.dockerVersion}`;
+                    task.title = `Using Docker version ${ctx.dockerVersion}`;
                 }
             }
         ]);

package/lib/util/config-file-validator.js

@@ -83,7 +83,13 @@ const serviceConfigurationSchema = Joi.object({
  * @type {Joi.ObjectSchema<import('../../typings').CMAConfiguration['configuration']['composer']>}
  */
 const composerConfigurationSchema = Joi.object({
-    version: Joi.string().optional().allow('1', '2')
+    version: Joi.string().optional().custom((value) => {
+        if (['1', '2'].includes(value)) {
+            return undefined;
+        }
+
+        return versionValidator(value);
+    })
 });
 
 /**