@scandipwa/magento-scripts 1.11.3 → 1.12.2

package/lib/tasks/composer/index.js

@@ -32,8 +32,12 @@ const createComposerDir = async ({ composer }) => {
 };
 
 const downloadComposerBinary = async ({ composer }) => {
+    const composerVersion = /^\d$/.test(composer.version)
+        ? `latest-${composer.version}.x`
+        : composer.version;
+
     try {
-        await downloadFile(`https://getcomposer.org/download/latest-${composer.version}.x/composer.phar`, {
+        await downloadFile(`https://getcomposer.org/download/${composerVersion}/composer.phar`, {
             destination: composer.binPath
         });
     } catch (e) {
@@ -48,7 +52,7 @@ const downloadComposerBinary = async ({ composer }) => {
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const installComposer = () => ({
-    title: 'Installing composer',
+    title: 'Installing Composer',
     task: async (ctx, task) => {
         const { composer, php } = ctx.config;
         const hasComposerInCache = await pathExists(composer.binPath);
@@ -59,11 +63,14 @@ const installComposer = () => ({
             await downloadComposerBinary({ composer });
         } else {
             const currentComposerVersion = await getComposerVersion({ composer, php });
+            const expectedComposerVersion = /^\d$/.test(composer.version)
+                ? `${composer.version}.x`
+                : composer.version;
 
-            if (!semver.satisfies(currentComposerVersion, `${composer.version}.x`)) {
+            if (!semver.satisfies(currentComposerVersion, expectedComposerVersion)) {
                 const continueComposerBinaryVersionSwitch = await task.prompt({
                     type: 'Select',
-                    message: `You have Composer ${logger.style.misc(`${currentComposerVersion}`)} while your Magento version requires ${logger.style.misc(`${composer.version}.x`)}!`,
+                    message: `You have Composer ${logger.style.misc(`${currentComposerVersion}`)} while your Magento version requires ${logger.style.misc(expectedComposerVersion)}!`,
                     choices: [
                         {
                             message: `Continue with current installed version (${logger.style.misc(`${currentComposerVersion}`)})`,
@@ -86,7 +93,7 @@ const installComposer = () => ({
                     break;
                 }
                 case 'exit': {
-                    throw new Error(`Current composer version ${logger.style.misc(`v${currentComposerVersion}`)} is not compatible with version ${logger.style.misc(`${composer.version}.x`)}!`);
+                    throw new Error(`Current composer version ${logger.style.misc(`v${currentComposerVersion}`)} is not compatible with version ${logger.style.misc(expectedComposerVersion)}!`);
                 }
                 case 'continue':
                 default: {
@@ -98,7 +105,7 @@ const installComposer = () => ({
         }
 
         const composerVersion = await getComposerVersion({ composer, php });
-        task.title = `Using composer version ${composerVersion}`;
+        task.title = `Using Composer version ${composerVersion}`;
         ctx.composerVersion = composerVersion;
     },
     options: {

package/lib/tasks/docker/index.js

@@ -6,7 +6,7 @@ const volumes = require('./volumes');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const startServices = () => ({
-    title: 'Starting docker services',
+    title: 'Starting Docker services',
     task: (ctx, task) => task.newListr([
         {
             title: 'Preparing services',

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,19 @@
 /* eslint-disable max-len */
+const path = require('path');
+const fs = require('fs');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
-const macosVersion = require('macos-version');
+const pathExists = require('../../util/path-exists');
+const enableExtension = require('./extensions/enable');
+const installExtension = require('./extensions/install');
+const disableExtension = require('./extensions/disable');
+const phpbrewConfig = require('../../config/phpbrew');
 
 /**
- * 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 +30,59 @@ const getInstalledModules = async ({ php }) => {
 };
 
 /**
- * @type {(extensions: string[]) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * Get disabled extensions list
+ * @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 getDisabledExtensions = async ({ php }) => {
+    const extensionsIniDirectory = path.join(phpbrewConfig.phpPath, `php-${php.version}`, 'var', 'db');
+
+    if (!await pathExists(extensionsIniDirectory)) {
+        return [];
     }
-});
+
+    const extensionIniList = await fs.promises.readdir(
+        extensionsIniDirectory,
+        {
+            encoding: 'utf-8',
+            withFileTypes: true
+        }
+    );
+
+    return extensionIniList.filter((f) => f.isFile() && f.name.endsWith('.disabled')).map((f) => f.name.replace('.disabled', ''));
+};
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * Get installed extensions
+ * @param {import('../../../typings/context').ListrContext['config']} param0
+ * @returns {Promise<string[]>}
+ */
+const getInstalledExtensions = async ({ php }) => {
+    const extensionDirectory = path.join(phpbrewConfig.buildPath, `php-${php.version}`, 'ext');
+
+    const availableExtensions = await fs.promises.readdir(extensionDirectory, {
+        encoding: 'utf-8'
+    });
+
+    return availableExtensions;
+};
+
+/**
+ * @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);
+        const disabledExtensionsInPHP = await getDisabledExtensions(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 +95,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) && disabledExtensionsInPHP.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;