@scandipwa/magento-scripts 2.0.3 → 2.0.4

package/lib/util/get-jsonfile-data.js

@@ -1,19 +1,24 @@
-const fs = require('fs');
-const UnknownError = require('../errors/unknown-error');
-const pathExists = require('./path-exists');
+const fs = require('fs')
+const UnknownError = require('../errors/unknown-error')
+const pathExists = require('./path-exists')
 
+/**
+ * @type {<T>(fileData: string) => Promise<T | null>}
+ */
 const getJsonfileData = async (filePath) => {
-    const fileExists = await pathExists(filePath);
+    const fileExists = await pathExists(filePath)
 
     if (!fileExists) {
-        return null;
+        return null
     }
 
     try {
-        return JSON.parse(await fs.promises.readFile(filePath, 'utf-8'));
+        return JSON.parse(await fs.promises.readFile(filePath, 'utf-8'))
     } catch (e) {
-        throw new UnknownError(`Ooops! Something went wrong when trying to json parse ${filePath} file!\n\n${e}`);
+        throw new UnknownError(
+            `Ooops! Something went wrong when trying to json parse ${filePath} file!\n\n${e}`
+        )
     }
-};
+}
 
-module.exports = getJsonfileData;
+module.exports = getJsonfileData

package/lib/util/install-dependencies-task.js

@@ -1,100 +1,112 @@
-const os = require('os');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const sleep = require('./sleep');
-const { execCommandTask } = require('./exec-async-command');
-const dependenciesForPlatforms = require('../config/dependencies-for-platforms');
-const KnownError = require('../errors/known-error');
+const os = require('os')
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+const sleep = require('./sleep')
+const { execCommandTask } = require('./exec-async-command')
+const dependenciesForPlatforms = require('../config/dependencies-for-platforms')
+const KnownError = require('../errors/known-error')
 
 /**
  * Install dependencies
  * @param {object} options
  * @param {keyof dependenciesForPlatforms} options.platform Platform
  * @param {string[]} options.dependenciesToInstall List of dependencies to install
- * @param {boolean} options.useMacNativeEnvironment Use Mac native environment
+ * @param {boolean} [options.useMacNativeEnvironment] Use Mac native environment
  * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const installDependenciesTask = (options) => ({
     task: async (ctx, task) => {
-        const { dependenciesToInstall, platform } = options;
-        task.title = `Installing ${platform} dependencies`;
-        let cmd;
+        const { dependenciesToInstall, platform } = options
+        task.title = `Installing ${platform} dependencies`
+        let cmd
         if (os.platform() === 'darwin') {
-            cmd = dependenciesForPlatforms[platform].installCommand(dependenciesToInstall.join(' '), {
-                native: options.useMacNativeEnvironment
-            });
+            cmd = dependenciesForPlatforms[platform].installCommand(
+                dependenciesToInstall.join(' '),
+                {
+                    native: options.useMacNativeEnvironment
+                }
+            )
         } else {
-            cmd = dependenciesForPlatforms[platform].installCommand(dependenciesToInstall.join(' '));
+            cmd = dependenciesForPlatforms[platform].installCommand(
+                dependenciesToInstall.join(' ')
+            )
         }
-        const installCommand = logger.style.code(cmd);
-        const dependenciesWordFormatter = `dependenc${dependenciesToInstall.length > 1 ? 'ies' : 'y'}`;
-        task.title = `Installing missing dependencies: ${ logger.style.code(dependenciesToInstall.join(', ')) }`;
-        task.output = `Missing ${ dependenciesWordFormatter } ${ logger.style.code(dependenciesToInstall.join(' ')) } detected!`;
+        const installCommand = logger.style.code(cmd)
+        const dependenciesWordFormatter = `dependenc${
+            dependenciesToInstall.length > 1 ? 'ies' : 'y'
+        }`
+        task.title = `Installing missing dependencies: ${logger.style.code(
+            dependenciesToInstall.join(', ')
+        )}`
+        task.output = `Missing ${dependenciesWordFormatter} ${logger.style.code(
+            dependenciesToInstall.join(' ')
+        )} detected!`
 
-        let promptSkipper = false;
+        let promptSkipper = false
         const timer = async () => {
             for (let i = 5 * 60; i !== 0; i--) {
-                await sleep(1000);
+                await sleep(1000)
                 if (promptSkipper) {
-                    return null;
+                    return null
                 }
-                task.title = `Checking ${platform} dependencies (${i} sec left...)`;
+                task.title = `Checking ${platform} dependencies (${i} sec left...)`
             }
-            task.cancelPrompt();
-            return 'timeout';
-        };
+            task.cancelPrompt()
+            return 'timeout'
+        }
 
         const installAnswer = await Promise.race([
             task.prompt({
                 type: 'Select',
-                message: `Do you want to install missing ${ dependenciesWordFormatter } now?`,
+                message: `Do you want to install missing ${dependenciesWordFormatter} now?`,
                 name: 'installAnswer',
                 choices: [
                     {
                         name: 'install',
-                        message: `Install ${ dependenciesWordFormatter } now!`
+                        message: `Install ${dependenciesWordFormatter} now!`
                     },
                     {
                         name: 'not-install',
-                        message: `Install ${ dependenciesWordFormatter } later, when I feel it.`
+                        message: `Install ${dependenciesWordFormatter} later, when I feel it.`
                     }
                 ]
             }),
             timer()
-        ]);
+        ])
 
-        promptSkipper = true;
+        promptSkipper = true
 
         if (installAnswer === 'timeout') {
             throw new KnownError(`Timeout!
 
-To install missing ${ dependenciesWordFormatter } manually, run the following command: ${ installCommand }`);
+To install missing ${dependenciesWordFormatter} manually, run the following command: ${installCommand}`)
         }
 
         if (installAnswer === 'not-install') {
-            task.skip(`User chose to skip installation of ${ dependenciesWordFormatter }`);
-            return;
+            task.skip(
+                `User chose to skip installation of ${dependenciesWordFormatter}`
+            )
+            return
         }
 
         if (installAnswer === 'install') {
             // on macos we don't need sudo permissions to install dependencies, so every other platform required to do that
             if (platform !== 'darwin') {
-                task.output = `Enter your sudo password! It's needed for ${ dependenciesWordFormatter } installation.`;
-                task.output = logger.style.command(`>[sudo] password for ${ os.userInfo().username }:`);
+                task.output = `Enter your sudo password! It's needed for ${dependenciesWordFormatter} installation.`
+                task.output = logger.style.command(
+                    `>[sudo] password for ${os.userInfo().username}:`
+                )
             }
 
             return task.newListr(
                 execCommandTask(cmd, {
-                    callback: (t) => {
-                        task.output = t;
-                    },
                     pipeInput: true
                 })
-            );
+            )
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
-module.exports = installDependenciesTask;
+module.exports = installDependenciesTask

package/lib/util/instance-metadata.js

@@ -1,20 +1,23 @@
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
 
-const WEB_LOCAL_LOCATION_TITLE = `Location on ${ logger.style.misc('localhost') }`;
-const WEB_LOCATION_TITLE = 'Location on the Web';
-const WEB_ADMIN_LOCATION_TITLE = 'Panel location';
-const WEB_ADMIN_CREDENTIALS_TITLE = 'Panel credentials';
-const WEB_MAILDEV_LOCATION_TITLE = 'Panel location';
+const WEB_LOCAL_LOCATION_TITLE = `Location on ${logger.style.misc('localhost')}`
+const WEB_LOCATION_TITLE = 'Location on the Web'
+const WEB_ADMIN_LOCATION_TITLE = 'Panel location'
+const WEB_ADMIN_CREDENTIALS_TITLE = 'Panel credentials'
+const WEB_MAILDEV_LOCATION_TITLE = 'Panel location'
 
+/**
+ * @param {{ title: string, text: string }} param0
+ */
 const mapDataStyle = ({ title, text }) => ({
     title,
     text: logger.style.link(text),
     link: text
-});
+})
 
 /**
  * @param {import("../../typings/context").ListrContext} ctx
- * @return {{ frontend: { title: string, text: string }[], admin: { title: string, url: string }[], maildev: { title: string, text: string }[] }}
+ * @return {{ frontend: { title: string, text: string }[], admin: { title: string, text: string }[], maildev: { title: string, text: string }[] }}
  */
 const getInstanceMetadata = (ctx) => {
     const {
@@ -23,64 +26,76 @@ const getInstanceMetadata = (ctx) => {
             magentoConfiguration,
             overridenConfiguration: { host, ssl }
         }
-    } = ctx;
+    } = ctx
 
     /**
      * @type {{ title: string, text: string }[]}
      */
-    const frontend = [];
+    const frontend = []
 
     /**
      * @type {{ title: string, text: string }[]}
      */
-    const admin = [];
+    const admin = []
 
     /**
      * @type {{ title: string, text: string }[]}
      */
-    const maildev = [];
+    const maildev = []
 
-    const isNgrok = host.endsWith('ngrok.io');
+    const isNgrok = host.endsWith('ngrok.io')
 
     if (isNgrok) {
         frontend.push({
             title: WEB_LOCAL_LOCATION_TITLE,
-            text: `${ssl.enabled ? 'https' : 'http'}://localhost${ssl.enabled || ports.sslTerminator === 80 ? '' : `:${ports.sslTerminator}`}/`
-        });
+            text: `${ssl.enabled ? 'https' : 'http'}://localhost${
+                ssl.enabled || ports.sslTerminator === 80
+                    ? ''
+                    : `:${ports.sslTerminator}`
+            }/`
+        })
         frontend.push({
             title: WEB_LOCATION_TITLE,
             text: `${ssl.enabled ? 'https' : 'http'}://${host}/`
-        });
+        })
     } else {
         frontend.push({
             title: WEB_LOCATION_TITLE,
-            text: `${ssl.enabled ? 'https' : 'http'}://${host}${ssl.enabled || ports.sslTerminator === 80 ? '' : `:${ports.sslTerminator}`}/`
-        });
+            text: `${ssl.enabled ? 'https' : 'http'}://${host}${
+                ssl.enabled || ports.sslTerminator === 80
+                    ? ''
+                    : `:${ports.sslTerminator}`
+            }/`
+        })
     }
 
-    const webLocation = frontend.find((u) => u.title === WEB_LOCATION_TITLE);
+    const webLocation = frontend.find((u) => u.title === WEB_LOCATION_TITLE)
 
-    admin.push({
-        title: WEB_ADMIN_LOCATION_TITLE,
-        text: logger.style.link(`${webLocation.text}admin`)
-    });
+    if (webLocation) {
+        admin.push({
+            title: WEB_ADMIN_LOCATION_TITLE,
+            text: logger.style.link(`${webLocation.text}admin`)
+        })
+    }
 
     admin.push({
         title: WEB_ADMIN_CREDENTIALS_TITLE,
-        text: `${logger.style.misc(magentoConfiguration.user)} - ${logger.style.misc(magentoConfiguration.password)}`
-    });
+        text: `${logger.style.misc(
+            magentoConfiguration.user
+        )} - ${logger.style.misc(magentoConfiguration.password)}`
+    })
 
     maildev.push({
         title: WEB_MAILDEV_LOCATION_TITLE,
         text: `http://${host}:${ports.maildevWeb}/`
-    });
+    })
 
     return {
         admin,
         frontend: frontend.map(mapDataStyle),
         maildev: maildev.map(mapDataStyle)
-    };
-};
+    }
+}
 
 module.exports = {
     getInstanceMetadata,
@@ -90,4 +105,4 @@ module.exports = {
         WEB_ADMIN_LOCATION_TITLE,
         WEB_ADMIN_CREDENTIALS_TITLE
     }
-};
+}

package/lib/util/ip.js

@@ -1,8 +1,12 @@
-const { request } = require('smol-request');
+const { request } = require('smol-request')
 
-const ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+const ipRegex =
+    /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
 
-const isIpAddress = (text) => ipRegex.test(text);
+/**
+ * @param {string} text
+ */
+const isIpAddress = (text) => ipRegex.test(text)
 
 const externalIpProviders = [
     'http://api.ipify.org/',
@@ -16,24 +20,24 @@ const externalIpProviders = [
     'http://ipecho.net/plain',
     'http://diagnostic.opendns.com/myip',
     'http://trackip.net/ip'
-];
+]
 
 /**
  * Get an external IP address
  * @returns {Promise<string>}
  */
 const getExternalIpAddress = async () => {
-    let ip;
+    let ip
 
     for (const ipProvider of externalIpProviders) {
         try {
             const response = await request(ipProvider, {
                 responseType: 'text'
-            });
+            })
 
             if (response.status === 200) {
-                ip = response.data;
-                break;
+                ip = response.data
+                break
             }
         } catch (e) {
             //
@@ -41,14 +45,14 @@ const getExternalIpAddress = async () => {
     }
 
     if (!ip) {
-        throw new Error('External IP address is not available!');
+        throw new Error('External IP address is not available!')
     }
 
-    return ip;
-};
+    return ip
+}
 
 module.exports = {
     ipRegex,
     isIpAddress,
     getExternalIpAddress
-};
+}

package/lib/util/is-running-root.js

@@ -1,5 +1,8 @@
-const os = require('os');
+const os = require('os')
 
-const isRunningRoot = () => ['linux', 'darwin'].includes(os.platform()) && process.getuid() === 0; // UID 0 is always root
+const isRunningRoot = () =>
+    ['linux', 'darwin'].includes(os.platform()) &&
+    process.getuid &&
+    process.getuid() === 0 // UID 0 is always root
 
-module.exports = isRunningRoot;
+module.exports = isRunningRoot

package/lib/util/is-wsl.js

@@ -1,5 +1,5 @@
-const os = require('os');
-const fs = require('fs');
+const os = require('os')
+const fs = require('fs')
 
 /**
  * Checks if process is running in wsl mode
@@ -7,24 +7,24 @@ const fs = require('fs');
  */
 const getIsWsl = async () => {
     if (process.platform !== 'linux') {
-        return false;
+        return false
     }
 
     if (typeof process.env.WSL_DISTRO_NAME === 'string') {
-        return true;
+        return true
     }
 
     if (os.release().toLowerCase().includes('microsoft')) {
-        return true;
+        return true
     }
 
     try {
-        const procVersion = await fs.promises.readFile('/proc/version', 'utf8');
+        const procVersion = await fs.promises.readFile('/proc/version', 'utf8')
 
-        return procVersion.toLowerCase().includes('microsoft');
+        return procVersion.toLowerCase().includes('microsoft')
     } catch (e) {
-        return false;
+        return false
     }
-};
+}
 
-module.exports = getIsWsl;
+module.exports = getIsWsl

package/lib/util/macos-version.js

@@ -1,20 +1,21 @@
-const semver = require('semver');
-const macosVersion = require('macos-version');
-const { execAsyncSpawn } = require('./exec-async-command');
+const semver = require('semver')
+const macosVersion = require('macos-version')
+const { execAsyncSpawn } = require('./exec-async-command')
 
 const getMacOSVersion = async () => {
-    const { code, result } = await execAsyncSpawn('sw_vers -productVersion',
-        {
-            withCode: true
-        });
+    const { code, result } = await execAsyncSpawn('sw_vers -productVersion', {
+        withCode: true
+    })
 
     if (code !== 0) {
-        return macosVersion();
+        return macosVersion()
     }
 
-    return semver.coerce(result).version;
-};
+    const { version } = semver.coerce(result) || {}
+
+    return version
+}
 
 module.exports = {
     getMacOSVersion
-};
+}

package/lib/util/magento-task.js

@@ -1,4 +1,5 @@
-const runMagentoCommand = require('./run-magento');
+const UnknownError = require('../errors/unknown-error')
+const runMagentoCommand = require('./run-magento')
 
 /**
  * @param {String} command
@@ -11,20 +12,24 @@ const magentoTask = (command, options = {}) => ({
     task: async (ctx, task) => {
         try {
             await runMagentoCommand(ctx, command, {
-                callback: !ctx.verbose ? undefined : (t) => {
-                    task.output = t;
-                },
+                callback: !ctx.verbose
+                    ? undefined
+                    : (t) => {
+                          task.output = t
+                      },
                 throwNonZeroCode: true
-            });
+            })
         } catch (e) {
-            if (options.onError) {
-                options.onError(e);
+            if (e instanceof UnknownError && options.onError) {
+                options.onError(e)
             }
+
+            throw e
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
-module.exports = magentoTask;
+module.exports = magentoTask

package/lib/util/match-filesystem.js

@@ -1,5 +1,5 @@
-const path = require('path');
-const pathExists = require('./path-exists');
+const path = require('path')
+const pathExists = require('./path-exists')
 
 /**
  * Check file system structure to detect possible unfinished installation
@@ -9,25 +9,31 @@ const pathExists = require('./path-exists');
  */
 const matchFilesystem = async (cwd, structure) => {
     if (Array.isArray(structure)) {
-        const ok = (await Promise.all(structure.map((str) => pathExists(path.join(cwd, str)))))
-            .every((value) => value === true);
+        const ok = (
+            await Promise.all(
+                structure.map((str) => pathExists(path.join(cwd, str)))
+            )
+        ).every((value) => value === true)
 
-        return ok;
+        return ok
     }
     if (typeof structure === 'object') {
-        const ok = (await Promise.all(Object.entries(structure).map(([key, value]) => {
-            if (typeof value === 'boolean') {
-                return pathExists(path.join(cwd, key));
-            }
+        const ok = (
+            await Promise.all(
+                Object.entries(structure).map(([key, value]) => {
+                    if (typeof value === 'boolean') {
+                        return pathExists(path.join(cwd, key))
+                    }
 
-            return matchFilesystem(path.join(cwd, key), value);
-        })))
-            .every((value) => value === true);
+                    return matchFilesystem(path.join(cwd, key), value)
+                })
+            )
+        ).every((value) => value === true)
 
-        return ok;
+        return ok
     }
 
-    return pathExists(path.join(cwd, structure));
-};
+    return pathExists(path.join(cwd, structure))
+}
 
-module.exports = matchFilesystem;
+module.exports = matchFilesystem

package/lib/util/move-file.js

@@ -1,38 +1,53 @@
-const fs = require('fs');
+const fs = require('fs')
 
+/**
+ * @param {{ from: string, to: string }} param0
+ */
 const moveFile = async ({ from, to }) => {
-    const copy = () => new Promise((resolve, reject) => {
-        const readStream = fs.createReadStream(from);
-        const writeStream = fs.createWriteStream(to);
-        const onError = async (e) => {
-            await fs.promises.unlink(to);
-            reject(e);
-        };
+    /**
+     * @returns {Promise<void>}
+     */
+    const copy = () =>
+        new Promise((resolve, reject) => {
+            const readStream = fs.createReadStream(from)
+            const writeStream = fs.createWriteStream(to)
+            /**
+             * @param {Error} e
+             */
+            const onError = async (e) => {
+                await fs.promises.unlink(to)
+                reject(e)
+            }
 
-        readStream.on('error', onError);
-        writeStream.on('error', onError);
+            readStream.on('error', onError)
+            writeStream.on('error', onError)
 
-        readStream.on('close', async () => {
-            try {
-                await fs.promises.unlink(from);
-            } catch (e) {
-                onError(e);
-            }
-            resolve();
-        });
+            readStream.on('close', async () => {
+                try {
+                    await fs.promises.unlink(from)
+                } catch (e) {
+                    if (e instanceof Error) {
+                        onError(e)
+                        return
+                    } else if (typeof e === 'string') {
+                        onError(new Error(e))
+                    }
+                }
+                resolve()
+            })
 
-        readStream.pipe(writeStream);
-    });
+            readStream.pipe(writeStream)
+        })
 
     try {
-        await fs.promises.rename(from, to);
+        await fs.promises.rename(from, to)
     } catch (e) {
         if (e && e.code === 'EXDEV') {
-            await copy();
+            await copy()
         } else {
-            throw e;
+            throw e
         }
     }
-};
+}
 
-module.exports = moveFile;
+module.exports = moveFile