@scandipwa/magento-scripts 2.0.3 → 2.0.5

package/lib/tasks/database/import-dump-to-database.js

@@ -1,45 +1,59 @@
 /* eslint-disable max-len */
-const logger = require('@scandipwa/scandipwa-dev-utils/logger');
-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 connectToDatabase = require('./connect-to-database');
-const defaultMagentoUser = require('./default-magento-user');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger')
+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 connectToDatabase = require('./connect-to-database')
+const defaultMagentoUser = require('./default-magento-user')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const copyDatabaseDumpIntoContainer = () => ({
     title: 'Copying database dump into container',
     task: async (ctx, task) => {
-        const { config: { docker }, ports } = ctx;
-        const { mariadb } = docker.getContainers(ports);
+        const {
+            config: { docker },
+            ports
+        } = ctx
+        const { mariadb } = docker.getContainers(ports)
 
         return task.newListr(
-            execCommandTask(`docker cp ${ctx.importDb} ${mariadb.name}:/dump.sql`, {
-                logOutput: true
-            })
-        );
+            execCommandTask(
+                `docker cp ${ctx.importDb} ${mariadb.name}:/dump.sql`,
+                {
+                    logOutput: true
+                }
+            )
+        )
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const runSetGlobalLogBinTrustFunctionCreatorsCommand = () => ({
     task: async (ctx, task) => {
-        const { config: { docker }, ports } = ctx;
-        const { mariadb } = docker.getContainers(ports);
+        const {
+            config: { docker },
+            ports
+        } = ctx
+        const { mariadb } = docker.getContainers(ports)
 
         return task.newListr(
-            execCommandTask(`docker exec ${mariadb.name} bash -c 'mysql -uroot -p${mariadb.env.MARIADB_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;"'`
+            )
+        )
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const deleteDatabaseBeforeImportingDumpPrompt = () => ({
     title: 'Deleting magento database before importing dump',
@@ -61,145 +75,168 @@ Note that you will lose your existing database!`,
                     message: 'Skip this step'
                 }
             ]
-        });
+        })
 
         if (deleteDatabaseMagentoChoice === 'delete') {
-            await ctx.databaseConnection.query('DROP DATABASE IF EXISTS magento;');
-            await ctx.databaseConnection.query('CREATE DATABASE magento;');
-            return;
+            await ctx.databaseConnection.query(
+                'DROP DATABASE IF EXISTS magento;'
+            )
+            await ctx.databaseConnection.query('CREATE DATABASE magento;')
+            return
         }
-        task.skip();
+        task.skip()
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const executeImportDumpSQL = () => ({
     task: async (ctx, task) => {
-        const { config: { docker }, ports } = ctx;
-        const { mariadb } = docker.getContainers(ports);
+        const {
+            config: { docker },
+            ports
+        } = ctx
+        const { mariadb } = docker.getContainers(ports)
 
         const userCredentialsForMariaDBCLI = await task.prompt({
             type: 'Select',
-            message: `Which user do you want to use to import db in ${ mariadb._ } client?`,
+            message: `Which user do you want to use to import db in ${mariadb._} client?`,
             choices: [
                 {
                     name: `--user=root --password=${mariadb.env.MARIADB_ROOT_PASSWORD}`,
-                    message: `root (${logger.style.command('Probably safest option')})`
+                    message: `root (${logger.style.command(
+                        'Probably safest option'
+                    )})`
                 },
                 {
                     name: `--user=${defaultMagentoUser.user} --password=${defaultMagentoUser.password}`,
                     message: `${defaultMagentoUser.user}`
                 }
             ]
-        });
+        })
 
-        const importCommand = `docker exec ${mariadb.name} bash -c "mysql ${userCredentialsForMariaDBCLI} magento < ./dump.sql"`;
+        const importCommand = `docker exec ${mariadb.name} bash -c "mysql ${userCredentialsForMariaDBCLI} magento < ./dump.sql"`
 
-        const startImportTime = Date.now();
+        const startImportTime = Date.now()
         const tickInterval = setInterval(() => {
-            task.title = `Importing Database Dump To ${ mariadb._ }, ${Math.floor((Date.now() - startImportTime) / 1000)}s in progress...`;
-        }, 1000);
+            task.title = `Importing Database Dump To ${mariadb._}, ${Math.floor(
+                (Date.now() - startImportTime) / 1000
+            )}s in progress...`
+        }, 1000)
 
         try {
-            await execAsyncSpawn(
-                importCommand,
-                {
-                    callback: (t) => {
-                        task.output = t;
-                    }
+            await execAsyncSpawn(importCommand, {
+                callback: (t) => {
+                    task.output = t
                 }
-            );
+            })
         } catch (e) {
-            if (e.message.includes('Unknown collation: \'utf8mb4_0900_ai_ci\'')) {
+            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')}!
+                    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')}
+${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)'
+                            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 = '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...';
+                    task.output = 'Trying to import dump again...'
                     try {
-                        await execAsyncSpawn(
-                            importCommand,
-                            {
-                                callback: (t) => {
-                                    task.output = t;
-                                }
+                        await execAsyncSpawn(importCommand, {
+                            callback: (t) => {
+                                task.output = t
                             }
-                        );
+                        })
 
-                        return;
+                        return
                     } catch (e) {
-                        throw new KnownError(`Fixing ${logger.style.file('dump.sql')} collations did not helped, we got the following error:
-${e.message}`);
+                        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.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!`);
+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}`);
+            throw new UnknownError(
+                `Unexpected error during dump import.\n\n${e}`
+            )
         } finally {
-            clearInterval(tickInterval);
+            clearInterval(tickInterval)
         }
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 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`);
+        if (!(await pathExists(ctx.importDb))) {
+            throw new KnownError(
+                `Dump file at ${ctx.importDb} does not exist. Please provide correct relative path to the file`
+            )
         }
 
-        return task.newListr([
-            copyDatabaseDumpIntoContainer(),
-            deleteDatabaseBeforeImportingDumpPrompt(),
-            runSetGlobalLogBinTrustFunctionCreatorsCommand(),
-            executeImportDumpSQL(),
-            connectToDatabase(),
+        return task.newListr(
+            [
+                copyDatabaseDumpIntoContainer(),
+                deleteDatabaseBeforeImportingDumpPrompt(),
+                runSetGlobalLogBinTrustFunctionCreatorsCommand(),
+                executeImportDumpSQL(),
+                connectToDatabase(),
+                {
+                    task: () => {
+                        task.title = 'Database imported!'
+                    }
+                }
+            ],
             {
-                task: () => {
-                    task.title = 'Database imported!';
+                rendererOptions: {
+                    collapse: false
                 }
             }
-        ], {
-            rendererOptions: {
-                collapse: false
-            }
-        });
+        )
     }
-});
+})
 
-module.exports = importDumpToDatabase;
+module.exports = importDumpToDatabase

package/lib/tasks/database/import-remote-db/index.js

@@ -1,13 +1,13 @@
-const UnknownError = require('../../../errors/unknown-error');
-const sshDb = require('./ssh');
+const UnknownError = require('../../../errors/unknown-error')
+const sshDb = require('./ssh')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const importRemoteDbSSH = () => ({
     skip: (ctx) => typeof ctx.remoteDb === 'undefined',
     task: async (ctx, task) => {
-        task.title = 'Importing database from remote server';
+        task.title = 'Importing database from remote server'
 
         if (!ctx.remoteDb) {
             ctx.remoteDb = await task.prompt({
@@ -15,26 +15,24 @@ const importRemoteDbSSH = () => ({
                 message: `Please enter a remote server connection string.
 It can be a SSH (ssh://<url>) connection or mysql (mysql://<url>) connection.
 `
-            });
+            })
         }
 
-        const url = new URL(ctx.remoteDb);
+        const url = new URL(ctx.remoteDb)
 
-        ctx.remoteDbUrl = url;
+        ctx.remoteDbUrl = url
 
-        const { protocol } = url;
+        const { protocol } = url
 
         switch (protocol) {
-        case 'ssh:': {
-            return task.newListr(
-                sshDb()
-            );
-        }
-        default: {
-            throw new UnknownError(`Unsupported protocol ${protocol}`);
-        }
+            case 'ssh:': {
+                return task.newListr(sshDb())
+            }
+            default: {
+                throw new UnknownError(`Unsupported protocol ${protocol}`)
+            }
         }
     }
-});
+})
 
-module.exports = importRemoteDbSSH;
+module.exports = importRemoteDbSSH

package/lib/tasks/database/import-remote-db/ssh/database-dump-command.js

@@ -7,6 +7,6 @@ const databaseDumpCommandWithOptions = [
     '--column-statistics=0',
     '--max_allowed_packet=1GB',
     '--no-tablespaces'
-];
+]
 
-module.exports = databaseDumpCommandWithOptions;
+module.exports = databaseDumpCommandWithOptions

package/lib/tasks/database/import-remote-db/ssh/index.js

@@ -1,67 +1,70 @@
-const os = require('os');
-const { NodeSSH } = require('node-ssh');
-const pathExists = require('../../../../util/path-exists');
-const regularSSHServer = require('./regular-server');
-const readymageSSH = require('./readymage');
-const KnownError = require('../../../../errors/known-error');
+const os = require('os')
+const { NodeSSH } = require('node-ssh')
+const pathExists = require('../../../../util/path-exists')
+const regularSSHServer = require('./regular-server')
+const readymageSSH = require('./readymage')
+const KnownError = require('../../../../errors/known-error')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../../typings/context').ListrContext>}
  */
 const sshDb = () => ({
     task: async (ctx, task) => {
-        const { remoteDbUrl, withCustomersData, noCompress } = ctx;
-        const { hostname, username, password } = remoteDbUrl;
+        const { remoteDbUrl, withCustomersData, noCompress } = ctx
+        const { hostname, username, password } = remoteDbUrl
 
-        task.title = `Importing database from remote ssh server ${hostname}`;
+        task.title = `Importing database from remote ssh server ${hostname}`
 
-        const ssh = new NodeSSH();
-        ctx.ssh = ssh;
+        const ssh = new NodeSSH()
+        ctx.ssh = ssh
 
         if (!password) {
             const privateKey = await task.prompt({
                 type: 'Input',
                 message: `Please enter your private key location to connect to ${hostname}\n`,
                 initial: `${os.homedir()}/.ssh/id_rsa`
-            });
+            })
 
             if (!(await pathExists(privateKey))) {
-                throw new KnownError(`Private key not found: ${privateKey}`);
+                throw new KnownError(`Private key not found: ${privateKey}`)
             }
 
-            ctx.privateKey = privateKey;
+            ctx.privateKey = privateKey
 
             const passphrase = await task.prompt({
                 type: 'Input',
-                message: 'Please enter your private key passphrase (if you have it)'
-            });
+                message:
+                    'Please enter your private key passphrase (if you have it)'
+            })
 
-            ctx.passphrase = passphrase || undefined;
+            ctx.passphrase = passphrase || undefined
 
             await ssh.connect({
                 host: hostname,
                 username,
                 privateKey,
                 passphrase
-            });
+            })
         } else {
             await ssh.connect({
                 host: hostname,
                 username,
                 password
-            });
+            })
         }
 
-        ctx.importDb = './dump.sql';
+        ctx.importDb = './dump.sql'
 
-        const { stdout: remoteFilesOutput } = await ssh.execCommand('ls');
+        const { stdout: remoteFilesOutput } = await ssh.execCommand('ls')
 
-        const dumpFileNames = !withCustomersData ? ['dump-0.sql', 'dump-1.sql'] : ['dump.sql'];
+        const dumpFileNames = !withCustomersData
+            ? ['dump-0.sql', 'dump-1.sql']
+            : ['dump.sql']
 
         if (!noCompress) {
-            dumpFileNames.push('dump.sql.gz');
+            dumpFileNames.push('dump.sql.gz')
         }
-        const remoteFiles = remoteFilesOutput.split('\n');
+        const remoteFiles = remoteFilesOutput.split('\n')
 
         if (dumpFileNames.every((dumpFile) => remoteFiles.includes(dumpFile))) {
             ctx.makeRemoteDumps = await task.prompt({
@@ -71,24 +74,20 @@ const sshDb = () => ({
                 message: `We found dump files on remote server.
   Do you want to replace them with new dump files or use existing ones?
 `
-            });
+            })
         } else {
-            ctx.makeRemoteDumps = true;
+            ctx.makeRemoteDumps = true
         }
 
         if (hostname.endsWith('readymage.com')) {
-            return task.newListr(
-                readymageSSH()
-            );
+            return task.newListr(readymageSSH())
         }
 
-        return task.newListr(
-            regularSSHServer()
-        );
+        return task.newListr(regularSSHServer())
     },
     options: {
         bottomBar: 10
     }
-});
+})
 
-module.exports = sshDb;
+module.exports = sshDb

package/lib/tasks/database/import-remote-db/ssh/readymage.js

@@ -1,10 +1,10 @@
-const mergeFiles = require('merge-files');
-const { orderTables, customerTables } = require('../../magento-tables');
-const { execAsyncSpawn } = require('../../../../util/exec-async-command');
-const databaseDumpCommandWithOptions = require('./database-dump-command');
+const mergeFiles = require('merge-files')
+const { orderTables, customerTables } = require('../../magento-tables')
+const { execAsyncSpawn } = require('../../../../util/exec-async-command')
+const databaseDumpCommandWithOptions = require('./database-dump-command')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh').NodeSSH }>}
+ * @returns {import('listr2').ListrTask<import('../../../../../typings/context').ListrContext & { ssh: import('node-ssh').NodeSSH }>}
  */
 const readymageSSH = () => ({
     task: async (ctx, task) => {
@@ -14,11 +14,12 @@ const readymageSSH = () => ({
             makeRemoteDumps,
             withCustomersData,
             noCompress
-        } = ctx;
-        const sshConnectString = remoteDbUrl.href.replace(/ssh:\/\//i, '');
+        } = ctx
+        const sshConnectString = remoteDbUrl.href.replace(/ssh:\/\//i, '')
         if (makeRemoteDumps) {
             if (!withCustomersData) {
-                task.output = 'Making remote database dump files without customers data...';
+                task.output =
+                    'Making remote database dump files without customers data...'
 
                 /**
                  * create dump without customers and orders
@@ -26,10 +27,12 @@ const readymageSSH = () => ({
                 await ssh.execCommand(
                     [
                         ...databaseDumpCommandWithOptions,
-                        ...[...orderTables, ...customerTables].map((table) => `--ignore-table=magento.${table}`),
+                        ...[...orderTables, ...customerTables].map(
+                            (table) => `--ignore-table=magento.${table}`
+                        ),
                         '--result-file=dump-0.sql'
                     ].join(' ')
-                );
+                )
 
                 await ssh.execCommand(
                     [
@@ -38,71 +41,71 @@ const readymageSSH = () => ({
                         '--result-file=dump-1.sql',
                         ...[...orderTables, ...customerTables]
                     ].join(' ')
-                );
+                )
             } else {
-                task.output = 'Making remote database dump file with customers data...';
-                await ssh.execCommand([...databaseDumpCommandWithOptions, '--result-file=dump.sql'].join(' '));
+                task.output =
+                    'Making remote database dump file with customers data...'
+                await ssh.execCommand(
+                    [
+                        ...databaseDumpCommandWithOptions,
+                        '--result-file=dump.sql'
+                    ].join(' ')
+                )
             }
 
             if (!noCompress) {
-                task.output = 'Compressing dump files...';
+                task.output = 'Compressing dump files...'
                 if (!withCustomersData) {
                     await ssh.execCommand(
                         'tar -czvf dump.sql.gz ./dump-0.sql ./dump-1.sql'
-                    );
+                    )
                 } else {
-                    await ssh.execCommand(
-                        'tar -czvf dump.sql.gz ./dump.sql'
-                    );
+                    await ssh.execCommand('tar -czvf dump.sql.gz ./dump.sql')
                 }
             }
         }
 
-        const { stdout: remotePwd } = await ssh.execCommand('pwd');
+        const { stdout: remotePwd } = await ssh.execCommand('pwd')
 
-        ssh.dispose();
+        ssh.dispose()
 
         if (!withCustomersData) {
-            task.output = 'Downloading dump files...';
+            task.output = 'Downloading dump files...'
             if (noCompress) {
                 await execAsyncSpawn(
                     `scp ${sshConnectString}:${remotePwd}/dump-0.sql .`
-                );
+                )
                 await execAsyncSpawn(
                     `scp ${sshConnectString}:${remotePwd}/dump-1.sql .`
-                );
+                )
             } else {
                 await execAsyncSpawn(
                     `scp ${sshConnectString}:${remotePwd}/dump.sql.gz .`
-                );
+                )
 
-                task.output = 'Extracting dump files...';
+                task.output = 'Extracting dump files...'
 
-                await execAsyncSpawn(
-                    'tar -xf ./dump.sql.gz'
-                );
+                await execAsyncSpawn('tar -xf ./dump.sql.gz')
             }
 
-            await mergeFiles(['./dump-0.sql', './dump-1.sql'], './dump.sql');
+            await mergeFiles(['./dump-0.sql', './dump-1.sql'], './dump.sql')
         } else {
-            task.output = 'Downloading dump file...';
+            task.output = 'Downloading dump file...'
             if (noCompress) {
                 await execAsyncSpawn(
                     `scp ${sshConnectString}:${remotePwd}/dump.sql .`
-                );
+                )
             } else {
                 await execAsyncSpawn(
                     `scp ${sshConnectString}:${remotePwd}/dump.sql.gz .`
-                );
+                )
 
-                task.output = 'Extracting dump file...';
+                task.output = 'Extracting dump file...'
 
-                await execAsyncSpawn(
-                    'tar -xf ./dump.sql.gz'
-                );
+                await execAsyncSpawn('tar -xf ./dump.sql.gz')
             }
         }
     }
-});
+})
 
-module.exports = readymageSSH;
+module.exports = readymageSSH