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

package/lib/config/versions/magento-2.4.8.js

@@ -0,0 +1,43 @@
+const sodium = require('../services/php/extensions/sodium')
+const ftp = require('../services/php/extensions/ftp')
+const {
+    magento24PHPExtensionList
+} = require('../magento/required-php-extensions')
+const { php83 } = require('../services/php/versions')
+const { sslTerminator } = require('../services/ssl-terminator')
+const { varnish76 } = require('../services/varnish')
+const { repo } = require('../services/php/base-repo')
+const { nginx126 } = require('../services/nginx/versions')
+const { composer28 } = require('../services/composer/versions')
+const { maildev } = require('../services/maildev')
+const { valkey80 } = require('../services/redis')
+const { mariadb114 } = require('../services/mariadb/versions')
+const { elasticsearch817 } = require('../services/elasticsearch/versions')
+const { mysql80 } = require('../services/mysql/versions')
+const { opensearch219 } = require('../services/opensearch/versions')
+
+/**
+ * @type {import('../../../typings/common').MagentoVersionConfigurationFunction}
+ */
+module.exports = ({ templateDir }) => ({
+    magentoVersion: '2.4.8',
+    isDefault: true,
+    configuration: {
+        php: php83({
+            templateDir,
+            extensions: { ...magento24PHPExtensionList, sodium, ftp },
+            baseImage: `${repo}:php-8.3-magento-2.4`
+        }),
+        nginx: nginx126({ templateDir }),
+        redis: valkey80(),
+        mysql: mysql80(),
+        mariadb: mariadb114(),
+        elasticsearch: elasticsearch817(),
+        composer: composer28(),
+        varnish: varnish76({ templateDir }),
+        sslTerminator: sslTerminator({ templateDir }),
+        maildev: maildev(),
+        opensearch: opensearch219(),
+        searchengine: 'opensearch'
+    }
+})

package/lib/tasks/database/create-magento-database.js

@@ -7,12 +7,14 @@ const { containerApi } = require('../docker/containers')
 const createMagentoDatabase = () => ({
     title: 'Creating Magento database',
     task: async (ctx, task) => {
+        const { configuration } = ctx.config.overridenConfiguration
         const { mariadb } = ctx.config.docker.getContainers()
         task.title = `Creating Magento database in ${mariadb._}`
-        await containerApi.exec(
-            `mysql -uroot -p${mariadb.env.MARIADB_ROOT_PASSWORD} -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`,
-            mariadb.name
-        )
+
+        await containerApi.exec({
+            command: `${configuration.mariadb.binFileName} -uroot -p${mariadb.env.MARIADB_ROOT_PASSWORD} -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`,
+            container: mariadb.name
+        })
     }
 })
 

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

@@ -38,6 +38,12 @@ export function ls(
 ): Promise<ContainerLsResult[]>
 
 export interface ContainerExecOptions {
+    command: string
+
+    /**
+     * container id or name
+     */
+    container: string
     /**
      * Set environment variables [docs](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file)
      */
@@ -57,15 +63,20 @@ export interface ContainerExecOptions {
      * Allocate a pseudo-TTY
      */
     tty?: boolean
+
+    /**
+     * Keep STDIN open even if not attached
+     */
+    interactive?: boolean
 }
 
 export function exec<T>(
-    command: string,
-    container: string,
-    options?: ContainerExecOptions,
+    options: ContainerExecOptions,
     execOptions?: ExecAsyncSpawnOptions<T>
 ): Promise<string>
 
+export function execCommand(options: ContainerExecOptions): string[]
+
 export interface ContainerRunOptions {
     /**
      * Add a custom host-to-IP mapping (host:ip)

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

@@ -100,13 +100,10 @@ const run = (options, execOptions = {}) =>
     execAsyncSpawn(runCommand(options).join(' '), execOptions)
 
 /**
- * @param {string} command
- * @param {string} container container id or name
  * @param {import('./container-api').ContainerExecOptions} options
- * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
  */
-const exec = (command, container, options = {}, execOptions = {}) => {
-    const { env, tty, user, workdir } = options
+const execCommand = (options) => {
+    const { command, container, env, tty, user, workdir, interactive } = options
     const envArgs = !env
         ? ''
         : Object.entries(env)
@@ -115,24 +112,33 @@ const exec = (command, container, options = {}, execOptions = {}) => {
     const ttyArg = tty ? '--tty' : ''
     const userArg = user ? `--user=${user}` : ''
     const workdirArg = workdir ? `--workdir=${workdir}` : ''
+    const interactiveArg = interactive ? '--interactive' : ''
 
-    const execCommand = [
+    const dockerCommand = [
         'docker',
         'container',
         'exec',
         envArgs,
         ttyArg,
+        interactiveArg,
         userArg,
         workdirArg,
         container,
         command
     ]
-        .filter(Boolean)
-        .join(' ')
+        .flat()
+        .filter((arg) => !!arg && typeof arg === 'string')
 
-    return execAsyncSpawn(execCommand, execOptions)
+    return dockerCommand
 }
 
+/**
+ * @param {import('./container-api').ContainerExecOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const exec = (options, execOptions = {}) =>
+    execAsyncSpawn(execCommand(options).join(' '), execOptions)
+
 /**
  * @type {typeof import('./container-api')['ls']}
  */
@@ -243,6 +249,7 @@ module.exports = {
     run,
     runCommand,
     exec,
+    execCommand,
     ls,
     logs,
     stop,

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

@@ -34,6 +34,17 @@ const remoteImageReducer = (acc, val) => {
     return acc.concat([val.image])
 }
 
+/**
+ * @param {{ pullImage?: boolean }} param0
+ */
+const filterNonPullableImages = ({ pullImage }) => {
+    if (typeof pullImage === 'boolean' && !pullImage) {
+        return false
+    }
+
+    return true
+}
+
 /**
  * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
@@ -45,6 +56,7 @@ const pullImages = () => ({
         if (pullImages) {
             return task.newListr(
                 containers
+                    .filter(filterNonPullableImages)
                     .reduce(remoteImageReducer, [])
                     .map((image) => {
                         const [repo, tag = 'latest'] = image.split(':')
@@ -77,6 +89,7 @@ const pullImages = () => ({
         }
 
         const imagesFilter = containers
+            .filter(filterNonPullableImages)
             .reduce(remoteImageReducer, [])
             .map((image) => `reference='${image}'`)
 
@@ -86,6 +99,7 @@ const pullImages = () => ({
         })
 
         const missingContainerImages = containers
+            .filter(filterNonPullableImages)
             .reduce(remoteImageReducer, [])
             .map((image) => {
                 const [repo, tag = 'latest'] = image.split(':')
@@ -134,48 +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) => {
-                        if (container.debugImage) {
-                            container.image = container.debugImage
-                        }
+        const containerStatuses = missingContainers.reduce(
+            (acc, container) => ({
+                ...acc,
+                [container.nameWithoutPrefix]: {
+                    started: false,
+                    onStarted: []
+                }
+            }),
+            {}
+        )
 
-                        return container
-                    })
-                    .map((container) =>
-                        containerApi.run(container).then((out) => {
-                            task.output = `From ${container._}: ${out}`
-                        })
-                    )
-            )
+        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()
+                                            }
+                                        )
+                                    })
+                            )
+                        )
+                    }
 
-            return
-        }
+                    subTask.title = `${container._} is starting...`
 
-        // TODO: we might stop containers here ?
-        await Promise.all(
-            missingContainers.map((container) =>
-                containerApi.run(container).then((out) => {
-                    task.output = `From ${container._}: ${out}`
-                })
-            )
+                    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/convert-mysql-to-mariadb.js

@@ -11,10 +11,7 @@ const {
     getCachedPorts
 } = require('../../config/get-port-config')
 const { saveConfiguration } = require('../../config/save-config')
-const {
-    buildProjectImage,
-    buildDebugProjectImage
-} = require('./project-image-builder')
+const { buildProjectImage } = require('./project-image-builder')
 const checkPHPVersion = require('../requirements/php-version')
 const { getComposerVersionTask } = require('../composer')
 const { prepareFileSystem } = require('../file-system')
@@ -190,15 +187,18 @@ Please wait, this will take some time and do not restart the MySQL container unt
                 task.output = 'Dumping MySQL database to dump file...'
 
                 await containerApi.exec(
-                    [
-                        'mysqldump',
-                        '--user=root',
-                        '--password=scandipwa',
-                        'magento',
-                        `--result-file=${path.parse(pathToMySQLDumpFile).base}`
-                    ].join(' '),
-                    containerName,
-                    {},
+                    {
+                        container: containerName,
+                        command: [
+                            'mysqldump',
+                            '--user=root',
+                            '--password=scandipwa',
+                            'magento',
+                            `--result-file=${
+                                path.parse(pathToMySQLDumpFile).base
+                            }`
+                        ].join(' ')
+                    },
                     {
                         callback: (t) => {
                             task.output = t
@@ -234,15 +234,7 @@ Please wait, this will take some time and do not restart the MySQL container unt
                     pullImages(),
                     dockerNetwork.tasks.createNetwork(),
                     createVolumes(),
-                    {
-                        task: (ctx, task) =>
-                            task.newListr(
-                                [buildProjectImage(), buildDebugProjectImage()],
-                                {
-                                    concurrent: true
-                                }
-                            )
-                    },
+                    buildProjectImage(),
                     {
                         task: (ctx, subTask) =>
                             subTask.newListr(