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

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')) {

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

@@ -0,0 +1,71 @@
+import { ExecAsyncSpawnOptions } from '../../util/exec-async-command';
+
+export interface DockerVersionOptions<T extends boolean = false> {
+    format?: string
+    format?: string
+    formatToJSON?: T
+}
+
+export interface DockerClientDetails {
+    Platform: {
+        Name: string
+    }
+    CloudIntegration: string
+    Version: string
+    ApiVersion: string
+    DefaultAPIVersion: string
+    GitCommit: string
+    GoVersion: string
+    Os: string
+    Arch: string
+    BuildTime: string
+    Context: string
+    Experimental: boolean
+}
+
+export interface DockerServerComponent {
+    Name: string
+    Version: string
+    Details: {
+        ApiVersion?: string
+        Arch?: string
+        BuildTime?: string
+        Experimental?: string
+        GitCommit: string
+        GoVersion?: string
+        KernelVersion?: string
+        MinApiVersion?: string
+        Os?: string
+    }
+}
+
+export interface DockerServerDetails {
+    Platform: {
+        Name: string
+    }
+    Components: DockerServerComponent[]
+    Version: string
+    ApiVersion: string
+    MinAPIVersion: string
+    GitCommit: string
+    GoVersion: string
+    Os: string
+    Arch: string
+    KernelVersion: string
+    BuildTime: string
+}
+
+export interface DockerVersionResult {
+    Client: DockerClientDetails
+    Server: DockerServerDetails
+}
+
+export function version(
+    options: DockerVersionOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+
+export function version(
+    options: DockerVersionOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<DockerVersionResult>

package/lib/tasks/docker/api.js

@@ -0,0 +1,30 @@
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+
+/**
+ * @param {import('./api').DockerVersionOptions} options
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const version = 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 version ${args}`, execOptions);
+        return JSON.parse(result);
+    }
+
+    return execAsyncSpawn(`docker version ${args}`, execOptions);
+};
+
+module.exports = {
+    version
+};

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

@@ -0,0 +1,128 @@
+/* eslint-disable max-len */
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+
+export interface ContainerLsOptions<T extends boolean = false> {
+    all?: boolean
+    filter?: string | string[]
+    format?: string
+    quiet?: boolean
+    noTrunc?: boolean
+    formatToJSON?: T
+    latest?: boolean
+}
+
+export interface ContainerLsResult {
+    Command: string
+    CreatedAt: string
+    ID: string
+    Image: string
+    Labels: string
+    LocalVolumes: string
+    Mounts: string
+    Names: string
+    Networks: string
+    Ports: string
+    RunningFor: string
+    Size: string
+    State: string
+    Status: string
+}
+
+export function ls(options?: ContainerLsOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<string>
+export function ls(options?: ContainerLsOptions<true>, execOptions?: ExecAsyncSpawnOptions<false>): Promise<ContainerLsResult[]>
+
+export interface ContainerExecOptions {
+    /**
+     * Set environment variables [docs](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file)
+     */
+    env?: Record<string, string>
+
+    /**
+     * Working directory inside the container
+     */
+    workdir?: string
+
+    /**
+     * Username or UID (format: <name|uid>[:<group|gid>])
+     */
+    user?: string
+
+    /**
+     * Allocate a pseudo-TTY
+     */
+    tty?: boolean
+}
+
+export function exec(command: string, container: string, options?: ContainerExecOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<string>
+
+export interface ContainerRunOptions {
+    /**
+     * Add a custom host-to-IP mapping (host:ip)
+     */
+    addHost?: string
+    /**
+     * Automatically remove the container when it exits
+     */
+    rm?: boolean
+
+    /**
+     * Run container in background and print container ID
+     */
+    detach?: boolean
+    /**
+     * Publish or expose port [docs](https://docs.docker.com/engine/reference/commandline/run/#publish-or-expose-port--p---expose)
+     */
+    ports?: number[]
+
+    /**
+     * Add bind mounts or volumes using the --mount flag [docs](https://docs.docker.com/engine/reference/commandline/run/#add-bind-mounts-or-volumes-using-the---mount-flag)
+     */
+    mounts?: string[]
+
+    /**
+     * Mount volume [docs](https://docs.docker.com/engine/reference/commandline/run/#mount-volume--v---read-only)
+     */
+    mountVolumes?: string[]
+
+    /**
+     * Set environment variables [docs](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file)
+     */
+    env?: Record<string, string>
+    image?: string
+    /**
+     * Restart policies [docs](https://docs.docker.com/engine/reference/commandline/run/#restart-policies---restart)
+     */
+    restart?: string
+
+    /**
+     * Container name
+     */
+    name?: string
+
+    /**
+     * Container entrypoint
+     */
+    entrypoint?: string
+
+    /**
+     * Container command
+     */
+    command?: string
+
+    /**
+     * Container heathcheck properties
+     */
+    healthCheck?: Record<'cmd' | 'interval' | 'retries' | 'start-period' | 'timeout', string>
+
+    /**
+     * Security options [docs](https://docs.docker.com/engine/reference/commandline/run/#optional-security-options---security-opt)
+     */
+    securityOptions?: string[]
+    tmpfs?: string[]
+    /**
+     * Username or UID (format: <name|uid>[:<group|gid>])
+     */
+    user?: string
+}
+
+export function run(containerOptions: ContainerRunOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<false>