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

package/lib/tasks/database/import-dump-to-database.js

@@ -39,14 +39,16 @@ const copyDatabaseDumpIntoContainer = () => ({
 const runSetGlobalLogBinTrustFunctionCreatorsCommand = () => ({
     task: async (ctx, task) => {
         const {
-            config: { docker },
+            config: { docker, overridenConfiguration },
             ports
         } = ctx
         const { mariadb } = docker.getContainers(ports)
 
+        const { binFileName } = overridenConfiguration.configuration.mariadb
+
         return task.newListr(
             execCommandTask(
-                `docker exec ${mariadb.name} bash -c 'mysql -uroot -p${mariadb.env.MARIADB_ROOT_PASSWORD} -e "SET GLOBAL log_bin_trust_function_creators = 1;"'`
+                `docker exec ${mariadb.name} bash -c '${binFileName} -uroot -p${mariadb.env.MARIADB_ROOT_PASSWORD} -e "SET GLOBAL log_bin_trust_function_creators = 1;"'`
             )
         )
     }
@@ -95,10 +97,11 @@ Note that you will lose your existing database!`,
 const executeImportDumpSQL = () => ({
     task: async (ctx, task) => {
         const {
-            config: { docker },
+            config: { docker, overridenConfiguration },
             ports
         } = ctx
         const { mariadb } = docker.getContainers(ports)
+        const { binFileName } = overridenConfiguration.configuration.mariadb
 
         const userCredentialsForMariaDBCLI = await task.prompt({
             type: 'Select',
@@ -117,7 +120,7 @@ const executeImportDumpSQL = () => ({
             ]
         })
 
-        const importCommand = `docker exec ${mariadb.name} bash -c "mysql ${userCredentialsForMariaDBCLI} magento < ./dump.sql"`
+        const importCommand = `docker exec ${mariadb.name} bash -c "${binFileName} ${userCredentialsForMariaDBCLI} magento < ./dump.sql"`
 
         const startImportTime = Date.now()
         const tickInterval = setInterval(() => {

package/lib/tasks/database/import-remote-db/ssh/index.js

@@ -1,5 +1,5 @@
 const os = require('os')
-const { NodeSSH } = require('node-ssh')
+const { NodeSSH } = require('node-ssh-no-cpu-features')
 const pathExists = require('../../../../util/path-exists')
 const regularSSHServer = require('./regular-server')
 const readymageSSH = require('./readymage')

package/lib/tasks/database/import-remote-db/ssh/readymage.js

@@ -4,7 +4,7 @@ const { execAsyncSpawn } = require('../../../../util/exec-async-command')
 const databaseDumpCommandWithOptions = require('./database-dump-command')
 
 /**
- * @returns {import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh').NodeSSH }>}
+ * @returns {import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh-no-cpu-features').NodeSSH }>}
  */
 const readymageSSH = () => ({
     task: async (ctx, task) => {

package/lib/tasks/database/import-remote-db/ssh/regular-server.js

@@ -4,7 +4,7 @@ const { execAsyncSpawn } = require('../../../../util/exec-async-command')
 const databaseDumpCommandWithOptions = require('./database-dump-command')
 const KnownError = require('../../../../errors/known-error')
 /**
- * @returns {import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh').NodeSSH }>}
+ * @returns {import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh-no-cpu-features').NodeSSH }>}
  */
 const regularSSHServer = () => ({
     task: async (ctx, task) => {

package/lib/tasks/docker/containers/container-api.d.ts

@@ -63,6 +63,11 @@ export interface ContainerExecOptions {
      * Allocate a pseudo-TTY
      */
     tty?: boolean
+
+    /**
+     * Keep STDIN open even if not attached
+     */
+    interactive?: boolean
 }
 
 export function exec<T>(

package/lib/tasks/docker/containers/container-api.js

@@ -103,7 +103,7 @@ const run = (options, execOptions = {}) =>
  * @param {import('./container-api').ContainerExecOptions} options
  */
 const execCommand = (options) => {
-    const { command, container, env, tty, user, workdir } = options
+    const { command, container, env, tty, user, workdir, interactive } = options
     const envArgs = !env
         ? ''
         : Object.entries(env)
@@ -112,6 +112,7 @@ const execCommand = (options) => {
     const ttyArg = tty ? '--tty' : ''
     const userArg = user ? `--user=${user}` : ''
     const workdirArg = workdir ? `--workdir=${workdir}` : ''
+    const interactiveArg = interactive ? '--interactive' : ''
 
     const dockerCommand = [
         'docker',
@@ -119,6 +120,7 @@ const execCommand = (options) => {
         'exec',
         envArgs,
         ttyArg,
+        interactiveArg,
         userArg,
         workdirArg,
         container,

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

@@ -169,9 +169,11 @@ const buildDockerFileInstructions = async (
         }
     }
 
-    if (!ctx.isDockerDesktop) {
+    if (ctx.platform === 'linux') {
+        const { gid, username } = os.userInfo()
         dockerFileInstructions.run(
-            `chown -R ${os.userInfo().uid}:${os.userInfo().gid} /composer/home`
+            `addgroup -g ${gid} ${username} && adduser -u ${gid} -G ${username} -H -s /sbin/nologin -D ${username} && \
+                addgroup www-data ${username}`
         )
     }
 
@@ -286,58 +288,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-php-fpm-config.js

@@ -1,3 +1,4 @@
+const os = require('os')
 const UnknownError = require('../../errors/unknown-error')
 const setConfigFile = require('../../util/set-config')
 
@@ -13,13 +14,17 @@ const createPhpFpmConfig = () => ({
         } = ctx
         const port = !isDockerDesktop ? ctx.ports.fpm : 9000
 
+        const user =
+            ctx.platform === 'linux' ? os.userInfo().username : 'www-data'
+
         try {
             await setConfigFile({
                 configPathname: php.fpmConfPath,
                 template: php.fpmTemplatePath,
                 overwrite: true,
                 templateArgs: {
-                    port
+                    port,
+                    user
                 }
             })
         } catch (e) {

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

@@ -1,3 +1,4 @@
+const os = require('os')
 const UnknownError = require('../../errors/unknown-error')
 const setConfigFile = require('../../util/set-config')
 
@@ -13,13 +14,17 @@ const createPhpFpmDebugConfig = () => ({
         } = ctx
         const port = !isDockerDesktop ? ctx.ports.fpmXdebug : 9000
 
+        const user =
+            ctx.platform === 'linux' ? os.userInfo().username : 'www-data'
+
         try {
             await setConfigFile({
                 configPathname: php.debugFpmConfPath,
                 template: php.fpmTemplatePath,
                 overwrite: true,
                 templateArgs: {
-                    port
+                    port,
+                    user
                 }
             })
         } catch (e) {

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
                 }
             })