@scandipwa/magento-scripts 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/tasks/docker/volume/volume-api.d.ts

@@ -37,3 +37,43 @@ export function create(
     options?: VolumeCreateOptions,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<string>
+
+export interface VolumeRmOptions {
+    force?: boolean
+    volumes: string[]
+}
+
+export function rm(
+    options?: VolumeRmOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+
+export interface VolumeInspectOptions<T extends boolean = false> {
+    volume: string
+    format?: string
+    formatToJSON?: T
+}
+
+export interface VolumeInspectResult {
+    CreatedAt: string
+    Driver: string
+    Labels: unknown
+    Mountpoint: string
+    Name: string
+    Options: unknown
+    Scope: string
+    CreatedTime: number
+    Containers: Record<string, {
+        Name: string
+        Destination: string
+    }>
+}
+
+export function inspect(
+    options?: VolumeInspectOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function inspect(
+    options?: VolumeInspectOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<VolumeInspectResult>

package/lib/tasks/docker/volume/volume-api.js

@@ -60,7 +60,60 @@ const ls = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker volume ls ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./volume-api').VolumeRmOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const rm = async (options, execOptions = {}) => {
+    const {
+        force,
+        volumes
+    } = options;
+
+    const forceArg = force && '--force';
+
+    const command = [
+        'docker',
+        'volume',
+        'rm',
+        forceArg,
+        ...volumes
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(command, execOptions);
+};
+
+/**
+ * @param {import('./volume-api').VolumeInspectOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const inspect = async (options, execOptions = {}) => {
+    const {
+        volume,
+        format,
+        formatToJSON = false
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+
+    const args = [
+        formatArg,
+        volume
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker volume inspect ${args}`, execOptions);
+        return JSON.parse(result);
+    }
+
+    return execAsyncSpawn(`docker volume inspect ${args}`, execOptions);
+};
+
 module.exports = {
     create,
-    ls
+    ls,
+    rm,
+    inspect
 };

package/lib/tasks/execute.js

@@ -0,0 +1,100 @@
+const { Listr } = require('listr2');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const { checkRequirements } = require('./requirements');
+const getMagentoVersionConfig = require('../config/get-magento-version-config');
+const checkConfigurationFile = require('../config/check-configuration-file');
+const getProjectConfiguration = require('../config/get-project-configuration');
+const { getCachedPorts } = require('../config/get-port-config');
+const { executeInContainer, runInContainer } = require('../util/execute-in-container');
+const { containerApi } = require('./docker/containers');
+const dockerNetwork = require('./docker/network');
+const KnownError = require('../errors/known-error');
+
+/**
+ *
+ * @param {{ containername: string, commands?: string[] }} argv
+ * @returns
+ */
+const executeTask = async (argv) => {
+    const tasks = new Listr([
+        checkRequirements(),
+        getMagentoVersionConfig(),
+        checkConfigurationFile(),
+        getProjectConfiguration(),
+        getCachedPorts(),
+        dockerNetwork.tasks.createNetwork()
+    ], {
+        concurrent: false,
+        exitOnError: true,
+        ctx: { throwMagentoVersionMissing: true },
+        rendererOptions: { collapse: false, clearOutput: true }
+    });
+
+    let ctx;
+    try {
+        ctx = await tasks.run();
+    } catch (e) {
+        logger.error(e.message || e);
+        process.exit(1);
+    }
+    const containers = ctx.config.docker.getContainers(ctx.ports);
+    const services = Object.keys(containers);
+
+    if (services.includes(argv.containername) || services.some((service) => service.includes(argv.containername))) {
+        /**
+         * @type {import('./docker/containers/container-api').ContainerRunOptions}
+         */
+        const container = containers[argv.containername]
+            ? containers[argv.containername]
+            : Object.entries(containers).find(([key]) => key.includes(argv.containername))[1];
+
+        if (argv.commands.length === 0) {
+        // if we have default connect command then use it
+            if (container.connectCommand) {
+            // eslint-disable-next-line no-param-reassign
+                argv.commands = container.connectCommand;
+            } else {
+            // otherwise fall back to bash (if it exists inside container)
+                argv.commands.push('bash');
+            }
+        }
+
+        const containerList = await containerApi.ls({
+            formatToJSON: true,
+            all: true,
+            filter: `name=${container.name}`
+        });
+
+        if (containerList.length > 0) {
+            logger.logN(`Executing container ${logger.style.misc(container._)} (command: ${logger.style.command(argv.commands.join(' '))})`);
+            const result = await executeInContainer({
+                containerName: container.name,
+                commands: argv.commands,
+                user: container.user
+            });
+
+            return result;
+        }
+
+        if (container.name.endsWith('php')) {
+            logger.logN(`Starting container ${logger.style.misc(container._)} with command: ${logger.style.command(argv.commands.join(' '))}`);
+            const result = await runInContainer(
+                {
+                    ...container,
+                    name: `${container.name}_exec-${Date.now()}`
+                },
+                argv.commands
+            );
+
+            return result;
+        }
+
+        throw new KnownError(`Container ${container.name} is not running!`);
+    }
+
+    logger.error(`No container found "${argv.containername}"`);
+};
+
+module.exports = {
+    executeTask
+};

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

@@ -14,7 +14,7 @@ const createNginxConfig = () => ({
                 overridenConfiguration,
                 baseConfig
             },
-            isWsl
+            isDockerDesktop
         } = ctx;
 
         const {
@@ -23,10 +23,8 @@ const createNginxConfig = () => ({
             }
         } = overridenConfiguration;
 
-        const isLinux = ctx.platform === 'linux';
-        const isNativeLinux = isLinux && !isWsl;
-        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
-        const hostPort = isNativeLinux ? ports.app : 80;
+        const hostMachine = !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal';
+        const hostPort = !isDockerDesktop ? ports.app : 80;
 
         try {
             await setConfigFile({

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

@@ -1,7 +1,5 @@
-const semver = require('semver');
 const UnknownError = require('../../errors/unknown-error');
 const setConfigFile = require('../../util/set-config');
-const { getEnabledExtensionsFromImage } = require('../docker/project-image-builder');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -9,32 +7,13 @@ const { getEnabledExtensionsFromImage } = require('../docker/project-image-build
 const createPhpConfig = () => ({
     title: 'Setting PHP config',
     task: async (ctx) => {
-        const {
-            config: {
-                php,
-                baseConfig
-            },
-            debug
-        } = ctx;
-        const containers = ctx.config.docker.getContainers(ctx.ports);
-        const phpExtensions = await getEnabledExtensionsFromImage(containers.php.debugImage);
-        const isXDebug2 = semver.satisfies(phpExtensions.xdebug, '2');
-
-        const isLinux = ctx.platform === 'linux';
-        const isNativeLinux = isLinux && !ctx.isWsl;
-        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
+        const { config: { php } } = ctx;
 
         try {
             await setConfigFile({
                 configPathname: php.iniPath,
                 template: php.iniTemplatePath,
-                overwrite: true,
-                templateArgs: {
-                    debug,
-                    mageRoot: baseConfig.containerMagentoDir,
-                    isXDebug2,
-                    hostMachine
-                }
+                overwrite: true
             });
         } catch (e) {
             throw new UnknownError(`Unexpected error accrued during php.ini config creation\n\n${e}`);

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

@@ -0,0 +1,45 @@
+const semver = require('semver');
+const UnknownError = require('../../errors/unknown-error');
+const setConfigFile = require('../../util/set-config');
+const { getEnabledExtensionsFromImage } = require('../docker/project-image-builder');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createPhpDebugConfig = () => ({
+    title: 'Setting PHP XDebug config',
+    skip: (ctx) => !ctx.debug,
+    task: async (ctx) => {
+        const {
+            config: {
+                php,
+                baseConfig
+            },
+            debug,
+            isDockerDesktop
+        } = ctx;
+        const containers = ctx.config.docker.getContainers(ctx.ports);
+        const phpExtensions = await getEnabledExtensionsFromImage(containers.php.debugImage);
+        const isXDebug2 = semver.satisfies(phpExtensions.xdebug, '2');
+
+        const hostMachine = !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal';
+
+        try {
+            await setConfigFile({
+                configPathname: php.debugIniPath,
+                template: php.debugTemplatePath,
+                overwrite: true,
+                templateArgs: {
+                    debug,
+                    mageRoot: baseConfig.containerMagentoDir,
+                    isXDebug2,
+                    hostMachine
+                }
+            });
+        } catch (e) {
+            throw new UnknownError(`Unexpected error accrued during xdebug.ini config creation\n\n${e}`);
+        }
+    }
+});
+
+module.exports = createPhpDebugConfig;

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

@@ -7,10 +7,8 @@ const setConfigFile = require('../../util/set-config');
 const createPhpFpmConfig = () => ({
     title: 'Setting php-fpm config',
     task: async (ctx) => {
-        const { config: { php } } = ctx;
-        const isLinux = ctx.platform === 'linux';
-        const isNativeLinux = isLinux && !ctx.isWsl;
-        const port = isNativeLinux ? ctx.ports.fpm : 9000;
+        const { config: { php }, isDockerDesktop } = ctx;
+        const port = !isDockerDesktop ? ctx.ports.fpm : 9000;
 
         try {
             await setConfigFile({

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

@@ -26,11 +26,21 @@ const mustBeIncludedPaths = [
 /**
  * Will retrieve project config file path from module.xml
  *
- * @returns {Promise<String>}
+ * @returns {Promise<String | null>}
  */
 const getProjectConfigFilePath = async () => {
     const modulesConfigData = await loadXmlFile(pathToModulesConfig);
-    return modulesConfigData.project.component.modules.module['@_filepath'].replace('$PROJECT_DIR$', process.cwd());
+    const {
+        project: {
+            component: {
+                modules: {
+                    module
+                } = {}
+            } = {}
+        } = {}
+    } = modulesConfigData || {};
+    const filePath = module && module['@_filepath'];
+    return filePath ? filePath.replace('$PROJECT_DIR$', process.cwd()) : null;
 };
 
 const setupDefaultsForExcludedFoldersConfig = (projectConfigData) => {
@@ -138,7 +148,7 @@ const setupExcludedFoldersConfig = () => ({
     task: async (ctx, task) => {
         if (await pathExists(pathToModulesConfig)) {
             const projectFilePath = await getProjectConfigFilePath();
-            if (await pathExists(projectFilePath)) {
+            if (projectFilePath && await pathExists(projectFilePath)) {
                 const projectConfigData = await loadXmlFile(projectFilePath);
                 setupDefaultsForExcludedFoldersConfig(projectConfigData);
                 const hasChanges = setupExcludedFolders(projectConfigData);

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

@@ -31,7 +31,7 @@ const setupPHPWorkspaceProjectConfiguration = async (workspaceConfigs, ctx) => {
         hasChanges = true;
         workspaceConfigs.push({
             [nameKey]: PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME,
-            [currentInterpreterImage]: currentInterpreterImage,
+            [interpreterNameKey]: currentInterpreterImage,
             include_path: []
         });
     }

package/lib/tasks/file-system/create-ssl-terminator-config.js

@@ -1,4 +1,3 @@
-const os = require('os');
 const path = require('path');
 const fs = require('fs');
 const setConfigFile = require('../../util/set-config');
@@ -19,8 +18,8 @@ const createSSLTerminatorConfig = () => ({
                 overridenConfiguration,
                 baseConfig
             },
-            isWsl,
-            debug
+            debug,
+            isDockerDesktop
         } = ctx;
 
         const {
@@ -65,10 +64,8 @@ const createSSLTerminatorConfig = () => ({
         }
 
         const networkToBindTo = isIpAddress(host) ? host : '127.0.0.1';
-        const isLinux = os.platform() === 'linux';
-        const isNativeLinux = isLinux && !isWsl;
-        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
-        const hostPort = isNativeLinux ? ports.sslTerminator : 80;
+        const hostMachine = !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal';
+        const hostPort = !isDockerDesktop ? ports.sslTerminator : 80;
 
         try {
             await setConfigFile({

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

@@ -17,8 +17,7 @@ const createVarnishConfig = () => ({
                     cacheDir
                 }
             },
-            isWsl,
-            platform
+            isDockerDesktop
         } = ctx;
 
         const {
@@ -27,9 +26,6 @@ const createVarnishConfig = () => ({
             }
         } = overridenConfiguration;
 
-        const isLinux = platform === 'linux';
-        const isNativeLinux = isLinux && !isWsl;
-
         try {
             await setConfigFile({
                 configPathname: path.join(
@@ -40,8 +36,9 @@ const createVarnishConfig = () => ({
                 template: varnish.configTemplate,
                 overwrite: true,
                 templateArgs: {
-                    hostMachine: isNativeLinux ? '127.0.0.1' : 'host.docker.internal',
-                    nginxPort: ports.app
+                    hostMachine: !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal',
+                    nginxPort: ports.app,
+                    healthCheck: varnish.healthCheck
                 }
             });
         } catch (e) {

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

@@ -1,6 +1,7 @@
 const createMariaDBConfig = require('./create-mariadb-config');
 const createNginxConfig = require('./create-nginx-config');
 const createPhpConfig = require('./create-php-config');
+const createPhpDebugConfig = require('./create-php-debug-config');
 const createPhpFpmConfig = require('./create-php-fpm-config');
 const createPhpStormConfig = require('./create-phpstorm-config');
 const createSSLTerminatorConfig = require('./create-ssl-terminator-config');
@@ -17,6 +18,7 @@ const prepareFileSystem = () => ({
         createNginxConfig(),
         createPhpFpmConfig(),
         createPhpConfig(),
+        createPhpDebugConfig(),
         createPhpStormConfig(),
         createVSCodeConfig(),
         createVarnishConfig(),

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

@@ -4,7 +4,6 @@ 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 KnownError = require('../../errors/known-error');
 
 const vendorPath = path.join(process.cwd(), 'vendor');
 const composerJsonPath = path.join(process.cwd(), 'composer.json');
@@ -86,29 +85,80 @@ const enableMagentoComposerPlugins = () => ({
         } = composerJsonData;
         const allowPluginsKeys = Object.keys(allowPlugins);
 
+        const missingPluginsFromAllowPlugins = composerPlugins.filter((plugin) => {
+            const [pluginVendor, pluginName] = plugin.split('/');
+            return !allowPluginsKeys.some((allowedPlugin) => {
+                const [allowedPluginVendor, allowedPluginName] = allowedPlugin.split('/');
+                if (allowedPluginVendor === pluginVendor) {
+                    if (allowedPluginName === '*') {
+                        return true;
+                    }
+
+                    return allowedPluginName === pluginName;
+                }
+
+                return false;
+            });
+        });
+
         if (
             allowPluginsKeys.length === 0
-            || composerPlugins.some((p) => !allowPluginsKeys.includes(p))
+            || missingPluginsFromAllowPlugins.length > 0
         ) {
-            const missingPlugins = composerPlugins.filter((p) => !allowPluginsKeys.includes(p));
+            const missingVendors = missingPluginsFromAllowPlugins.reduce((acc, val) => {
+                const [pluginVendor] = val.split('/');
+
+                if (acc.length === 0) {
+                    return [pluginVendor];
+                }
+
+                if (!acc.includes(pluginVendor)) {
+                    return [...acc, pluginVendor];
+                }
+
+                return acc;
+            }, []);
+
+            const pluginOptions = [
+                {
+                    name: 'all-individual',
+                    message: 'Enable all individually'
+                },
+                {
+                    name: 'manual',
+                    message: 'Configure manually'
+                },
+                {
+                    name: 'skip',
+                    message: 'Skip this step'
+                }
+            ];
+
+            if (missingVendors.length === 1) {
+                pluginOptions.unshift({
+                    name: 'all',
+                    message: `Enable all (${logger.style.code(`"${missingVendors[0]}/*"`)})`
+                });
+            }
+
             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')}
+${missingPluginsFromAllowPlugins.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']
+                choices: pluginOptions
             });
 
             switch (answerForEnablingPlugins.toLowerCase()) {
-            case 'enable all': {
+            case 'all': {
                 composerJsonData.config = {
                     ...(composerJsonData.config || {}),
                     'allow-plugins': {
                         ...allowPlugins,
-                        ...missingPlugins.reduce((acc, val) => ({ ...acc, [val]: true }), {})
+                        [`${missingVendors[0]}/*`]: true
                     }
                 };
 
@@ -117,36 +167,41 @@ Do you want to enable them all or disable some of them?`,
                 });
                 break;
             }
-            case 'configure manually': {
+            case 'all-individual': {
+                composerJsonData.config = {
+                    ...(composerJsonData.config || {}),
+                    'allow-plugins': {
+                        ...allowPlugins,
+                        ...missingPluginsFromAllowPlugins.reduce((acc, val) => ({ ...acc, [val]: true }), {})
+                    }
+                };
+
+                await fs.promises.writeFile(composerJsonPath, JSON.stringify(composerJsonData, null, 4), {
+                    encoding: 'utf-8'
+                });
+                break;
+            }
+            case 'manual': {
                 const userEnabledPlugins = await task.prompt({
                     type: 'MultiSelect',
                     message: 'Please pick plugins you want to enable!',
-                    choices: missingPlugins.map((p) => ({ name: p }))
+                    choices: missingPluginsFromAllowPlugins.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`
-                });
+                const disabledPlugins = composerPlugins.filter((p) => !userEnabledPlugins.includes(p));
 
-                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 }), {})
-                        }
-                    };
+                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 KnownError('Please confirm your choice or choose other option.');
-                }
+                await fs.promises.writeFile(composerJsonPath, JSON.stringify(composerJsonData, null, 4), {
+                    encoding: 'utf-8'
+                });
 
                 break;
             }

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

@@ -97,8 +97,9 @@ const createMagentoProject = async (ctx, task, {
         `"${tempDir}"`
     ];
 
-    await runPHPContainerCommand(ctx, `composer ${installCommand.join(' ')} \n
-&& mv ${tempDir}/composer.json ${ctx.config.baseConfig.containerMagentoDir}/composer.json`);
+    await runPHPContainerCommand(ctx, `bash -c 'mkdir ${tempDir} && \
+composer ${installCommand.join(' ')} && \
+mv ${tempDir}/composer.json ${ctx.config.baseConfig.containerMagentoDir}/composer.json'`);
 };
 
 /**

package/lib/tasks/magento/setup-magento/configure-elasticsearch.js

@@ -7,10 +7,8 @@ module.exports = () => ({
     title: 'Configuring Elasticsearch',
     skip: async (ctx) => !(await isTableExists('magento', 'core_config_data', ctx)),
     task: async (ctx, task) => {
-        const { ports, databaseConnection } = ctx;
-        const isLinux = ctx.platform === 'linux';
-        const isNativeLinux = isLinux && !ctx.isWsl;
-        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
+        const { ports, databaseConnection, isDockerDesktop } = ctx;
+        const hostMachine = !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal';
         await updateTableValues('core_config_data', [
             { path: 'catalog/search/engine', value: 'elasticsearch7' },
             { path: 'catalog/search/elasticsearch7_server_hostname', value: hostMachine },

package/lib/tasks/magento/setup-magento/flush-redis-config.js

@@ -1,18 +1,15 @@
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
-const os = require('os');
 const UnknownError = require('../../../errors/unknown-error');
 
-const isLinux = os.platform() === 'linux';
-
 /**
  * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 module.exports = () => ({
     title: 'Flushing Magento redis cache',
-    task: async ({ ports, config: { docker } }) => {
+    task: async ({ ports, config: { docker }, isDockerDesktop }) => {
         const { redis: { name } } = docker.getContainers(ports);
-        const host = isLinux ? 'localhost' : 'host.docker.internal';
-        const port = isLinux ? '6379' : ports.redis;
+        const host = !isDockerDesktop ? 'localhost' : 'host.docker.internal';
+        const port = !isDockerDesktop ? '6379' : ports.redis;
         const result = await execAsyncSpawn(`docker exec ${ name } redis-cli -h ${ host } -p ${ port } -n 0 flushdb`);
 
         if (!result.trim().includes('OK')) {