@scandipwa/magento-scripts 1.12.0-alpha.0 → 1.13.0-alpha.0

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

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

package/lib/tasks/magento/enable-magento-composer-plugins.js

@@ -0,0 +1,173 @@
+const path = require('path');
+const fs = require('fs');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const semver = require('semver');
+const pathExists = require('../../util/path-exists');
+const getJsonfileData = require('../../util/get-jsonfile-data');
+
+const vendorPath = path.join(process.cwd(), 'vendor');
+const composerJsonPath = path.join(process.cwd(), 'composer.json');
+
+/**
+ * @returns {Promise<string[]}
+ */
+const getInstalledComposerPlugins = async () => {
+    const rootVendorFolders = await fs.promises.readdir(vendorPath, {
+        encoding: 'utf-8',
+        withFileTypes: true
+    });
+
+    const composerPlugins = (await Promise.all(
+        rootVendorFolders.map(async (f) => {
+            if (f.isDirectory()) {
+                const vendorDirectoryPath = path.join(vendorPath, f.name);
+
+                const vendorPackages = await fs.promises.readdir(vendorDirectoryPath, {
+                    encoding: 'utf-8',
+                    withFileTypes: true
+                });
+
+                const vendorPackagesComposerPlugins = (await Promise.all(
+                    vendorPackages.map(async (p) => {
+                        if (p.isDirectory()) {
+                            const vendorPackageComposerJsonPath = path.join(vendorDirectoryPath, p.name, 'composer.json');
+
+                            if (await pathExists(vendorPackageComposerJsonPath)) {
+                                const {
+                                    name: vendorPackageName,
+                                    type: vendorPackageType
+                                } = JSON.parse(await fs.promises.readFile(vendorPackageComposerJsonPath, {
+                                    encoding: 'utf-8'
+                                }));
+
+                                if (vendorPackageType === 'composer-plugin') {
+                                    return vendorPackageName;
+                                }
+
+                                return null;
+                            }
+                        }
+
+                        return null;
+                    })
+                )).filter((p) => typeof p === 'string');
+
+                return vendorPackagesComposerPlugins;
+            }
+
+            return null;
+        })
+    ))
+        .reduce((acc, val) => acc.concat(val), []) // flattens the array
+        .filter((p) => typeof p === 'string');
+
+    return composerPlugins;
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const enableMagentoComposerPlugins = () => ({
+    task: async (ctx, task) => {
+        if (!semver.satisfies(ctx.composerVersion, '^2.2.0')) {
+            task.skip();
+            return;
+        }
+
+        task.title = 'Checking allowed composer plugins...';
+
+        const composerPlugins = await getInstalledComposerPlugins();
+        const composerJsonData = await getJsonfileData(composerJsonPath);
+        const {
+            config: {
+                'allow-plugins': allowPlugins = {}
+            }
+        } = composerJsonData;
+        const allowPluginsKeys = Object.keys(allowPlugins);
+
+        if (
+            allowPluginsKeys.length === 0
+            || composerPlugins.some((p) => !allowPluginsKeys.includes(p))
+        ) {
+            const missingPlugins = composerPlugins.filter((p) => !allowPluginsKeys.includes(p));
+            const answerForEnablingPlugins = await task.prompt({
+                type: 'Select',
+                message: `Composer 2.2 requires manually allowing composer-plugins to run.
+Magento requires the following plugins to correctly operate:
+
+${missingPlugins.map((p) => logger.style.code(p)).join('\n')}
+
+Do you want to enable them all or disable some of them?`,
+                choices: ['Enable all', 'Configure manually', 'Skip this step']
+            });
+
+            switch (answerForEnablingPlugins.toLowerCase()) {
+            case 'enable all': {
+                const userConfirmation = await task.prompt({
+                    type: 'Confirm',
+                    message: `Please confirm enabling of the following plugins:\n\n${missingPlugins.map((p) => logger.style.code(p)).join('\n')}\n`
+                });
+
+                if (userConfirmation) {
+                    composerJsonData.config = {
+                        ...composerJsonData.config,
+                        'allow-plugins': {
+                            ...allowPlugins,
+                            ...missingPlugins.reduce((acc, val) => ({ ...acc, [val]: true }), {})
+                        }
+                    };
+
+                    await fs.promises.writeFile(composerJsonPath, JSON.stringify(composerJsonData, null, 4), {
+                        encoding: 'utf-8'
+                    });
+                } else {
+                    throw new Error('Please confirm your choice or choose other option.');
+                }
+                break;
+            }
+            case 'configure manually': {
+                const userEnabledPlugins = await task.prompt({
+                    type: 'MultiSelect',
+                    message: 'Please pick plugins you want to enable!',
+                    choices: missingPlugins.map((p) => ({ name: p }))
+                });
+
+                const userConfirmation = await task.prompt({
+                    type: 'Confirm',
+                    message: `Please confirm enabling of the following plugins:\n\n${userEnabledPlugins.map((p) => logger.style.code(p)).join('\n')}\n`
+                });
+
+                if (userConfirmation) {
+                    const disabledPlugins = composerPlugins.filter((p) => !userEnabledPlugins.includes(p));
+
+                    composerJsonData.config = {
+                        ...composerJsonData.config,
+                        'allow-plugins': {
+                            ...allowPlugins,
+                            ...disabledPlugins.reduce((acc, val) => ({ ...acc, [val]: false }), {}),
+                            ...userEnabledPlugins.reduce((acc, val) => ({ ...acc, [val]: true }), {})
+                        }
+                    };
+
+                    await fs.promises.writeFile(composerJsonPath, JSON.stringify(composerJsonData, null, 4), {
+                        encoding: 'utf-8'
+                    });
+                } else {
+                    throw new Error('Please confirm your choice or choose other option.');
+                }
+
+                break;
+            }
+            case 'skip this step': {
+                task.skip();
+                break;
+            }
+            default: {
+                //
+            }
+            }
+        }
+    }
+});
+
+module.exports = enableMagentoComposerPlugins;

package/lib/tasks/php/compile.js

@@ -1,4 +1,3 @@
-const os = require('os');
 const osPlatform = require('../../util/os-platform');
 const logger = require('@scandipwa/scandipwa-dev-utils/logger');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
@@ -10,15 +9,15 @@ const compileOptions = require('./compile-options');
 const compile = () => ({
     title: 'Compiling PHP',
     task: async ({ config: { php } }, task) => {
-        const platformCompileOptions = compileOptions[os.platform()];
-        if (os.platform() === 'linux') {
+        const platformCompileOptions = compileOptions[process.platform];
+        if (process.platform === 'linux') {
             const { dist } = await osPlatform();
             if (['Fedora', 'Manjaro'].some((distro) => dist.includes(distro))) {
                 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,11 +1,12 @@
 /* eslint-disable max-len */
 const path = require('path');
-const os = require('os');
 const fs = require('fs');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
+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 enabled extensions list with versions
@@ -28,13 +29,36 @@ const getEnabledExtensions = async ({ php }) => {
         .reduce((acc, [name, version]) => ({ ...acc, [name]: version }), {});
 };
 
+/**
+ * Get disabled extensions list
+ * @param {import('../../../typings/context').ListrContext['config']} param0
+ * @returns {Promise<string[]>}
+ */
+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', ''));
+};
+
 /**
  * Get installed extensions
  * @param {import('../../../typings/context').ListrContext['config']} param0
  * @returns {Promise<string[]>}
  */
 const getInstalledExtensions = async ({ php }) => {
-    const extensionDirectory = path.join(os.homedir(), '.phpbrew', 'build', `php-${php.version}`, 'ext');
+    const extensionDirectory = path.join(phpbrewConfig.buildPath, `php-${php.version}`, 'ext');
 
     const availableExtensions = await fs.promises.readdir(extensionDirectory, {
         encoding: 'utf-8'
@@ -52,6 +76,7 @@ const configure = () => ({
         const { php, php: { disabledExtensions = [] } } = config;
         const enabledExtensions = await getEnabledExtensions(config);
         const installedExtensions = await getInstalledExtensions(config);
+        const disabledExtensionsInPHP = await getDisabledExtensions(config);
 
         if (!debug && enabledExtensions.xdebug && !disabledExtensions.includes('xdebug')) {
             disabledExtensions.push('xdebug');
@@ -86,7 +111,7 @@ const configure = () => ({
 
         if (missingExtensions.length > 0) {
             missingExtensions.forEach(([extensionName, extensionOptions]) => {
-                if (installedExtensions.includes(extensionName)) {
+                if (installedExtensions.includes(extensionName) && disabledExtensionsInPHP.includes(extensionName)) {
                     extensionTasks.push(enableExtension(extensionName, extensionOptions));
                 } else {
                     extensionTasks.push(installExtension(extensionName, extensionOptions));

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

@@ -1,4 +1,5 @@
 /* eslint-disable max-len */
+const phpbrewConfig = require('../../../config/phpbrew');
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
@@ -20,7 +21,7 @@ const disableExtension = (extensionName) => ({
             if (hooks && hooks.preDisable) {
                 await Promise.resolve(hooks.preDisable(config));
             }
-            await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
+            await execAsyncSpawn(`source ${phpbrewConfig.bashrcPath} && \
             phpbrew use ${ php.version } && \
             phpbrew ext disable ${ extensionName }`,
             {

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

@@ -1,4 +1,5 @@
 /* eslint-disable max-len */
+const phpbrewConfig = require('../../../config/phpbrew');
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
@@ -22,7 +23,7 @@ const enableExtension = (extensionName, extensionOptions) => ({
                 await Promise.resolve(hooks.postEnable(config));
             }
 
-            await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
+            await execAsyncSpawn(`source ${phpbrewConfig.bashrcPath} && \
             phpbrew use ${ php.version } && \
             phpbrew ext enable ${ extensionName }`,
             {

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

@@ -1,5 +1,6 @@
 /* eslint-disable max-len */
 const macosVersion = require('macos-version');
+const phpbrewConfig = require('../../../config/phpbrew');
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
@@ -25,7 +26,7 @@ const installExtension = (extensionName, extensionOptions) => ({
                 await Promise.resolve(hooks.preInstall(config));
             }
 
-            await execAsyncSpawn(`source ~/.phpbrew/bashrc && \
+            await execAsyncSpawn(`source ${phpbrewConfig.bashrcPath} && \
                 phpbrew use ${ php.version } && \
                 phpbrew ext install ${ extensionName }${ extensionOptions.version ? ` ${extensionOptions.version}` : ''}${ options ? ` -- ${ options }` : ''}`,
             {

package/lib/tasks/php/index.js

@@ -1,9 +1,10 @@
+const fs = require('fs');
 const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const { execAsyncSpawn } = require('../../util/exec-async-command');
 const pathExists = require('../../util/path-exists');
 const compile = require('./compile');
 const configure = require('./configure');
 const updatePhpBrew = require('./update-phpbrew');
+const phpbrewConfig = require('../../config/phpbrew');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -21,12 +22,17 @@ const installPhp = () => ({
         }
 
         task.title = `Installing PHP ${php.version}`;
-        const versionRegex = new RegExp(php.version);
 
         try {
-            const phpVersions = await execAsyncSpawn('phpbrew list');
+            const hasPHPVersion = (
+                await fs.promises.readdir(phpbrewConfig.phpPath, {
+                    encoding: 'utf-8',
+                    withFileTypes: true
+                })
+            )
+                .some((f) => f.isDirectory() && f.name === `php-${php.version}`);
 
-            if (versionRegex.test(phpVersions) && !recompilePhp) {
+            if (hasPHPVersion && !recompilePhp) {
                 task.skip();
                 // eslint-disable-next-line consistent-return
                 return;

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');
 

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');
 

package/lib/tasks/requirements/dependency/centos.js

@@ -5,7 +5,7 @@ const installDependenciesTask = require('../../../util/install-dependencies-task
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
-const fedoraDependenciesCheck = () => ({
+const centosDependenciesCheck = () => ({
     title: 'Checking CentOS dependencies',
     task: async (ctx, task) => {
         const installedDependencies = (await execAsyncSpawn('yum list installed')).split('\n')
@@ -32,4 +32,4 @@ const fedoraDependenciesCheck = () => ({
     }
 });
 
-module.exports = fedoraDependenciesCheck;
+module.exports = centosDependenciesCheck;

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

@@ -1,4 +1,3 @@
-const os = require('os');
 const osPlatform = require('../../../util/os-platform');
 const archDependenciesCheck = require('./arch');
 const fedoraDependenciesCheck = require('./fedora');
@@ -7,9 +6,7 @@ const ubuntuDependenciesCheck = require('./ubuntu');
 const macDependenciesCheck = require('./mac');
 
 const dependencyCheck = async () => {
-    const currentPlatform = os.platform();
-
-    if (currentPlatform === 'darwin') {
+    if (process.platform === 'darwin') {
         return macDependenciesCheck();
     }
 

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

@@ -45,7 +45,7 @@ const installDocker = () => ({
                 execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh'),
                 executeSudoCommand('sudo sh get-docker.sh'),
                 executeSudoCommand('sudo service docker start'),
-                executeSudoCommand('sudo service docker enable'),
+                executeSudoCommand('sudo systemctl enable docker.service'),
                 ...postInstallSteps
             ]);
         }

package/lib/tasks/requirements/index.js

@@ -1,8 +1,9 @@
 const checkPlatform = require('./platform');
-const checkPhpbrew = require('./phpbrew');
+const checkPHPbrew = require('./phpbrew');
 const checkComposer = require('./composer');
 const checkDocker = require('./docker');
 const checkNodeVersion = require('./node-version');
+const checkPHPVersion = require('./php-version');
 const localAuthJson = require('../composer/local-auth-json');
 
 /**
@@ -11,11 +12,12 @@ const localAuthJson = require('../composer/local-auth-json');
 const checkRequirements = () => ({
     title: 'Checking requirements',
     task: (ctx, task) => task.newListr([
-        // TODO add support for mac
         // checking if user is on supported platform
         checkPlatform(),
         // check the PHPBrew installation
-        checkPhpbrew(),
+        checkPHPbrew(),
+        // check installed PHP version
+        checkPHPVersion(),
         // check the Docker installation
         checkDocker(),
         // check for COMPOSER_AUTH or auth.json

package/lib/tasks/requirements/php-version.js

@@ -0,0 +1,113 @@
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const fs = require('fs');
+const path = require('path');
+const semver = require('semver');
+const phpbrewConfig = require('../../config/phpbrew');
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+const pathExists = require('../../util/path-exists');
+const compileOptions = require('../php/compile-options');
+
+const latestStablePHP74 = '7.4.27';
+const phpbrewPHPName = `php-${latestStablePHP74}-phpbrew`;
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const installPHPForPHPBrew = () => ({
+    title: `Installing PHP ${latestStablePHP74} for PHPBrew...`,
+    task: async (ctx, task) => {
+        const platformCompileOptions = compileOptions[process.platform];
+
+        if (!await pathExists(path.join(phpbrewConfig.phpPath, `${phpbrewPHPName}`, 'bin'))) {
+            try {
+                await execAsyncSpawn(
+                    // eslint-disable-next-line max-len
+                    `phpbrew install -j ${platformCompileOptions.cpuCount} ${latestStablePHP74} as ${phpbrewPHPName}`,
+                    {
+                        callback: (t) => {
+                            task.output = t;
+                        }
+                    }
+                );
+            } catch (e) {
+                throw new Error(
+                    `Failed to compile the required by PHPBrew PHP version.
+Tried compiling the PHP version ${ latestStablePHP74 }.
+Use your favorite search engine to resolve the issue.
+See error details in the output below.\n\n${e}`
+                );
+            }
+        }
+
+        try {
+            const phpbrewInitFileContent = `# DO NOT EDIT THIS FILE
+
+export PHPBREW_ROOT=${phpbrewConfig.homePath}
+export PHPBREW_HOME=${phpbrewConfig.homePath}
+export PHPBREW_PHP=${phpbrewPHPName}
+export PHPBREW_PATH=${phpbrewConfig.homePath}/php/${phpbrewPHPName}/bin
+# Run this command to configure your shell:
+# eval "$(phpbrew env)"\n`;
+
+            await fs.promises.writeFile(
+                path.join(phpbrewConfig.homePath, 'init'),
+                phpbrewInitFileContent,
+                {
+                    encoding: 'utf-8'
+                }
+            );
+        } catch (e) {
+            throw new Error(`Something went wrong when trying to switch PHP to ${phpbrewPHPName}!\n\n${e}`);
+        }
+
+        throw new Error(`You will need to restart your terminal and run ${logger.style.command('start')} again.
+
+You can use keyboard shortcut ${logger.style.command('CTRL+D')} to close terminal.`);
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const checkPHPVersion = () => ({
+    title: 'Checking system PHP version',
+    task: async (ctx, task) => {
+        const phpVersionResponse = await execAsyncSpawn('php --version');
+
+        const phpVersionResponseResult = phpVersionResponse.match(/^PHP\s(\d\.\d\.\d)/i);
+
+        if (phpVersionResponseResult.length > 0) {
+            const phpVersion = phpVersionResponseResult[1];
+
+            if (semver.satisfies(phpVersion, '<=7.2.x')) {
+                throw new Error(`Your installed PHP version ${phpVersion} is not supported by PHPBrew.
+Please install PHP 7.3 and newer to operate!`);
+            }
+
+            if (semver.satisfies(phpVersion, '>=8.1.x')) {
+                const userConfirmation = await task.prompt({
+                    type: 'Confirm',
+                    message: `You have PHP ${phpVersion} installed in the system.
+PHPBrew can work with this version but it will have a lot of warning.
+To fix that we will build special PHP version that will be used by PHPBrew, please confirm this action.`
+                });
+
+                if (userConfirmation) {
+                    return task.newListr(
+                        installPHPForPHPBrew,
+                        {
+                            rendererOptions: {
+                                collapse: false
+                            }
+                        }
+                    );
+                }
+            }
+        }
+    }
+});
+
+module.exports = checkPHPVersion;

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

@@ -12,7 +12,7 @@ const installDependenciesTask = require('../../../util/install-dependencies-task
 const installPHPBrewDependencies = () => ({
     title: 'Installing PHPBrew dependencies',
     task: async (ctx, task) => {
-        if (os.platform() === 'darwin') {
+        if (process.platform === 'darwin') {
             return task.newListr(
                 installDependenciesTask({
                     platform: 'darwin',
@@ -183,9 +183,7 @@ Then you can continue installation.`);
 const installPHPBrew = () => ({
     title: 'Installing PHPBrew',
     task: async (ctx, task) => {
-        const currentPlatform = os.platform();
-
-        if (currentPlatform === 'darwin') {
+        if (process.platform === 'darwin') {
             return task.newListr([
                 installXcode(),
                 installPHPBrewDependencies(),

package/lib/tasks/start.js

@@ -26,6 +26,7 @@ const setupThemes = require('./theme/setup-themes');
 const pkg = require('../../package.json');
 const checkConfigurationFile = require('../config/check-configuration-file');
 const convertLegacyVolumes = require('./docker/convert-legacy-volumes');
+const enableMagentoComposerPlugins = require('./magento/enable-magento-composer-plugins');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
@@ -111,6 +112,7 @@ const configureProject = () => ({
         configurePhp(),
         installPrestissimo(),
         installMagento(),
+        enableMagentoComposerPlugins(),
         startServices(),
         startPhpFpm(),
         connectToMySQL()