@scandipwa/magento-scripts 2.4.0-alpha.0 → 2.4.0-alpha.2

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

@@ -1,9 +1,11 @@
 const path = require('path')
 const fs = require('fs')
+const semver = require('semver')
 const setConfigFile = require('../../util/set-config')
 const pathExists = require('../../util/path-exists')
 const KnownError = require('../../errors/known-error')
 const UnknownError = require('../../errors/unknown-error')
+const { run } = require('../docker/containers/container-api')
 
 /**
  * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -13,8 +15,7 @@ const createSSLTerminatorConfig = () => ({
     task: async (ctx) => {
         const {
             ports,
-            config: { overridenConfiguration, baseConfig },
-            debug,
+            config: { overridenConfiguration, baseConfig, docker },
             isDockerDesktop
         } = ctx
 
@@ -70,11 +71,49 @@ const createSSLTerminatorConfig = () => ({
             )
         }
 
-        const hostMachine = !isDockerDesktop
-            ? '127.0.0.1'
-            : 'host.docker.internal'
+        const networkSettings = {
+            backendNetwork: '127.0.0.1',
+            backendPort: overridenConfiguration.configuration.varnish.enabled
+                ? ports.varnish
+                : ports.app
+        }
+
+        if (isDockerDesktop) {
+            const containers = docker.getContainers(ports)
+
+            if (overridenConfiguration.configuration.varnish.enabled) {
+                networkSettings.backendNetwork = containers.varnish.name
+                networkSettings.backendPort = 80
+            } else {
+                networkSettings.backendNetwork = containers.nginx.name
+                networkSettings.backendPort = 80
+            }
+        }
         const hostPort = !isDockerDesktop ? ports.sslTerminator : 80
 
+        const nginxVersionOutput = await run({
+            image: sslTerminator.image,
+            command: 'nginx -v',
+            detach: false,
+            rm: true
+        })
+
+        const nginxVersionMatch = nginxVersionOutput.match(
+            /nginx version: nginx\/(\d+\.\d+\.\d+)/
+        )
+        if (!nginxVersionMatch) {
+            throw new UnknownError(
+                `Unexpected error appeared during ssl terminator config creation\n\n${nginxVersionOutput}`
+            )
+        }
+
+        const nginxVersion = nginxVersionMatch[1]
+
+        const isSSLDirectiveDeprecated = semver.satisfies(
+            nginxVersion,
+            '>=1.25.0'
+        )
+
         try {
             await setConfigFile({
                 configPathname: path.join(
@@ -87,10 +126,10 @@ const createSSLTerminatorConfig = () => ({
                 overwrite: true,
                 templateArgs: {
                     ports,
-                    hostMachine,
+                    ...networkSettings,
                     hostPort,
                     config: overridenConfiguration,
-                    debug
+                    isSSLDirectiveDeprecated
                 }
             })
         } catch (e) {

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

@@ -3,6 +3,7 @@ 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 createPhpFpmDebugConfig = require('./create-php-fpm-debug-config')
 const createPhpStormConfig = require('./create-phpstorm-config')
 const createSSLTerminatorConfig = require('./create-ssl-terminator-config')
 const createVarnishConfig = require('./create-varnish-config')
@@ -19,6 +20,7 @@ const prepareFileSystem = () => ({
                 createSSLTerminatorConfig(),
                 createNginxConfig(),
                 createPhpFpmConfig(),
+                createPhpFpmDebugConfig(),
                 createPhpConfig(),
                 createPhpDebugConfig(),
                 createPhpStormConfig(),

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

@@ -9,6 +9,11 @@ const getJsonFileData = require('../../util/get-jsonfile-data')
 const KnownError = require('../../errors/known-error')
 const UnknownError = require('../../errors/unknown-error')
 const { runPHPContainerCommand } = require('../php/php-container')
+const {
+    setupMagentoFilePermissions,
+    setupComposerCachePermissions
+} = require('./setup-magento/setup-file-permissions')
+const makeBinariesExecutable = require('./setup-magento/make-magento-binaries-executable')
 
 const magentoProductEnterpriseEdition = 'magento/product-enterprise-edition'
 const magentoProductCommunityEdition = 'magento/product-community-edition'
@@ -59,7 +64,8 @@ const adjustComposerJson = async (
                     ? undefined
                     : (t) => {
                           task.output = t
-                      }
+                      },
+                useAutomaticUser: true
             }
         )
     }
@@ -213,30 +219,40 @@ const installMagentoProject = () => ({
             })
         }
 
-        try {
-            await runComposerCommand(ctx, 'install', {
-                callback: !ctx.verbose
-                    ? undefined
-                    : (t) => {
-                          task.output = t
-                      }
-            })
-        } catch (e) {
-            if (
-                e instanceof UnknownError &&
-                e.message.includes('man-in-the-middle attack')
-            ) {
-                throw new KnownError(`Probably you haven't setup pubkeys in composer.
-        Please run ${logger.style.command(
-            'composer diagnose'
-        )} in cli to get mode.\n\n${e}`)
-            }
+        return task.newListr([
+            setupMagentoFilePermissions(),
+            setupComposerCachePermissions(),
+            {
+                title: 'Installing Magento dependencies',
+                task: async () => {
+                    try {
+                        await runComposerCommand(ctx, 'install', {
+                            callback: !ctx.verbose
+                                ? undefined
+                                : (t) => {
+                                      task.output = t
+                                  }
+                        })
+                    } catch (e) {
+                        if (
+                            e instanceof UnknownError &&
+                            e.message.includes('man-in-the-middle attack')
+                        ) {
+                            throw new KnownError(`Probably you haven't setup pubkeys in composer.
+                    Please run ${logger.style.command(
+                        'composer diagnose'
+                    )} in cli to get mode.\n\n${e}`)
+                        }
 
-            throw new UnknownError(
-                `Unexpected error during composer install.\n\n${e}`
-            )
-        }
-        ctx.magentoFirstInstall = true
+                        throw new UnknownError(
+                            `Unexpected error during composer install.\n\n${e}`
+                        )
+                    }
+                    ctx.magentoFirstInstall = true
+                }
+            },
+            makeBinariesExecutable()
+        ])
     },
     options: {
         bottomBar: 10

package/lib/tasks/magento/setup-magento/check-file-permissions.php

@@ -0,0 +1,32 @@
+<?php
+$directories = [
+    '/var',
+    '/generated',
+    '/vendor',
+    '/pub/static',
+    '/pub/media',
+    '/app/etc',
+];
+
+$results = [];
+
+foreach ($directories as $dir) {
+    $directory = getcwd() . $dir;
+    $result = [];
+    $result['exists'] = file_exists($directory);
+    $result['writable'] = is_writable($directory);
+    $result['readable'] = is_readable($directory);
+
+    if ($result['exists']) {
+        $result['owner'] = posix_getpwuid(fileowner($directory));
+        $result['group'] = posix_getgrgid(filegroup($directory));
+        $result['current_user'] = posix_getpwuid(posix_geteuid());
+
+        $result['permissions'] =substr(sprintf('%o', fileperms($directory)), -4);
+        $result['is_current_user_directory_owner'] = $result['current_user'] === $result['owner'];
+    }
+
+    $results[] = $result;
+}
+
+echo json_encode($results, JSON_PRETTY_PRINT);

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

@@ -13,6 +13,7 @@ const urnHighlighter = require('./urn-highlighter')
 const adjustFullPageCache = require('./adjust-full-page-cache')
 const updateEnvPHP = require('../../php/update-env-php')
 const setMailConfig = require('./set-mail-config')
+const { setupMagentoFilePermissions } = require('./setup-file-permissions')
 
 /**
  * @param {Object} [options]
@@ -34,6 +35,7 @@ const setupMagento = (options = {}) => ({
         return task.newListr(
             [
                 waitingForRedis(),
+                setupMagentoFilePermissions(),
                 updateEnvPHP(),
                 migrateDatabase(),
                 flushRedisConfig(),

package/lib/tasks/magento/setup-magento/make-magento-binaries-executable.js

@@ -0,0 +1,44 @@
+// Yes, I know binary files are files in binary format, but this is a common term for executable files
+
+const fs = require('fs')
+const path = require('path')
+const pathExists = require('../../../util/path-exists')
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeBinariesExecutable = () => ({
+    task: async (ctx, task) => {
+        const directoriesWithBinFiles = [
+            path.join(ctx.config.baseConfig.magentoDir, 'bin'),
+            path.join(ctx.config.baseConfig.magentoDir, 'vendor', 'bin')
+        ]
+
+        for (const directory of directoriesWithBinFiles) {
+            if (!(await pathExists(directory))) {
+                continue
+            }
+            const files = await fs.promises.readdir(directory, {
+                withFileTypes: true
+            })
+
+            for (const file of files) {
+                if (!file.isFile()) {
+                    continue
+                }
+
+                const filePath = path.join(directory, file.name)
+                const stats = await fs.promises.stat(filePath)
+
+                if (!filePath.startsWith(file.name) && stats.mode & 0o111) {
+                    continue
+                }
+
+                task.output = `Making ${filePath} executable`
+                await fs.promises.chmod(filePath, 0o755)
+            }
+        }
+    }
+})
+
+module.exports = makeBinariesExecutable

package/lib/tasks/magento/setup-magento/setup-file-permissions.js

@@ -0,0 +1,160 @@
+const os = require('os')
+const fs = require('fs')
+const path = require('path')
+const {
+    runPHPContainerCommandTask,
+    runPHPContainerCommand
+} = require('../../php/php-container')
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeNewFilesCreatedInFolderUseDirectoryGroup = () => ({
+    title: 'Make new files created in folder use directory group',
+    task: (ctx, task) =>
+        task.newListr([
+            runPHPContainerCommandTask(
+                'find var generated vendor pub/static pub/media app/etc -type d -exec chmod g+ws {} +',
+                {
+                    // should prevent command from failing the task
+                    // if the folder does not exist
+                    withCode: true
+                }
+            )
+        ])
+})
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeFilesWritableForGroupMembers = () => ({
+    title: 'Make files writable for group members',
+    task: (ctx, task) =>
+        task.newListr([
+            runPHPContainerCommandTask(
+                'find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +',
+                {
+                    // should prevent command from failing the task
+                    // if the folder does not exist
+                    withCode: true
+                }
+            )
+        ])
+})
+
+/**
+ * @param {string} folder
+ * @param {string | number} user
+ * @param {string | number} [group]
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const makeFolderOwnedByUser = (folder, user, group) => ({
+    title: `Make folder ${folder} owned by ${user} user${
+        group ? ` and ${group} group` : ''
+    }`,
+    task: (ctx, task) =>
+        task.newListr([
+            runPHPContainerCommandTask(
+                `chown -R ${user}${group ? `:${group}` : ''} ${folder}`,
+                {
+                    user: 'root:root'
+                }
+            )
+        ])
+})
+
+/**
+ * @param {import('../../../../typings/context').ListrContext} ctx
+ */
+const doesFileSystemNeedsPermissionsSetup = async (ctx) => {
+    const checkPHPPermissionsFileName = 'check-file-permissions.php'
+    const cacheDirFilePath = path.join(
+        ctx.config.baseConfig.cacheDir,
+        checkPHPPermissionsFileName
+    )
+    await fs.promises.copyFile(
+        path.join(__dirname, checkPHPPermissionsFileName),
+        cacheDirFilePath
+    )
+
+    const result = await runPHPContainerCommand(
+        ctx,
+        `php ${path.relative(process.cwd(), cacheDirFilePath)}`,
+        {
+            user: 'www-data:www-data',
+            cwd: ctx.config.baseConfig.containerMagentoDir
+        }
+    )
+
+    await fs.promises.unlink(cacheDirFilePath)
+
+    /**
+     * @type {{directory: string, exists: boolean, writable: boolean, permissions: string, directory_owner: {name: string, passwd: string, uid: number, gid: number, gecos: string, dir: string, shell: string} | boolean, directory_group: boolean, current_user: {name: string, passwd: string, uid: number, gid: number, gecos: string, dir: string, shell: string} | boolean, is_current_user_directory_owner: boolean}[]}
+     */
+    const parsedResult = JSON.parse(result)
+
+    if (parsedResult.some(({ exists, writable }) => exists && !writable)) {
+        return true
+    }
+
+    return false
+}
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupMagentoFilePermissions = () => ({
+    title: 'Setting Magento file permissions',
+    // skip: true,
+    skip: async (ctx) =>
+        ctx.magentoFirstInstall ||
+        !(await doesFileSystemNeedsPermissionsSetup(ctx)),
+    task: (ctx, task) =>
+        task.newListr(
+            [
+                makeNewFilesCreatedInFolderUseDirectoryGroup(),
+                makeFilesWritableForGroupMembers()
+            ].concat(
+                ctx.isDockerDesktop
+                    ? [
+                          makeFolderOwnedByUser(
+                              ctx.config.baseConfig.containerMagentoDir,
+                              'www-data',
+                              'www-data'
+                          )
+                      ]
+                    : []
+            )
+        )
+})
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const setupComposerCachePermissions = () => ({
+    title: 'Setting Composer Cache permissions',
+    task: (ctx, task) =>
+        task.newListr([
+            ctx.isDockerDesktop
+                ? makeFolderOwnedByUser(
+                      '/composer/home',
+                      'www-data',
+                      'www-data'
+                  )
+                : makeFolderOwnedByUser(
+                      '/composer/home',
+                      os.userInfo().uid,
+                      os.userInfo().gid
+                  ),
+
+            runPHPContainerCommandTask('chmod g+ws /composer/home/cache'),
+            runPHPContainerCommandTask('chmod g+w /composer/home/cache')
+        ])
+})
+
+module.exports = {
+    makeFilesWritableForGroupMembers,
+    makeNewFilesCreatedInFolderUseDirectoryGroup,
+    setupMagentoFilePermissions,
+    setupComposerCachePermissions
+}

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

@@ -55,7 +55,6 @@ const getIsHealthCheckRequestBroken = async (ctx) => {
 const waitingForVarnish = () => ({
     title: 'Waiting for Varnish to return code 200',
     skip: (ctx) =>
-        ctx.debug ||
         !ctx.config.overridenConfiguration.configuration.varnish.enabled ||
         ctx.config.overridenConfiguration.ssl.enabled ||
         !ctx.config.overridenConfiguration.configuration.varnish.healthCheck,

package/lib/tasks/php/php-container.d.ts

@@ -4,16 +4,16 @@ import { ExecAsyncSpawnOptions } from "../../util/exec-async-command";
 export function runPHPContainerCommand<T>(
     ctx: ListrContext,
     command: string,
-    options?: ExecAsyncSpawnOptions<T> & { useXDebugContainer?: boolean }
+    options?: ExecAsyncSpawnOptions<T>
 ): Promise<any>
 
 export function runPHPContainerCommandTask<T>(
     command: string,
-    options?: ExecAsyncSpawnOptions<T> & { useXDebugContainer?: boolean }
+    options?: ExecAsyncSpawnOptions<T>
 ): import('listr2').ListrTask<import('../../../typings/context').ListrContext>
 
 export function execPHPContainerCommand<T>(
     ctx: ListrContext,
     command: string,
-    options?: ExecAsyncSpawnOptions<T> & { useXDebugContainer?: boolean }
+    options?: ExecAsyncSpawnOptions<T>
 ): Promise<any>

package/lib/tasks/php/php-container.js

@@ -1,9 +1,12 @@
 /* eslint-disable no-use-before-define */
+const os = require('os')
 const { deepmerge } = require('../../util/deepmerge')
 const { containerApi } = require('../docker/containers')
 
 /**
- * @type {typeof import('./php-container')['runPHPContainerCommand']}
+ * @param {Parameters<typeof import('./php-container')['runPHPContainerCommand']>[0]} ctx
+ * @param {Parameters<typeof import('./php-container')['runPHPContainerCommand']>[1]} command
+ * @param {Parameters<typeof import('./php-container')['runPHPContainerCommand']>[2] & { useAutomaticUser?: boolean}} [options]
  */
 const runPHPContainerCommand = async (ctx, command, options = {}) => {
     const { php } = ctx.config.docker.getContainers(ctx.ports)
@@ -23,16 +26,21 @@ const runPHPContainerCommand = async (ctx, command, options = {}) => {
             php,
             {
                 detach: false,
-                rm: true
+                rm: true,
+                command
             },
-            options.useXDebugContainer
+            options.user
                 ? {
-                      image: php.debugImage
+                      user: options.user
                   }
                 : {},
-            {
-                command
-            }
+            options.useAutomaticUser
+                ? {
+                      user: ctx.isDockerDesktop
+                          ? 'www-data:www-data'
+                          : `${os.userInfo().uid}:${os.userInfo().gid}`
+                  }
+                : {}
         ),
         options
     )
@@ -70,23 +78,19 @@ const execPHPContainerCommand = async (ctx, command, options = {}) => {
     }
 
     return containerApi.exec(
-        command,
-        php.name,
-        deepmerge(
-            php,
-            options.env
-                ? {
-                      env: options.env
-                  }
-                : {}
-        ),
+        {
+            container: php.name,
+            ...deepmerge(php, options.env ? { env: options.env } : {}),
+            command,
+            ...(options.user ? { user: options.user } : {})
+        },
         options
     )
 }
 
 /**
  * @param {string} command
- * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions<false> & { useXDebugContainer?: boolean, title?: string }} [options]
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions<false> & { title?: string }} [options]
  * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const execPHPContainerCommandTask = (command, options = {}) => ({

package/lib/tasks/php/update-env-php.js

@@ -1,5 +1,4 @@
 const path = require('path')
-const os = require('os')
 const getJsonfileData = require('../../util/get-jsonfile-data')
 const pathExists = require('../../util/path-exists')
 const { containerApi } = require('../docker/containers')
@@ -25,11 +24,10 @@ const updateEnvPHP = () => ({
             ? '127.0.0.1'
             : 'host.docker.internal'
 
-        const useVarnish =
-            !ctx.debug &&
-            ctx.config.overridenConfiguration.configuration.varnish.enabled
-                ? '1'
-                : ''
+        const useVarnish = ctx.config.overridenConfiguration.configuration
+            .varnish.enabled
+            ? '1'
+            : ''
         const varnishHost = hostMachine
         const varnishPort = ctx.ports.varnish
         const previousVarnishPort = ctx.cachedPorts
@@ -66,21 +64,16 @@ const updateEnvPHP = () => ({
                 HOST_MACHINE: hostMachine,
                 PORTS: JSON.stringify(ctx.ports)
             },
-            command: 'php ./update-env-php.php',
+            command: 'php ./update-env.php',
             mountVolumes: [
                 `${path.join(__dirname, 'update-env.php')}:${
                     ctx.config.baseConfig.containerMagentoDir
-                }/update-env-php.php`,
+                }/update-env.php`,
                 `${envPhpPath}:${ctx.config.baseConfig.containerMagentoDir}/env.php`
             ],
             image: php.image,
             detach: false,
-            rm: true,
-            user:
-                (ctx.platform === 'linux' && isDockerDesktop) ||
-                !isDockerDesktop
-                    ? `${os.userInfo().uid}:${os.userInfo().gid}`
-                    : ''
+            rm: true
         })
 
         task.output = result

package/lib/tasks/project-config/index.js

@@ -1,4 +1,3 @@
-const { setProjectConfig } = require('../../config/config')
 const { setPrefix: setPrefixUtil } = require('../../util/prefix')
 
 /**
@@ -14,8 +13,6 @@ const setProjectConfigTask = () => ({
         } = ctx
 
         setPrefixUtil(prefix)
-
-        setProjectConfig('debug', ctx.debug)
     },
     options: {
         showTimer: false

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

@@ -0,0 +1,69 @@
+const semver = require('semver')
+const { execAsync } = require('../../util/exec-async')
+const { systemApi } = require('../docker/system')
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const checkCGroupVersion = () => ({
+    title: 'Checking CGroup version',
+    task: async (ctx, task) => {
+        ctx.cgroupVersion = 'v1'
+
+        let cgroupVersionDetected
+
+        if (ctx.platform === 'linux' && !ctx.isWsl) {
+            const cgroupVersion = await execAsync(`stat -fc %T /sys/fs/cgroup/`)
+
+            if (cgroupVersion && cgroupVersion.includes('cgroup2')) {
+                ctx.cgroupVersion = 'v2'
+
+                cgroupVersionDetected = true
+            } else {
+                const kernelReleaseVersionResult =
+                    ctx.platformVersion.match(/(\d+\.\d+\.\d+)/)
+
+                if (
+                    kernelReleaseVersionResult &&
+                    kernelReleaseVersionResult.length > 0
+                ) {
+                    const kernelVersion = kernelReleaseVersionResult[1]
+
+                    if (semver.satisfies(kernelVersion, '>=6.12.0')) {
+                        ctx.cgroupVersion = 'v2'
+
+                        cgroupVersionDetected = true
+                    } else {
+                        cgroupVersionDetected = true
+                    }
+                }
+            }
+        }
+
+        if (!cgroupVersionDetected) {
+            const dockerSystemVersions = await systemApi.version({
+                formatToJSON: true
+            })
+
+            const kernelReleaseVersionResult =
+                dockerSystemVersions.Server.KernelVersion.match(
+                    /(\d+\.\d+\.\d+)/
+                )
+
+            if (
+                kernelReleaseVersionResult &&
+                kernelReleaseVersionResult.length > 0
+            ) {
+                const kernelVersion = kernelReleaseVersionResult[1]
+
+                if (semver.satisfies(kernelVersion, '>=6.12.0')) {
+                    ctx.cgroupVersion = 'v2'
+                }
+            }
+        }
+
+        task.title = `Using CGroup ${ctx.cgroupVersion}`
+    }
+})
+
+module.exports = checkCGroupVersion