@scandipwa/magento-scripts 2.0.3 → 2.0.5

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

@@ -1,130 +1,152 @@
 /* eslint-disable max-len */
-const sleep = require('../../../util/sleep');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const KnownError = require('../../../errors/known-error');
-const containerApi = require('./container-api');
-const { imageApi } = require('../image');
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const sleep = require('../../../util/sleep')
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+const KnownError = require('../../../errors/known-error')
+const containerApi = require('./container-api')
+const { imageApi } = require('../image')
+const { execAsyncSpawn } = require('../../../util/exec-async-command')
 
+/**
+ * @param {string[]} containers
+ */
 const stopAndRemoveContainers = async (containers) => {
-    await containerApi.stop(containers);
-    await containerApi.rm(containers);
-};
+    await containerApi.stop(containers)
+    await containerApi.rm(containers)
+}
 
-const pull = async (image) => execAsyncSpawn(`docker pull ${image}`);
+/**
+ * @param {string} image
+ */
+const pull = async (image) => execAsyncSpawn(`docker pull ${image}`)
 
+/**
+ * @param {string[]} acc
+ * @param {{ remoteImages?: string[], image: string }} val
+ */
 const remoteImageReducer = (acc, val) => {
-    if (Array.isArray(val.remoteImages) && val.remoteImages.every((image) => typeof image === 'string')) {
-        return acc.concat(val.remoteImages);
+    if (
+        Array.isArray(val.remoteImages) &&
+        val.remoteImages.every((image) => typeof image === 'string')
+    ) {
+        return acc.concat(val.remoteImages)
     }
 
-    return acc.concat([val.image]);
-};
+    return acc.concat([val.image])
+}
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const pullImages = () => ({
     title: 'Pulling container images',
     task: async ({ config: { docker }, pullImages }, task) => {
-        const containers = Object.values(docker.getContainers());
+        const containers = Object.values(docker.getContainers())
 
         if (pullImages) {
             return task.newListr(
                 containers
                     .reduce(remoteImageReducer, [])
                     .map((image) => {
-                        const [repo, tag = 'latest'] = image.split(':');
+                        const [repo, tag = 'latest'] = image.split(':')
 
-                        return { repo, tag };
+                        return { repo, tag }
                     })
                     .reduce(
-                        (acc, val) => acc.concat(
-                            acc.some(
-                                (c) => c.repo === val.repo
-                                && c.tag === val.tag
-                            )
-                                ? []
-                                : val
-                        ),
+                        (acc, val) =>
+                            acc.concat(
+                                acc.some(
+                                    (c) =>
+                                        c.repo === val.repo && c.tag === val.tag
+                                )
+                                    ? []
+                                    : val
+                            ),
                         []
                     )
                     .map(({ repo, tag }) => ({
-                        title: `Pulling ${ logger.style.file(`${repo}:${tag}`) } image`,
+                        title: `Pulling ${logger.style.file(
+                            `${repo}:${tag}`
+                        )} image`,
                         task: () => pull(`${repo}:${tag}`)
-                    })), {
+                    })),
+                {
                     concurrent: true,
                     exitOnError: true
                 }
-            );
+            )
         }
 
         const imagesFilter = containers
             .reduce(remoteImageReducer, [])
-            .map((image) => `reference='${image}'`);
+            .map((image) => `reference='${image}'`)
 
         const existingImages = await imageApi.ls({
             formatToJSON: true,
             filter: imagesFilter
-        });
+        })
 
         const missingContainerImages = containers
             .reduce(remoteImageReducer, [])
             .map((image) => {
-                const [repo, tag = 'latest'] = image.split(':');
+                const [repo, tag = 'latest'] = image.split(':')
 
-                return { repo, tag };
+                return { repo, tag }
             })
             .filter(
-                ({ repo, tag }) => !existingImages.some(
-                    (image) => image.Repository === repo
-                    && image.Tag === tag
-                )
+                ({ repo, tag }) =>
+                    !existingImages.some(
+                        (image) =>
+                            image.Repository === repo && image.Tag === tag
+                    )
             )
             .reduce(
-                (acc, val) => acc.concat(
-                    acc.some(
-                        (c) => c.repo === val.repo
-                        && c.tag === val.tag
-                    )
-                        ? []
-                        : val
-                ),
+                (acc, val) =>
+                    acc.concat(
+                        acc.some(
+                            (c) => c.repo === val.repo && c.tag === val.tag
+                        )
+                            ? []
+                            : val
+                    ),
                 []
-            );
+            )
 
         if (missingContainerImages.length === 0) {
-            task.skip();
-            return;
+            task.skip()
+            return
         }
 
         return task.newListr(
             missingContainerImages.map(({ repo, tag }) => ({
-                title: `Pulling ${ logger.style.file(`${repo}:${tag}`) } image`,
+                title: `Pulling ${logger.style.file(`${repo}:${tag}`)} image`,
                 task: () => pull(`${repo}:${tag}`)
-            })), {
+            })),
+            {
                 concurrent: true,
                 exitOnError: true
             }
-        );
+        )
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const startContainers = () => ({
     title: 'Starting containers',
     task: async ({ ports, config: { docker }, debug }, task) => {
-        const containerList = await containerApi.ls({ formatToJSON: true, all: true });
+        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.values(
+            docker.getContainers(ports)
+        ).filter(({ name }) => !containerList.some((c) => c.Names === name))
 
         if (missingContainers.length === 0) {
-            task.skip();
-            return;
+            task.skip()
+            return
         }
 
         if (debug) {
@@ -132,109 +154,159 @@ const startContainers = () => ({
                 missingContainers
                     .map((container) => {
                         if (container.debugImage) {
-                            container.image = container.debugImage;
+                            container.image = container.debugImage
                         }
 
-                        return container;
-                    }).map((container) => containerApi.run(container).then((out) => {
-                        task.output = `From ${container._}: ${out}`;
-                    }))
-            );
+                        return container
+                    })
+                    .map((container) =>
+                        containerApi.run(container).then((out) => {
+                            task.output = `From ${container._}: ${out}`
+                        })
+                    )
+            )
 
-            return;
+            return
         }
 
         // TODO: we might stop containers here ?
-        await Promise.all(missingContainers.map((container) => containerApi.run(container).then((out) => {
-            task.output = `From ${container._}: ${out}`;
-        })));
+        await Promise.all(
+            missingContainers.map((container) =>
+                containerApi.run(container).then((out) => {
+                    task.output = `From ${container._}: ${out}`
+                })
+            )
+        )
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const stopContainers = () => ({
     title: 'Stopping Docker containers',
-    task: async ({ config: { baseConfig: { prefix } } }, task) => {
-        const containerList = await containerApi.ls({ formatToJSON: true, all: true });
+    task: async (
+        {
+            config: {
+                baseConfig: { prefix }
+            }
+        },
+        task
+    ) => {
+        const containerList = await containerApi.ls({
+            formatToJSON: true,
+            all: true
+        })
 
-        const runningContainers = containerList.filter((containerName) => containerName.Names.startsWith(prefix));
+        const runningContainers = containerList.filter((containerName) =>
+            containerName.Names.startsWith(prefix)
+        )
 
         if (runningContainers.length === 0) {
-            task.skip();
-            return;
+            task.skip()
+            return
         }
 
-        await stopAndRemoveContainers(runningContainers.map(({ Names }) => Names));
+        await stopAndRemoveContainers(
+            runningContainers.map(({ Names }) => Names)
+        )
     }
-});
+})
 
+/**
+ * @param {string} containerName
+ */
 const getContainerStatus = async (containerName) => {
     try {
-        return JSON.parse(await execAsyncSpawn(`docker inspect --format='{{json .}}' ${containerName}`));
+        return JSON.parse(
+            await execAsyncSpawn(
+                `docker inspect --format='{{json .}}' ${containerName}`
+            )
+        )
     } catch {
-        return null;
+        return null
     }
-};
+}
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkContainersAreRunning = () => ({
     title: 'Checking container statuses',
     task: async (ctx, task) => {
-        const { config: { docker }, ports } = ctx;
-        const containers = Object.values(docker.getContainers(ports));
-        let tries = 0;
+        const {
+            config: { docker },
+            ports
+        } = ctx
+        const containers = Object.values(docker.getContainers(ports))
+        let tries = 0
         while (tries < 3) {
             const containersWithStatus = await Promise.all(
                 containers.map(async (container) => ({
                     ...container,
                     status: await getContainerStatus(container.name)
                 }))
-            );
+            )
 
-            if (containersWithStatus.some((c) => c.status.State.Status !== 'running')) {
+            if (
+                containersWithStatus.some(
+                    (c) => c.status.State.Status !== 'running'
+                )
+            ) {
                 if (tries === 2) {
-                    throw new KnownError(`${containersWithStatus.filter((c) => c.status.State.Status !== 'running').map((c) => c._).join(', ')} containers are not running! Please check container logs for more details!`);
+                    throw new KnownError(
+                        `${containersWithStatus
+                            .filter((c) => c.status.State.Status !== 'running')
+                            .map((c) => c._)
+                            .join(
+                                ', '
+                            )} containers are not running! Please check container logs for more details!`
+                    )
                 } else {
-                    task.output = `${containersWithStatus.filter((c) => c.status.State.Status !== 'running').map((c) => c._).join(', ')} are not running, waiting if something will change...`;
-                    await sleep(2000);
-                    tries++;
+                    task.output = `${containersWithStatus
+                        .filter((c) => c.status.State.Status !== 'running')
+                        .map((c) => c._)
+                        .join(
+                            ', '
+                        )} are not running, waiting if something will change...`
+                    await sleep(2000)
+                    tries++
                 }
             } else {
-                break;
+                break
             }
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const statusContainers = () => ({
     task: async (ctx) => {
-        const { config: { docker }, ports } = ctx;
-        const containers = Object.values(docker.getContainers(ports));
+        const {
+            config: { docker },
+            ports
+        } = ctx
+        const containers = Object.values(docker.getContainers(ports))
 
         ctx.containers = await Promise.all(
             containers.map(async (container) => ({
                 ...container,
                 status: await getContainerStatus(container.name)
             }))
-        );
+        )
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 module.exports = {
     startContainers,
@@ -243,4 +315,4 @@ module.exports = {
     statusContainers,
     checkContainersAreRunning,
     getContainerStatus
-};
+}

package/lib/tasks/docker/convert-composer-home-to-composer-cache-volume.js

@@ -1,52 +1,61 @@
-const { containerApi } = require('./containers');
-const volumeApi = require('./volume/volume-api');
+/* eslint-disable camelcase */
+const { containerApi } = require('./containers')
+const volumeApi = require('./volume/volume-api')
 
-const composeHomeDataVolumeName = 'composer_home-data';
+const composeHomeDataVolumeName = 'composer_home-data'
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const convertComposerHomeToComposerCacheVolume = () => ({
     skip: async () => {
         const volumeList = await volumeApi.ls({
             formatToJSON: true,
-            filter: `name=${ composeHomeDataVolumeName }`
-        });
+            filter: `name=${composeHomeDataVolumeName}`
+        })
 
-        return volumeList.length === 0;
+        return volumeList.length === 0
     },
     task: async (ctx, task) => {
         if (ctx.platform === 'linux' && !ctx.isDockerDesktop) {
-            await volumeApi.rm({ volumes: [composeHomeDataVolumeName] });
-            return;
+            await volumeApi.rm({ volumes: [composeHomeDataVolumeName] })
+            return
         }
 
-        const { composer_cache } = ctx.config.docker.volumes;
-        task.title = `Migrating from ${ composer_cache.name } volume to ${ composeHomeDataVolumeName }...`;
+        const { composer_cache } = ctx.config.docker.volumes
+        task.title = `Migrating from ${composer_cache.name} volume to ${composeHomeDataVolumeName}...`
         await containerApi.run({
             rm: true,
             detach: false,
             mountVolumes: [
-                `${ composeHomeDataVolumeName }:/from:ro`,
-                `${ composer_cache.name }:/to`
+                `${composeHomeDataVolumeName}:/from:ro`,
+                `${composer_cache.name}:/to`
             ],
             image: 'alpine',
             command: 'ash -c "cd /from/cache; cp -av . /to"'
-        });
-
-        const runningContainers = await volumeApi.inspect({ volume: composeHomeDataVolumeName, formatToJSON: true });
-
-        if (runningContainers.Containers && Object.entries(runningContainers.Containers).length > 0) {
-            await Promise.all(Object.values(runningContainers.Containers).map(async (c) => {
-                await containerApi.stop([c.Name]);
-                await containerApi.rm([c.Name]);
-            }));
+        })
+
+        const runningContainers = await volumeApi.inspect({
+            volume: composeHomeDataVolumeName,
+            formatToJSON: true
+        })
+
+        if (
+            runningContainers.Containers &&
+            Object.entries(runningContainers.Containers).length > 0
+        ) {
+            await Promise.all(
+                Object.values(runningContainers.Containers).map(async (c) => {
+                    await containerApi.stop([c.Name])
+                    await containerApi.rm([c.Name])
+                })
+            )
         }
 
-        await volumeApi.rm({ volumes: [composeHomeDataVolumeName] });
+        await volumeApi.rm({ volumes: [composeHomeDataVolumeName] })
     }
-});
+})
 
 module.exports = {
     convertComposerHomeToComposerCacheVolume
-};
+}