@scandipwa/magento-scripts 2.0.3 → 2.0.4

package/lib/util/download-file.js

@@ -1,21 +1,33 @@
-const https = require('https');
-const http = require('http');
-const fs = require('fs');
+const https = require('https')
+const http = require('http')
+const fs = require('fs')
 
-const downloadFile = (url, { destination } = {}) => new Promise((resolve, reject) => {
-    const client = url.startsWith('https') ? https : http;
+/**
+ * @param {string} url
+ * @param {Object} param1
+ * @param {string} param1.destination
+ * @returns {Promise<void>}
+ */
+const downloadFile = (url, { destination }) =>
+    new Promise((resolve, reject) => {
+        const client = url.startsWith('https') ? https : http
 
-    const writeStream = fs.createWriteStream(destination, { encoding: 'utf-8' });
+        const writeStream = fs.createWriteStream(destination, {
+            encoding: 'utf-8'
+        })
 
-    const onError = (err) => {
-        reject(err);
-    };
-    const req = client.get(url, (res) => {
-        res.pipe(writeStream);
-    });
+        /**
+         * @param {Error} err
+         */
+        const onError = (err) => {
+            reject(err)
+        }
+        const req = client.get(url, (res) => {
+            res.pipe(writeStream)
+        })
 
-    req.on('error', onError);
-    req.once('close', resolve);
-});
+        req.on('error', onError)
+        req.once('close', resolve)
+    })
 
-module.exports = downloadFile;
+module.exports = downloadFile

package/lib/util/env-php-json.js

@@ -1,29 +1,55 @@
-const path = require('path');
-const UnknownError = require('../errors/unknown-error');
-const { runPHPContainerCommand } = require('../tasks/php/php-container');
-const pathExists = require('./path-exists');
+const path = require('path')
+const UnknownError = require('../errors/unknown-error')
+const { runPHPContainerCommand } = require('../tasks/php/php-container')
+const pathExists = require('./path-exists')
+
+/**
+ * @typedef EnvPHPData
+ *
+ * @prop {Record<string, number>} cache_types
+ * @prop {{ key: string }} crypt
+ */
 
 /**
  * @param {import('../../typings/context').ListrContext} ctx
+ * @returns {Promise<EnvPHPData | null>}
  */
 const envPhpToJson = async (ctx) => {
-    const envPhpOnSystemPath = path.join(ctx.config.baseConfig.magentoDir, 'app', 'etc', 'env.php');
-    const envPhpInContainerPath = path.join(ctx.config.baseConfig.containerMagentoDir, 'app', 'etc', 'env.php');
-    if (!await pathExists(envPhpOnSystemPath)) {
-        return null;
+    const envPhpOnSystemPath = path.join(
+        ctx.config.baseConfig.magentoDir,
+        'app',
+        'etc',
+        'env.php'
+    )
+    const envPhpInContainerPath = path.join(
+        ctx.config.baseConfig.containerMagentoDir,
+        'app',
+        'etc',
+        'env.php'
+    )
+    if (!(await pathExists(envPhpOnSystemPath))) {
+        return null
     }
-    const { code, result } = await runPHPContainerCommand(ctx, `php -r "echo json_encode(require '${envPhpInContainerPath}');"`, {
-        withCode: true
-    });
+    const { code, result } = await runPHPContainerCommand(
+        ctx,
+        `php -r "echo json_encode(require '${envPhpInContainerPath}');"`,
+        {
+            withCode: true
+        }
+    )
 
     if (code !== 0) {
-        throw new UnknownError(`Received non-zero code during converting app/etc/env.php to json:\n\n${result}`);
+        throw new UnknownError(
+            `Received non-zero code during converting app/etc/env.php to json:\n\n${result}`
+        )
     }
     try {
-        return JSON.parse(result);
+        return JSON.parse(result)
     } catch (e) {
-        throw new UnknownError(`Ooops! Something went wrong when trying to parse app/etc/env.php file!\n\n${e}\n\nFile result: ${result}`);
+        throw new UnknownError(
+            `Ooops! Something went wrong when trying to parse app/etc/env.php file!\n\n${e}\n\nFile result: ${result}`
+        )
     }
-};
+}
 
-module.exports = envPhpToJson;
+module.exports = envPhpToJson

package/lib/util/exec-async-command.d.ts

@@ -1,7 +1,7 @@
-/* eslint-disable max-len */
-import { ListrTask } from 'listr2';
+/* eslint-disable no-redeclare */
+import { ListrTask } from 'listr2'
 
-import { ListrContext } from '../../typings/context';
+import { ListrContext } from '../../typings/context'
 
 interface ExecAsyncSpawnOptions<T extends boolean> {
     callback?: (result: string) => void
@@ -9,9 +9,9 @@ interface ExecAsyncSpawnOptions<T extends boolean> {
     logOutput?: boolean
     cwd?: string
     withCode?: T
+    env?: Record<string, string> & NodeJS.ProcessEnv
     // only for mac
     useRosetta2?: boolean
-    env: NodeJS.ProcessEnv
 }
 
 /**
@@ -20,13 +20,13 @@ interface ExecAsyncSpawnOptions<T extends boolean> {
 export function execAsyncSpawn(
     command: string,
     options?: ExecAsyncSpawnOptions<false>
-): Promise<string>;
-export function execAsyncSpawn (
+): Promise<string>
+export function execAsyncSpawn(
     command: string,
     options?: ExecAsyncSpawnOptions<true>
-): Promise<{ code: number, result: string }>;
+): Promise<{ code: number; result: string }>
 
-export function execCommandTask(
+export function execCommandTask<T extends boolean>(
     command: string,
-    options?: Omit<ExecAsyncSpawnOptions<false>, 'callback'>
+    options?: Omit<ExecAsyncSpawnOptions<T>, 'callback'>
 ): ListrTask<ListrContext>

package/lib/util/exec-async-command.js

@@ -1,18 +1,24 @@
-const os = require('os');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const { spawn } = require('child_process');
-const { getArchSync } = require('./arch');
-const UnknownError = require('../errors/unknown-error');
+const os = require('os')
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+const { spawn } = require('child_process')
+const { getArchSync } = require('./arch')
+const UnknownError = require('../errors/unknown-error')
 
-const execAsyncSpawn = (command, {
-    callback = () => {},
-    pipeInput,
-    logOutput = false,
-    cwd,
-    withCode = false,
-    useRosetta2 = false,
-    env = process.env
-} = {}) => {
+/**
+ * @type {typeof import('./exec-async-command')['execAsyncSpawn']}
+ */
+const execAsyncSpawn = (
+    command,
+    {
+        callback,
+        pipeInput,
+        logOutput = false,
+        cwd,
+        withCode = false,
+        useRosetta2 = false,
+        env = process.env
+    } = {}
+) => {
     /**
      * @type {import('child_process').SpawnOptionsWithoutStdio}
      */
@@ -20,81 +26,98 @@ const execAsyncSpawn = (command, {
         stdio: pipeInput ? ['inherit', 'pipe', 'pipe'] : 'pipe',
         cwd,
         env
-    };
+    }
 
     /**
      * @type {import('child_process').ChildProcessWithoutNullStreams}
      */
-    let childProcess;
-    if (useRosetta2 && os.platform() === 'darwin' && getArchSync() === 'arm64') {
+    let childProcess
+    if (
+        useRosetta2 &&
+        os.platform() === 'darwin' &&
+        getArchSync() === 'arm64'
+    ) {
         childProcess = spawn(
             'arch',
-            // eslint-disable-next-line max-len
             ['-x86_64', 'bash', '-c', command],
             spawnOptions
-        );
+        )
     } else {
-        childProcess = spawn(
-            'bash',
-            ['-c', command],
-            spawnOptions
-        );
+        childProcess = spawn('bash', ['-c', command], spawnOptions)
     }
 
     return new Promise((resolve, reject) => {
-        const chunks = [];
+        /**
+         * @type {Buffer[]}
+         */
+        const chunks = []
 
         /**
          * @param {Buffer} chunk
          */
         const addChunk = (chunk) => {
-            chunks.push(Buffer.from(chunk));
-            const newData = chunk.toString('utf-8');
-            newData.split('\n').map((str) => str.trim()).forEach((str) => {
-                callback(str);
-            });
+            chunks.push(Buffer.from(chunk))
+            const newData = chunk.toString('utf-8')
+            newData
+                .split('\n')
+                .map((str) => str.trim())
+                .forEach((str) => {
+                    callback && callback(str)
+                })
             if (logOutput) {
-                newData.split('\n').filter(Boolean).forEach((line) => {
-                    logger.log(line);
-                });
+                newData
+                    .split('\n')
+                    .filter(Boolean)
+                    .forEach((line) => {
+                        logger.log(line)
+                    })
             }
-        };
+        }
 
-        childProcess.stdout.on('data', addChunk);
-        childProcess.stderr.on('data', addChunk);
+        childProcess.stdout.on('data', addChunk)
+        childProcess.stderr.on('data', addChunk)
 
         childProcess.on('error', (error) => {
-            reject(error);
-        });
+            reject(error)
+        })
         childProcess.on('close', (code) => {
-            const result = Buffer.concat(chunks).toString('utf8').trim();
-            if (withCode) {
-                resolve({ code, result });
-                return;
+            const result = Buffer.concat(chunks).toString('utf8').trim()
+            if (typeof code === 'number') {
+                if (withCode) {
+                    resolve({ code, result })
+                    return
+                }
+                if (code > 0) {
+                    reject(new UnknownError(result))
+                    return
+                }
             }
-            if (code > 0) {
-                reject(new UnknownError(result));
-            } else {
-                resolve(result);
-            }
-        });
-    });
-};
 
+            resolve(result)
+        })
+    })
+}
+
+/**
+ * @type {typeof import('./exec-async-command')['execCommandTask']}
+ */
 const execCommandTask = (command, options = {}) => ({
     title: `Running command "${command}"`,
-    task: (ctx, task) => execAsyncSpawn(command, {
-        callback: !ctx.verbose ? undefined : (t) => {
-            task.output = t;
-        },
-        ...options
-    }),
-    option: {
+    task: (ctx, task) =>
+        execAsyncSpawn(command, {
+            callback: !ctx.verbose
+                ? undefined
+                : (t) => {
+                      task.output = t
+                  },
+            ...options
+        }),
+    options: {
         bottomBar: 10
     }
-});
+})
 
 module.exports = {
     execAsyncSpawn,
     execCommandTask
-};
+}

package/lib/util/exec-async.d.ts

@@ -1,4 +1,6 @@
 /* eslint-disable max-len */
+import { ExecOptions } from 'child_process'
+
 /**
  * Execute bash command
  * @param command Bash command

package/lib/util/exec-async.js

@@ -1,9 +1,16 @@
-const { exec } = require('child_process');
+const { exec } = require('child_process')
 
-const execAsync = (command, options) => new Promise((resolve, reject) => {
-    exec(command, options, (err, stdout) => (err ? reject(err) : resolve(stdout)));
-});
+/**
+ * @param {string} command
+ * @param {{ encoding: 'buffer' | null; } & import('child_process').ExecOptions} options
+ */
+const execAsync = (command, options) =>
+    new Promise((resolve, reject) => {
+        exec(command, options, (err, stdout) =>
+            err ? reject(err) : resolve(stdout)
+        )
+    })
 
 module.exports = {
     execAsync
-};
+}

package/lib/util/execute-in-container.js

@@ -1,44 +1,39 @@
-const { spawn } = require('child_process');
-const { runCommand } = require('../tasks/docker/containers/container-api');
+const { spawn } = require('child_process')
+const { runCommand } = require('../tasks/docker/containers/container-api')
 
 /**
  * @param {{ containerName: string, commands: string[], user?: string }} param0
+ * @returns {Promise<never>}
  */
-const executeInContainer = ({
-    containerName, commands, user
-}) => {
+const executeInContainer = ({ containerName, commands, user }) => {
     if (!process.stdin.isTTY) {
-        process.stderr.write('This app works only in TTY mode');
-        process.exit(1);
+        process.stderr.write('This app works only in TTY mode')
+        process.exit(1)
     }
 
-    const userArg = user && `--user=${user}`;
-
-    spawn('docker', [
-        'exec',
-        '-it',
-        userArg,
-        containerName
-    ]
+    const userArg = (user && `--user=${user}`) || ''
+    const args = ['exec', '-it', userArg, containerName]
         .filter(Boolean)
-        .concat(...commands.map((command) => command.split(' ')).flat()),
-    {
+        .concat(...commands.map((command) => command.split(' ')).flat())
+
+    spawn('docker', args, {
         stdio: [0, 1, 2]
-    });
+    })
 
     return new Promise((_resolve) => {
         // never resolve
-    });
-};
+    })
+}
 
 /**
  * @param {import('../tasks/docker/containers/container-api').ContainerRunOptions} options
  * @param {string[]} commands
+ * @returns {Promise<never>}
  */
 const runInContainer = (options, commands) => {
     if (!process.stdin.isTTY) {
-        process.stderr.write('This app works only in TTY mode');
-        process.exit(1);
+        process.stderr.write('This app works only in TTY mode')
+        process.exit(1)
     }
 
     const runArgs = runCommand({
@@ -47,16 +42,16 @@ const runInContainer = (options, commands) => {
         detach: false,
         rm: true,
         command: commands.join(' ')
-    });
+    })
 
-    spawn('bash', ['-c', runArgs.join(' ')], { stdio: [0, 1, 2] });
+    spawn('bash', ['-c', runArgs.join(' ')], { stdio: [0, 1, 2] })
 
     return new Promise((_resolve) => {
         // never resolve
-    });
-};
+    })
+}
 
 module.exports = {
     executeInContainer,
     runInContainer
-};
+}

package/lib/util/execute-sudo-command.js

@@ -1,31 +1,27 @@
-const os = require('os');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const { execCommandTask } = require('./exec-async-command');
+const os = require('os')
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+const { execCommandTask } = require('./exec-async-command')
 
 /**
- * @type {(
- *   command: string,
- *   options: Omit<import('../util/exec-async-command').ExecAsyncSpawnOptions<false>, 'callback' | 'pipeInput'>
- * ) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @type {<T extends boolean>(command: string, options?: Omit<import('../util/exec-async-command').ExecAsyncSpawnOptions<T>, 'pipeInput'>) => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const executeSudoCommand = (command, options = {}) => ({
     task: async (ctx, task) => {
-        task.output = 'Enter your sudo password!';
-        task.output = logger.style.command(`>[sudo] password for ${ os.userInfo().username }:`);
+        task.output = 'Enter your sudo password!'
+        task.output = logger.style.command(
+            `>[sudo] password for ${os.userInfo().username}:`
+        )
 
         return task.newListr(
             execCommandTask(command, {
-                callback: (t) => {
-                    task.output = t;
-                },
                 pipeInput: true,
                 ...options
             })
-        );
+        )
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
-module.exports = executeSudoCommand;
+module.exports = executeSudoCommand

package/lib/util/get-brew-bin-path.js

@@ -1,57 +1,61 @@
-const { getArch, getArchSync } = require('./arch');
+const { getArch, getArchSync } = require('./arch')
 
-const BREW_BIN_PATH_INTEL = '/usr/local/bin/brew';
-const BREW_BIN_PATH_ARM_ROSETTA = '/usr/local/homebrew/bin/brew';
+const BREW_BIN_PATH_INTEL = '/usr/local/bin/brew'
+const BREW_BIN_PATH_ARM_ROSETTA = '/usr/local/homebrew/bin/brew'
 // native is not used ATM
-const BREW_BIN_PATH_ARM_NATIVE = '/opt/homebrew/bin/brew';
+const BREW_BIN_PATH_ARM_NATIVE = '/opt/homebrew/bin/brew'
 
 const getBrewBinPath = async () => {
-    const arch = await getArch();
+    const arch = await getArch()
 
     if (arch === 'arm64') {
-        return BREW_BIN_PATH_ARM_ROSETTA;
+        return BREW_BIN_PATH_ARM_ROSETTA
     }
 
-    return BREW_BIN_PATH_INTEL;
-};
+    return BREW_BIN_PATH_INTEL
+}
 
 const getBrewBinPathSync = () => {
-    const arch = getArchSync();
+    const arch = getArchSync()
 
     if (arch === 'arm64') {
-        return BREW_BIN_PATH_ARM_ROSETTA;
+        return BREW_BIN_PATH_ARM_ROSETTA
     }
 
-    return BREW_BIN_PATH_INTEL;
-};
+    return BREW_BIN_PATH_INTEL
+}
 
 const getBrewCommand = async ({ native } = { native: false }) => {
-    const arch = await getArch();
+    const arch = await getArch()
 
     if (arch === 'arm64') {
         if (native) {
-            return `arch -arm64 ${BREW_BIN_PATH_ARM_NATIVE}`;
+            return `arch -arm64 ${BREW_BIN_PATH_ARM_NATIVE}`
         }
 
-        return `arch -x86_64 ${BREW_BIN_PATH_ARM_ROSETTA}`;
+        return `arch -x86_64 ${BREW_BIN_PATH_ARM_ROSETTA}`
     }
 
-    return BREW_BIN_PATH_INTEL;
-};
+    return BREW_BIN_PATH_INTEL
+}
 
+/**
+ * @param {{ native?: boolean }} param0
+ * @returns
+ */
 const getBrewCommandSync = ({ native } = { native: false }) => {
-    const arch = getArchSync();
+    const arch = getArchSync()
 
     if (arch === 'arm64') {
         if (native) {
-            return `arch -arm64 ${BREW_BIN_PATH_ARM_NATIVE}`;
+            return `arch -arm64 ${BREW_BIN_PATH_ARM_NATIVE}`
         }
 
-        return `arch -x86_64 ${BREW_BIN_PATH_ARM_ROSETTA}`;
+        return `arch -x86_64 ${BREW_BIN_PATH_ARM_ROSETTA}`
     }
 
-    return BREW_BIN_PATH_INTEL;
-};
+    return BREW_BIN_PATH_INTEL
+}
 
 module.exports = {
     getBrewBinPath,
@@ -61,4 +65,4 @@ module.exports = {
     BREW_BIN_PATH_INTEL,
     BREW_BIN_PATH_ARM_ROSETTA,
     BREW_BIN_PATH_ARM_NATIVE
-};
+}

package/lib/util/get-installed-magento-version.js

@@ -1,34 +1,40 @@
-const fs = require('fs');
-const path = require('path');
-const KnownError = require('../errors/known-error');
-const pathExists = require('./path-exists');
-
+const fs = require('fs')
+const path = require('path')
+const KnownError = require('../errors/known-error')
+const pathExists = require('./path-exists')
+
+/**
+ * @param {string} composerPath
+ * @returns {Promise<{ require: Record<string, string> } | null>}
+ */
 const getComposerData = async (composerPath) => {
-    const composerExists = await pathExists(composerPath);
+    const composerExists = await pathExists(composerPath)
 
     if (!composerExists) {
-        return null;
+        return null
     }
 
-    return JSON.parse(await fs.promises.readFile(composerPath, 'utf-8'));
-};
+    return JSON.parse(await fs.promises.readFile(composerPath, 'utf-8'))
+}
 
 const getInstalledMagentoVersion = async (projectPath = process.cwd()) => {
-    const composerData = await getComposerData(path.join(projectPath, 'composer.json'));
+    const composerData = await getComposerData(
+        path.join(projectPath, 'composer.json')
+    )
 
     if (!composerData) {
-        throw new KnownError('composer.json not found');
+        throw new KnownError('composer.json not found')
     }
     const magentoDependency = [
         'magento/product-community-edition',
         'magento/product-enterprise-edition'
-    ].find((magentoEdition) => composerData.require[magentoEdition]);
+    ].find((magentoEdition) => composerData.require[magentoEdition])
 
     if (!magentoDependency) {
-        throw new KnownError('No Magento dependency found in composer.json');
+        throw new KnownError('No Magento dependency found in composer.json')
     }
 
-    return composerData.require[magentoDependency].replace(/\^/i, '');
-};
+    return composerData.require[magentoDependency].replace(/\^/i, '')
+}
 
-module.exports = getInstalledMagentoVersion;
+module.exports = getInstalledMagentoVersion