@scandipwa/magento-scripts 2.0.3 → 2.0.4

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,12 @@
-const { execAsync } = require('./exec-async');
+const { execAsync } = require('./exec-async')
 
+/**
+ * @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}`)
+}
 
-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

package/lib/util/portscanner.js

@@ -1,10 +1,11 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 /**
  * This is modified version of node-portscanner (https://github.com/baalexander/node-portscanner/blob/master/lib/portscanner.js)
  * with added option to ignore ports and reduced dependencies count
  */
-const net = require('net');
+const net = require('net')
 
-const { Socket } = net;
+const { Socket } = net
 
 /**
  * Checks the status of an individual port.
@@ -14,141 +15,152 @@ const { Socket } = net;
  * @param {Number} [options.timeout] - Connection timeout in ms.
  * @returns {Promise<string>}
  */
-const checkPortStatus = (port, options = {}) => new Promise((resolve, reject) => {
-    const {
-        host = '127.0.0.1',
-        timeout = 400
-    } = options;
-
-    let connectionRefused = false;
-
-    const socket = new Socket();
-    let status = null;
-    let error = null;
-
-    // Socket connection established, port is open
-    socket.on('connect', () => {
-        status = 'open';
-        socket.destroy();
-    });
-
-    // If no response, assume port is not listening
-    socket.setTimeout(timeout);
-    socket.on('timeout', () => {
-        status = 'closed';
-        error = new Error(`Timeout (${ timeout }ms) occurred waiting for ${ host }:${ port } to be available`);
-        socket.destroy();
-    });
-
-    // Assuming the port is not open if an error. May need to refine based on
-    // exception
-    socket.on('error', (exception) => {
-        if (exception.code !== 'ECONNREFUSED') {
-            error = exception;
-        } else {
-            connectionRefused = true;
-        }
-        status = 'closed';
-    });
-
-    // Return after the socket has closed
-    socket.on('close', (exception) => {
-        if (exception && !connectionRefused) {
-            error = error || exception;
-        } else {
-            error = null;
-        }
-        if (error) {
-            return reject(error);
-        }
-
-        return resolve(status);
-    });
-
-    socket.connect(port, host);
-});
+const checkPortStatus = (port, options = {}) =>
+    new Promise((resolve, reject) => {
+        const { host = '127.0.0.1', timeout = 400 } = options
+
+        let connectionRefused = false
+
+        const socket = new Socket()
+        /**
+         * @type {string}
+         */
+        let status
+
+        /**
+         * @type {Error | null}
+         */
+        let error
+
+        // Socket connection established, port is open
+        socket.on('connect', () => {
+            status = 'open'
+            socket.destroy()
+        })
+
+        // If no response, assume port is not listening
+        socket.setTimeout(timeout)
+        socket.on('timeout', () => {
+            status = 'closed'
+            error = new Error(
+                `Timeout (${timeout}ms) occurred waiting for ${host}:${port} to be available`
+            )
+            socket.destroy()
+        })
+
+        // Assuming the port is not open if an error. May need to refine based on
+        // exception
+        socket.on('error', (exception) => {
+            // @ts-ignore
+            if (exception.code !== 'ECONNREFUSED') {
+                error = exception
+            } else {
+                connectionRefused = true
+            }
+            status = 'closed'
+        })
+
+        // Return after the socket has closed
+        socket.on('close', (hadError) => {
+            if (hadError && !connectionRefused) {
+                error = new Error('Socket closed with an error!')
+            } else {
+                error = null
+            }
+            if (error) {
+                return reject(error)
+            }
+
+            return resolve(status)
+        })
+
+        socket.connect(port, host)
+    })
 
 /**
  * Internal helper function used by {@link findAPortInUse} and {@link findAPortNotInUse}
  * to find a port from a range or a list with a specific status.
  * @param {String} status - Status to check.
- * @param {Object} [options]
+ * @param {Object} options
  * @param {Number} options.startPort Port to begin status check on (inclusive).
  * @param {Number} options.endPort Last port to check status on (inclusive).
- * @param {String} options.host Host of where to scan.
- * @param {Number[]} options.portList Array of ports to check status on.
- * @param {Number[]} options.portIgnoreList Array of ports to check status on.
- * @returns {Promise<number>}
+ * @param {String} [options.host] Host of where to scan.
+ * @param {Number[]} [options.portList] Array of ports to check status on.
+ * @param {Number[]} [options.portIgnoreList] Array of ports to check status on.
+ * @returns {Promise<number | false>}
  */
-async function findAPortWithStatus(status, options = {}) {
+async function findAPortWithStatus(status, options) {
     const {
         portList,
         startPort,
         endPort = 65535,
         host,
         portIgnoreList = []
-    } = options;
+    } = options
 
-    let foundPort = false;
-    let numberOfPortsChecked = 0;
-    let port = portList ? portList[0] : startPort;
+    let foundPort = false
+    let numberOfPortsChecked = 0
+    let port = portList ? portList[0] : startPort
 
     // Returns true if a port with matching status has been found or if checked
     // the entire range of ports
-    const hasFoundPort = () => foundPort || numberOfPortsChecked === (portList ? portList.length : endPort - startPort + 1);
+    const hasFoundPort = () =>
+        foundPort ||
+        numberOfPortsChecked ===
+            (portList ? portList.length : endPort - startPort + 1)
 
     // Checks the status of the port
     const checkNextPort = async () => {
         if (portIgnoreList.includes(port)) {
-            numberOfPortsChecked++;
-            port = portList ? portList[numberOfPortsChecked] : port + 1;
-            return;
+            numberOfPortsChecked++
+            port = portList ? portList[numberOfPortsChecked] : port + 1
+            return
         }
-        const statusOfPort = await checkPortStatus(port, { host });
+        const statusOfPort = await checkPortStatus(port, { host })
         if (statusOfPort === status) {
-            foundPort = true;
-            return;
+            foundPort = true
+            return
         }
-        numberOfPortsChecked++;
-        port = portList ? portList[numberOfPortsChecked] : port + 1;
-    };
+        numberOfPortsChecked++
+        port = portList ? portList[numberOfPortsChecked] : port + 1
+    }
 
     while (!hasFoundPort()) {
-        await checkNextPort();
+        await checkNextPort()
     }
 
     if (foundPort) {
-        return port;
+        return port
     }
 
-    return false;
+    return false
 }
 
 /**
  * Finds the first port with a status of 'open', implying the port is in use and
  * there is likely a service listening on it.
- * @param {Object} [options]
+ * @param {Object} options
  * @param {Number} options.startPort Port to begin status check on (inclusive).
  * @param {Number} options.endPort Last port to check status on (inclusive).
  * @param {String} options.host Host of where to scan.
  * @param {Number[]} options.portList Array of ports to check status on.
  * @param {Number[]} options.portIgnoreList Array of ports to check status on.
  */
-const findAPortInUse = (options) => findAPortWithStatus('open', options);
+const findAPortInUse = (options) => findAPortWithStatus('open', options)
 
 /**
  * Finds the first port with a status of 'closed', implying the port is not in
- * @param {Object} [options]
+ * @param {Object} options
  * @param {Number} options.startPort Port to begin status check on (inclusive).
  * @param {Number} options.endPort Last port to check status on (inclusive).
- * @param {String} options.host Host of where to scan.
- * @param {Number[]} options.portList Array of ports to check status on.
+ * @param {String} [options.host] Host of where to scan.
+ * @param {Number[]} [options.portList] Array of ports to check status on.
  * @param {Number[]} options.portIgnoreList Array of ports to check status on.
  */
-const findAPortNotInUse = (options) => findAPortWithStatus('closed', options);
+const findAPortNotInUse = (options) => findAPortWithStatus('closed', options)
 
 module.exports = {
     findAPortInUse,
     findAPortNotInUse,
     checkPortStatus
-};
+}