@scandipwa/magento-scripts 1.16.1 → 2.0.0-alpha.10

package/lib/config/versions/magento-2.4.4.js

@@ -1,14 +1,21 @@
 const path = require('path');
 const { defaultMagentoConfig } = require('../magento-config');
-const { php81 } = require('../php/releases');
+const sodium = require('../php/extensions/sodium');
+const { magento24PHPExtensionList } = require('../magento/required-php-extensions');
+const { php81 } = require('../php/versions');
 const { sslTerminator } = require('../ssl-terminator');
 const { varnish70 } = require('../varnish/varnish-7-0');
+const { repo } = require('../php/base-repo');
 
 module.exports = ({ templateDir } = {}) => ({
     magentoVersion: '2.4.4',
     isDefault: true,
     configuration: {
-        php: php81({ templateDir }),
+        php: php81({
+            templateDir,
+            extensions: { ...magento24PHPExtensionList, sodium },
+            baseImage: `${ repo }:php-8.1-magento-2.4`
+        }),
         nginx: {
             version: '1.18.0',
             configTemplate: path.join(templateDir || '', 'nginx.template.conf')

package/lib/config/versions/magento-2.4.5.js

@@ -0,0 +1,46 @@
+const path = require('path');
+const { defaultMagentoConfig } = require('../magento-config');
+const sodium = require('../php/extensions/sodium');
+const { magento24PHPExtensionList } = require('../magento/required-php-extensions');
+const { php81 } = require('../php/versions');
+const { sslTerminator } = require('../ssl-terminator');
+const { varnish70 } = require('../varnish/varnish-7-0');
+const { repo } = require('../php/base-repo');
+
+module.exports = ({ templateDir } = {}) => ({
+    magentoVersion: '2.4.5',
+    isDefault: true,
+    configuration: {
+        php: php81({
+            templateDir,
+            extensions: { ...magento24PHPExtensionList, sodium },
+            baseImage: `${ repo }:php-8.1-magento-2.4`
+        }),
+        nginx: {
+            version: '1.18.0',
+            configTemplate: path.join(templateDir || '', 'nginx.template.conf')
+        },
+        redis: {
+            version: '6.0'
+        },
+        mysql: {
+            version: '8.0'
+        },
+        mariadb: {
+            version: '10.4'
+        },
+        elasticsearch: {
+            version: '7.17.5'
+        },
+        composer: {
+            version: '2'
+        },
+        varnish: varnish70({ templateDir }),
+        sslTerminator: sslTerminator({ templateDir })
+    },
+    magento: defaultMagentoConfig,
+    host: 'localhost',
+    ssl: {
+        enabled: false
+    }
+});

package/lib/tasks/cleanup.js

@@ -1,12 +1,12 @@
 const { removeCacheFolder } = require('./cache');
 const { stopServices } = require('./docker');
-const { removeVolumes } = require('./docker/volumes');
+const { removeVolumes } = require('./docker/volume/tasks');
 const {
     uninstallMagento,
     removeMagento
 } = require('./magento');
 const getMagentoVersionConfig = require('../config/get-magento-version-config');
-const { stopPhpFpm } = require('./php-fpm');
+// const { stopPhpFpm } = require('./php-fpm');
 const getProjectConfiguration = require('../config/get-project-configuration');
 const checkConfigurationFile = require('../config/check-configuration-file');
 
@@ -19,7 +19,7 @@ const cleanup = () => ({
         checkConfigurationFile(),
         getMagentoVersionConfig(),
         getProjectConfiguration(),
-        stopPhpFpm(),
+        // stopPhpFpm(),
         stopServices(),
         removeVolumes(),
         removeCacheFolder(),

package/lib/tasks/composer/index.js

@@ -1,127 +1,33 @@
-const fs = require('fs');
-const path = require('path');
-const semver = require('semver');
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-const downloadFile = require('../../util/download-file');
-const { execAsyncSpawn } = require('../../util/exec-async-command');
-const pathExists = require('../../util/path-exists');
 const safeRegexExtract = require('../../util/safe-regex-extract');
-const installPrestissimo = require('./install-prestissimo');
 const UnknownError = require('../../errors/unknown-error');
-const KnownError = require('../../errors/known-error');
+const { runContainerImage } = require('../../util/run-container-image');
 
 /**
- * @param {import('../../../typings/context').ListrContext['config']} param0
+ * @param {import('../../../typings/context').ListrContext} ctx
  * @returns {Promise<string>}
  */
-const getComposerVersion = async ({ composer, php }) => {
-    const composerVersionOutput = await execAsyncSpawn(`${php.binPath} -c ${php.iniPath} ${composer.binPath} --version --no-ansi`);
+const getComposerVersion = async (ctx) => {
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+    const composerVersionOutput = await runContainerImage(php.image, 'composer --version --no-ansi');
 
     const composerVersion = safeRegexExtract({
         string: composerVersionOutput,
         regex: /composer.+(\d+\.\d+\.\d+)/i,
         onNoMatch: () => {
-            throw new UnknownError(`
-No composer version found in composer version output!\n\n${composerVersionOutput}
-
-Follow steps below to resolve this issue:
-1. Check ${logger.style.file(path.relative(process.cwd(), composer.binPath))} file content, inside this file should be Composer PHP code.
-2. If file content is not correct, try deleting this file and run ${logger.style.command('start')} command again, CMA will try re-download this file.
-3. If steps above didn't help, manually download Composer version ${composer.version} from ${logger.style.code('https://getcomposer.org/download/')} and put it inside cache directory ${logger.style.file(path.relative(process.cwd(), composer.dirPath))} with ${logger.style.code('composer.phar')} file name.
-`);
+            throw new UnknownError(`No composer version found in composer version output!\n\n${composerVersionOutput}`);
         }
     });
 
     return composerVersion;
 };
 
-/**
- * @param {import('../../../typings/context').ListrContext['config']} param0
- */
-const createComposerDir = async ({ composer }) => {
-    const dirExists = await pathExists(composer.dirPath);
-    if (!dirExists) {
-        await fs.promises.mkdir(composer.dirPath, { recursive: true });
-    }
-};
-
-/**
- * @param {import('../../../typings/context').ListrContext['config']} param0
- */
-const downloadComposerBinary = async ({ composer }) => {
-    const composerVersion = /^\d$/.test(composer.version)
-        ? `latest-${composer.version}.x`
-        : composer.version;
-
-    try {
-        await downloadFile(`https://getcomposer.org/download/${composerVersion}/composer.phar`, {
-            destination: composer.binPath
-        });
-    } catch (e) {
-        throw new UnknownError(
-            `Unexpected issue, while installing composer.
-            Please see the error log below.\n\n${e}`
-        );
-    }
-};
-
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const installComposer = () => ({
-    title: 'Installing Composer',
+const getComposerVersionTask = () => ({
+    title: 'Retrieving Composer version',
     task: async (ctx, task) => {
-        const { composer, php } = ctx.config;
-        const hasComposerInCache = await pathExists(composer.binPath);
-
-        if (!hasComposerInCache) {
-            task.title = 'Installing Composer';
-            await createComposerDir({ composer });
-            await downloadComposerBinary({ composer });
-        } else {
-            const currentComposerVersion = await getComposerVersion({ composer, php });
-            const expectedComposerVersion = /^\d$/.test(composer.version)
-                ? `${composer.version}.x`
-                : composer.version;
-
-            if (!semver.satisfies(currentComposerVersion, expectedComposerVersion)) {
-                const continueComposerBinaryVersionSwitch = await task.prompt({
-                    type: 'Select',
-                    message: `You have Composer ${logger.style.misc(`${currentComposerVersion}`)} while your Magento version requires ${logger.style.misc(expectedComposerVersion)}!`,
-                    choices: [
-                        {
-                            message: `Continue with current installed version (${logger.style.misc(`${currentComposerVersion}`)})`,
-                            name: 'continue'
-                        },
-                        {
-                            message: 'Install correct version and continue (you will probably have to fix composer dependencies versions)',
-                            name: 'install-and-continue'
-                        },
-                        {
-                            message: 'Exit installation.',
-                            name: 'exit'
-                        }
-                    ]
-                });
-
-                switch (continueComposerBinaryVersionSwitch) {
-                case 'install-and-continue': {
-                    await downloadComposerBinary({ composer });
-                    break;
-                }
-                case 'exit': {
-                    throw new KnownError(`Current composer version ${logger.style.misc(`v${currentComposerVersion}`)} is not compatible with version ${logger.style.misc(expectedComposerVersion)}!`);
-                }
-                case 'continue':
-                default: {
-                    ctx.continueWithExistingComposerVersion = true;
-                    break;
-                }
-                }
-            }
-        }
-
-        const composerVersion = await getComposerVersion({ composer, php });
+        const composerVersion = await getComposerVersion(ctx);
         task.title = `Using Composer version ${composerVersion}`;
         ctx.composerVersion = composerVersion;
     },
@@ -130,4 +36,8 @@ const installComposer = () => ({
     }
 });
 
-module.exports = { installComposer, installPrestissimo, getComposerVersion };
+module.exports = {
+    getComposerVersionTask,
+    // installPrestissimo,
+    getComposerVersion
+};

package/lib/tasks/database/connect-to-database.js

@@ -0,0 +1,117 @@
+const mysql2 = require('mysql2/promise');
+const UnknownError = require('../../errors/unknown-error');
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+const sleep = require('../../util/sleep');
+const { createMagentoDatabase } = require('./create-magento-database');
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const waitForDatabaseInitialization = () => ({
+    title: 'Waiting for Database to initialize',
+    task: async (ctx, task) => {
+        const { mariadb } = ctx.config.docker.getContainers();
+
+        let databaseReadyForConnections = false;
+
+        while (!databaseReadyForConnections) {
+            const databaseOutput = await execAsyncSpawn(`docker logs ${mariadb.name}`);
+            if (databaseOutput.includes('ready for connections')) {
+                databaseReadyForConnections = true;
+                break;
+            } else if (databaseOutput.includes('Initializing database files')) {
+                task.output = `${mariadb._} is initializing database files!
+Please wait, this will take some time and do not restart the ${mariadb._} container until initialization is finished!`;
+
+                let databaseFinishedInitialization = false;
+                while (!databaseFinishedInitialization) {
+                    const databaseOutput2 = await execAsyncSpawn(`docker logs ${mariadb.name}`);
+                    if (databaseOutput2.includes('init process done.') && !databaseFinishedInitialization) {
+                        databaseFinishedInitialization = true;
+                        break;
+                    }
+                    await sleep(2000);
+                }
+            }
+
+            await sleep(2000);
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const gettingDatabaseConnection = () => ({
+    title: 'Getting Database connection',
+    task: async (ctx, task) => {
+        const { config: { docker }, ports } = ctx;
+        const { mariadb } = docker.getContainers(ctx.ports);
+        let tries = 0;
+        const maxTries = 20;
+        const errors = [];
+
+        while (tries < maxTries) {
+            tries++;
+            try {
+                const connection = await mysql2.createConnection({
+                    host: '127.0.0.1',
+                    port: ports.mariadb,
+                    user: mariadb.env.MARIADB_USER,
+                    password: mariadb.env.MARIADB_PASSWORD,
+                    database: mariadb.env.MARIADB_DATABASE
+                });
+
+                ctx.databaseConnection = connection;
+                break;
+            } catch (e) {
+                errors.push(e);
+            }
+            await sleep(1000);
+        }
+
+        if (tries === maxTries) {
+            throw new UnknownError(`Unable to connect to ${ mariadb._ } server. Check your server configuration!\n\n${ errors.join(' ') }`);
+        }
+
+        task.title = `${ mariadb._ } server connected!`;
+    }
+});
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const terminatingExistingConnection = () => ({
+    title: 'Terminating existing Database connection',
+    skip: (ctx) => !ctx.databaseConnection,
+    task: (ctx) => {
+        ctx.databaseConnection.destroy();
+    }
+});
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const connectToDatabase = () => ({
+    title: 'Connecting to Database server',
+    skip: (ctx) => ctx.skipSetup,
+    task: (ctx, task) => task.newListr([
+        waitForDatabaseInitialization(),
+        createMagentoDatabase(),
+        terminatingExistingConnection(),
+        gettingDatabaseConnection()
+    ], {
+        concurrent: false,
+        rendererOptions: {
+            collapse: true
+        }
+    }),
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = connectToDatabase;

package/lib/tasks/database/create-magento-database.js

@@ -0,0 +1,18 @@
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+
+/**
+ * Will create database 'magento' in MariaDB if it does not exist for some reason
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createMagentoDatabase = () => ({
+    title: 'Creating Magento database',
+    task: async (ctx, task) => {
+        const { mariadb } = ctx.config.docker.getContainers();
+        task.title = `Creating Magento database in ${ mariadb._ }`;
+        await execAsyncSpawn(`docker exec ${mariadb.name} mysql -umagento -pmagento -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`);
+    }
+});
+
+module.exports = {
+    createMagentoDatabase
+};

package/lib/tasks/{mysql → database}/dump-theme-config.js

@@ -6,9 +6,9 @@ const { isTableExists } = require('../../util/database');
 const dumpThemeConfig = () => ({
     title: 'Dumping themes and theme configuration',
     task: async (ctx, task) => {
-        const { mysqlConnection } = ctx;
+        const { databaseConnection } = ctx;
         if (await isTableExists('magento', 'theme', ctx)) {
-            const [themes] = await mysqlConnection.query('select * from theme;');
+            const [themes] = await databaseConnection.query('select * from theme;');
             if (themes.length === 0) {
                 ctx.themeDump = {
                     themes: [],
@@ -17,7 +17,7 @@ const dumpThemeConfig = () => ({
             }
 
             if (await isTableExists('magento', 'core_config_data', ctx)) {
-                const [themeIdConfig] = await mysqlConnection.query('select * from core_config_data where path = \'design/theme/theme_id\';');
+                const [themeIdConfig] = await databaseConnection.query('select * from core_config_data where path = \'design/theme/theme_id\';');
                 if (themeIdConfig.length !== 0) {
                     ctx.themeDump = {
                         themes,

package/lib/tasks/{mysql → database}/fix-db.js

@@ -8,14 +8,14 @@ const varnishConfigSetup = require('../magento/setup-magento/varnish-config');
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const enableForeignKeyCheck = () => ({
-    task: ({ mysqlConnection }) => mysqlConnection.query('SET FOREIGN_KEY_CHECKS = 0;')
+    task: ({ databaseConnection }) => databaseConnection.query('SET FOREIGN_KEY_CHECKS = 0;')
 });
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const disableForeignKeyCheck = () => ({
-    task: ({ mysqlConnection }) => mysqlConnection.query('SET FOREIGN_KEY_CHECKS = 1;')
+    task: ({ databaseConnection }) => databaseConnection.query('SET FOREIGN_KEY_CHECKS = 1;')
 });
 
 /**

package/lib/tasks/{mysql/import-dump-to-mysql.js → database/import-dump-to-database.js}

@@ -4,7 +4,7 @@ const KnownError = require('../../errors/known-error');
 const UnknownError = require('../../errors/unknown-error');
 const { execAsyncSpawn, execCommandTask } = require('../../util/exec-async-command');
 const pathExists = require('../../util/path-exists');
-const connectToMySQL = require('./connect-to-mysql');
+const connectToDatabase = require('./connect-to-database');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -13,10 +13,10 @@ const copyDatabaseDumpIntoContainer = () => ({
     title: 'Copying database dump into container',
     task: async (ctx, task) => {
         const { config: { docker }, ports } = ctx;
-        const { mysql } = docker.getContainers(ports);
+        const { mariadb } = docker.getContainers(ports);
 
         return task.newListr(
-            execCommandTask(`docker cp ${ctx.importDb} ${mysql.name}:/dump.sql`, {
+            execCommandTask(`docker cp ${ctx.importDb} ${mariadb.name}:/dump.sql`, {
                 logOutput: true
             })
         );
@@ -29,10 +29,10 @@ const copyDatabaseDumpIntoContainer = () => ({
 const runSetGlobalLogBinTrustFunctionCreatorsCommand = () => ({
     task: async (ctx, task) => {
         const { config: { docker }, ports } = ctx;
-        const { mysql } = docker.getContainers(ports);
+        const { mariadb } = docker.getContainers(ports);
 
         return task.newListr(
-            execCommandTask(`docker exec ${mysql.name} bash -c 'mysql -uroot -p${mysql.env.MYSQL_ROOT_PASSWORD} -e "SET GLOBAL log_bin_trust_function_creators = 1;"'`)
+            execCommandTask(`docker exec ${mariadb.name} bash -c 'mysql -uroot -p${mariadb.env.MARIADB_ROOT_PASSWORD} -e "SET GLOBAL log_bin_trust_function_creators = 1;"'`)
         );
     }
 });
@@ -63,8 +63,8 @@ Note that you will lose your existing database!`,
         });
 
         if (deleteDatabaseMagentoChoice === 'delete') {
-            await ctx.mysqlConnection.query('DROP DATABASE IF EXISTS magento;');
-            await ctx.mysqlConnection.query('CREATE DATABASE magento;');
+            await ctx.databaseConnection.query('DROP DATABASE IF EXISTS magento;');
+            await ctx.databaseConnection.query('CREATE DATABASE magento;');
             return;
         }
         task.skip();
@@ -77,28 +77,28 @@ Note that you will lose your existing database!`,
 const executeImportDumpSQL = () => ({
     task: async (ctx, task) => {
         const { config: { docker }, ports } = ctx;
-        const { mysql } = docker.getContainers(ports);
+        const { mariadb } = docker.getContainers(ports);
 
-        const userCredentialsForMySQLCLI = await task.prompt({
+        const userCredentialsForMariaDBCLI = await task.prompt({
             type: 'Select',
-            message: 'Which user do you want to use to import db in MySQL client?',
+            message: `Which user do you want to use to import db in ${ mariadb._ } client?`,
             choices: [
                 {
-                    name: `--user=root --password=${mysql.env.MYSQL_ROOT_PASSWORD}`,
+                    name: `--user=root --password=${mariadb.env.MARIADB_ROOT_PASSWORD}`,
                     message: `root (${logger.style.command('Probably safest option')})`
                 },
                 {
-                    name: `--user=${mysql.env.MYSQL_USER} --password=${mysql.env.MYSQL_PASSWORD}`,
-                    message: `${mysql.env.MYSQL_USER}`
+                    name: `--user=${mariadb.env.MARIADB_USER} --password=${mariadb.env.MARIADB_PASSWORD}`,
+                    message: `${mariadb.env.MARIADB_USER}`
                 }
             ]
         });
 
-        const importCommand = `docker exec ${mysql.name} bash -c "mysql ${userCredentialsForMySQLCLI} magento < ./dump.sql"`;
+        const importCommand = `docker exec ${mariadb.name} bash -c "mysql ${userCredentialsForMariaDBCLI} magento < ./dump.sql"`;
 
         const startImportTime = Date.now();
         const tickInterval = setInterval(() => {
-            task.title = `Importing Database Dump To MySQL, ${Math.floor((Date.now() - startImportTime) / 1000)}s in progress...`;
+            task.title = `Importing Database Dump To ${ mariadb._ }, ${Math.floor((Date.now() - startImportTime) / 1000)}s in progress...`;
         }, 1000);
 
         try {
@@ -111,12 +111,55 @@ const executeImportDumpSQL = () => ({
                 }
             );
         } catch (e) {
-            if (e.includes('Unknown collation: \'utf8mb4_0900_ai_ci\'')) {
-                throw new KnownError(`Error happened during database dump import!
+            if (e.message.includes('Unknown collation: \'utf8mb4_0900_ai_ci\'')) {
+                const confirmFixingCollation = await task.prompt({
+                    type: 'Select',
+                    message: `We got the following error while trying to import ${logger.style.file('dump.sql')}!
+
+${e.message}
+
+To fix this error we suggest running the following commands:
+${logger.style.command('sed -i \'s/utf8mb4_0900_ai_ci/utf8mb4_general_ci/g\' dump.sql')}
+`,
+                    choices: [
+                        {
+                            name: 'yes',
+                            message: 'Yes, run the following commands, I reaaaalllyy want dump to work! (this will not edit original dump.sql)'
+                        },
+                        {
+                            name: 'no',
+                            message: 'Okay, I got it. Will try to fix myself'
+                        }
+                    ]
+                });
+
+                if (confirmFixingCollation === 'yes') {
+                    task.output = 'Running fix command...';
+                    await execAsyncSpawn(`docker exec ${mariadb.name} bash -c "sed -i 's/utf8mb4_0900_ai_ci/utf8mb4_general_ci/g' dump.sql"`);
+
+                    task.output = 'Trying to import dump again...';
+                    try {
+                        await execAsyncSpawn(
+                            importCommand,
+                            {
+                                callback: (t) => {
+                                    task.output = t;
+                                }
+                            }
+                        );
+
+                        return;
+                    } catch (e) {
+                        throw new KnownError(`Fixing ${logger.style.file('dump.sql')} collations did not helped, we got the following error:
+${e.message}`);
+                    }
+                } else {
+                    throw new KnownError(`Database dump import unsuccessful!
 
-${e}
+${e.message}
 
 You can try replacing all occurrences of ${logger.style.misc('utf8mb4_0900_ai_ci')} with ${logger.style.misc('utf8mb4_general_ci')} in your ${logger.style.file(ctx.importDb)} file!`);
+                }
             }
 
             throw new UnknownError(`Unexpected error during dump import.\n\n${e}`);
@@ -132,8 +175,8 @@ You can try replacing all occurrences of ${logger.style.misc('utf8mb4_0900_ai_ci
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const importDumpToMySQL = () => ({
-    title: 'Importing Database Dump To MySQL',
+const importDumpToDatabase = () => ({
+    title: 'Importing Database Dump',
     task: async (ctx, task) => {
         if (!await pathExists(ctx.importDb)) {
             throw new KnownError(`Dump file at ${ctx.importDb} does not exist. Please provide correct relative path to the file`);
@@ -144,7 +187,7 @@ const importDumpToMySQL = () => ({
             deleteDatabaseBeforeImportingDumpPrompt(),
             runSetGlobalLogBinTrustFunctionCreatorsCommand(),
             executeImportDumpSQL(),
-            connectToMySQL(),
+            connectToDatabase(),
             {
                 task: () => {
                     task.title = 'Database imported!';
@@ -158,4 +201,4 @@ const importDumpToMySQL = () => ({
     }
 });
 
-module.exports = importDumpToMySQL;
+module.exports = importDumpToDatabase;

package/lib/tasks/{mysql/import-remote-db/ssh/mysqldump-command.js → database/import-remote-db/ssh/database-dump-command.js}

@@ -1,4 +1,4 @@
-const mysqlDumpCommandWithOptions = [
+const databaseDumpCommandWithOptions = [
     'mysqldump',
     'magento',
     '--skip-lock-tables',
@@ -9,4 +9,4 @@ const mysqlDumpCommandWithOptions = [
     '--no-tablespaces'
 ];
 
-module.exports = mysqlDumpCommandWithOptions;
+module.exports = databaseDumpCommandWithOptions;

package/lib/tasks/{mysql → database}/import-remote-db/ssh/readymage.js

@@ -1,7 +1,7 @@
 const mergeFiles = require('merge-files');
 const { orderTables, customerTables } = require('../../magento-tables');
 const { execAsyncSpawn } = require('../../../../util/exec-async-command');
-const mysqlDumpCommandWithOptions = require('./mysqldump-command');
+const databaseDumpCommandWithOptions = require('./database-dump-command');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh').NodeSSH }>}
@@ -25,7 +25,7 @@ const readymageSSH = () => ({
                  */
                 await ssh.execCommand(
                     [
-                        ...mysqlDumpCommandWithOptions,
+                        ...databaseDumpCommandWithOptions,
                         ...[...orderTables, ...customerTables].map((table) => `--ignore-table=magento.${table}`),
                         '--result-file=dump-0.sql'
                     ].join(' ')
@@ -33,7 +33,7 @@ const readymageSSH = () => ({
 
                 await ssh.execCommand(
                     [
-                        ...mysqlDumpCommandWithOptions,
+                        ...databaseDumpCommandWithOptions,
                         '--no-data',
                         '--result-file=dump-1.sql',
                         ...[...orderTables, ...customerTables]
@@ -41,7 +41,7 @@ const readymageSSH = () => ({
                 );
             } else {
                 task.output = 'Making remote database dump file with customers data...';
-                await ssh.execCommand([...mysqlDumpCommandWithOptions, '--result-file=dump.sql'].join(' '));
+                await ssh.execCommand([...databaseDumpCommandWithOptions, '--result-file=dump.sql'].join(' '));
             }
 
             if (!noCompress) {

package/lib/tasks/{mysql → database}/import-remote-db/ssh/regular-server.js

@@ -1,7 +1,7 @@
 const mergeFiles = require('merge-files');
 const { orderTables, customerTables } = require('../../magento-tables');
 const { execAsyncSpawn } = require('../../../../util/exec-async-command');
-const mysqlDumpCommandWithOptions = require('./mysqldump-command');
+const databaseDumpCommandWithOptions = require('./database-dump-command');
 const KnownError = require('../../../../errors/known-error');
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh').NodeSSH }>}
@@ -27,7 +27,7 @@ Do not enter "--result-file" option, we need to control that part.
 
 (documentation reference available here: https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html)
 `,
-                initial: mysqlDumpCommandWithOptions.join(' ')
+                initial: databaseDumpCommandWithOptions.join(' ')
             });
 
             if (dumpCommand.includes('--result-file')) {