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

package/lib/tasks/docker/containers/tasks.js

@@ -148,40 +148,105 @@ const pullImages = () => ({
  */
 const startContainers = () => ({
     title: 'Starting containers',
-    task: async ({ ports, config: { docker }, debug }, task) => {
+    task: async ({ ports, config: { docker } }, task) => {
         const containerList = await containerApi.ls({
             formatToJSON: true,
             all: true
         })
 
-        const missingContainers = Object.values(
-            docker.getContainers(ports)
-        ).filter(({ name }) => !containerList.some((c) => c.Names === name))
+        const missingContainers = Object.entries(docker.getContainers(ports))
+            .filter(
+                ([nameWithoutPrefix, { name }]) =>
+                    !containerList.some((c) => c.Names === name)
+            )
+            .map(([nameWithoutPrefix, containerOptions]) => ({
+                ...containerOptions,
+                nameWithoutPrefix
+            }))
 
         if (missingContainers.length === 0) {
             task.skip()
             return
         }
 
-        if (debug) {
-            await Promise.all(
-                missingContainers.map((container) =>
-                    containerApi.run(container).then((out) => {
-                        task.output = `From ${container._}: ${out}`
-                    })
-                )
-            )
+        const containerStatuses = missingContainers.reduce(
+            (acc, container) => ({
+                ...acc,
+                [container.nameWithoutPrefix]: {
+                    started: false,
+                    onStarted: []
+                }
+            }),
+            {}
+        )
 
-            return
-        }
+        return task.newListr(
+            missingContainers.map((container) => ({
+                title: `Deploying ${logger.style.file(container._)} container`,
+                task: async (subCtx, subTask) => {
+                    const { dependsOn } = container
+                    if (Array.isArray(dependsOn)) {
+                        const startedContainers = []
+                        subTask.title = `Container ${
+                            container._
+                        } is waiting for ${dependsOn.join(', ')} to start...`
+                        await Promise.all(
+                            dependsOn.map(
+                                async (name) =>
+                                    new Promise((resolve, reject) => {
+                                        const timeout = setTimeout(
+                                            () => {
+                                                reject(
+                                                    new Error(
+                                                        `Container ${name} not started in time`
+                                                    )
+                                                )
+                                            },
+                                            // 2 minutes
+                                            1000 * 60 * 2
+                                        )
+                                        containerStatuses[name].onStarted.push(
+                                            () => {
+                                                startedContainers.push(name)
+                                                subTask.title = `Container ${
+                                                    container._
+                                                } is waiting for ${dependsOn
+                                                    .filter(
+                                                        (d) =>
+                                                            !startedContainers.includes(
+                                                                d
+                                                            )
+                                                    )
+                                                    .join(', ')} to start...`
+                                                clearTimeout(timeout)
+                                                resolve()
+                                            }
+                                        )
+                                    })
+                            )
+                        )
+                    }
 
-        // TODO: we might stop containers here ?
-        await Promise.all(
-            missingContainers.map((container) =>
-                containerApi.run(container).then((out) => {
-                    task.output = `From ${container._}: ${out}`
-                })
-            )
+                    subTask.title = `${container._} is starting...`
+
+                    await containerApi.run(container)
+
+                    containerStatuses[
+                        container.nameWithoutPrefix
+                    ].started = true
+                    containerStatuses[
+                        container.nameWithoutPrefix
+                    ].onStarted.forEach((cb) => {
+                        cb()
+                    })
+
+                    subTask.output = `${container._} container started`
+                }
+            })),
+            {
+                concurrent: true,
+                exitOnError: true
+            }
         )
     },
     options: {

package/lib/tasks/docker/project-image-builder.js

@@ -170,9 +170,8 @@ const buildDockerFileInstructions = async (
     }
 
     if (!ctx.isDockerDesktop) {
-        dockerFileInstructions.run(
-            `chown -R ${os.userInfo().uid}:${os.userInfo().gid} /composer/home`
-        )
+        const { uid, gid } = os.userInfo()
+        dockerFileInstructions.run(`chown -R ${uid}:${gid} /composer/home`)
     }
 
     dockerFileInstructions.workDir(ctx.config.baseConfig.containerMagentoDir)
@@ -286,58 +285,69 @@ const buildProjectImage = () => ({
     title: 'Building Project Images',
     task: async (ctx, task) => {
         const containers = ctx.config.docker.getContainers(ctx.ports)
-        const [image, tag = 'latest'] =
-            ctx.config.overridenConfiguration.configuration.php.baseImage.split(
-                ':'
-            )
-        const dockerFileInstructions = await buildDockerFileInstructions(ctx, {
-            image,
-            tag,
-            ignorePHPExtensions: ['xdebug']
-        })
 
-        try {
-            await execAsyncSpawn(
-                `docker build -t ${containers.php.image} -<<EOF
+        return task.newListr([
+            {
+                title: 'Building PHP image',
+                task: async () => {
+                    const [image, tag = 'latest'] =
+                        ctx.config.overridenConfiguration.configuration.php.baseImage.split(
+                            ':'
+                        )
+                    const dockerFileInstructions =
+                        await buildDockerFileInstructions(ctx, {
+                            image,
+                            tag,
+                            ignorePHPExtensions: ['xdebug']
+                        })
+
+                    try {
+                        await execAsyncSpawn(
+                            `docker build -t ${containers.php.image} -<<EOF
 ${dockerFileInstructions}
 EOF`,
-                {
-                    callback: (r) => {
-                        task.output = r
+                            {
+                                callback: (r) => {
+                                    task.output = r
+                                }
+                            }
+                        )
+                    } catch (e) {
+                        throw new KnownError(
+                            `Unexpected error during PHP image building!\n\n${e}`
+                        )
                     }
                 }
-            )
-        } catch (e) {
-            throw new KnownError(
-                `Unexpected error during project image building!\n\n${e}`
-            )
-        }
-
-        const [phpImage, phpTag] = containers.php.image.split(':')
-        const debugImageInstructions = await buildDebugDockerFileInstructions(
-            ctx,
+            },
             {
-                image: phpImage,
-                tag: phpTag
-            }
-        )
-
-        try {
-            await execAsyncSpawn(
-                `docker build -t ${containers.phpWithXdebug.image} -<<EOF
+                title: 'Building PHP with XDebug image',
+                task: async () => {
+                    const [phpImage, phpTag] = containers.php.image.split(':')
+                    const debugImageInstructions =
+                        await buildDebugDockerFileInstructions(ctx, {
+                            image: phpImage,
+                            tag: phpTag
+                        })
+
+                    try {
+                        await execAsyncSpawn(
+                            `docker build -t ${containers.phpWithXdebug.image} -<<EOF
 ${debugImageInstructions}
 EOF`,
-                {
-                    callback: (r) => {
-                        task.output = r
+                            {
+                                callback: (r) => {
+                                    task.output = r
+                                }
+                            }
+                        )
+                    } catch (e) {
+                        throw new KnownError(
+                            `Unexpected error during PHP with XDebug image building!\n\n${e}`
+                        )
                     }
                 }
-            )
-        } catch (e) {
-            throw new KnownError(
-                `Unexpected error during project image building!\n\n${e}`
-            )
-        }
+            }
+        ])
     },
     options: {
         bottomBar: 10

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

@@ -69,3 +69,69 @@ export function df(
     options?: SystemDFOptions<true>,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<SystemDFResult>
+
+export interface SystemVersionOptions<T extends boolean = false> {
+    format?: string
+    formatToJSON?: T
+    verbose?: boolean
+}
+
+interface DockerServiceComponent {
+    Name: string;
+    Version: string;
+    Details: {
+        ApiVersion?: string;
+        Arch?: string;
+        BuildTime?: string;
+        Experimental?: string;
+        GitCommit?: string;
+        GoVersion?: string;
+        KernelVersion?: string;
+        MinAPIVersion?: string;
+        Os?: string;
+    };
+}
+interface DockerServerInfo {
+    Platform: {
+        Name: string;
+    };
+    Components: DockerServiceComponent[];
+    Version: string;
+    ApiVersion: string;
+    MinAPIVersion: string;
+    GitCommit: string;
+    GoVersion: string;
+    Os: string;
+    Arch: string;
+    KernelVersion: string;
+    BuildTime: string;
+}
+
+interface DockerClientInfo {
+    Platform: {
+        Name: string;
+    };
+    Version: string;
+    ApiVersion: string;
+    DefaultAPIVersion: string;
+    GitCommit: string;
+    GoVersion: string;
+    Os: string;
+    Arch: string;
+    BuildTime: string;
+    Context: string;
+}
+
+export interface SystemVersionResult {
+    Client: DockerClientInfo
+    Server: DockerServerInfo
+}
+
+export function version(
+    options?: SystemVersionOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function version(
+    options?: SystemVersionOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<SystemVersionResult>

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

@@ -27,6 +27,33 @@ const df = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker system df ${args}`, execOptions)
 }
 
+/**
+ * @param {import('./system-api').SystemVersionOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const version = async (options, execOptions = {}) => {
+    const { format, formatToJSON } = options
+
+    const formatArg =
+        !formatToJSON && format
+            ? `--format=${format}`
+            : formatToJSON && "--format='{{json .}}'"
+
+    const args = [formatArg].filter(Boolean).join(' ')
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(
+            `docker version ${args}`,
+            execOptions
+        )
+
+        return JSON.parse(result)
+    }
+
+    return execAsyncSpawn(`docker version ${args}`, execOptions)
+}
+
 module.exports = {
-    df
+    df,
+    version
 }

package/lib/tasks/execute.js

@@ -102,7 +102,7 @@ const executeTask = async (argv) => {
             return result
         }
 
-        if (container.name.endsWith('php')) {
+        if (container.name.includes('php')) {
             if (process.stdout.isTTY) {
                 logger.logN(
                     `Starting container ${logger.style.misc(

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

@@ -10,7 +10,7 @@ const createNginxConfig = () => ({
     task: async (ctx) => {
         const {
             ports,
-            config: { overridenConfiguration, baseConfig },
+            config: { overridenConfiguration, baseConfig, docker },
             isDockerDesktop
         } = ctx
 
@@ -19,10 +19,26 @@ const createNginxConfig = () => ({
             storeDomains
         } = overridenConfiguration
 
-        const hostMachine = !isDockerDesktop
-            ? '127.0.0.1'
-            : 'host.docker.internal'
-        const hostPort = !isDockerDesktop ? ports.app : 80
+        const networkSettings = {
+            phpNetwork: '127.0.0.1',
+            phpWithXdebugNetwork: '127.0.0.1',
+            fpmPort: ports.fpm,
+            fpmXdebugPort: ports.fpmXdebug,
+            hostPort: ports.app
+        }
+
+        if (isDockerDesktop) {
+            const containers = docker.getContainers(ports)
+
+            networkSettings.phpNetwork = containers.php.name
+            networkSettings.phpWithXdebugNetwork = containers.phpWithXdebug.name
+
+            networkSettings.fpmPort = 9000
+            networkSettings.fpmXdebugPort = 9001
+
+            networkSettings.hostPort = 80
+        }
+
         const useStoreDomainMapping =
             storeDomains && Object.keys(storeDomains).length > 1
 
@@ -37,10 +53,8 @@ const createNginxConfig = () => ({
                 template: nginx.configTemplate,
                 overwrite: true,
                 templateArgs: {
-                    ports,
+                    ...networkSettings,
                     mageRoot: baseConfig.containerMagentoDir,
-                    hostMachine,
-                    hostPort,
                     config: overridenConfiguration,
                     storeDomains,
                     useStoreDomainMapping

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

@@ -15,8 +15,7 @@ const createSSLTerminatorConfig = () => ({
     task: async (ctx) => {
         const {
             ports,
-            config: { overridenConfiguration, baseConfig },
-            debug,
+            config: { overridenConfiguration, baseConfig, docker },
             isDockerDesktop
         } = ctx
 
@@ -72,9 +71,24 @@ 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({
@@ -112,10 +126,9 @@ const createSSLTerminatorConfig = () => ({
                 overwrite: true,
                 templateArgs: {
                     ports,
-                    hostMachine,
+                    ...networkSettings,
                     hostPort,
                     config: overridenConfiguration,
-                    debug,
                     isSSLDirectiveDeprecated
                 }
             })

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