@scandipwa/magento-scripts 2.0.3 → 2.0.5

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

@@ -1,95 +1,132 @@
-const path = require('path');
-const os = require('os');
-const { DockerFileBuilder } = require('../../util/dockerfile-builder');
-const { execAsyncSpawn } = require('../../util/exec-async-command');
-const KnownError = require('../../errors/known-error');
-const { runContainerImage } = require('../../util/run-container-image');
-const { imageApi } = require('./image');
+const path = require('path')
+const os = require('os')
+const { DockerFileBuilder } = require('../../util/dockerfile-builder')
+const { execAsyncSpawn } = require('../../util/exec-async-command')
+const KnownError = require('../../errors/known-error')
+const { runContainerImage } = require('../../util/run-container-image')
+const { imageApi } = require('./image')
 
 /**
  * Get enabled extensions list with versions
  * @param {string} imageWithTag
- * @returns {Promise<{[key: string]: string}}>}
+ * @returns {Promise<{[key: string]: string}>}>}
  */
 const getEnabledExtensionsFromImage = async (imageWithTag) => {
     const output = await runContainerImage(
         imageWithTag,
-        // eslint-disable-next-line quotes
+
         `php -r 'foreach (get_loaded_extensions() as $extension) echo "$extension:" . phpversion($extension) . "\n";'`
-    );
+    )
 
     return output
         .split('\n')
         .map((m) => {
-            // eslint-disable-next-line no-unused-vars
-            const [_, moduleName, moduleVersion] = m.match(/(.+):(.+)/i);
+            const moduleMatch = m.match(/(.+):(.+)/i)
+
+            if (moduleMatch) {
+                const [_, moduleName, moduleVersion] = moduleMatch
+
+                return [moduleName, moduleVersion]
+            }
 
-            return [moduleName, moduleVersion];
+            return []
         })
-        .reduce((acc, [name, version]) => ({ ...acc, [name]: version }), {});
-};
-
-const addExtensionToBuilder = (builder, ctx) => async ([extensionName, extensionInstructions]) => {
-    const { command, ...extensionInstructionsWithoutCommand } = extensionInstructions;
-    let runCommand = '';
-    if (typeof command === 'string') {
-        runCommand += ` ${command}`;
-    } else if (typeof command === 'function' || command instanceof Promise) {
-        runCommand += ` ${await Promise.resolve(command({ ...extensionInstructionsWithoutCommand, ctx }))}`;
-    } else {
-        runCommand += ` docker-php-ext-install ${extensionInstructionsWithoutCommand.name || extensionName}`;
+        .filter((a) => a.length > 0)
+        .reduce((acc, [name, version]) => ({ ...acc, [name]: version }), {})
+}
+
+/**
+ * @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 (command instanceof Promise) {
+            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())
     }
-    builder
-        .comment(`extension ${extensionName} installation command`)
-        .run(runCommand.trim());
-};
 
 /**
  * @param {import('../../../typings/context').ListrContext} ctx
  * @param {{ image: string, tag: string}} param1
  */
 const buildDockerFileInstructions = async (ctx, { image, tag }) => {
-    const { composer } = ctx.config.overridenConfiguration.configuration;
-    const existingPHPExtensions = await getEnabledExtensionsFromImage(`${image}:${tag}`);
-    const imageDetails = await imageApi.inspect({ image: `${image}:${tag}`, formatToJSON: true });
+    const { composer } = ctx.config.overridenConfiguration.configuration
+    const existingPHPExtensions = await getEnabledExtensionsFromImage(
+        `${image}:${tag}`
+    )
+    const imageDetails = await imageApi.inspect({
+        image: `${image}:${tag}`,
+        formatToJSON: true
+    })
 
     const missingExtensions = Object.entries(
         ctx.config.overridenConfiguration.configuration.php.extensions
-    ).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)
-                )
-            )
-    ).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))
+                    )
+        )
+        .filter(([extensionName]) => extensionName.toLowerCase() !== 'xdebug')
 
     const dockerFileInstructions = new DockerFileBuilder()
         .comment('project image')
-        .from({ image, tag });
+        .from({ image, tag })
 
     if (missingExtensions.length > 0) {
-        const allDependencies = missingExtensions.map(
-            ([_extensionName, extensionInstructions]) => (extensionInstructions.dependencies || [])
-        )
-            .reduce((acc, val) => acc.concat(val.filter((ex) => !acc.includes(ex))), []);
+        const allDependencies = missingExtensions
+            .map(
+                ([_extensionName, extensionInstructions]) =>
+                    extensionInstructions.dependencies || []
+            )
+            .reduce(
+                (acc, val) => acc.concat(val.filter((ex) => !acc.includes(ex))),
+                []
+            )
 
-        dockerFileInstructions.run(`apk add --no-cache ${allDependencies.join(' ')}`);
+        dockerFileInstructions.run(
+            `apk add --no-cache ${allDependencies.join(' ')}`
+        )
         for (const missingExtensionInstructions of missingExtensions) {
-            await addExtensionToBuilder(dockerFileInstructions, ctx)(missingExtensionInstructions);
+            await addExtensionToBuilder(
+                dockerFileInstructions,
+                ctx
+            )(missingExtensionInstructions)
         }
     }
 
     const composerVersion = /^\d$/.test(composer.version)
         ? `latest-${composer.version}.x`
-        : composer.version;
+        : composer.version
 
     dockerFileInstructions
         .comment('download composer')
-        .run(`curl https://getcomposer.org/download/${composerVersion}/composer.phar --output composer`)
+        .run(
+            `curl https://getcomposer.org/download/${composerVersion}/composer.phar --output composer`
+        )
         .comment('make composer executable')
         .run('chmod +x ./composer')
         .comment('move composer to bin directory')
@@ -98,95 +135,141 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         .env({
             COMPOSER_HOME: '/composer/home',
             COMPOSER_CACHE_DIR: '/composer/home/cache'
-        });
+        })
 
     if (composer.plugins && Object.values(composer.plugins).length > 0) {
-        for (const [pluginName, pluginOptions] of Object.entries(composer.plugins)) {
+        for (const [pluginName, pluginOptions] of Object.entries(
+            composer.plugins
+        )) {
             if (pluginOptions.enabled) {
                 dockerFileInstructions
                     .comment(`install ${pluginName} composer global package`)
-                    // eslint-disable-next-line max-len
-                    .run(`composer global require ${pluginName}${ pluginOptions.options ? ` ${pluginOptions.options}` : '' }${ pluginOptions.options ? ` ${pluginOptions.options}` : ''}`);
+
+                    .run(
+                        `composer global require ${pluginName}${
+                            pluginOptions.options
+                                ? ` ${pluginOptions.options}`
+                                : ''
+                        }${
+                            pluginOptions.options
+                                ? ` ${pluginOptions.options}`
+                                : ''
+                        }`
+                    )
             }
         }
     }
 
     if (!ctx.isDockerDesktop) {
-        dockerFileInstructions
-            .run(`chown -R ${os.userInfo().uid}:${os.userInfo().gid} /composer/home`);
+        dockerFileInstructions.run(
+            `chown -R ${os.userInfo().uid}:${os.userInfo().gid} /composer/home`
+        )
     }
 
-    dockerFileInstructions
-        .workDir(ctx.config.baseConfig.containerMagentoDir);
+    dockerFileInstructions.workDir(ctx.config.baseConfig.containerMagentoDir)
 
-    const imagePathEnv = imageDetails.Config.Env.find((env) => env.startsWith('PATH'));
-    const magentoBinDir = path.join(ctx.config.baseConfig.containerMagentoDir, 'bin');
-    const vendorBinDir = path.join(ctx.config.baseConfig.containerMagentoDir, 'vendor', 'bin');
+    const imagePathEnv = imageDetails.Config.Env.find((env) =>
+        env.startsWith('PATH')
+    )
+    const magentoBinDir = path.join(
+        ctx.config.baseConfig.containerMagentoDir,
+        'bin'
+    )
+    const vendorBinDir = path.join(
+        ctx.config.baseConfig.containerMagentoDir,
+        'vendor',
+        'bin'
+    )
 
-    dockerFileInstructions
-        .env({
-            PATH: `${ imagePathEnv.split('=').pop() }:${ magentoBinDir }:${vendorBinDir }`
-        });
+    if (imagePathEnv) {
+        dockerFileInstructions.env({
+            PATH: `${imagePathEnv
+                .split('=')
+                .pop()}:${magentoBinDir}:${vendorBinDir}`
+        })
+    }
 
-    return dockerFileInstructions;
-};
+    return dockerFileInstructions
+}
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 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 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
+        })
 
         try {
-            await execAsyncSpawn(`docker build -t ${containers.php.image} -<<EOF
+            await execAsyncSpawn(
+                `docker build -t ${containers.php.image} -<<EOF
 ${dockerFileInstructions.build()}
-EOF`, {
-                callback: (r) => {
-                    task.output = r;
+EOF`,
+                {
+                    callback: (r) => {
+                        task.output = r
+                    }
                 }
-            });
+            )
         } catch (e) {
-            throw new KnownError(`Unexpected error during project image building!\n\n${e}`);
+            throw new KnownError(
+                `Unexpected error during project image building!\n\n${e}`
+            )
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const buildDebugProjectImage = () => ({
     title: 'Building Debug Project Image',
     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 });
+        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
+            await execAsyncSpawn(
+                `docker build -t ${containers.php.debugImage} -<<EOF
 ${dockerFileInstructions.build()}
-EOF`, {
-                callback: (r) => {
-                    task.output = r;
+EOF`,
+                {
+                    callback: (r) => {
+                        task.output = r
+                    }
                 }
-            });
+            )
         } catch (e) {
-            throw new KnownError(`Unexpected error during debug project image building!\n\n${e}`);
+            throw new KnownError(
+                `Unexpected error during debug project image building!\n\n${e}`
+            )
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 module.exports = {
     buildProjectImage,
     buildDebugProjectImage,
     getEnabledExtensionsFromImage
-};
+}

package/lib/tasks/docker/system/index.js

@@ -1,5 +1,5 @@
-const systemApi = require('./system-api');
+const systemApi = require('./system-api')
 
 module.exports = {
     systemApi
-};
+}

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

@@ -1,4 +1,4 @@
-import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command'
 
 export interface SystemDFOptions<T extends boolean = false> {
     format?: string
@@ -30,7 +30,7 @@ export interface SystemDFResult {
         Mounts: string
         Names: string
         Networks: string
-        Ports: StreamPipeOptions
+        Ports: string
         RunningFor: string
         Size: string
         State: string

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

@@ -1,35 +1,32 @@
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const { execAsyncSpawn } = require('../../../util/exec-async-command')
 
 /**
  * @param {import('./system-api').SystemDFOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
 const df = async (options, execOptions = {}) => {
-    const {
-        format,
-        formatToJSON,
-        verbose
-    } = options;
+    const { format, formatToJSON, verbose } = options
 
-    const formatArg = !formatToJSON && format
-        ? `--format=${format}`
-        : formatToJSON && '--format=\'{{json .}}\'';
-    const verboseArg = verbose && '--verbose';
+    const formatArg =
+        !formatToJSON && format
+            ? `--format=${format}`
+            : formatToJSON && "--format='{{json .}}'"
+    const verboseArg = verbose && '--verbose'
 
-    const args = [
-        formatArg,
-        verboseArg
-    ].filter(Boolean).join(' ');
+    const args = [formatArg, verboseArg].filter(Boolean).join(' ')
 
     if (formatToJSON) {
-        const result = await execAsyncSpawn(`docker system df ${args}`, execOptions);
+        const result = await execAsyncSpawn(
+            `docker system df ${args}`,
+            execOptions
+        )
 
-        return JSON.parse(result);
+        return JSON.parse(result)
     }
 
-    return execAsyncSpawn(`docker system df ${args}`, execOptions);
-};
+    return execAsyncSpawn(`docker system df ${args}`, execOptions)
+}
 
 module.exports = {
     df
-};
+}

package/lib/tasks/docker/volume/index.js

@@ -1,9 +1,9 @@
-const volumeApi = require('./volume-api');
-const { createVolumes, removeVolumes, removeLocalVolumes } = require('./tasks');
+const volumeApi = require('./volume-api')
+const { createVolumes, removeVolumes, removeLocalVolumes } = require('./tasks')
 
 module.exports = {
     createVolumes,
     removeVolumes,
     removeLocalVolumes,
     volumeApi
-};
+}

package/lib/tasks/docker/volume/tasks.js

@@ -1,107 +1,124 @@
-const fs = require('fs');
-const pathExists = require('../../../util/path-exists');
-const { containerApi } = require('../containers');
-const volumeApi = require('./volume-api');
+const fs = require('fs')
+const pathExists = require('../../../util/path-exists')
+const { containerApi } = require('../containers')
+const volumeApi = require('./volume-api')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const createVolumes = () => ({
     title: 'Creating volumes',
     task: async ({ config: { docker } }, task) => {
         const volumeList = await volumeApi.ls({
             formatToJSON: true
-        });
+        })
 
         const missingVolumes = Object.values(docker.volumes).filter(
             ({ name }) => !volumeList.some((v) => v.Name === name)
-        );
+        )
 
         if (missingVolumes.length === 0) {
-            task.skip();
-            return;
+            task.skip()
+            return
         }
 
-        await Promise.all(missingVolumes.map(async (volume) => {
-            if (volume.opt && volume.opt.device && !await pathExists(volume.opt.device)) {
-                await fs.promises.mkdir(volume.opt.device, {
-                    recursive: true
-                });
-            }
-        }));
+        await Promise.all(
+            missingVolumes.map(async (volume) => {
+                if (
+                    volume.opt &&
+                    volume.opt.device &&
+                    !(await pathExists(volume.opt.device))
+                ) {
+                    await fs.promises.mkdir(volume.opt.device, {
+                        recursive: true
+                    })
+                }
+            })
+        )
 
-        await Promise.all(missingVolumes.map((volume) => volumeApi.create(volume)));
+        await Promise.all(
+            missingVolumes.map((volume) => volumeApi.create(volume))
+        )
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const removeVolumes = () => ({
     title: 'Removing volumes',
     task: async ({ config: { docker } }, task) => {
         const volumeList = await volumeApi.ls({
             formatToJSON: true
-        });
+        })
 
         const deployedVolumes = Object.values(docker.volumes).filter(
             ({ name }) => volumeList.some((v) => v.Name === name)
-        );
+        )
 
         if (deployedVolumes.length === 0) {
-            task.skip();
-            return;
+            task.skip()
+            return
         }
 
         await volumeApi.rm({
             volumes: deployedVolumes.map(({ name }) => name)
-        });
+        })
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const removeLocalVolumes = () => ({
     title: 'Removing local volumes',
     task: async (ctx, task) => {
         const volumeList = await volumeApi.ls({
             formatToJSON: true
-        });
-        const { volumes } = ctx.config.docker;
+        })
+        const { volumes } = ctx.config.docker
 
         const localVolumes = Object.values(volumes).filter(
             (volume) => volume.opt && volume.opt.device
-        );
+        )
 
-        const existingLocalVolumes = localVolumes.filter(
-            (volume) => volumeList.some((v) => v.Name === volume.name)
-        );
+        const existingLocalVolumes = localVolumes.filter((volume) =>
+            volumeList.some((v) => v.Name === volume.name)
+        )
 
         if (existingLocalVolumes.length > 0) {
             const existingLocalVolumesDetails = await Promise.all(
-                existingLocalVolumes.map((v) => volumeApi.inspect({ volume: v.name, formatToJSON: true }))
-            );
+                existingLocalVolumes.map((v) =>
+                    volumeApi.inspect({ volume: v.name, formatToJSON: true })
+                )
+            )
 
-            await Promise.all(existingLocalVolumesDetails.map(async (v) => {
-                if (v.Containers && Object.entries(v.Containers).length > 0) {
-                    await Promise.all(Object.values(v.Containers).map(async (c) => {
-                        await containerApi.stop([c.Name]);
-                        await containerApi.rm([c.Name]);
-                    }));
-                }
-            }));
+            await Promise.all(
+                existingLocalVolumesDetails.map(async (v) => {
+                    if (
+                        v.Containers &&
+                        Object.entries(v.Containers).length > 0
+                    ) {
+                        await Promise.all(
+                            Object.values(v.Containers).map(async (c) => {
+                                await containerApi.stop([c.Name])
+                                await containerApi.rm([c.Name])
+                            })
+                        )
+                    }
+                })
+            )
             await volumeApi.rm({
                 volumes: existingLocalVolumes.map((volume) => volume.name)
-            });
+            })
         } else {
-            task.skip();
+            task.skip()
         }
     }
-});
+})
 
 module.exports = {
     createVolumes,
     removeVolumes,
     removeLocalVolumes
-};
+}

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

@@ -1,4 +1,4 @@
-import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command'
 
 export interface VolumeLsOptions<T extends boolean = false> {
     filter?: string | string[]
@@ -63,10 +63,13 @@ export interface VolumeInspectResult {
     Options: unknown
     Scope: string
     CreatedTime: number
-    Containers: Record<string, {
-        Name: string
-        Destination: string
-    }>
+    Containers: Record<
+        string,
+        {
+            Name: string
+            Destination: string
+        }
+    >
 }
 
 export function inspect(