@scandipwa/magento-scripts 2.0.3 → 2.0.5

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

package/lib/util/nginx-logs-parser.js

@@ -1,52 +1,62 @@
-/* eslint-disable no-bitwise */
-/* eslint-disable max-len */
+/**
+ * @typedef {{ date: Date | null, timestamp: number | null, ip: number | null } & Record<string, string | null>} LogRow
+ */
+
 class NginxParser {
+    /**
+     * @param {String} format
+     */
     constructor(format) {
-        this.directives = {};
+        /**
+         * @type {Record<string, number>}
+         */
+        this.directives = {}
 
-        const prefix = format.match(/^[^$]*/);
+        const prefix = format.match(/^[^$]*/)
         if (prefix) {
-            format = this.escape(prefix[0]) + format.slice(prefix[0].length);
+            format = this.escape(prefix[0]) + format.slice(prefix[0].length)
         }
 
-        this.parser = format;
+        this.parser = format
 
-        const directive = /\$([a-z_]+)(.)?([^$]+)?/g;
-        let match;
-        let regex;
-        let boundary;
-        let i = 1;
+        const directive = /\$([a-z_]+)(.)?([^$]+)?/g
+        let match
+        let regex
+        let boundary
+        let i = 1
 
-        // eslint-disable-next-line no-cond-assign
         while ((match = directive.exec(format))) {
-            this.directives[match[1]] = i++;
+            this.directives[match[1]] = i++
             if (match[2]) {
-                boundary = this.escape(match[2]);
-                regex = `([^${ boundary }]*?)${ boundary}`;
+                boundary = this.escape(match[2])
+                regex = `([^${boundary}]*?)${boundary}`
                 if (match[3]) {
-                    regex += this.escape(match[3]);
+                    regex += this.escape(match[3])
                 }
             } else {
-                regex = '(.+)$';
+                regex = '(.+)$'
             }
-            this.parser = this.parser.replace(match[0], regex);
+            this.parser = this.parser.replace(match[0], regex)
         }
 
-        this.parser = new RegExp(this.parser);
+        this.parser = new RegExp(this.parser)
     }
 
     /**
      * Parse a log line.
      *
      * @param {String} line
-     * @returns {Record<'msec' | 'time_iso8601' | 'remote_addr' | 'query_string' | 'http_x_forwarded_for' | 'http_user_agent' | 'http_referer' | 'time_local' | 'request' | 'status' | 'request_time' | 'request_length' | 'pipe' | 'connection' | 'bytes_sent' | 'body_bytes_sent' | 'date' | 'timestamp' | 'ip' | 'ip_str', string>}
+     * @returns {LogRow | null}
      */
     parseLine(line) {
-        const match = line.match(this.parser);
+        const match = line.match(this.parser)
         if (!match) {
-            return;
+            return null
         }
 
+        /**
+         * @type {LogRow}
+         */
         const row = {
             msec: null,
             time_iso8601: null,
@@ -69,41 +79,41 @@ class NginxParser {
             timestamp: null,
             ip: null,
             ip_str: null
-        };
+        }
 
-        // eslint-disable-next-line guard-for-in
         for (const key in this.directives) {
-            row[key] = match[this.directives[key]];
+            row[key] = match[this.directives[key]]
             if (row[key] === '-') {
-                row[key] = null;
+                row[key] = null
             }
         }
 
         // Parse the timestamp
         if (row.time_iso8601) {
-            row.date = new Date(row.time_iso8601);
+            row.date = new Date(row.time_iso8601)
         } else if (row.msec) {
-            row.date = new Date(Number(row.msec.replace('.', '')));
+            row.date = new Date(Number(row.msec.replace('.', '')))
         }
         if (row.date) {
-            row.timestamp = row.date.getTime();
+            row.timestamp = row.date.getTime()
         }
 
         // Parse the user's IP
         if (row.http_x_forwarded_for) {
-            row.ip_str = row.http_x_forwarded_for;
+            row.ip_str = row.http_x_forwarded_for
         } else if (row.remote_addr) {
-            row.ip_str = row.remote_addr;
+            row.ip_str = row.remote_addr
         }
         if (row.ip_str) {
-            const ip = row.ip_str.split('.', 4);
-            row.ip = Number(ip[0]) * (2 << 23)
-                + Number(ip[1]) * (2 << 15)
-                + Number(ip[2]) * (2 << 7)
-                + Number(ip[3]);
+            const ip = row.ip_str.split('.', 4)
+            row.ip =
+                Number(ip[0]) * (2 << 23) +
+                Number(ip[1]) * (2 << 15) +
+                Number(ip[2]) * (2 << 7) +
+                Number(ip[3])
         }
 
-        return row;
+        return row
     }
 
     /**
@@ -113,10 +123,11 @@ class NginxParser {
      * @return {String}
      */
     escape(str) {
-        return str.replace(new RegExp('[.*+?|()\\[\\]{}]', 'g'), '\\$&');
+        // eslint-disable-next-line no-useless-escape
+        return str.replace(/[.*+?|()\[\]{}]/g, '\\$&')
     }
 }
 
 module.exports = {
     NginxParser
-};
+}

package/lib/util/open-browser.js

@@ -1,9 +1,14 @@
-const { execAsync } = require('./exec-async');
+const { execAsync } = require('./exec-async')
 
+// eslint-disable-next-line no-control-regex
+const consoleStyleReplacer = /[\u001b]\[\S+?m/g
+/**
+ * @param {string} url
+ */
 const openBrowser = async (url) => {
-    const start = process.platform === 'darwin' ? 'open' : 'xdg-open';
+    const start = process.platform === 'darwin' ? 'open' : 'xdg-open'
 
-    await execAsync(`${ start } ${ url }`);
-};
+    await execAsync(`${start} ${url.replace(consoleStyleReplacer, '')}`)
+}
 
-module.exports = openBrowser;
+module.exports = openBrowser

package/lib/util/os-platform.js

@@ -1,51 +1,59 @@
-const fs = require('fs');
-const systeminformation = require('systeminformation');
-const pathExists = require('./path-exists');
-const dependenciesForPlatforms = require('../config/dependencies-for-platforms');
+const fs = require('fs')
+const systeminformation = require('systeminformation')
+const pathExists = require('./path-exists')
+const dependenciesForPlatforms = require('../config/dependencies-for-platforms')
 
 const packageManagers = Object.entries(dependenciesForPlatforms).map((d) => ({
     platform: d[0],
     packageManager: d[1].packageManager
-}));
+}))
 /**
  *
  * @returns {Promise<keyof typeof dependenciesForPlatforms>}
  */
 const osPlatform = async () => {
-    const binPaths = process.env.PATH.split(':');
+    const binPaths = process.env.PATH.split(':')
 
-    const platforms = await Promise.all(binPaths.map(async (binPath) => {
-        if (!await pathExists(binPath)) {
-            return null;
-        }
-        const bins = await fs.promises.readdir(binPath);
-
-        for (const bin of bins) {
-            const possiblePlatforms = packageManagers.filter((p) => p.packageManager === bin);
+    const platforms = (
+        await Promise.all(
+            binPaths.map(async (binPath) => {
+                if (!(await pathExists(binPath))) {
+                    return null
+                }
+                const bins = await fs.promises.readdir(binPath)
 
-            if (possiblePlatforms.length > 0) {
-                if (possiblePlatforms.length > 1) {
-                    const { distro } = await systeminformation.osInfo();
+                for (const bin of bins) {
+                    const possiblePlatforms = packageManagers.filter(
+                        (p) => p.packageManager === bin
+                    )
 
-                    const foundDistro = possiblePlatforms.find((p) => p.platform.toLowerCase().includes(distro.toLowerCase()));
+                    if (possiblePlatforms.length > 0) {
+                        if (possiblePlatforms.length > 1) {
+                            const { distro } = await systeminformation.osInfo()
 
-                    if (foundDistro) {
-                        return foundDistro.platform;
-                    }
+                            const foundDistro = possiblePlatforms.find((p) =>
+                                p.platform
+                                    .toLowerCase()
+                                    .includes(distro.toLowerCase())
+                            )
 
-                    return possiblePlatforms[0].platform;
-                }
+                            if (foundDistro) {
+                                return foundDistro.platform
+                            }
 
-                return possiblePlatforms[0].platform;
-            }
-        }
+                            return possiblePlatforms[0].platform
+                        }
 
-        return null;
-    }));
+                        return possiblePlatforms[0].platform
+                    }
+                }
 
-    const filteredPlatforms = platforms.filter(Boolean);
+                return null
+            })
+        )
+    ).filter(Boolean)
 
-    return filteredPlatforms.shift();
-};
+    return platforms.shift()
+}
 
-module.exports = osPlatform;
+module.exports = osPlatform

package/lib/util/path-exists-sync.js

@@ -1,13 +1,17 @@
-const fs = require('fs');
+const fs = require('fs')
 
+/**
+ * @param {string} path
+ * @returns {boolean}
+ */
 const pathExistsSync = (path) => {
     try {
-        fs.accessSync(path, fs.constants.F_OK);
+        fs.accessSync(path, fs.constants.F_OK)
     } catch (e) {
-        return false;
+        return false
     }
 
-    return true;
-};
+    return true
+}
 
-module.exports = pathExistsSync;
+module.exports = pathExistsSync

package/lib/util/path-exists.js

@@ -1,4 +1,4 @@
-const fs = require('fs');
+const fs = require('fs')
 
 /**
  * Check if provided path exists in filesystem
@@ -7,12 +7,12 @@ const fs = require('fs');
  */
 const pathExists = async (path) => {
     try {
-        await fs.promises.access(path, fs.constants.F_OK);
+        await fs.promises.access(path, fs.constants.F_OK)
     } catch (e) {
-        return false;
+        return false
     }
 
-    return true;
-};
+    return true
+}
 
-module.exports = pathExists;
+module.exports = pathExists

package/lib/util/php-task.js

@@ -1,18 +1,19 @@
-const { runPHPContainerCommand } = require('../tasks/php/php-container');
+const { runPHPContainerCommand } = require('../tasks/php/php-container')
 
 /**
  * @param {String} command
- * @param {{ noTitle: boolean, env: Record<string, string> }} options
+ * @param {{ noTitle?: boolean, env?: Record<string, string> }} [options]
  * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const phpTask = (command, options = {}) => ({
     title: !options.noTitle ? `Running command 'php ${command}` : undefined,
-    task: (ctx, task) => runPHPContainerCommand(ctx, command, {
-        callback: (t) => {
-            task.output = t;
-        },
-        throwNonZeroCode: true
-    })
-});
+    task: (ctx, task) =>
+        runPHPContainerCommand(ctx, command, {
+            callback: (t) => {
+                task.output = t
+            },
+            withCode: true
+        })
+})
 
-module.exports = phpTask;
+module.exports = phpTask