@scandipwa/magento-scripts 2.0.0-alpha.0 → 2.0.0-alpha.11

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

@@ -0,0 +1,120 @@
+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');
+const { createMagentoUser } = require('./create-magento-user');
+const defaultMagentoUser = require('./default-magento-user');
+
+/**
+ * @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: defaultMagentoUser.user,
+                    password: defaultMagentoUser.password,
+                    database: 'magento'
+                });
+
+                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(),
+        createMagentoUser(),
+        terminatingExistingConnection(),
+        gettingDatabaseConnection()
+    ], {
+        concurrent: false,
+        rendererOptions: {
+            collapse: true
+        }
+    }),
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = connectToDatabase;

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

@@ -0,0 +1,21 @@
+const { containerApi } = require('../docker/containers');
+
+/**
+ * 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 containerApi.exec(
+            `mysql -uroot -p${ mariadb.env.MARIADB_ROOT_PASSWORD } -h 127.0.0.1 -e "CREATE DATABASE IF NOT EXISTS magento;"`,
+            mariadb.name
+        );
+    }
+});
+
+module.exports = {
+    createMagentoDatabase
+};

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

@@ -0,0 +1,50 @@
+const mysql2 = require('mysql2/promise');
+const defaultMagentoUser = require('./default-magento-user');
+
+/**
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createMagentoUser = () => ({
+    title: 'Creating Magento user',
+    task: async (ctx, task) => {
+        const { mariadb } = ctx.config.docker.getContainers();
+        const connection = await mysql2.createConnection({
+            host: '127.0.0.1',
+            port: ctx.ports.mariadb,
+            user: 'root',
+            password: mariadb.env.MARIADB_ROOT_PASSWORD
+        });
+
+        const result = await connection.query('select Host, User from mysql.user;');
+
+        if (result.length === 0) {
+            task.skip();
+            return;
+        }
+
+        const [users] = result;
+
+        if (users.some((user) => user.User === defaultMagentoUser.user && user.Host === '%')) {
+            task.skip();
+            return;
+        }
+
+        if (users.some((user) => user.User === defaultMagentoUser.user)) {
+            const magentoUser = users.find((user) => user.User === defaultMagentoUser.user);
+
+            await connection.query(`DROP USER '${ magentoUser.User }'@'${ magentoUser.Host }'`);
+        }
+
+        await connection.query(
+            `CREATE USER '${ defaultMagentoUser.user }'@'${ defaultMagentoUser.host }' IDENTIFIED BY '${ defaultMagentoUser.password }';`
+        );
+        await connection.query(`GRANT ALL PRIVILEGES ON *.* TO '${ defaultMagentoUser.user }'@'${ defaultMagentoUser.host }' WITH GRANT OPTION;`);
+        await connection.query('FLUSH PRIVILEGES;');
+
+        await connection.destroy();
+    }
+});
+
+module.exports = {
+    createMagentoUser
+};

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

@@ -0,0 +1,3 @@
+module.exports = {
+    defaultMagentoDatabase: 'magento'
+};

package/lib/tasks/database/default-magento-user.js

@@ -0,0 +1,7 @@
+const defaultMagentoUser = {
+    user: 'magento',
+    password: 'magento',
+    host: '%'
+};
+
+module.exports = defaultMagentoUser;

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,8 @@ 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');
+const defaultMagentoUser = require('./default-magento-user');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -13,10 +14,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 +30,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 +64,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 +78,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=${defaultMagentoUser.user} --password=${defaultMagentoUser.password}`,
+                    message: `${defaultMagentoUser.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 {
@@ -135,7 +136,7 @@ ${logger.style.command('sed -i \'s/utf8mb4_0900_ai_ci/utf8mb4_general_ci/g\' dum
 
                 if (confirmFixingCollation === 'yes') {
                     task.output = 'Running fix command...';
-                    await execAsyncSpawn(`docker exec ${mysql.name} bash -c "sed -i 's/utf8mb4_0900_ai_ci/utf8mb4_general_ci/g' dump.sql"`);
+                    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 {
@@ -175,8 +176,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`);
@@ -187,7 +188,7 @@ const importDumpToMySQL = () => ({
             deleteDatabaseBeforeImportingDumpPrompt(),
             runSetGlobalLogBinTrustFunctionCreatorsCommand(),
             executeImportDumpSQL(),
-            connectToMySQL(),
+            connectToDatabase(),
             {
                 task: () => {
                     task.title = 'Database imported!';
@@ -201,4 +202,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')) {

package/lib/tasks/{mysql → database}/index.js

@@ -1,6 +1,6 @@
 module.exports = {
-    connectToMySQL: require('./connect-to-mysql'),
-    importDumpToMySQL: require('./import-dump-to-mysql'),
+    connectToDatabase: require('./connect-to-database'),
+    importDumpToDatabase: require('./import-dump-to-database'),
     fixDB: require('./fix-db'),
     dumpThemeConfig: require('./dump-theme-config'),
     restoreThemeConfig: require('./restore-theme-config')

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

@@ -6,7 +6,7 @@ const { updateTableValues } = require('../../util/database');
 const restoreThemeConfig = () => ({
     title: 'Restoring themes and theme configuration',
     task: async (ctx, task) => {
-        const { themeDump, mysqlConnection } = ctx;
+        const { themeDump, databaseConnection } = ctx;
 
         const { themeIdConfig, themes } = themeDump;
 
@@ -22,7 +22,7 @@ const restoreThemeConfig = () => ({
                     path: themeIdConfig.path,
                     value: themeIdConfig.value
                 }
-            ], { mysqlConnection, task });
+            ], { databaseConnection, task });
         }
 
         if (themes.length === 0) {
@@ -31,10 +31,10 @@ const restoreThemeConfig = () => ({
 
         // restore themes
         const themeKeys = Object.keys(themes[0]);
-        await mysqlConnection.query('delete from theme;');
+        await databaseConnection.query('delete from theme;');
 
         for (const theme of themes) {
-            await mysqlConnection.query(`
+            await databaseConnection.query(`
                 insert into theme (${themeKeys.join(', ')})
                 values (${themeKeys.map(() => '?').join(', ')})
             `, Object.values(theme));

package/lib/tasks/docker/api.d.ts

@@ -1,7 +1,6 @@
 import { ExecAsyncSpawnOptions } from '../../util/exec-async-command';
 
 export interface DockerVersionOptions<T extends boolean = false> {
-    format?: string
     format?: string
     formatToJSON?: T
 }
@@ -69,3 +68,28 @@ export function version(
     options: DockerVersionOptions<true>,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<DockerVersionResult>
+
+export interface DockerContextOptions<T extends boolean = false> {
+    format?: string
+    formatToJSON?: T
+}
+
+export interface DockerContextResult {
+    Current: boolean
+    Description: string
+    DockerEndpoint: string
+    KubernetesEndpoint: string
+    ContextType: string
+    Name: string
+    StackOrchestrator: string
+}
+
+export function context(
+    options: DockerContextOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+
+export function context(
+    options: DockerContextOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<DockerContextResult[]>

package/lib/tasks/docker/api.js

@@ -25,6 +25,36 @@ const version = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker version ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./api').DockerContextOptions} options
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const context = async (options, execOptions = {}) => {
+    const {
+        format,
+        formatToJSON
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const args = [
+        formatArg
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker context ls ${args}`, execOptions);
+        if (result.startsWith('[')) {
+            return JSON.parse(result);
+        }
+
+        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+    }
+
+    return execAsyncSpawn(`docker context ls ${args}`, execOptions);
+};
+
 module.exports = {
-    version
+    version,
+    context
 };

package/lib/tasks/docker/containers/container-api.d.ts

@@ -69,6 +69,8 @@ export interface ContainerRunOptions {
      * Run container in background and print container ID
      */
     detach?: boolean
+
+    tty?: boolean
     /**
      * Publish or expose port [docs](https://docs.docker.com/engine/reference/commandline/run/#publish-or-expose-port--p---expose)
      */
@@ -126,3 +128,19 @@ export interface ContainerRunOptions {
 }
 
 export function run(containerOptions: ContainerRunOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<false>
+
+export function runCommand(options: ContainerRunOptions): string[]
+
+export interface ContainerLogsOptions<T = never> {
+    name: string
+    details?: boolean
+    follow?: boolean
+    since?: string
+    tail?: string
+    timestamps?: boolean
+    until?: string
+    parser?: (line: string) => T
+}
+
+export function logs(options?: ContainerLogsOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<string>
+export function logs<T>(options?: ContainerLogsOptions<T>, execOptions?: ExecAsyncSpawnOptions<false>): Promise<T[]>