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

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

@@ -1,4 +1,4 @@
-const mysql = require('mysql2/promise');
+const mysql2 = require('mysql2/promise');
 const UnknownError = require('../../errors/unknown-error');
 const { execAsyncSpawn } = require('../../util/exec-async-command');
 const sleep = require('../../util/sleep');
@@ -10,10 +10,14 @@ const { createMagentoDatabase } = require('./create-magento-database');
 const waitForMySQLInitialization = () => ({
     title: 'Waiting for MySQL to initialize',
     task: async (ctx, task) => {
-        const { mysql: { name } } = ctx.config.docker.getContainers();
+        const { mysql } = ctx.config.docker.getContainers();
+
+        task.title = `Waiting for ${mysql._} to initialize`;
+
         let mysqlReadyForConnections = false;
+
         while (!mysqlReadyForConnections) {
-            const mysqlOutput = await execAsyncSpawn(`docker logs ${name}`);
+            const mysqlOutput = await execAsyncSpawn(`docker logs ${mysql.name}`);
             if (mysqlOutput.includes('ready for connections')) {
                 mysqlReadyForConnections = true;
                 break;
@@ -23,7 +27,7 @@ Please wait, this will take some time and do not restart the MySQL container unt
 
                 let mysqlFinishedInitialization = false;
                 while (!mysqlFinishedInitialization) {
-                    const mysqlOutput = await execAsyncSpawn(`docker logs ${name}`);
+                    const mysqlOutput = await execAsyncSpawn(`docker logs ${mysql.name}`);
                     if (mysqlOutput.includes('init process done.') && !mysqlFinishedInitialization) {
                         mysqlFinishedInitialization = true;
                         break;
@@ -47,19 +51,22 @@ const gettingMySQLConnection = () => ({
     title: 'Getting MySQL connection',
     task: async (ctx, task) => {
         const { config: { docker }, ports } = ctx;
-        const { mysql: { env } } = docker.getContainers();
+        const { mysql } = docker.getContainers(ctx.ports);
         let tries = 0;
         const maxTries = 20;
         const errors = [];
+
+        task.title = `Getting ${mysql._} connection`;
+
         while (tries < maxTries) {
             tries++;
             try {
-                const connection = await mysql.createConnection({
+                const connection = await mysql2.createConnection({
                     host: '127.0.0.1',
                     port: ports.mysql,
-                    user: env.MYSQL_USER,
-                    password: env.MYSQL_PASSWORD,
-                    database: env.MYSQL_DATABASE
+                    user: mysql.env.MYSQL_USER,
+                    password: mysql.env.MYSQL_PASSWORD,
+                    database: mysql.env.MYSQL_DATABASE
                 });
 
                 ctx.mysqlConnection = connection;
@@ -82,7 +89,7 @@ const gettingMySQLConnection = () => ({
  * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const terminatingExistingConnection = () => ({
-    title: 'Terminating existing MySQL connection',
+    title: 'Terminating existing Database connection',
     skip: (ctx) => !ctx.mysqlConnection,
     task: (ctx) => {
         ctx.mysqlConnection.destroy();
@@ -95,17 +102,23 @@ const terminatingExistingConnection = () => ({
 const connectToMySQL = () => ({
     title: 'Connecting to MySQL server',
     skip: (ctx) => ctx.skipSetup,
-    task: (ctx, task) => task.newListr([
-        waitForMySQLInitialization(),
-        createMagentoDatabase(),
-        terminatingExistingConnection(),
-        gettingMySQLConnection()
-    ], {
-        concurrent: false,
-        rendererOptions: {
-            collapse: true
-        }
-    }),
+    task: (ctx, task) => {
+        const { mysql } = ctx.config.docker.getContainers();
+
+        task.title = `Connecting to ${mysql._} server`;
+
+        return task.newListr([
+            waitForMySQLInitialization(),
+            createMagentoDatabase(),
+            terminatingExistingConnection(),
+            gettingMySQLConnection()
+        ], {
+            concurrent: false,
+            rendererOptions: {
+                collapse: true
+            }
+        });
+    },
     options: {
         bottomBar: 10
     }

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

@@ -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 ${mysql.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}`);

package/lib/tasks/php/php-container.js

@@ -0,0 +1,108 @@
+/* eslint-disable no-use-before-define */
+const { deepmerge } = require('../../util/deepmerge');
+const { containerApi } = require('../docker/containers');
+
+/**
+ * @param {import('../../../typings/context').ListrContext} ctx
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions<false> & { useXDebugContainer?: boolean }} [options]
+ * @param {string} command
+ */
+const runPHPContainerCommand = async (ctx, command, options = {}) => {
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+
+    const containers = await containerApi.ls({ formatToJSON: true, all: true });
+
+    if (containers.some((c) => c.Names === php.name)) {
+        return execPHPContainerCommand(ctx, command, options);
+    }
+
+    return containerApi.run(
+        deepmerge(
+            php,
+            {
+                detach: false,
+                rm: true
+            },
+            options.useXDebugContainer
+                ? {
+                    image: `${ php.image }.xdebug`
+                }
+                : {},
+            {
+                command
+            },
+        ),
+        options
+    );
+};
+
+/**
+ * @param {string} command
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions<false> & { useXDebugContainer?: boolean }} [options]
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const runPHPContainerCommandTask = (command, options = {}) => ({
+    title: `Running command "${command}"`,
+    task: (ctx, task) => runPHPContainerCommand(ctx, command, {
+        callback: !ctx.verbose ? undefined : (t) => {
+            task.output = t;
+        },
+        ...options
+    }),
+    option: {
+        bottomBar: 10
+    }
+});
+
+/**
+ *
+ * @param {import('../../../typings/context').ListrContext} ctx
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions<false> & { useXDebugContainer?: boolean }} [options]
+ * @param {string} command
+ */
+const execPHPContainerCommand = async (ctx, command, options = {}) => {
+    const { php } = ctx.config.docker.getContainers(ctx.ports);
+
+    const containers = await containerApi.ls({ formatToJSON: true, all: true });
+
+    if (!containers.some((c) => c.Names === php.name)) {
+        return runPHPContainerCommand(ctx, command, options);
+    }
+
+    return containerApi.exec(
+        command,
+        php.name,
+        deepmerge(
+            php,
+            options.env ? {
+                env: options.env
+            } : {}
+        ),
+        options
+    );
+};
+
+/**
+ * @param {string} command
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions<false> & { useXDebugContainer?: boolean, title?: string }} [options]
+ * @returns {import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const execPHPContainerCommandTask = (command, options = {}) => ({
+    title: typeof options.title === 'string' && options.title === '' ? undefined : options.title || `Running command "${command}"`,
+    task: (ctx, task) => execPHPContainerCommand(ctx, command, {
+        callback: !ctx.verbose ? undefined : (t) => {
+            task.output = t;
+        },
+        ...options
+    }),
+    option: {
+        bottomBar: 10
+    }
+});
+
+module.exports = {
+    runPHPContainerCommand,
+    runPHPContainerCommandTask,
+    execPHPContainerCommand,
+    execPHPContainerCommandTask
+};

package/lib/tasks/php/update-env-php.js

@@ -2,9 +2,10 @@ const path = require('path');
 const envPhpToJson = require('../../util/env-php-json');
 const getJsonfileData = require('../../util/get-jsonfile-data');
 const pathExists = require('../../util/path-exists');
-const phpTask = require('../../util/php-task');
+const { containerApi } = require('../docker/containers');
 
 const composerLockPath = path.join(process.cwd(), 'composer.lock');
+const envPhpPath = path.join(process.cwd(), 'app', 'etc', 'env.php');
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
@@ -12,13 +13,19 @@ const updateEnvPHP = () => ({
     title: 'Updating env.php',
     task: async (ctx, task) => {
         // update env.php only if it's exist
-        if (!await pathExists(path.join(process.cwd(), 'app', 'etc', 'env.php'))) {
+        if (!await pathExists(envPhpPath)) {
             task.skip();
             return;
         }
 
-        const useVarnish = ctx.config.overridenConfiguration.configuration.varnish.enabled ? '1' : '';
-        const varnishHost = '127.0.0.1';
+        const { php } = ctx.config.docker.getContainers(ctx.ports);
+
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
+
+        const useVarnish = (!ctx.debug && ctx.config.overridenConfiguration.configuration.varnish.enabled) ? '1' : '';
+        const varnishHost = hostMachine;
         const varnishPort = ctx.ports.varnish;
         const previousVarnishPort = ctx.cachedPorts
             ? ctx.cachedPorts.varnish
@@ -34,7 +41,7 @@ const updateEnvPHP = () => ({
                     ctx.CSAThemeInstalled = true;
                 }
 
-                const envPhp = await envPhpToJson(process.cwd(), { magentoVersion: ctx.magentoVersion });
+                const envPhp = await envPhpToJson(ctx);
 
                 const persistedQueryConfig = envPhp.cache && envPhp.cache['persisted-query'];
 
@@ -50,20 +57,29 @@ const updateEnvPHP = () => ({
             }
         }
 
-        return task.newListr(
-            phpTask(`-f ${ path.join(__dirname, 'update-env.php') }`, {
-                noTitle: true,
-                env: {
-                    USE_VARNISH: useVarnish,
-                    VARNISH_PORT: `${ varnishPort }`,
-                    VARNISH_HOST: varnishHost,
-                    PREVIOUS_VARNISH_PORT: `${ previousVarnishPort }`,
-                    SETUP_PQ,
-                    REDIS_PORT: ctx.ports.redis,
-                    ADMIN_URI: ctx.config.overridenConfiguration.magento.adminuri
-                }
-            })
-        );
+        const result = await containerApi.run({
+            env: {
+                USE_VARNISH: useVarnish,
+                VARNISH_PORT: `${ varnishPort }`,
+                VARNISH_HOST: varnishHost,
+                PREVIOUS_VARNISH_PORT: `${ previousVarnishPort }`,
+                SETUP_PQ,
+                REDIS_PORT: ctx.ports.redis,
+                ADMIN_URI: ctx.config.overridenConfiguration.magento.adminuri,
+                HOST_MACHINE: hostMachine,
+                PORTS: JSON.stringify(ctx.ports)
+            },
+            command: 'php ./update-env-php.php',
+            mountVolumes: [
+                `${path.join(__dirname, 'update-env.php')}:${ctx.config.baseConfig.containerMagentoDir}/update-env-php.php`,
+                `${envPhpPath}:/${ctx.config.baseConfig.containerMagentoDir}/env.php`
+            ],
+            image: php.image,
+            detach: false,
+            rm: true
+        });
+
+        task.output = result;
     }
 });
 

package/lib/tasks/php/update-env.php

@@ -3,9 +3,9 @@
 function varexport($expression, $return=false): string
 {
     $export = var_export($expression, true);
-    $export = preg_replace("/^([ ]*)(.*)/m", '$1$1$2', $export);
+    $export = preg_replace("/^([ ]*)(.*)/m", "$1$1$2", $export);
     $array = preg_split("/\r\n|\n|\r/", $export);
-    $array = preg_replace(["/\s*array\s\($/", "/\)(,)?$/", "/\s=>\s$/"], [null, ']$1', ' => ['], $array);
+    $array = preg_replace(["/\s*array\s\($/", "/\)(,)?$/", "/\s=>\s$/"], [null, "]$1", " => ["], $array);
     $export = join(PHP_EOL, array_filter(["["] + $array));
     if ((bool)$return) {
         return $export;
@@ -19,12 +19,12 @@ function joinpaths(): string
     $paths = array();
 
     foreach (func_get_args() as $arg) {
-        if ($arg !== '') {
+        if ($arg !== "") {
             $paths[] = $arg;
         }
     }
 
-    return preg_replace('#/+#', '/', join('/', $paths));
+    return preg_replace("#/+#", "/", join("/", $paths));
 }
 
 class EnvUpdater
@@ -42,7 +42,7 @@ class EnvUpdater
 
     public function loadConfig()
     {
-        $this->config = require './app/etc/env.php';
+        $this->config = require "./env.php";
     }
 
     /**
@@ -63,14 +63,14 @@ class EnvUpdater
 
     public function loadPortConfig()
     {
-        $portConfigContent = file_get_contents('./node_modules/.create-magento-app-cache/port-config.json');
+        $portConfigContent = getenv("PORTS");
         if ($portConfigContent === false) {
-            throw new Error('Port config file does not exists in cache directory');
+            throw new Error("Ports env does not exists");
         }
 
         $portConfigJsonData = json_decode($portConfigContent, true);
         if ($portConfigJsonData === null) {
-            throw new Error('Port config file is not content');
+            throw new Error("Ports env is not parseable");
         }
 
         $this->portConfig = $portConfigJsonData;
@@ -79,91 +79,96 @@ class EnvUpdater
     public function modifyConfig()
     {
         // set admin uri
-        $this->config['backend']['frontName'] = getenv('ADMIN_URI');
+        $this->config["backend"]["frontName"] = getenv("ADMIN_URI");
+        $hostMachine = getenv("HOST_MACHINE");
+        if ($hostMachine === false) {
+            $hostMachine = '127.0.0.1';
+        }
 
         // update mysql config
-        if (isset($this->config['db']['connection']['default'])) {
-            $conn = &$this->config['db']['connection']['default'];
+        if (isset($this->config["db"]["connection"]["default"])) {
+            $conn = &$this->config["db"]["connection"]["default"];
+            $mysqlHost = $hostMachine . ":" . $this->portConfig["mysql"];
             if (
-                isset($conn['engine']) &&
-                isset($conn['host']) &&
-                $conn['engine'] === 'innodb' &&
-                $conn['host'] !== '127.0.0.1:' . $this->portConfig['mysql']
+                isset($conn["engine"]) &&
+                isset($conn["host"]) &&
+                $conn["engine"] === "innodb" &&
+                $conn["host"] !== $mysqlHost
             ) {
-                $conn['host'] = '127.0.0.1:' . $this->portConfig['mysql'];
+                $conn["host"] = $mysqlHost;
             }
         }
 
         // update redis session config
         if (
-            isset($this->config['session']) &&
-            $this->config['session']['save'] === 'redis' &&
-            $this->config['session']['redis']['port'] !== strval($this->portConfig['redis'])
+            isset($this->config["session"]) &&
+            $this->config["session"]["save"] === "redis" &&
+            $this->config["session"]["redis"]["port"] !== strval($this->portConfig["redis"])
         ) {
-            $this->config['session']['redis']['port'] = strval($this->portConfig['redis']);
+            $this->config["session"]["redis"]["port"] = strval($this->portConfig["redis"]);
         }
 
         if (
-            isset($this->config['session']) &&
-            $this->config['session']['save'] === 'redis' &&
-            $this->config['session']['redis']['host'] !== '127.0.0.1'
+            isset($this->config["session"]) &&
+            $this->config["session"]["save"] === "redis" &&
+            $this->config["session"]["redis"]["host"] !== $hostMachine
         ) {
-            $this->config['session']['redis']['host'] = '127.0.0.1';
+            $this->config["session"]["redis"]["host"] = $hostMachine;
         }
 
         // update redis frontend config
-        if (isset($this->config['cache']['frontend']['default'])) {
-            $frontendCache = &$this->config['cache']['frontend']['default'];
-            if ($frontendCache['backend_options']['port'] !== strval($this->portConfig['redis'])) {
-                $frontendCache['backend_options']['port'] = strval($this->portConfig['redis']);
+        if (isset($this->config["cache"]["frontend"]["default"])) {
+            $frontendCache = &$this->config["cache"]["frontend"]["default"];
+            if ($frontendCache["backend_options"]["port"] !== strval($this->portConfig["redis"])) {
+                $frontendCache["backend_options"]["port"] = strval($this->portConfig["redis"]);
             }
-            if ($frontendCache['backend_options']['server'] !== '127.0.0.1') {
-                $frontendCache['backend_options']['server'] = '127.0.0.1';
+            if ($frontendCache["backend_options"]["server"] !== $hostMachine) {
+                $frontendCache["backend_options"]["server"] = $hostMachine;
             }
         }
 
         // update persisted query redis config
-        if (getenv('SETUP_PQ') == '1') {
-            $cacheConfig = &$this->config['cache'];
-            $redisPort = getenv('REDIS_PORT');
+        if (getenv("SETUP_PQ") == "1") {
+            $cacheConfig = &$this->config["cache"];
+            $redisPort = getenv("REDIS_PORT");
 
-            if (isset($cacheConfig) && isset($cacheConfig['persisted-query']) && isset($cacheConfig['persisted-query']['redis']) && $cacheConfig['persisted-query']['redis']['port'] != $redisPort) {
-                $cacheConfig['persisted-query']['redis']['port'] = $redisPort;
+            if (isset($cacheConfig) && isset($cacheConfig["persisted-query"]) && isset($cacheConfig["persisted-query"]["redis"]) && $cacheConfig["persisted-query"]["redis"]["port"] != $redisPort) {
+                $cacheConfig["persisted-query"]["redis"]["port"] = $redisPort;
             } else {
                 if (!isset($cacheConfig)) {
-                    $this->config['cache'] = [];
+                    $this->config["cache"] = [];
                 }
-                $this->config['cache']['persisted-query'] = [
-                    'redis' => [
-                        'host' => 'localhost',
-                        'port' => $redisPort,
-                        'database' => '5',
-                        'scheme' => 'tcp'
+                $this->config["cache"]["persisted-query"] = [
+                    "redis" => [
+                        "host" => $hostMachine,
+                        "port" => $redisPort,
+                        "database" => "5",
+                        "scheme" => "tcp"
                     ]
                 ];
             }
         } else {
-            unset($this->config['cache']['persisted-query']);
+            unset($this->config["cache"]["persisted-query"]);
         }
 
         // set varnish config
-        $httpCacheHosts = &$this->config['http_cache_hosts'];
+        $httpCacheHosts = &$this->config["http_cache_hosts"];
         $httpCacheHosts = [];
 
-        if (getenv('USE_VARNISH') == '1') {
-            $varnishHost = getenv('VARNISH_HOST');
-            $varnishPort = getenv('VARNISH_PORT');
-            $previousVarnishPort = getenv('PREVIOUS_VARNISH_PORT');
+        if (getenv("USE_VARNISH") == "1") {
+            $varnishHost = getenv("VARNISH_HOST");
+            $varnishPort = getenv("VARNISH_PORT");
+            $previousVarnishPort = getenv("PREVIOUS_VARNISH_PORT");
             $varnishConfig = [
-                'host' => $varnishHost,
-                'port' => $varnishPort
+                "host" => $varnishHost,
+                "port" => $varnishPort
             ];
 
             if (isset($httpCacheHosts)) {
                 $varnishHostExists = false;
                 foreach ($httpCacheHosts as $host) {
-                    if ($host['host'] == $varnishHost && $host['port'] == $previousVarnishPort) {
-                        $host['port'] = $varnishPort;
+                    if ($host["host"] == $varnishHost && $host["port"] == $previousVarnishPort) {
+                        $host["port"] = $varnishPort;
                         $varnishHostExists = true;
                         break;
                     }
@@ -173,10 +178,10 @@ class EnvUpdater
                     $httpCacheHosts = [$varnishConfig];
                 }
             } else {
-                $this->config['http_cache_hosts'] = [$varnishConfig];
+                $this->config["http_cache_hosts"] = [$varnishConfig];
             }
         } else {
-            unset($this->config['http_cache_hosts']);
+            unset($this->config["http_cache_hosts"]);
         }
     }
 
@@ -184,7 +189,7 @@ class EnvUpdater
     {
         file_put_contents(
             $filePath,
-            '<?php'.PHP_EOL.'return '.varexport($this->config, true).';' . PHP_EOL
+            "<?php".PHP_EOL."return ".varexport($this->config, true).";" . PHP_EOL
         );
     }
 
@@ -193,7 +198,7 @@ class EnvUpdater
         $this->loadConfig();
         $this->loadPortConfig();
         $this->modifyConfig();
-        $this->saveConfig(joinpaths(getcwd(), './app/etc/env.php'));
+        $this->saveConfig("./env.php");
     }
 }