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

package/lib/tasks/docker/project-image-builder.js

@@ -0,0 +1,167 @@
+const { DockerFileBuilder } = require('../../util/dockerfile-builder');
+const semver = require('semver');
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+const KnownError = require('../../errors/known-error');
+const { runContainerImage } = require('../../util/run-container-image');
+
+/**
+ * Get enabled extensions list with versions
+ * @param {string} imageWithTag
+ * @returns {Promise<{[key: string]: string}}>}
+ */
+const getEnabledExtensionsFromImage = async (imageWithTag) => {
+    const output = await runContainerImage(
+        imageWithTag,
+        // eslint-disable-next-line quotes
+        `php -r 'foreach (get_loaded_extensions() as $extension) echo "$extension:" . phpversion($extension) . "\n";'`
+    );
+
+    return output
+        .split('\n')
+        .map((m) => {
+            // eslint-disable-next-line no-unused-vars
+            const [_, moduleName, moduleVersion] = m.match(/(.+):(.+)/i);
+
+            return [moduleName, moduleVersion];
+        })
+        .reduce((acc, [name, version]) => ({ ...acc, [name]: version }), {});
+};
+
+const addExtensionToBuilder = (builder, ctx) => ([extensionName, extensionInstructions]) => {
+    const { command, ...extensionInstructionsWithoutCommand } = extensionInstructions;
+    let runCommand = '';
+    if (typeof command === 'string') {
+        runCommand += ` ${command}`;
+    } else if (typeof command === 'function') {
+        runCommand += ` ${command({ ...extensionInstructionsWithoutCommand, ctx })}`;
+    } else {
+        runCommand += ` docker-php-ext-install ${extensionInstructionsWithoutCommand.name}`;
+    }
+    builder
+        .comment(`extension ${extensionName} installation command`)
+        .run(runCommand.trim());
+};
+
+/**
+ * @param {import('../../../typings/context').ListrContext} ctx
+ * @param {{ image: string, tag: string}} param1
+ */
+const buildDockerFileInstructions = async (ctx, { image, tag }) => {
+    const { composer } = ctx.config.overridenConfiguration.configuration;
+    const existingPHPExtensions = await getEnabledExtensionsFromImage(`${image}:${tag}`);
+
+    const missingExtensions = Object.entries(
+        ctx.config.overridenConfiguration.configuration.php.extensions
+    ).filter(
+        ([extensionName, extensionInstructions]) => !Object.entries(existingPHPExtensions)
+            .map(([n, i]) => [n.toLowerCase(), i])
+            .some(
+                ([n]) => extensionName === n || (
+                    extensionInstructions.alternativeName && extensionInstructions.alternativeName.map(
+                        (s) => s.toLowerCase()
+                    ).includes(n)
+                )
+            )
+    ).filter(([extensionName]) => extensionName.toLowerCase() !== 'xdebug');
+
+    const dockerFileInstructions = new DockerFileBuilder()
+        .comment('project image')
+        .from({ image, tag });
+
+    // install bash in image
+    dockerFileInstructions
+        .run('apk add --no-cache bash');
+
+    if (missingExtensions.length > 0) {
+        const allDependencies = missingExtensions.map(
+            ([_extensionName, extensionInstructions]) => (extensionInstructions.dependencies || [])
+        )
+            .reduce((acc, val) => acc.concat(val.filter((ex) => !acc.includes(ex))), []);
+
+        dockerFileInstructions.run(`apk add --no-cache ${allDependencies.join(' ')}`);
+        missingExtensions.forEach(addExtensionToBuilder(dockerFileInstructions, ctx));
+    }
+
+    const composerVersion = /^\d$/.test(composer.version)
+        ? `latest-${composer.version}.x`
+        : composer.version;
+
+    dockerFileInstructions
+        .comment('download composer')
+        .run(`curl https://getcomposer.org/download/${composerVersion}/composer.phar --output composer`)
+        .comment('make composer executable')
+        .run('chmod +x ./composer')
+        .comment('move composer to bin directory')
+        .run('mv composer /usr/local/bin/composer');
+
+    if (semver.satisfies(composer.version, '^1')) {
+        dockerFileInstructions
+            .comment('install prestissimo composer plugin')
+            .run('composer global require hirak/prestissimo');
+    }
+
+    dockerFileInstructions
+        .workDir(ctx.config.baseConfig.containerMagentoDir);
+
+    return dockerFileInstructions;
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const buildProjectImage = () => ({
+    title: 'Building Project Image',
+    task: async (ctx, task) => {
+        const containers = ctx.config.docker.getContainers(ctx.ports);
+        const [image, tag = 'latest'] = ctx.config.overridenConfiguration.configuration.php.baseImage.split(':');
+        const dockerFileInstructions = await buildDockerFileInstructions(ctx, { image, tag });
+
+        try {
+            await execAsyncSpawn(`docker build -t ${containers.php.image} -<<EOF
+${dockerFileInstructions.build()}
+EOF`, {
+                callback: (r) => {
+                    task.output = r;
+                }
+            });
+        } catch (e) {
+            throw new KnownError(`Unexpected error during project image building!\n\n${e}`);
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const buildDebugProjectImage = () => ({
+    title: 'Building Debug Project Image',
+    task: async (ctx, task) => {
+        const containers = ctx.config.docker.getContainers(ctx.ports);
+        const [image, tag = 'latest'] = ctx.config.overridenConfiguration.configuration.php.debugImage.split(':');
+        const dockerFileInstructions = await buildDockerFileInstructions(ctx, { image, tag });
+
+        try {
+            await execAsyncSpawn(`docker build -t ${containers.php.debugImage} -<<EOF
+${dockerFileInstructions.build()}
+EOF`, {
+                callback: (r) => {
+                    task.output = r;
+                }
+            });
+        } catch (e) {
+            throw new KnownError(`Unexpected error during debug project image building!\n\n${e}`);
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = {
+    buildProjectImage,
+    buildDebugProjectImage,
+    getEnabledExtensionsFromImage
+};

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

@@ -0,0 +1,8 @@
+const volumeApi = require('./volume-api');
+const { createVolumes, removeVolumes } = require('./tasks');
+
+module.exports = {
+    createVolumes,
+    removeVolumes,
+    volumeApi
+};

package/lib/tasks/docker/{volumes.js → volume/tasks.js}

@@ -1,21 +1,8 @@
-const { execAsyncSpawn } = require('../../util/exec-async-command');
-
-const create = ({
-    driver,
-    opts = {},
-    name
-}) => {
-    let command = `docker volume create ${ Object.entries(opts).map(([name, value]) => `--opt ${name}=${value}`).join(' ') } `;
-
-    if (driver) {
-        command += `--driver ${ driver }`;
-    }
-
-    return execAsyncSpawn(`${ command } ${ name }`);
-};
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+const { create } = require('./volume-api');
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const createVolumes = () => ({
     title: 'Creating volumes',
@@ -36,7 +23,7 @@ const createVolumes = () => ({
 });
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const removeVolumes = () => ({
     title: 'Removing volumes',
@@ -58,6 +45,5 @@ const removeVolumes = () => ({
 
 module.exports = {
     createVolumes,
-    removeVolumes,
-    createVolume: create
+    removeVolumes
 };

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

@@ -0,0 +1,39 @@
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+
+export interface VolumeLsOptions<T extends boolean = false> {
+    filter?: string | string[]
+    format?: string
+    formatToJSON?: T
+    quiet?: boolean
+}
+
+export interface VolumeLsResult {
+    Driver: string
+    Labels: string
+    Links: string
+    MountPoint: string
+    Name: string
+    Scope: string
+    Size: string
+}
+
+export function ls(
+    options?: VolumeLsOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function ls(
+    options?: VolumeLsOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<VolumeLsResult[]>
+
+export interface VolumeCreateOptions {
+    driver?: string
+    label?: string
+    name: string
+    opt?: Record<string, string>
+}
+
+export function create(
+    options?: VolumeCreateOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>

package/lib/tasks/docker/volume/volume-api.js

@@ -0,0 +1,66 @@
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {import('./volume-api').VolumeCreateOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const create = async (options, execOptions = {}) => {
+    const {
+        driver,
+        label,
+        opt,
+        name
+    } = options;
+
+    const driverArg = driver && `--driver=${driver}`;
+    const labelArg = label && `--label=${label}`;
+    const optArg = opt && Object.entries(opt).map(([name, value]) => `--opt ${name}='${value}'`).join(' ');
+
+    const args = [
+        driverArg,
+        labelArg,
+        optArg,
+        name
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(`docker volume create ${args}`, execOptions);
+};
+
+/**
+ * @param {import('./volume-api').VolumeLsOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const ls = async (options, execOptions = {}) => {
+    const {
+        filter,
+        format,
+        formatToJSON = false,
+        quiet
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const filterArg = filter && typeof filter === 'string'
+        ? `--filter=${filter}`
+        : filter && Array.isArray(filter) && filter.every((f) => typeof f === 'string') && filter.map((f) => `--filter=${f}`).join(' ');
+    const quietArg = quiet && '--quiet';
+
+    const args = [
+        filterArg,
+        formatArg,
+        quietArg
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker volume ls ${args}`, execOptions);
+        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+    }
+
+    return execAsyncSpawn(`docker volume ls ${args}`, execOptions);
+};
+
+module.exports = {
+    create,
+    ls
+};

package/lib/tasks/execute/index.js

@@ -1,4 +1,4 @@
-// const path = require('path');
+const os = require('os');
 const { spawn } = require('child_process');
 
 const executeInContainer = ({ containerName, commands }) => {
@@ -7,11 +7,14 @@ const executeInContainer = ({ containerName, commands }) => {
         process.exit(1);
     }
 
+    const userArg = os.platform() === 'linux' && `--user=${os.userInfo().uid}:${os.userInfo().gid}`;
+
     spawn('docker', [
         'exec',
         '-it',
+        userArg,
         containerName
-    ].concat(...commands.map((command) => command.split(' '))), {
+    ].filter(Boolean).concat(...commands.map((command) => command.split(' '))), {
         stdio: [0, 1, 2]
     });
 

package/lib/tasks/file-system/create-mariadb-config.js

@@ -0,0 +1,23 @@
+const path = require('path');
+const UnknownError = require('../../errors/unknown-error');
+const setConfigFile = require('../../util/set-config');
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const createMariaDBConfig = () => ({
+    title: 'Setting MariaDB config',
+    task: async (ctx) => {
+        try {
+            await setConfigFile({
+                configPathname: path.join(ctx.config.baseConfig.cacheDir, 'mariadb.cnf'),
+                template: path.join(ctx.config.baseConfig.templateDir, 'mariadb.template.cnf'),
+                overwrite: true
+            });
+        } catch (e) {
+            throw new UnknownError(`Unexpected error accrued during php-fpm config creation\n\n${e}`);
+        }
+    }
+});
+
+module.exports = createMariaDBConfig;

package/lib/tasks/file-system/create-nginx-config.js

@@ -1,4 +1,3 @@
-const os = require('os');
 const path = require('path');
 const setConfigFile = require('../../util/set-config');
 const UnknownError = require('../../errors/unknown-error');
@@ -24,7 +23,7 @@ const createNginxConfig = () => ({
             }
         } = overridenConfiguration;
 
-        const isLinux = os.platform() === 'linux';
+        const isLinux = ctx.platform === 'linux';
         const isNativeLinux = isLinux && !isWsl;
         const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
         const hostPort = isNativeLinux ? ports.app : 80;
@@ -41,7 +40,7 @@ const createNginxConfig = () => ({
                 overwrite: true,
                 templateArgs: {
                     ports,
-                    mageRoot: baseConfig.magentoDir,
+                    mageRoot: baseConfig.containerMagentoDir,
                     hostMachine,
                     hostPort,
                     config: overridenConfiguration

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

@@ -1,24 +1,39 @@
 const semver = require('semver');
 const UnknownError = require('../../errors/unknown-error');
 const setConfigFile = require('../../util/set-config');
+const { getEnabledExtensionsFromImage } = require('../docker/project-image-builder');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const createPhpConfig = () => ({
     title: 'Setting PHP config',
-    task: async ({ config: { php, baseConfig, overridenConfiguration: { configuration } }, debug, ports }) => {
-        const isXDebug2 = semver.satisfies(configuration.php.extensions.xdebug.version, '2');
+    task: async (ctx) => {
+        const {
+            config: {
+                php,
+                baseConfig
+            },
+            debug
+        } = ctx;
+        const containers = ctx.config.docker.getContainers(ctx.ports);
+        const phpExtensions = await getEnabledExtensionsFromImage(containers.php.debugImage);
+        const isXDebug2 = semver.satisfies(phpExtensions.xdebug, '2');
+
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const hostMachine = isNativeLinux ? '127.0.0.1' : 'host.docker.internal';
+
         try {
             await setConfigFile({
                 configPathname: php.iniPath,
                 template: php.iniTemplatePath,
                 overwrite: true,
                 templateArgs: {
-                    ports,
                     debug,
-                    mageRoot: baseConfig.magentoDir,
-                    isXDebug2
+                    mageRoot: baseConfig.containerMagentoDir,
+                    isXDebug2,
+                    hostMachine
                 }
             });
         } catch (e) {

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

@@ -1,4 +1,3 @@
-const path = require('path');
 const UnknownError = require('../../errors/unknown-error');
 const setConfigFile = require('../../util/set-config');
 
@@ -7,14 +6,19 @@ const setConfigFile = require('../../util/set-config');
  */
 const createPhpFpmConfig = () => ({
     title: 'Setting php-fpm config',
-    task: async ({ ports, config: { php, baseConfig } }) => {
+    task: async (ctx) => {
+        const { config: { php } } = ctx;
+        const isLinux = ctx.platform === 'linux';
+        const isNativeLinux = isLinux && !ctx.isWsl;
+        const port = isNativeLinux ? ctx.ports.fpm : 9000;
+
         try {
             await setConfigFile({
                 configPathname: php.fpmConfPath,
-                template: path.join(baseConfig.templateDir, 'php-fpm.template.conf'),
+                template: php.fpmTemplatePath,
                 overwrite: true,
                 templateArgs: {
-                    ports
+                    port
                 }
             });
         } catch (e) {

package/lib/tasks/file-system/create-phpstorm-config/exclude-folder-config.js

@@ -1,17 +1,26 @@
 const path = require('path');
 const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
 const pathExists = require('../../../util/path-exists');
+const {
+    urlKey, typeKey, versionKey, nameKey
+} = require('./keys');
 const { formatPathForPHPStormConfig } = require('./xml-utils');
 
 const pathToModulesConfig = path.join(process.cwd(), '.idea', 'modules.xml');
 const excludeFoldersPaths = [
     'bin',
     'dev',
-    'pub',
-    'setup',
+    'pub/static',
     'var/cache',
     'var/page_cache',
-    'var/log'
+    'var/log',
+    'var/composer_home',
+    'var/view_preprocessed'
+].map((p) => `file://$MODULE_DIR$/${p}`);
+
+const mustBeIncludedPaths = [
+    'pub',
+    'setup'
 ].map((p) => `file://$MODULE_DIR$/${p}`);
 
 /**
@@ -24,26 +33,23 @@ const getProjectConfigFilePath = async () => {
     return modulesConfigData.project.component.modules.module['@_filepath'].replace('$PROJECT_DIR$', process.cwd());
 };
 
-/**
- * @returns {Array<{'@_url': string}>}
- */
-const getExcludedFoldersConfig = (projectConfigData) => {
+const setupDefaultsForExcludedFoldersConfig = (projectConfigData) => {
     if (!projectConfigData.module) {
         projectConfigData.module = {
-            '@_type': 'WEB_MODULE',
-            '@_version': '4'
+            [typeKey]: 'WEB_MODULE',
+            [versionKey]: '4'
         };
     }
 
     if (!projectConfigData.module.component) {
         projectConfigData.module.component = {
-            '@_name': 'NewModuleRootManager',
+            [nameKey]: 'NewModuleRootManager',
             orderEntry: [
                 {
-                    '@_type': 'inheritedJdk'
+                    [typeKey]: 'inheritedJdk'
                 },
                 {
-                    '@_type': 'sourceFolder',
+                    [typeKey]: 'sourceFolder',
                     '@_forTest': 'false'
                 }
             ]
@@ -52,37 +58,42 @@ const getExcludedFoldersConfig = (projectConfigData) => {
 
     if (!projectConfigData.module.component.content) {
         projectConfigData.module.component.content = {
-            '@_url': 'file://$MODULE_DIR$'
+            [urlKey]: 'file://$MODULE_DIR$'
         };
     }
 
     if (!projectConfigData.module.component.content.excludeFolder) {
         projectConfigData.module.component.content.excludeFolder = [];
     }
-
-    return projectConfigData
-        .module.component.content.excludeFolder;
 };
 
-const setupExcludedFolders = (excludedFoldersConfig) => {
+const setupExcludedFolders = (projectConfigData) => {
+    const { excludeFolder } = projectConfigData.module.component.content;
     let hasChanges = false;
     // filter excluded folders to get ones that needs to be added to excluded folders list
     const missingExcludedFolders = excludeFoldersPaths
         .filter(
-            (excludeFoldersPath) => !excludedFoldersConfig.some(
-                (config) => config['@_url'] === excludeFoldersPath
+            (excludeFoldersPath) => !excludeFolder.some(
+                (config) => config[urlKey] === excludeFoldersPath
             )
         );
 
     if (missingExcludedFolders.length > 0) {
         hasChanges = true;
         missingExcludedFolders.forEach((missingExcludedFolder) => {
-            excludedFoldersConfig.unshift({
-                '@_url': missingExcludedFolder
+            projectConfigData.module.component.content.excludeFolder.unshift({
+                [urlKey]: missingExcludedFolder
             });
         });
     }
 
+    const hasSomePathsThatMustBeFiltered = excludeFolder.some((config) => mustBeIncludedPaths.includes(config[urlKey]));
+
+    if (hasSomePathsThatMustBeFiltered) {
+        projectConfigData.module.component.content.excludeFolder = excludeFolder.filter((config) => !mustBeIncludedPaths.includes(config[urlKey]));
+        hasChanges = true;
+    }
+
     return hasChanges;
 };
 
@@ -94,13 +105,13 @@ const getIMLFilePath = async () => {
 
         const modulesConfig = {
             '?xml': {
-                '@_version': '1.0',
+                [versionKey]: '1.0',
                 '@_encoding': 'UTF-8'
             },
             project: {
-                '@_version': '4',
+                [versionKey]: '4',
                 component: {
-                    '@_name': 'ProjectModuleManager',
+                    [nameKey]: 'ProjectModuleManager',
                     modules: [
                         {
                             module: {
@@ -129,8 +140,8 @@ const setupExcludedFoldersConfig = () => ({
             const projectFilePath = await getProjectConfigFilePath();
             if (await pathExists(projectFilePath)) {
                 const projectConfigData = await loadXmlFile(projectFilePath);
-                const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
-                const hasChanges = setupExcludedFolders(excludedFoldersConfig);
+                setupDefaultsForExcludedFoldersConfig(projectConfigData);
+                const hasChanges = setupExcludedFolders(projectConfigData);
                 if (hasChanges) {
                     await buildXmlFile(projectFilePath, projectConfigData);
                 } else {
@@ -144,12 +155,13 @@ const setupExcludedFoldersConfig = () => ({
         const projectFilePath = await getIMLFilePath();
         const projectConfigData = {
             '?xml': {
-                '@_version': '1.0',
+                [versionKey]: '1.0',
                 '@_encoding': 'UTF-8'
             }
         };
-        const excludedFoldersConfig = getExcludedFoldersConfig(projectConfigData);
-        setupExcludedFolders(excludedFoldersConfig);
+
+        setupDefaultsForExcludedFoldersConfig(projectConfigData);
+        setupExcludedFolders(projectConfigData);
 
         await buildXmlFile(projectFilePath, projectConfigData);
     }

package/lib/tasks/file-system/create-phpstorm-config/index.js

@@ -5,6 +5,7 @@ const setupInspectionToolsConfig = require('./inspection-tools-config');
 const setupExcludedFoldersConfig = require('./exclude-folder-config');
 const setupStylelintConfig = require('./stylelint-config');
 const setupESLintConfig = require('./eslint-config');
+const setupPhpDockerSettingsConfig = require('./php-docker-settings-config');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -14,6 +15,7 @@ const createPhpStormConfig = () => ({
     task: (ctx, task) => task.newListr([
         setupWorkspaceConfig(),
         setupPhpConfig(),
+        setupPhpDockerSettingsConfig(),
         setupDatabaseConfig(),
         setupInspectionToolsConfig(),
         setupExcludedFoldersConfig(),

package/lib/tasks/file-system/create-phpstorm-config/keys.js

@@ -4,11 +4,25 @@ const nameKey = '@_name';
 const valueKey = '@_value';
 const toolPathKey = '@_tool_path';
 const standardsKey = '@_standards';
+const urlKey = '@_url';
+const typeKey = '@_type';
+const versionKey = '@_version';
+
+/**
+ * Makes a xml property key
+ * @param {string} key
+ * @returns {string}
+ */
+const propertyKey = (key) => `@_${key}`;
 
 module.exports = {
     classKey,
     nameKey,
     valueKey,
     toolPathKey,
-    standardsKey
+    standardsKey,
+    urlKey,
+    typeKey,
+    versionKey,
+    propertyKey
 };