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

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

@@ -35,36 +35,41 @@ const getEnabledExtensionsFromImage = async (imageWithTag) => {
 }
 
 /**
- * @type {(builder: DockerFileBuilder, ctx: import('../../../typings/context').ListrContext) => ([extensionName, extensionInstructions]: [string, import('../../../typings').PHPExtensionInstallationInstruction]) => Promise<void>}
+ * @type {(builder: DockerFileBuilder, ctx: import('../../../typings/context').ListrContext, [extensionName, extensionInstructions]: [string, import('../../../typings').PHPExtensionInstallationInstruction]) => Promise<void>}
  */
-const addExtensionToBuilder =
-    (builder, ctx) =>
-    async ([extensionName, extensionInstructions]) => {
-        const { command, ...extensionInstructionsWithoutCommand } =
-            extensionInstructions
-        let runCommand = ''
-        if (typeof command === 'string') {
-            runCommand += ` ${command}`
-        } else if (typeof command === 'function') {
-            runCommand += ` ${await Promise.resolve(
-                command({ ...extensionInstructionsWithoutCommand, ctx })
-            )}`
-        } else {
-            runCommand += ` docker-php-ext-install ${
-                extensionInstructionsWithoutCommand.name || extensionName
-            }`
-        }
-        builder
-            .comment(`extension ${extensionName} installation command`)
-            .run(runCommand.trim())
+const addExtensionToBuilder = async (
+    builder,
+    ctx,
+    [extensionName, extensionInstructions]
+) => {
+    const { command, ...extensionInstructionsWithoutCommand } =
+        extensionInstructions
+    let runCommand = ''
+    if (typeof command === 'string') {
+        runCommand += ` ${command}`
+    } else if (typeof command === 'function') {
+        runCommand += ` ${await Promise.resolve(
+            command({ ...extensionInstructionsWithoutCommand, ctx })
+        )}`
+    } else {
+        runCommand += ` docker-php-ext-install ${
+            extensionInstructionsWithoutCommand.name || extensionName
+        }`
     }
+    builder
+        .comment(`extension ${extensionName} installation command`)
+        .run(runCommand.trim())
+}
 
 /**
  * @param {import('../../../typings/context').ListrContext} ctx
- * @param {{ image: string, tag: string}} param1
+ * @param {{ image: string, tag: string, ignorePHPExtensions?: string[] }} param1
  */
-const buildDockerFileInstructions = async (ctx, { image, tag }) => {
-    const { composer } = ctx.config.overridenConfiguration.configuration
+const buildDockerFileInstructions = async (
+    ctx,
+    { image, tag, ignorePHPExtensions = [] }
+) => {
+    const { composer, php } = ctx.config.overridenConfiguration.configuration
     const existingPHPExtensions = await getEnabledExtensionsFromImage(
         `${image}:${tag}`
     )
@@ -73,9 +78,11 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         formatToJSON: true
     })
 
-    const missingExtensions = Object.entries(
-        ctx.config.overridenConfiguration.configuration.php.extensions
-    )
+    const missingExtensions = Object.entries(php.extensions)
+        .filter(
+            ([extensionName]) =>
+                !ignorePHPExtensions.includes(extensionName.toLowerCase())
+        )
         .filter(
             ([extensionName, extensionInstructions]) =>
                 !Object.entries(existingPHPExtensions)
@@ -89,7 +96,6 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
                                     .includes(n))
                     )
         )
-        .filter(([extensionName]) => extensionName.toLowerCase() !== 'xdebug')
 
     const dockerFileInstructions = new DockerFileBuilder()
         .comment('project image')
@@ -112,8 +118,9 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         for (const missingExtensionInstructions of missingExtensions) {
             await addExtensionToBuilder(
                 dockerFileInstructions,
-                ctx
-            )(missingExtensionInstructions)
+                ctx,
+                missingExtensionInstructions
+            )
         }
     }
 
@@ -163,9 +170,8 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
     }
 
     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)
@@ -191,9 +197,10 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         })
     }
 
-    if (ctx.config.overridenConfiguration.configuration.newRelic.enabled) {
-        const { agentVersion, licenseKey } =
-            ctx.config.overridenConfiguration.configuration.newRelic
+    const { newRelic } = ctx.config.overridenConfiguration.configuration
+
+    if (newRelic && newRelic.enabled) {
+        const { agentVersion, licenseKey } = newRelic
 
         // eslint-disable-next-line max-len
         dockerFileInstructions.run('apk add --no-cache gcompat')
@@ -212,79 +219,135 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
 \\$PHP_INI_DIR/conf.d/newrelic.ini`)
     }
 
-    return dockerFileInstructions
+    return dockerFileInstructions.build()
 }
 
 /**
- * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @param {import('../../../typings/context').ListrContext} ctx
+ * @param {{ image: string, tag: string }} param1
  */
-const buildProjectImage = () => ({
-    title: 'Building Project Image',
-    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
-        })
+const buildDebugDockerFileInstructions = async (ctx, { image, tag }) => {
+    const { php } = ctx.config.overridenConfiguration.configuration
+    const existingPHPExtensions = await getEnabledExtensionsFromImage(
+        `${image}:${tag}`
+    )
 
-        try {
-            await execAsyncSpawn(
-                `docker build -t ${containers.php.image} -<<EOF
-${dockerFileInstructions.build()}
-EOF`,
-                {
-                    callback: (r) => {
-                        task.output = r
-                    }
-                }
+    const missingExtensions = Object.entries(php.extensions)
+        .filter(([extensionName]) => extensionName.toLowerCase() === 'xdebug')
+        .filter(
+            ([extensionName, extensionInstructions]) =>
+                !Object.entries(existingPHPExtensions)
+                    .map(([n, i]) => [n.toLowerCase(), i])
+                    .some(
+                        ([n]) =>
+                            extensionName === n ||
+                            (extensionInstructions.alternativeName &&
+                                extensionInstructions.alternativeName
+                                    .map((s) => s.toLowerCase())
+                                    .includes(n))
+                    )
+        )
+
+    const dockerFileInstructions = new DockerFileBuilder()
+        .comment('project image')
+        .from({ image, tag })
+
+    if (missingExtensions.length > 0) {
+        const allDependencies = missingExtensions
+            .map(
+                ([_extensionName, extensionInstructions]) =>
+                    extensionInstructions.dependencies || []
             )
-        } catch (e) {
-            throw new KnownError(
-                `Unexpected error during project image building!\n\n${e}`
+            .reduce(
+                (acc, val) => acc.concat(val.filter((ex) => !acc.includes(ex))),
+                []
+            )
+
+        dockerFileInstructions.run(
+            `apk add --no-cache ${allDependencies.join(' ')}`
+        )
+        for (const missingExtensionInstructions of missingExtensions) {
+            await addExtensionToBuilder(
+                dockerFileInstructions,
+                ctx,
+                missingExtensionInstructions
             )
         }
-    },
-    options: {
-        bottomBar: 10
     }
-})
+
+    return dockerFileInstructions.build()
+}
 
 /**
  * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const buildDebugProjectImage = () => ({
-    title: 'Building Debug Project Image',
+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.debugImage.split(
-                ':'
-            )
-        const dockerFileInstructions = await buildDockerFileInstructions(ctx, {
-            image,
-            tag
-        })
 
-        try {
-            await execAsyncSpawn(
-                `docker build -t ${containers.php.debugImage} -<<EOF
-${dockerFileInstructions.build()}
+        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 debug project image building!\n\n${e}`
-            )
-        }
+            },
+            {
+                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
+                                }
+                            }
+                        )
+                    } catch (e) {
+                        throw new KnownError(
+                            `Unexpected error during PHP with XDebug image building!\n\n${e}`
+                        )
+                    }
+                }
+            }
+        ])
     },
     options: {
         bottomBar: 10
@@ -293,6 +356,5 @@ EOF`,
 
 module.exports = {
     buildProjectImage,
-    buildDebugProjectImage,
     getEnabledExtensionsFromImage
 }

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

@@ -15,7 +15,7 @@ const KnownError = require('../errors/known-error')
 
 /**
  *
- * @param {{ containername: string, commands: string[] }} argv
+ * @param {{ containerName: string, commands: string[] }} argv
  * @returns
  */
 const executeTask = async (argv) => {
@@ -47,17 +47,17 @@ const executeTask = async (argv) => {
     const services = Object.keys(containers)
 
     if (
-        services.includes(argv.containername) ||
-        services.some((service) => service.includes(argv.containername))
+        services.includes(argv.containerName) ||
+        services.some((service) => service.includes(argv.containerName))
     ) {
-        const containerResult = containers[argv.containername]
-            ? containers[argv.containername]
+        const containerResult = containers[argv.containerName]
+            ? containers[argv.containerName]
             : Object.entries(containers).find(([key]) =>
-                  key.includes(argv.containername)
+                  key.includes(argv.containerName)
               )
 
         if (!containerResult) {
-            logger.error(`No container found "${argv.containername}"`)
+            logger.error(`No container found "${argv.containerName}"`)
             process.exit(1)
         }
 
@@ -95,14 +95,14 @@ const executeTask = async (argv) => {
 
             const result = await executeInContainer({
                 containerName: container.name,
-                commands: argv.commands,
+                command: argv.commands.join(' '),
                 user: container.user
             })
 
             return result
         }
 
-        if (container.name.endsWith('php')) {
+        if (container.name.includes('php')) {
             if (process.stdout.isTTY) {
                 logger.logN(
                     `Starting container ${logger.style.misc(
@@ -127,7 +127,7 @@ const executeTask = async (argv) => {
         throw new KnownError(`Container ${container.name} is not running!`)
     }
 
-    logger.error(`No container found "${argv.containername}"`)
+    logger.error(`No container found "${argv.containerName}"`)
     process.exit(1)
 }
 

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-debug-config.js

@@ -10,7 +10,6 @@ const {
  */
 const createPhpDebugConfig = () => ({
     title: 'Setting PHP XDebug config',
-    skip: (ctx) => !ctx.debug,
     task: async (ctx) => {
         const {
             config: { php, baseConfig },
@@ -19,7 +18,7 @@ const createPhpDebugConfig = () => ({
         } = ctx
         const containers = ctx.config.docker.getContainers(ctx.ports)
         const phpExtensions = await getEnabledExtensionsFromImage(
-            containers.php.debugImage
+            containers.phpWithXdebug.image
         )
         const isXDebug2 = semver.satisfies(phpExtensions.xdebug, '2')
 

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

@@ -0,0 +1,33 @@
+const UnknownError = require('../../errors/unknown-error')
+const setConfigFile = require('../../util/set-config')
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createPhpFpmDebugConfig = () => ({
+    title: 'Setting php-fpm debug config',
+    task: async (ctx) => {
+        const {
+            config: { php },
+            isDockerDesktop
+        } = ctx
+        const port = !isDockerDesktop ? ctx.ports.fpmXdebug : 9000
+
+        try {
+            await setConfigFile({
+                configPathname: php.debugFpmConfPath,
+                template: php.fpmTemplatePath,
+                overwrite: true,
+                templateArgs: {
+                    port
+                }
+            })
+        } catch (e) {
+            throw new UnknownError(
+                `Unexpected error accrued during php-fpm config creation\n\n${e}`
+            )
+        }
+    }
+})
+
+module.exports = createPhpFpmDebugConfig

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

@@ -3,7 +3,7 @@ const { nameKey, propertyKey } = require('../keys')
 const PHP_INTERPRETERS_COMPONENT_NAME = 'PhpInterpreters'
 
 /**
- * @param {Array} phpConfigs
+ * @param {Array<Record<string, any>>} phpConfigs
  * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
@@ -13,8 +13,9 @@ const setupPHPInterpreters = async (phpConfigs, ctx) => {
         (phpConfig) => phpConfig[nameKey] === PHP_INTERPRETERS_COMPONENT_NAME
     )
 
-    const { php } = ctx.config.docker.getContainers(ctx.ports)
-    const currentInterpreterImage = ctx.debug ? php.debugImage : php.image
+    const {
+        phpWithXdebug: { image: currentInterpreterImage }
+    } = ctx.config.docker.getContainers(ctx.ports)
 
     const defaultPhpInterpreterConfiguration = {
         [nameKey]: currentInterpreterImage,
@@ -49,8 +50,7 @@ const setupPHPInterpreters = async (phpConfigs, ctx) => {
         const phpInterpreterConfiguration =
             phpInterpretersComponent.interpreters.interpreter.find(
                 (interpreter) =>
-                    interpreter[nameKey] === php.image ||
-                    interpreter[nameKey] === php.debugImage
+                    interpreter[nameKey] === currentInterpreterImage
             )
 
         if (!phpInterpreterConfiguration) {

package/lib/tasks/file-system/create-phpstorm-config/workspace-config/composer-settings-config.js

@@ -18,7 +18,7 @@ const defaultComposerSettingsProperties = {
 }
 
 /**
- * @param {Array} workspaceConfigs
+ * @param {Array<Record<string, any>>} workspaceConfigs
  * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
@@ -32,7 +32,7 @@ const setupComposerSettings = async (workspaceConfigs, ctx) => {
     const isComposerJsonExists = await pathExists(composerJsonPath)
     const { php } = ctx.config.docker.getContainers(ctx.ports)
     const defaultInterpreterConfig = {
-        [nameKey]: ctx.debug ? php.debugImage : php.image,
+        [nameKey]: php.image,
         [composerKey]: 'composer'
     }
 

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

@@ -6,7 +6,7 @@ const PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME =
 const interpreterNameKey = '@_interpreter_name'
 
 /**
- * @param {Array} workspaceConfigs
+ * @param {Array<Record<string, any>>} workspaceConfigs
  * @param {import('../../../../../typings/context').ListrContext} ctx
  * @returns {Promise<Boolean>}
  */
@@ -17,8 +17,9 @@ const setupPHPWorkspaceProjectConfiguration = async (workspaceConfigs, ctx) => {
             workspaceConfig[nameKey] ===
             PHP_WORKSPACE_PROJECT_CONFIGURATION_COMPONENT_NAME
     )
-    const { php } = ctx.config.docker.getContainers(ctx.ports)
-    const currentInterpreterImage = ctx.debug ? php.debugImage : php.image
+    const {
+        php: { image: currentInterpreterImage }
+    } = ctx.config.docker.getContainers(ctx.ports)
 
     if (phpWorkspaceProjectConfigurationComponent) {
         if (