@scandipwa/magento-scripts 2.0.3-alpha.0 → 2.0.4

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
-};
+}

package/lib/util/prefix.js

@@ -1,16 +1,18 @@
-const path = require('path');
-const fs = require('fs');
-const { projectsConfig, projectKey } = require('../config/config');
+const path = require('path')
+const fs = require('fs')
+const { projectsConfig, projectKey } = require('../config/config')
 
-const { name: legacyFolderName, base: folderName } = path.parse(process.cwd());
+const { name: legacyFolderName, base: folderName } = path.parse(process.cwd())
 
 const getPrefix = (fName = folderName) => {
-    const projectInGlobalConfig = projectsConfig.get(projectKey);
+    const projectInGlobalConfig = projectsConfig.get(projectKey)
 
     if (!projectInGlobalConfig || !projectInGlobalConfig.createdAt) {
-        const projectStat = fs.statSync(process.cwd());
-        const projectCreatedAt = Math.floor(projectStat.birthtime.getTime() / 1000).toString();
-        process.isFirstStart = 1;
+        const projectStat = fs.statSync(process.cwd())
+        const projectCreatedAt = Math.floor(
+            projectStat.birthtime.getTime() / 1000
+        ).toString()
+        process.isFirstStart = 1
 
         // if createdAt property does not set in config, means that project is threaded as legacy
         // so it uses docker volumes and containers names without prefixes, so it doesn't have creation date
@@ -18,38 +20,45 @@ const getPrefix = (fName = folderName) => {
         projectsConfig.set(projectKey, {
             prefix: '',
             createdAt: projectCreatedAt
-        });
+        })
     }
 
     if (projectInGlobalConfig && projectInGlobalConfig.prefix) {
-        return `${fName}-${projectInGlobalConfig.prefix}`;
+        return `${fName}-${projectInGlobalConfig.prefix}`
     }
 
-    return fName;
-};
+    return fName
+}
 
 const getProjectCreatedAt = () => {
-    const projectInGlobalConfig = projectsConfig.get(projectKey);
+    const projectInGlobalConfig = projectsConfig.get(projectKey)
 
     if (projectInGlobalConfig && projectInGlobalConfig.createdAt) {
-        return new Date(parseInt(projectInGlobalConfig.createdAt, 10) * 1000);
+        return new Date(parseInt(projectInGlobalConfig.createdAt, 10) * 1000)
     }
 
-    return null;
-};
+    return null
+}
 
+/**
+ * @param {boolean} usePrefix
+ */
 const setPrefix = (usePrefix) => {
-    const projectInGlobalConfig = projectsConfig.get(projectKey);
+    const projectInGlobalConfig = projectsConfig.get(projectKey)
     if (projectInGlobalConfig) {
         if (usePrefix && !projectInGlobalConfig.prefix) {
-            const createdAt = projectInGlobalConfig.createdAt || Math.floor(fs.statSync(process.cwd()).birthtime.getTime() / 1000).toString();
-            projectsConfig.set(`${projectKey}.prefix`, createdAt);
+            const createdAt =
+                projectInGlobalConfig.createdAt ||
+                Math.floor(
+                    fs.statSync(process.cwd()).birthtime.getTime() / 1000
+                ).toString()
+            projectsConfig.set(`${projectKey}.prefix`, createdAt)
         }
         if (!usePrefix && projectInGlobalConfig.prefix) {
-            projectsConfig.set(`${projectKey}.prefix`, '');
+            projectsConfig.set(`${projectKey}.prefix`, '')
         }
     }
-};
+}
 
 module.exports = {
     setPrefix,
@@ -57,4 +66,4 @@ module.exports = {
     getProjectCreatedAt,
     legacyFolderName,
     folderName
-};
+}

package/lib/util/resolve-configuration-with-overrides.js

@@ -1,32 +1,47 @@
-const path = require('path');
-const UnknownError = require('../errors/unknown-error');
-const { configFileSchema } = require('./config-file-validator');
-const { deepmerge } = require('./deepmerge');
-const pathExists = require('./path-exists');
+const path = require('path')
+const UnknownError = require('../errors/unknown-error')
+const { configFileSchema } = require('./config-file-validator')
+const { deepmerge } = require('./deepmerge')
+const pathExists = require('./path-exists')
 
-const resolveConfigurationWithOverrides = async (configuration, baseConfig, projectPath = process.cwd()) => {
-    const configJSFilePath = path.join(projectPath, 'cma.js');
+/**
+ * @param {import('../../typings/index').CMAConfiguration} configuration
+ * @param {string} [projectPath]
+ */
+const resolveConfigurationWithOverrides = async (
+    configuration,
+    projectPath = process.cwd()
+) => {
+    const configJSFilePath = path.join(projectPath, 'cma.js')
     if (await pathExists(configJSFilePath)) {
-        const userConfiguration = require(configJSFilePath);
+        /**
+         * @type {import('../../typings/index').CMAConfiguration}
+         */
+        const userConfiguration = require(configJSFilePath)
 
         try {
-            await configFileSchema.validateAsync(userConfiguration);
+            await configFileSchema.validateAsync(userConfiguration)
         } catch (e) {
-            throw new UnknownError(`Configuration file validation error!\n\n${e.message}`);
+            throw new UnknownError(
+                `Configuration file validation error!\n\n${e.message}`
+            )
         }
 
-        const overridenConfiguration = deepmerge(configuration, userConfiguration);
+        const overridenConfiguration = deepmerge(
+            configuration,
+            userConfiguration
+        )
 
         return {
             userConfiguration,
             overridenConfiguration
-        };
+        }
     }
 
     return {
         userConfiguration: configuration,
         overridenConfiguration: configuration
-    };
-};
+    }
+}
 
-module.exports = resolveConfigurationWithOverrides;
+module.exports = resolveConfigurationWithOverrides

package/lib/util/rmdir-safe.js

@@ -1,28 +1,32 @@
-const fs = require('fs');
-const path = require('path');
+const fs = require('fs')
+const path = require('path')
 
-const pathExists = require('./path-exists');
+const pathExists = require('./path-exists')
 
+/**
+ * @param {string} dirPath
+ * @returns {Promise<boolean>}
+ */
 const rmdirSafe = async (dirPath) => {
-    const dirExists = await pathExists(dirPath);
+    const dirExists = await pathExists(dirPath)
 
     if (!dirExists) {
-        return true;
+        return true
     }
     const files = await fs.promises.readdir(dirPath, {
         encoding: 'utf-8',
         withFileTypes: true
-    });
+    })
 
     for (const file of files) {
-        const filePath = path.join(dirPath, file.name);
+        const filePath = path.join(dirPath, file.name)
         await fs.promises.rm(filePath, {
             recursive: true,
             force: true
-        });
+        })
     }
 
-    return true;
-};
+    return true
+}
 
-module.exports = rmdirSafe;
+module.exports = rmdirSafe

package/lib/util/run-composer.js

@@ -1,28 +1,28 @@
-const UnknownError = require('../errors/unknown-error');
-const { runPHPContainerCommand } = require('../tasks/php/php-container');
+const UnknownError = require('../errors/unknown-error')
+const { runPHPContainerCommand } = require('../tasks/php/php-container')
 /**
  * Execute composer command
  * @param {import('../../typings/context').ListrContext} ctx
  * @param {String} command composer command
- * @param {Object} options
- * @param {Boolean} options.throwNonZeroCode Throw if command return non 0 code.
- * @param {String} options.magentoVersion Magento version for config
+ * @param {Parameters<import('../tasks/php/php-container')['runPHPContainerCommand']>[2] & { throwNonZeroCode?: boolean }} [options]
  */
 const runComposerCommand = async (ctx, command, options = {}) => {
-    const {
-        throwNonZeroCode = true
-    } = options;
-    const { code, result } = await runPHPContainerCommand(ctx, `composer ${command}`, {
-        ...options,
-        withCode: true
-    });
+    const { throwNonZeroCode = true } = options
+    const { code, result } = await runPHPContainerCommand(
+        ctx,
+        `composer ${command}`,
+        {
+            ...options,
+            withCode: true
+        }
+    )
 
     if (throwNonZeroCode && code !== 0) {
         throw new UnknownError(`Code: ${code}
-Response: ${result}`);
+Response: ${result}`)
     }
 
-    return { code, result };
-};
+    return { code, result }
+}
 
-module.exports = runComposerCommand;
+module.exports = runComposerCommand

package/lib/util/run-container-image.js

@@ -1,6 +1,11 @@
-const { execAsyncSpawn } = require('./exec-async-command');
+const { execAsyncSpawn } = require('./exec-async-command')
 
-const runContainerImage = async (imageWithTag, command) => execAsyncSpawn(`docker run --rm ${imageWithTag} ${command}`);
+/**
+ * @param {string} imageWithTag
+ * @param {string} command
+ */
+const runContainerImage = async (imageWithTag, command) =>
+    execAsyncSpawn(`docker run --rm ${imageWithTag} ${command}`)
 
 /**
  * @param {string} imageWithTag
@@ -9,9 +14,9 @@ const runContainerImage = async (imageWithTag, command) => execAsyncSpawn(`docke
  */
 const runContainerImageTask = (imageWithTag, command) => ({
     task: () => runContainerImage(imageWithTag, command)
-});
+})
 
 module.exports = {
     runContainerImage,
     runContainerImageTask
-};
+}

package/lib/util/run-magento.js

@@ -1,30 +1,29 @@
-const UnknownError = require('../errors/unknown-error');
-const { runPHPContainerCommand } = require('../tasks/php/php-container');
+const UnknownError = require('../errors/unknown-error')
+const { runPHPContainerCommand } = require('../tasks/php/php-container')
 /**
  * Execute magento command
  *
  * @param {import('../../typings/context').ListrContext} ctx
  * @param {String} command magento command
- * @param {Object} options
- * @param {Boolean} options.logOutput Log output to console using logger
- * @param {Boolean} options.withCode
- * @param {String} options.cwd
- * @param {() => {}} options.callback
- * @param {Boolean} options.throwNonZeroCode Throw if command return non 0 code.
+ * @param {Parameters<typeof import('../tasks/php/php-container')['runPHPContainerCommand']>[2] & { throwNonZeroCode?: boolean }} options
  */
 const runMagentoCommand = async (ctx, command, options = {}) => {
-    const { throwNonZeroCode = true } = options;
-    const { code, result } = await runPHPContainerCommand(ctx, `bin/magento ${command}`, {
-        ...options,
-        withCode: true
-    });
+    const { throwNonZeroCode = true } = options
+    const { code, result } = await runPHPContainerCommand(
+        ctx,
+        `bin/magento ${command}`,
+        {
+            ...options,
+            withCode: true
+        }
+    )
 
     if (throwNonZeroCode && code !== 0) {
         throw new UnknownError(`Code: ${code}
-Response: ${result}`);
+Response: ${result}`)
     }
 
-    return { code, result };
-};
+    return { code, result }
+}
 
-module.exports = runMagentoCommand;
+module.exports = runMagentoCommand

package/lib/util/run-php.js

@@ -1,33 +1,28 @@
-const UnknownError = require('../errors/unknown-error');
-const { runPHPContainerCommand } = require('../tasks/php/php-container');
+const UnknownError = require('../errors/unknown-error')
+const { runPHPContainerCommand } = require('../tasks/php/php-container')
 /**
  * Execute PHP code
  * @param {import('../../typings/context').ListrContext} ctx
  * @param {String} command php command
- * @param {Object} options
- * @param {Boolean} options.logOutput Log output to console using logger
- * @param {Boolean} options.withCode
- * @param {String} options.cwd
- * @param {() => {}} options.callback
- * @param {Boolean} options.throwNonZeroCode Throw if command return non 0 code.
- * @param {Record<string, string>} options.env Environment variables
- * @param {Boolean} options.useRosettaOnMac Use Rosetta 2 on MacOS
+ * @param {Parameters<typeof import('../tasks/php/php-container')['runPHPContainerCommand']>[2] & { throwNonZeroCode?: boolean }} [options]
  */
 const runPhpCode = async (ctx, command, options = {}) => {
-    const {
-        throwNonZeroCode = true
-    } = options;
-    const { code, result } = await runPHPContainerCommand(ctx, `php ${command}`, {
-        ...options,
-        withCode: true
-    });
+    const { throwNonZeroCode = true } = options
+    const { code, result } = await runPHPContainerCommand(
+        ctx,
+        `php ${command}`,
+        {
+            ...options,
+            withCode: true
+        }
+    )
 
     if (throwNonZeroCode && code !== 0) {
         throw new UnknownError(`Code: ${code}
-Response: ${result}`);
+Response: ${result}`)
     }
 
-    return { code, result };
-};
+    return { code, result }
+}
 
-module.exports = runPhpCode;
+module.exports = runPhpCode

package/lib/util/safe-regex-extract.js

@@ -3,24 +3,20 @@
  * @param {object} param0
  * @param {string} param0.string
  * @param {RegExp} param0.regex
- * @param {(result: RegExpMatchArray) => string} param0.onNoMatch
+ * @param {(result: RegExpMatchArray | null) => string} param0.onNoMatch
  */
-const safeRegexExtract = ({
-    string,
-    regex,
-    onNoMatch
-}) => {
-    const result = string.match(regex);
+const safeRegexExtract = ({ string, regex, onNoMatch }) => {
+    const result = string.match(regex)
 
     if (result && result.length > 1) {
-        return result[1];
+        return result[1]
     }
 
     if (onNoMatch) {
-        return onNoMatch(result);
+        return onNoMatch(result)
     }
 
-    return result;
-};
+    return result
+}
 
-module.exports = safeRegexExtract;
+module.exports = safeRegexExtract