@scandipwa/magento-scripts 1.14.1-alpha.2 → 1.14.1-alpha.3

package/index.js

@@ -5,6 +5,19 @@ const getLatestVersion = require('@scandipwa/scandipwa-dev-utils/latest-version'
 const logger = require('@scandipwa/scandipwa-dev-utils/logger');
 const semver = require('semver');
 const isInstalledGlobally = require('is-installed-globally');
+const isRunningRoot = require('./lib/util/is-running-root');
+
+if (isRunningRoot()) {
+    logger.error('Root privileges detected!');
+    console.log(`
+We detected that you are running ${ logger.style.misc('magento-scripts') } as root user.
+We cannot allow you to run ${ logger.style.misc('magento-scripts') } with root privileges, this will only cause more problems.
+
+If you are experiencing problems with ${ logger.style.misc('Docker') }, ${ logger.style.misc('PHPBrew') } and ${ logger.style.misc('PHP') } compilation or ${ logger.style.misc('Magento') } setup, running ${ logger.style.misc('magento-scripts') } as root will not solve those problems.
+`);
+
+    process.exit(1);
+}
 
 const commands = [
     require('./lib/commands/link'),

package/lib/tasks/file-system/create-php-storm-config.js

@@ -0,0 +1,82 @@
+const setConfigFile = require('../../util/set-config');
+const pathExists = require('../../util/path-exists');
+const path = require('path');
+const fs = require('fs');
+
+const createPhpStormConfig = () => ({
+    title: 'Setting PHPStorm config',
+    task: async ({ config: { phpStorm }, ports }) => {
+        const { phpLanguageLevel } = phpStorm.php;
+        const jdbcUrl = `jdbc:mysql://localhost:${ports.mysql}/magento`;
+
+        try {
+            await setConfigFile({
+                configPathname: phpStorm.xdebug.path,
+                template: phpStorm.xdebug.templatePath,
+                overwrite: true,
+                templateArgs: {
+                    phpStorm
+                }
+            });
+        } catch (e) {
+            throw new Error(`Unexpected error accrued during workspace.xml config creation\n\n${e}`);
+        }
+
+        try {
+            await setConfigFile({
+                configPathname: phpStorm.php.path,
+                template: phpStorm.php.templatePath,
+                overwrite: true,
+                templateArgs: {
+                    phpLanguageLevel
+                }
+            });
+        } catch (e) {
+            throw new Error(`Unexpected error accrued during php.xml config creation\n\n${e}`);
+        }
+
+        try {
+            await setConfigFile({
+                configPathname: phpStorm.database.dataSourcesLocal.path,
+                template: phpStorm.database.dataSourcesLocal.templatePath,
+                overwrite: true,
+                templateArgs: {
+                    phpStorm
+                }
+            });
+        } catch (e) {
+            throw new Error(`Unexpected error accrued during dataSources.local.xml config creation\n\n${e}`);
+        }
+
+        try {
+            await setConfigFile({
+                configPathname: phpStorm.database.dataSources.path,
+                template: phpStorm.database.dataSources.templatePath,
+                overwrite: true,
+                templateArgs: {
+                    phpStorm,
+                    jdbcUrl
+                }
+            });
+        } catch (e) {
+            throw new Error(`Unexpected error accrued during dataSources.xml config creation\n\n${e}`);
+        }
+
+        if (!await pathExists(path.resolve('./.idea/dataSources'))) {
+            await fs.promises.mkdir(path.resolve('./.idea/dataSources'));
+        }
+
+        try {
+            await setConfigFile({
+                configPathname: phpStorm.inspectionTools.path,
+                template: phpStorm.inspectionTools.templatePath,
+                overwrite: true,
+                templateArgs: {}
+            });
+        } catch (e) {
+            throw new Error(`Unexpected error accrued during Project_Default.xml config creation\n\n${e}`);
+        }
+    }
+});
+
+module.exports = createPhpStormConfig;

package/lib/tasks/file-system/index.js

@@ -1,7 +1,7 @@
 const createNginxConfig = require('./create-nginx-config');
 const createPhpConfig = require('./create-php-config');
 const createPhpFpmConfig = require('./create-php-fpm-config');
-const createPhpStormConfig = require('./create-phpstorm-config');
+const createPhpStormConfig = require('./create-php-storm-config');
 const createVSCodeConfig = require('./create-vscode-config');
 
 /**

package/lib/tasks/requirements/docker/index.js

@@ -4,6 +4,7 @@ const { execAsyncSpawn } = require('../../../util/exec-async-command');
 const getIsWsl = require('../../../util/is-wsl');
 const installDocker = require('./install');
 const { checkDockerSocketPermissions } = require('./permissions');
+const checkDockerStatus = require('./running-status');
 const getDockerVersion = require('./version');
 
 /**
@@ -61,6 +62,7 @@ ${ logger.style.link('https://docs.create-magento-app.com/getting-started/prereq
         }
 
         return task.newListr([
+            checkDockerStatus(),
             getDockerVersion(),
             {
                 task: (ctx) => {

package/lib/tasks/requirements/docker/install.js

@@ -3,13 +3,16 @@ const { execCommandTask } = require('../../../util/exec-async-command');
 const installDependenciesTask = require('../../../util/install-dependencies-task');
 const executeSudoCommand = require('../../../util/execute-sudo-command');
 
+const downloadDockerInstallScriptCommand = () => execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh');
+const runDockerInstallScriptCommand = () => executeSudoCommand('sudo sh get-docker.sh');
+const enableAndStartDockerCommand = () => executeSudoCommand('sudo systemctl enable docker --now');
+
 const postInstallSteps = [
     executeSudoCommand('[ $(getent group docker) ] && sudo groupadd docker', {
         withCode: true
     }),
     executeSudoCommand(`sudo usermod -aG docker ${process.env.USER}`)
 ];
-
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
@@ -24,26 +27,23 @@ const installDocker = () => ({
                     platform: 'Arch Linux',
                     dependenciesToInstall: ['docker']
                 }),
-                executeSudoCommand('sudo systemctl start docker.service'),
-                executeSudoCommand('sudo systemctl enable docker.service'),
+                enableAndStartDockerCommand(),
                 ...postInstallSteps
             ]);
         }
         case 'Fedora':
         case 'CentOS': {
             return task.newListr([
-                execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh'),
-                executeSudoCommand('sudo sh get-docker.sh'),
-                executeSudoCommand('sudo systemctl start docker'),
-                executeSudoCommand('sudo systemctl enable docker')
+                downloadDockerInstallScriptCommand(),
+                runDockerInstallScriptCommand(),
+                enableAndStartDockerCommand()
             ]);
         }
         case 'Ubuntu': {
             return task.newListr([
-                execCommandTask('curl -fsSL https://get.docker.com -o get-docker.sh'),
-                executeSudoCommand('sudo sh get-docker.sh'),
-                executeSudoCommand('sudo service docker start'),
-                executeSudoCommand('sudo systemctl enable docker.service'),
+                downloadDockerInstallScriptCommand(),
+                runDockerInstallScriptCommand(),
+                enableAndStartDockerCommand(),
                 ...postInstallSteps
             ]);
         }

package/lib/tasks/requirements/docker/running-status.js

@@ -0,0 +1,137 @@
+const os = require('os');
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const getIsWsl = require('../../../util/is-wsl');
+const pathExists = require('../../../util/path-exists');
+const sleep = require('../../../util/sleep');
+const { systemctlControl } = require('../../../util/systemctl');
+
+const pathToDockerApplication = '/Applications/Docker.app';
+
+const getDockerVersion = () => execAsyncSpawn('docker version --format {{.Server.Version}}', {
+    withCode: true
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatusMacOS = () => ({
+    title: 'Checking Docker status on MacOS',
+    task: async (ctx, task) => {
+        const { result, code } = await getDockerVersion();
+
+        if (code !== 0 && result.includes('Is the docker daemon running?')) {
+            const dockerOpenAppConfirmation = await task.prompt({
+                type: 'Confirm',
+                message: 'Looks like Docker is not running, would you like us to open a Docker for Mac application and wait for it to start up?'
+            });
+
+            if (dockerOpenAppConfirmation && await pathExists(pathToDockerApplication)) {
+                await execAsyncSpawn(`open ${pathToDockerApplication}`);
+                let ready = false;
+                let attempts = 0;
+                while (!ready) {
+                    if (attempts > 24 && !ready) {
+                        throw new Error('Docker haven\'t started in 2 mins, exiting...');
+                    }
+                    try {
+                        const { code: startupCode } = await getDockerVersion();
+                        if (startupCode !== 0) {
+                            task.output = `Waiting for Docker to startup for ${attempts * 5} seconds...`;
+                            attempts++;
+                            await sleep(5000);
+                        } else {
+                            ready = true;
+                        }
+                    } catch (e) {
+                        //
+                    }
+                }
+
+                return;
+            }
+
+            task.skip('User skipped running Docker');
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatusWSL = () => ({
+    title: 'Checking Docker status on Windows WSL',
+    task: async () => {
+        const { result, code } = await getDockerVersion();
+
+        if (code !== 0 && result.includes('Is the docker daemon running?')) {
+            throw new Error(`Docker is not running!
+
+Please open Docker Desktop application for Windows and make sure that Docker is running. Then you can try again!`);
+        }
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatusLinux = () => ({
+    title: 'Checking Docker status on Linux',
+    task: async (ctx, task) => {
+        const dockerService = systemctlControl('docker');
+
+        const isRunning = await dockerService.isRunning();
+        const isEnabled = await dockerService.isEnabled();
+
+        if (!isEnabled && !isRunning) {
+            const dockerStartConfirmation = await task.prompt({
+                type: 'Confirm',
+                message: `Looks like Docker is not enabled and not running, would you like to enable and run it?
+
+This action requires root privileges.`
+            });
+
+            if (dockerStartConfirmation) {
+                await dockerService.enableAndStart();
+
+                return;
+            }
+            task.skip('User skipped running Docker');
+        } else if (!isRunning) {
+            const dockerStartConfirmation = await task.prompt({
+                type: 'Confirm',
+                message: `Looks like Docker is not running, would you like to run it?
+
+This action requires root privileges.`
+            });
+
+            if (dockerStartConfirmation) {
+                await dockerService.start();
+
+                return;
+            }
+            task.skip('User skipped running Docker');
+        }
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const checkDockerStatus = () => ({
+    title: 'Checking Docker status',
+    task: async (ctx, task) => {
+        if (os.platform() === 'darwin') {
+            return task.newListr(checkDockerStatusMacOS());
+        }
+        if (!await getIsWsl()) {
+            return task.newListr(checkDockerStatusLinux());
+        }
+
+        return task.newListr(checkDockerStatusWSL());
+    }
+});
+
+module.exports = checkDockerStatus;

package/lib/tasks/requirements/docker/version.js

@@ -13,6 +13,8 @@ const getDockerVersion = () => ({
             const dockerVersion = result.split('').filter((c) => /[\d.]/i.test(c)).join('') || result;
 
             ctx.dockerVersion = dockerVersion;
+        } else {
+            throw new Error(`Got unexpected result during Docker version retrieval!\n\n${ result }`);
         }
     }
 });

package/lib/tasks/start.js

@@ -29,7 +29,6 @@ const convertLegacyVolumes = require('./docker/convert-legacy-volumes');
 const enableMagentoComposerPlugins = require('./magento/enable-magento-composer-plugins');
 const getIsWsl = require('../util/is-wsl');
 const checkForXDGOpen = require('../util/xdg-open-exists');
-const { getInstanceMetadata, constants: { WEB_LOCATION_TITLE } } = require('../util/instance-metadata');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
@@ -190,11 +189,8 @@ const start = () => ({
 
                     return false;
                 },
-                task: (ctx) => {
-                    const instanceMetadata = getInstanceMetadata(ctx);
-                    const locationOnTheWeb = instanceMetadata.frontend.find(({ title }) => title === WEB_LOCATION_TITLE);
-
-                    openBrowser(locationOnTheWeb.text);
+                task: ({ ports, config: { overridenConfiguration: { host, ssl } } }) => {
+                    openBrowser(`${ssl.enabled ? 'https' : 'http'}://${host}${ssl.enabled || ports.app === 80 ? '' : `:${ports.app}`}/`);
                 },
                 options: {
                     showTimer: false

package/lib/util/instance-metadata.js

@@ -70,11 +70,5 @@ const getInstanceMetadata = (ctx) => {
 };
 
 module.exports = {
-    getInstanceMetadata,
-    constants: {
-        WEB_LOCAL_LOCATION_TITLE,
-        WEB_LOCATION_TITLE,
-        WEB_ADMIN_LOCATION_TITLE,
-        WEB_ADMIN_CREDENTIALS_TITLE
-    }
+    getInstanceMetadata
 };

package/lib/util/is-running-root.js

@@ -0,0 +1,3 @@
+const isRunningRoot = () => process.getuid() === 0; // UID 0 is always root
+
+module.exports = isRunningRoot;

package/lib/util/systemctl.js

@@ -0,0 +1,46 @@
+const { execAsyncSpawn } = require('./exec-async-command');
+
+/**
+ * @param {String} cmd
+ * @param {String} serviceName
+ * @param {{ now: boolean }} options
+ */
+const run = (cmd, serviceName, options = {}) => execAsyncSpawn(
+    `systemctl ${ cmd }${ serviceName ? ` ${ serviceName }` : '' }${ options.now ? ' --now' : ''}`,
+    {
+        withCode: true
+    }
+);
+
+const daemonReload = () => run('daemon-reload');
+
+const systemctlControl = (serviceName) => ({
+    disable: () => run('disable', serviceName),
+    enable: () => run('enable', serviceName),
+    enableAndStart: () => run('enable', serviceName, { now: true }),
+    restart: () => run('restart', serviceName),
+    start: () => run('start', serviceName),
+    stop: () => run('stop', serviceName),
+    isEnabled: async () => {
+        try {
+            const { result } = await run('is-enabled', serviceName);
+            return result.includes('enabled');
+        } catch (e) {
+            return false;
+        }
+    },
+    isRunning: async () => {
+        try {
+            const { result } = await run('status', serviceName);
+
+            return result.includes('active (running)');
+        } catch (e) {
+            return false;
+        }
+    }
+});
+
+module.exports = {
+    systemctlControl,
+    daemonReload
+};

package/package.json

@@ -3,7 +3,7 @@
     "description": "Scripts and configuration used by CMA.",
     "homepage": "https://docs.create-magento-app.com/",
     "repository": "github:scandipwa/create-magento-app",
-    "version": "1.14.1-alpha.2",
+    "version": "1.14.1-alpha.3",
     "main": "./index.js",
     "types": "./typings/index.d.ts",
     "license": "OSL-3.0",
@@ -26,7 +26,6 @@
         "conf": "10.1.1",
         "enquirer": "2.3.6",
         "eta": "1.12.3",
-        "fast-xml-parser": "^4.0.7",
         "hjson": "^3.2.2",
         "is-installed-globally": "0.4.0",
         "joi": "17.6.0",
@@ -52,5 +51,5 @@
         "mysql",
         "scandipwa"
     ],
-    "gitHead": "8f43ab3d68af6442bbd618efd785654ac62e54b8"
+    "gitHead": "262eae9eb5d71053f48d177426320182c5b5a9eb"
 }

package/typings/context.d.ts

@@ -1,7 +1,6 @@
 import mysql2 from 'mysql2';
 
 import { CMAConfiguration, PHPExtensions } from './index';
-import { PHPStormConfig } from './phpstorm';
 
 export interface ListrContext {
     magentoVersion: string
@@ -83,7 +82,6 @@ export interface ListrContext {
         overridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
         userConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
         nonOverridenConfiguration: Omit<CMAConfiguration, 'prefix' | 'useNonOverlappingPorts'>
-        phpStorm: PHPStormConfig
     }
     systemConfiguration: {
         analytics: boolean

package/lib/config/xml-parser.js

@@ -1,61 +0,0 @@
-const { XMLParser, XMLBuilder } = require('fast-xml-parser');
-const fs = require('fs');
-const path = require('path');
-const pathExists = require('../util/path-exists');
-
-/**
- * @type {import('fast-xml-parser').X2jOptions}
- */
-const xmlParserConfig = {
-    ignoreAttributes: false,
-    parseAttributeValue: false,
-    trimValues: true,
-    allowBooleanAttributes: true
-};
-
-/**
- * @type {Partial<import('fast-xml-parser').XmlBuilderOptions>}
- */
-const xmlBuilderConfig = {
-    ...xmlParserConfig,
-    format: true,
-    suppressEmptyNode: true,
-    suppressBooleanAttributes: false
-};
-
-const parser = new XMLParser(xmlParserConfig);
-const builder = new XMLBuilder(xmlBuilderConfig);
-
-/**
- * Load xml file to js object
- * @param {String} filePath
- */
-const loadXmlFile = async (filePath) => {
-    const fileData = await fs.promises.readFile(filePath, 'utf-8');
-
-    return parser.parse(fileData);
-};
-
-/**
- * Build xml from js object and write it to file
- * @param {String} filePath
- * @param {String} fileData
- */
-const buildXmlFile = async (filePath, fileData) => {
-    const xmlFileData = builder.build(fileData);
-
-    const { dir } = path.parse(filePath);
-
-    if (!await pathExists(dir)) {
-        await fs.promises.mkdir(dir, {
-            recursive: true
-        });
-    }
-
-    await fs.promises.writeFile(filePath, xmlFileData, 'utf-8');
-};
-
-module.exports = {
-    loadXmlFile,
-    buildXmlFile
-};