@scandipwa/magento-scripts 2.0.3 → 2.0.4

package/lib/tasks/requirements/docker/install.js

@@ -1,73 +1,84 @@
-const osPlatform = require('../../../util/os-platform');
-const { execCommandTask } = require('../../../util/exec-async-command');
-const installDependenciesTask = require('../../../util/install-dependencies-task');
-const executeSudoCommand = require('../../../util/execute-sudo-command');
-const KnownError = require('../../../errors/known-error');
+const osPlatform = require('../../../util/os-platform')
+const { execCommandTask } = require('../../../util/exec-async-command')
+const installDependenciesTask = require('../../../util/install-dependencies-task')
+const executeSudoCommand = require('../../../util/execute-sudo-command')
+const KnownError = require('../../../errors/known-error')
 
-const downloadDockerInstallScriptCommand = () => execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh');
-const runDockerInstallScriptCommand = () => executeSudoCommand('sudo sh get-docker.sh');
-const enableAndStartDockerCommand = () => executeSudoCommand('sudo systemctl enable docker --now');
+const downloadDockerInstallScriptCommand = () =>
+    execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh')
+const runDockerInstallScriptCommand = () =>
+    executeSudoCommand('sudo sh get-docker.sh')
+const enableAndStartDockerCommand = () =>
+    executeSudoCommand('sudo systemctl enable docker --now')
 
 const postInstallSteps = [
     executeSudoCommand('[ $(getent group docker) ] && sudo groupadd docker', {
         withCode: true
     }),
     executeSudoCommand(`sudo usermod -aG docker ${process.env.USER}`)
-];
+]
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const installDockerEngine = () => ({
     title: 'Installing Docker Engine',
     task: async (ctx, task) => {
-        const distro = await osPlatform();
+        const distro = await osPlatform()
         switch (distro) {
-        case 'Arch Linux': {
-            return task.newListr([
-                installDependenciesTask({
-                    platform: 'Arch Linux',
-                    dependenciesToInstall: ['docker']
-                }),
-                enableAndStartDockerCommand(),
-                ...postInstallSteps
-            ]);
-        }
-        case 'Fedora': {
-            return task.newListr([
-                executeSudoCommand('sudo dnf -y install dnf-plugins-core'),
-                executeSudoCommand('sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo'),
-                executeSudoCommand('sudo dnf -y install docker-ce docker-ce-cli containerd.io docker-compose-plugin'),
-                enableAndStartDockerCommand(),
-                ...postInstallSteps
-            ]);
-        }
-        case 'CentOS': {
-            return task.newListr([
-                executeSudoCommand('sudo yum install -y yum-utils'),
-                executeSudoCommand('sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo'),
-                executeSudoCommand('sudo yum install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin'),
-                ...postInstallSteps
-            ]);
-        }
-        case 'Ubuntu': {
-            return task.newListr([
-                downloadDockerInstallScriptCommand(),
-                runDockerInstallScriptCommand(),
-                enableAndStartDockerCommand(),
-                ...postInstallSteps
-            ]);
-        }
-        default: {
-            throw new KnownError(`Docker is not installed!
-Your distro ${distro} is not supported by automatic installation.`);
-        }
+            case 'Arch Linux': {
+                return task.newListr([
+                    installDependenciesTask({
+                        platform: 'Arch Linux',
+                        dependenciesToInstall: ['docker']
+                    }),
+                    enableAndStartDockerCommand(),
+                    ...postInstallSteps
+                ])
+            }
+            case 'Fedora': {
+                return task.newListr([
+                    executeSudoCommand('sudo dnf -y install dnf-plugins-core'),
+                    executeSudoCommand(
+                        'sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo'
+                    ),
+                    executeSudoCommand(
+                        'sudo dnf -y install docker-ce docker-ce-cli containerd.io docker-compose-plugin'
+                    ),
+                    enableAndStartDockerCommand(),
+                    ...postInstallSteps
+                ])
+            }
+            case 'CentOS': {
+                return task.newListr([
+                    executeSudoCommand('sudo yum install -y yum-utils'),
+                    executeSudoCommand(
+                        'sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo'
+                    ),
+                    executeSudoCommand(
+                        'sudo yum install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin'
+                    ),
+                    ...postInstallSteps
+                ])
+            }
+            case 'Ubuntu': {
+                return task.newListr([
+                    downloadDockerInstallScriptCommand(),
+                    runDockerInstallScriptCommand(),
+                    enableAndStartDockerCommand(),
+                    ...postInstallSteps
+                ])
+            }
+            default: {
+                throw new KnownError(`Docker is not installed!
+Your distro ${distro} is not supported by automatic installation.`)
+            }
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 module.exports = {
     installDockerEngine
-};
+}

package/lib/tasks/requirements/docker/performance.js

@@ -1,8 +1,8 @@
-const os = require('os');
-const path = require('path');
-const semver = require('semver');
-const getJsonfileData = require('../../../util/get-jsonfile-data');
-const pathExists = require('../../../util/path-exists');
+const os = require('os')
+const path = require('path')
+const semver = require('semver')
+const getJsonfileData = require('../../../util/get-jsonfile-data')
+const pathExists = require('../../../util/path-exists')
 
 const dockerSettingsJsonPath = path.join(
     os.homedir(),
@@ -10,45 +10,61 @@ const dockerSettingsJsonPath = path.join(
     'Group Containers',
     'group.com.docker',
     'settings.json'
-);
+)
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDockerPerformance = () => ({
     title: 'Checking Docker Performance',
-    // eslint-disable-next-line no-return-await
-    skip: async (ctx) => ctx.platform !== 'darwin' || (ctx.platform === 'darwin' && !(await pathExists(dockerSettingsJsonPath))),
+
+    skip: async (ctx) =>
+        ctx.platform !== 'darwin' ||
+        (ctx.platform === 'darwin' &&
+            !(await pathExists(dockerSettingsJsonPath))),
     task: async (ctx, task) => {
-        const dockerSettings = await getJsonfileData(dockerSettingsJsonPath);
+        const dockerSettings = await getJsonfileData(dockerSettingsJsonPath)
 
         if (!dockerSettings) {
-            task.skip();
-            return;
+            task.skip()
+            return
         }
 
-        const dockerForMacVersionMatch = ctx.dockerServerData.Platform.Name.match(/(\d+\.\d+\.\d+)/i);
+        const dockerForMacVersionMatch =
+            ctx.dockerServerData &&
+            ctx.dockerServerData.Platform.Name.match(/(\d+\.\d+\.\d+)/i)
 
-        const dockerForMacVersion = dockerForMacVersionMatch && dockerForMacVersionMatch[1];
+        const dockerForMacVersion =
+            dockerForMacVersionMatch && dockerForMacVersionMatch[1]
 
-        if (ctx.arch === 'arm64'
-        && semver.gt('12.2.0', ctx.platformVersion)
-        && semver.gt(dockerForMacVersion, '4.6.0')) {
+        if (
+            dockerForMacVersion &&
+            ctx.platformVersion &&
+            ctx.arch === 'arm64' &&
+            semver.gt('12.2.0', ctx.platformVersion) &&
+            semver.gt(dockerForMacVersion, '4.6.0')
+        ) {
             if (!dockerSettings.useVirtualizationFrameworkVirtioFS) {
-                task.title = 'Performance is not optimal. VirtioFS is not enabled.';
+                task.title =
+                    'Performance is not optimal. VirtioFS is not enabled.'
             }
         }
 
-        if (ctx.arch === 'x64'
-        && semver.gt('12.3.0', ctx.platformVersion)
-        && semver.gt(dockerForMacVersion, '4.6.0')) {
+        if (
+            dockerForMacVersion &&
+            ctx.platformVersion &&
+            ctx.arch === 'x64' &&
+            semver.gt('12.3.0', ctx.platformVersion) &&
+            semver.gt(dockerForMacVersion, '4.6.0')
+        ) {
             if (!dockerSettings.useVirtualizationFrameworkVirtioFS) {
-                task.title = 'Performance is not optimal. VirtioFS is not enabled.';
+                task.title =
+                    'Performance is not optimal. VirtioFS is not enabled.'
             }
         }
     }
-});
+})
 
 module.exports = {
     checkDockerPerformance
-};
+}

package/lib/tasks/requirements/docker/permissions.js

@@ -1,49 +1,59 @@
-const os = require('os');
-const fs = require('fs');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const pathExists = require('../../../util/path-exists');
-const executeSudoCommand = require('../../../util/execute-sudo-command');
+const os = require('os')
+const fs = require('fs')
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+const pathExists = require('../../../util/path-exists')
+const executeSudoCommand = require('../../../util/execute-sudo-command')
 
-const dockerSocketPath = '/var/run/docker.sock';
+const dockerSocketPath = '/var/run/docker.sock'
 
-const fixCommand = `sudo chmod 666 ${ dockerSocketPath }`;
+const fixCommand = `sudo chmod 666 ${dockerSocketPath}`
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDockerSocketPermissions = () => ({
     title: 'Checking Docker permissions',
     // skip check if socket does not exist
-    skip: async () => !await pathExists(dockerSocketPath),
+    skip: async () => !(await pathExists(dockerSocketPath)),
     task: async (ctx, task) => {
         try {
-            await fs.promises.access(dockerSocketPath, fs.constants.R_OK);
+            await fs.promises.access(dockerSocketPath, fs.constants.R_OK)
         } catch (e) {
             // check for permission
             if (Math.abs(e.errno) === Math.abs(os.constants.errno.EACCES)) {
                 const confirmPrompt = await task.prompt({
                     type: 'Confirm',
-                    message: `We detected that your Docker socket, located in ${ logger.style.file(dockerSocketPath) }, have permissions set, that prevents user (${ logger.style.misc(os.userInfo().username) }) from accessing it.
+                    message: `We detected that your Docker socket, located in ${logger.style.file(
+                        dockerSocketPath
+                    )}, have permissions set, that prevents user (${logger.style.misc(
+                        os.userInfo().username
+                    )}) from accessing it.
 
-We can fix it by running the following command: ${ logger.style.command(fixCommand) }
+We can fix it by running the following command: ${logger.style.command(
+                        fixCommand
+                    )}
 
 Would you like to fix this permission issue?
 
 Otherwise installation will likely fail.`
-                });
+                })
 
                 if (confirmPrompt) {
-                    return task.newListr(executeSudoCommand(fixCommand));
+                    return task.newListr(executeSudoCommand(fixCommand))
                 }
-                task.skip(`Permission issue detected in ${ logger.style.file(dockerSocketPath) } but user decided not to fix it.`);
+                task.skip(
+                    `Permission issue detected in ${logger.style.file(
+                        dockerSocketPath
+                    )} but user decided not to fix it.`
+                )
             }
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 module.exports = {
     checkDockerSocketPermissions
-};
+}

package/lib/tasks/requirements/docker/running-status.js

@@ -1,18 +1,21 @@
-const KnownError = require('../../../errors/known-error');
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
-const pathExists = require('../../../util/path-exists');
-const sleep = require('../../../util/sleep');
-const { systemctlControl } = require('../../../util/systemctl');
+const KnownError = require('../../../errors/known-error')
+const { execAsyncSpawn } = require('../../../util/exec-async-command')
+const pathExists = require('../../../util/path-exists')
+const sleep = require('../../../util/sleep')
+const { systemctlControl } = require('../../../util/systemctl')
 
-const pathToDockerApplication = '/Applications/Docker.app';
+const pathToDockerApplication = '/Applications/Docker.app'
 
-const getDockerVersion = () => execAsyncSpawn('docker version --format {{.Server.Version}}', {
-    withCode: true
-});
+const getDockerVersion = () =>
+    execAsyncSpawn('docker version --format {{.Server.Version}}', {
+        withCode: true
+    })
 
 const getDockerEngineAndDesktopServiceStatus = async () => {
-    const dockerEngineService = systemctlControl('docker');
-    const dockerDesktopService = systemctlControl('docker-desktop', { user: true });
+    const dockerEngineService = systemctlControl('docker')
+    const dockerDesktopService = systemctlControl('docker-desktop', {
+        user: true
+    })
     const [
         dockerEngineServiceExists,
         dockerDesktopServiceExists,
@@ -27,7 +30,7 @@ const getDockerEngineAndDesktopServiceStatus = async () => {
         dockerDesktopService.isRunning(),
         dockerEngineService.isEnabled(),
         dockerDesktopService.isEnabled()
-    ]);
+    ])
 
     return {
         engine: {
@@ -42,84 +45,94 @@ const getDockerEngineAndDesktopServiceStatus = async () => {
             isRunning: dockerDesktopServiceIsRunning,
             isEnabled: dockerDesktopServiceIsEnabled
         }
-    };
-};
+    }
+}
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDockerStatusMacOS = () => ({
     title: 'Checking Docker status on MacOS',
     task: async (ctx, task) => {
-        const { result, code } = await getDockerVersion();
+        const { result, code } = await getDockerVersion()
 
         if (code !== 0) {
-            if (result.includes('Is the docker daemon running?') || result.includes('docker: command not found')) {
+            if (
+                result.includes('Is the docker daemon running?') ||
+                result.includes('docker: command not found')
+            ) {
                 const dockerOpenAppConfirmation = await task.prompt({
                     type: 'Confirm',
-                    message: 'Looks like Docker is not running, would you like us to open a Docker for Mac application and wait for it to start up?'
-                });
-
-                if (dockerOpenAppConfirmation && await pathExists(pathToDockerApplication)) {
-                    await execAsyncSpawn(`open ${pathToDockerApplication}`);
-                    let ready = false;
-                    let attempts = 0;
+                    message:
+                        'Looks like Docker is not running, would you like us to open a Docker for Mac application and wait for it to start up?'
+                })
+
+                if (
+                    dockerOpenAppConfirmation &&
+                    (await pathExists(pathToDockerApplication))
+                ) {
+                    await execAsyncSpawn(`open ${pathToDockerApplication}`)
+                    let ready = false
+                    let attempts = 0
                     while (!ready) {
                         if (attempts > 24 && !ready) {
-                            throw new KnownError('Docker haven\'t started in 2 mins, exiting...');
+                            throw new KnownError(
+                                "Docker haven't started in 2 mins, exiting..."
+                            )
                         }
                         try {
-                            const { code: startupCode } = await getDockerVersion();
+                            const { code: startupCode } =
+                                await getDockerVersion()
                             if (startupCode !== 0) {
-                                task.output = `Waiting for Docker to startup for ${attempts * 5} seconds...`;
-                                attempts++;
-                                await sleep(5000);
+                                task.output = `Waiting for Docker to startup for ${
+                                    attempts * 5
+                                } seconds...`
+                                attempts++
+                                await sleep(5000)
                             } else {
-                                ready = true;
+                                ready = true
                             }
                         } catch (e) {
-                        //
+                            //
                         }
                     }
 
-                    return;
+                    return
                 }
 
-                task.skip('User skipped running Docker');
+                task.skip('User skipped running Docker')
             }
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDockerStatusWSL = () => ({
     title: 'Checking Docker status on Windows WSL',
     task: async () => {
-        const { result, code } = await getDockerVersion();
+        const { result, code } = await getDockerVersion()
 
         if (code !== 0 && result.includes('Is the docker daemon running?')) {
             throw new KnownError(`Docker is not running!
 
-Please open Docker Desktop application for Windows and make sure that Docker is running. Then you can try again!`);
+Please open Docker Desktop application for Windows and make sure that Docker is running. Then you can try again!`)
         }
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDockerStatusLinux = () => ({
     title: 'Checking Docker status on Linux',
     task: async (ctx, task) => {
-        const {
-            engine,
-            desktop
-        } = await getDockerEngineAndDesktopServiceStatus();
+        const { engine, desktop } =
+            await getDockerEngineAndDesktopServiceStatus()
 
         if (engine.exists) {
             if (!engine.isEnabled && !engine.isRunning) {
@@ -128,28 +141,28 @@ const checkDockerStatusLinux = () => ({
                     message: `Looks like Docker Engine is not enabled and not running, would you like to enable and run it?
 
     This action requires root privileges.`
-                });
+                })
 
                 if (dockerStartConfirmation) {
-                    await engine.service.enableAndStart();
+                    await engine.service.enableAndStart()
 
-                    return;
+                    return
                 }
-                task.skip('User skipped running Docker');
+                task.skip('User skipped running Docker')
             } else if (!engine.isRunning) {
                 const dockerStartConfirmation = await task.prompt({
                     type: 'Confirm',
                     message: `Looks like Docker Engine is not running, would you like to run it?
 
     This action requires root privileges.`
-                });
+                })
 
                 if (dockerStartConfirmation) {
-                    await engine.service.start();
+                    await engine.service.start()
 
-                    return;
+                    return
                 }
-                task.skip('User skipped running Docker Engine');
+                task.skip('User skipped running Docker Engine')
             }
         } else if (desktop.exists) {
             if (!desktop.isEnabled && !desktop.isRunning) {
@@ -158,51 +171,51 @@ const checkDockerStatusLinux = () => ({
                     message: `Looks like Docker Desktop is not enabled and not running, would you like to enable and run it?
 
     This action requires root privileges.`
-                });
+                })
 
                 if (dockerStartConfirmation) {
-                    await desktop.service.enableAndStart();
+                    await desktop.service.enableAndStart()
 
-                    return;
+                    return
                 }
-                task.skip('User skipped running Docker');
+                task.skip('User skipped running Docker')
             } else if (!desktop.isRunning) {
                 const dockerStartConfirmation = await task.prompt({
                     type: 'Confirm',
                     message: `Looks like Docker Desktop is not running, would you like to run it?
 
     This action requires root privileges.`
-                });
+                })
 
                 if (dockerStartConfirmation) {
-                    await desktop.service.start();
+                    await desktop.service.start()
 
-                    return;
+                    return
                 }
-                task.skip('User skipped running Docker Desktop');
+                task.skip('User skipped running Docker Desktop')
             }
         }
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const checkDockerStatus = () => ({
     title: 'Checking Docker status',
     task: async (ctx, task) => {
         if (ctx.platform === 'darwin') {
-            return task.newListr(checkDockerStatusMacOS());
+            return task.newListr(checkDockerStatusMacOS())
         }
         if (!ctx.isWsl) {
-            return task.newListr(checkDockerStatusLinux());
+            return task.newListr(checkDockerStatusLinux())
         }
 
-        return task.newListr(checkDockerStatusWSL());
+        return task.newListr(checkDockerStatusWSL())
     }
-});
+})
 
 module.exports = {
     checkDockerStatus,
     getDockerEngineAndDesktopServiceStatus
-};
+}

package/lib/tasks/requirements/docker/version.js

@@ -1,24 +1,27 @@
-const UnknownError = require('../../../errors/unknown-error');
-const { version } = require('../../docker/api');
+const UnknownError = require('../../../errors/unknown-error')
+const { version } = require('../../docker/api')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const getDockerVersion = () => ({
     task: async (ctx) => {
         const dockerVersion = await version({
             formatToJSON: true
-        });
+        })
 
         if (dockerVersion) {
-            ctx.dockerServerData = dockerVersion.Server;
-            ctx.dockerClientData = dockerVersion.Client;
-            ctx.dockerVersion = dockerVersion.Server.Version;
-            ctx.isDockerDesktop = dockerVersion.Server.Platform.Name.includes('Desktop');
+            ctx.dockerServerData = dockerVersion.Server
+            ctx.dockerClientData = dockerVersion.Client
+            ctx.dockerVersion = dockerVersion.Server.Version
+            ctx.isDockerDesktop =
+                dockerVersion.Server.Platform.Name.includes('Desktop')
         } else {
-            throw new UnknownError(`Got unexpected result during Docker version retrieval!\n\n${ dockerVersion }`);
+            throw new UnknownError(
+                `Got unexpected result during Docker version retrieval!\n\n${dockerVersion}`
+            )
         }
     }
-});
+})
 
-module.exports = getDockerVersion;
+module.exports = getDockerVersion