@scandipwa/magento-scripts 2.0.3 → 2.0.4

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

package/lib/util/set-config.js

@@ -1,35 +1,44 @@
-const eta = require('eta');
-const fs = require('fs');
-const path = require('path');
-const pathExists = require('./path-exists');
+const eta = require('eta')
+const fs = require('fs')
+const path = require('path')
+const pathExists = require('./path-exists')
 
+/**
+ * @param {{ configPathname: string, template: string, overwrite?: boolean, templateArgs?: Record<string, unknown> }} param0
+ */
 const setConfigFile = async ({
     configPathname,
     template,
     overwrite,
     templateArgs = {}
 }) => {
-    const pathOk = await pathExists(configPathname);
+    const pathOk = await pathExists(configPathname)
 
     if (pathOk && !overwrite) {
-        return true;
+        return true
     }
 
-    const configTemplate = await fs.promises.readFile(template, 'utf-8');
+    const configTemplate = await fs.promises.readFile(template, 'utf-8')
     const compliedConfig = await eta.render(configTemplate, {
         date: new Date().toUTCString(),
         ...templateArgs
-    });
+    })
 
-    const { dir } = path.parse(configPathname);
+    if (!compliedConfig) {
+        return false
+    }
+
+    const { dir } = path.parse(configPathname)
 
-    const dirExists = await pathExists(dir);
+    const dirExists = await pathExists(dir)
     if (!dirExists) {
-        await fs.promises.mkdir(dir, { recursive: true });
+        await fs.promises.mkdir(dir, { recursive: true })
     }
-    await fs.promises.writeFile(configPathname, compliedConfig, { encoding: 'utf-8' });
+    await fs.promises.writeFile(configPathname, compliedConfig, {
+        encoding: 'utf-8'
+    })
 
-    return true;
-};
+    return true
+}
 
-module.exports = setConfigFile;
+module.exports = setConfigFile

package/lib/util/sleep.js

@@ -1,3 +1,8 @@
-const sleep = (timeout) => new Promise((resolve) => setTimeout(resolve, timeout));
+/**
+ * @param {number} timeout
+ * @returns {Promise<void>}
+ */
+const sleep = (timeout) =>
+    new Promise((resolve) => setTimeout(resolve, timeout))
 
-module.exports = sleep;
+module.exports = sleep

package/lib/util/systemctl.js

@@ -1,95 +1,113 @@
-const { execAsyncSpawn } = require('./exec-async-command');
+const { execAsyncSpawn } = require('./exec-async-command')
 
 /**
- * @param {String} cmd
- * @param {String} serviceName
- * @param {{ now: boolean, user: boolean }} options
+ * @param {string} cmd
+ * @param {string} [serviceName]
+ * @param {{ now?: boolean, user?: boolean }} options
  */
-const run = (cmd, serviceName, options = {}) => execAsyncSpawn(
-    `systemctl ${ options.user ? '--user ' : '' }${ cmd }${ serviceName ? ` ${ serviceName }` : '' }${ options.now ? ' --now' : ''}`,
-    {
-        withCode: true
-    }
-);
+const run = (cmd, serviceName, options = {}) =>
+    execAsyncSpawn(
+        `systemctl ${options.user ? '--user ' : ''}${cmd}${
+            serviceName ? ` ${serviceName}` : ''
+        }${options.now ? ' --now' : ''}`,
+        {
+            withCode: true
+        }
+    )
 
-const daemonReload = () => run('daemon-reload');
+const daemonReload = () => run('daemon-reload')
 
 /**
  * @param {String} serviceName
- * @param {{ now: boolean, user: boolean }} defaultOptions
+ * @param {{ now?: boolean, user?: boolean }} [defaultOptions]
  */
 const systemctlControl = (serviceName, defaultOptions = {}) => ({
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    disable: (options = {}) => run('disable', serviceName, { ...defaultOptions, ...options }),
+    disable: (options = {}) =>
+        run('disable', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    enable: (options = {}) => run('enable', serviceName, { ...defaultOptions, ...options }),
+    enable: (options = {}) =>
+        run('enable', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    enableAndStart: (options = {}) => run('enable', serviceName, { now: true, ...defaultOptions, ...options }),
+    enableAndStart: (options = {}) =>
+        run('enable', serviceName, {
+            now: true,
+            ...defaultOptions,
+            ...options
+        }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    restart: (options = {}) => run('restart', serviceName, { ...defaultOptions, ...options }),
+    restart: (options = {}) =>
+        run('restart', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    start: (options = {}) => run('start', serviceName, { ...defaultOptions, ...options }),
+    start: (options = {}) =>
+        run('start', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
-    stop: (options = {}) => run('stop', serviceName, { ...defaultOptions, ...options }),
+    stop: (options = {}) =>
+        run('stop', serviceName, { ...defaultOptions, ...options }),
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
     isEnabled: async (options = {}) => {
         try {
-            const { result } = await run('is-enabled', serviceName, { ...defaultOptions, ...options });
-            return result.includes('enabled');
+            const { result } = await run('is-enabled', serviceName, {
+                ...defaultOptions,
+                ...options
+            })
+            return result.includes('enabled')
         } catch (e) {
-            return false;
+            return false
         }
     },
     /**
-     * @param {{ now: boolean, user: boolean }} options
+     * @param {{ now?: boolean, user?: boolean }} [options]
      */
     isRunning: async (options = {}) => {
         try {
-            const { result } = await run('status', serviceName, { ...defaultOptions, ...options });
+            const { result } = await run('status', serviceName, {
+                ...defaultOptions,
+                ...options
+            })
 
-            return result.includes('active (running)');
+            return result.includes('active (running)')
         } catch (e) {
-            return false;
+            return false
         }
     },
     /**
-     * @param {{ user: boolean }} options
+     * @param {{ user?: boolean }} [options]
      */
     exists: async (options = {}) => {
-        const optionsToUse = { ...defaultOptions, ...options };
+        const optionsToUse = { ...defaultOptions, ...options }
         try {
-            // eslint-disable-next-line max-len, no-useless-escape
-            const command = `if [[ $(systemctl ${ optionsToUse.user ? '--user ' : ''}list-units --all -t service --full --no-legend "${ serviceName }.service" | sed 's/^\\s*//g' | cut -f1 -d' ') == ${ serviceName }.service ]]; then
+            const command = `if [[ $(systemctl ${
+                optionsToUse.user ? '--user ' : ''
+            }list-units --all -t service --full --no-legend "${serviceName}.service" | sed 's/^\\s*//g' | cut -f1 -d' ') == ${serviceName}.service ]]; then
                 echo "1"
             else
                 echo "0"
-            fi`;
-            const result = await execAsyncSpawn(
-                command
-            );
+            fi`
+            const result = await execAsyncSpawn(command)
 
-            return result === '1';
+            return result === '1'
         } catch (e) {
-            return false;
+            return false
         }
     }
-});
+})
 
 module.exports = {
     systemctlControl,
     daemonReload
-};
+}