@scandipwa/magento-scripts 2.0.0-alpha.1 → 2.0.0-alpha.12

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[]>

package/lib/tasks/docker/containers/container-api.js

@@ -3,9 +3,9 @@ const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
  * @param {import('./container-api').ContainerRunOptions} options
- * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ * @returns {string[]}
  */
-const run = (options, execOptions = {}) => {
+const runCommand = (options) => {
     const {
         addHost,
         ports = [],
@@ -24,32 +24,35 @@ const run = (options, execOptions = {}) => {
         expose = [],
         detach = true,
         rm = false,
+        tty = false,
         user
     } = options;
 
     const detachArg = detach && '-d';
     const rmArg = rm && '--rm';
+    const ttyArg = tty && '-it';
     const exposeArg = expose && expose.map((e) => `--expose=${ e }`);
-    const restartArg = !rm && restart && `--restart ${ restart }`;
-    const networkArg = network && `--network ${ network }`;
-    const portsArgs = ports.map((port) => `-p ${ port }`).join(' ');
-    const mountsArgs = mounts.map((mount) => `--mount ${ mount }`).join(' ');
-    const mountVolumesArgs = mountVolumes.map((mount) => `-v ${mount}`).join(' ');
-    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env ${ key }='${ value }'`).join(' ');
-    const nameArg = name && `--name ${name}`;
-    const entrypointArg = entrypoint && `--entrypoint "${entrypoint}"`;
-    const healthCheckArg = healthCheck && Object.entries(healthCheck).map(([key, value]) => `--health-${key} '${value}'`).join(' ');
-    const securityArg = securityOptions.length > 0 && securityOptions.map((opt) => `--security-opt ${opt}`).join(' ');
-    const tmpfsArg = tmpfs.length > 0 && tmpfs.map((t) => `--tmpfs ${t}`).join(' ');
+    const restartArg = !rm && restart && `--restart=${ restart }`;
+    const networkArg = network && `--network=${ network }`;
+    const portsArgs = ports && ports.length > 0 && ports.map((port) => `-p=${ port }`).join(' ');
+    const mountsArgs = mounts && mounts.map((mount) => `--mount=${ mount }`).join(' ');
+    const mountVolumesArgs = mountVolumes && mountVolumes.map((mount) => `-v=${mount}`).join(' ');
+    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env=${ key }='${ value }'`).join(' ');
+    const nameArg = name && `--name=${name}`;
+    const entrypointArg = entrypoint && `--entrypoint="${entrypoint}"`;
+    const healthCheckArg = healthCheck && Object.entries(healthCheck).map(([key, value]) => `--health-${key}='${value}'`).join(' ');
+    const securityArg = securityOptions.length > 0 && securityOptions.map((opt) => `--security-opt=${opt}`).join(' ');
+    const tmpfsArg = tmpfs.length > 0 && tmpfs.map((t) => `--tmpfs=${t}`).join(' ');
     const userArg = user && `--user=${user}`;
     const addHostArg = addHost && `--add-host=${addHost}`;
 
     const dockerCommand = [
         'docker',
         'run',
+        nameArg,
+        ttyArg,
         detachArg,
         rmArg,
-        nameArg,
         networkArg,
         restartArg,
         portsArgs,
@@ -65,11 +68,17 @@ const run = (options, execOptions = {}) => {
         addHostArg,
         image,
         command
-    ].filter(Boolean).join(' ');
+    ].filter(Boolean).filter((arg) => typeof arg === 'string');
 
-    return execAsyncSpawn(dockerCommand, execOptions);
+    return dockerCommand;
 };
 
+/**
+ * @param {import('./container-api').ContainerRunOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const run = (options, execOptions = {}) => execAsyncSpawn(runCommand(options).join(' '), execOptions);
+
 /**
  * @param {string} command
  * @param {string} container container id or name
@@ -140,14 +149,64 @@ const ls = async (options = {}, execOptions = {}) => {
 
     if (formatToJSON) {
         const result = await execAsyncSpawn(`docker container ls ${args}`, execOptions);
+        if (result.startsWith('[')) {
+            return JSON.parse(result);
+        }
+
         return JSON.parse(`[${result.split('\n').join(', ')}]`);
     }
 
     return execAsyncSpawn(`docker container ls ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./container-api').ContainerLogsOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const logs = async (options = {}, execOptions = {}) => {
+    const {
+        name,
+        details = false,
+        follow = false,
+        since = '',
+        tail = '',
+        timestamps = false,
+        until = '',
+        parser
+    } = options;
+    const detailsArg = details && '--details';
+    const followArg = follow && '--follow';
+    const sinceArg = since && `--since=${since}`;
+    const tailArg = tail && `--tail=${tail}`;
+    const timestampsArg = timestamps && '--timestamps';
+    const untilArg = until && `--until=${until}`;
+
+    const logsCommand = [
+        'docker',
+        'container',
+        'logs',
+        detailsArg,
+        followArg,
+        sinceArg,
+        tailArg,
+        timestampsArg,
+        untilArg,
+        name
+    ].filter(Boolean).join(' ');
+
+    if (parser) {
+        const result = await execAsyncSpawn(logsCommand, execOptions);
+
+        return result.split('\n').map((line) => parser(line));
+    }
+
+    return execAsyncSpawn(logsCommand, execOptions);
+};
+
 module.exports = {
     run,
+    runCommand,
     exec,
-    ls
+    ls,
+    logs
 };

package/lib/tasks/docker/containers/tasks.js

@@ -26,8 +26,39 @@ const remoteImageReducer = (acc, val) => {
  */
 const pullImages = () => ({
     title: 'Pulling container images',
-    task: async ({ config: { docker } }, task) => {
+    task: async ({ config: { docker }, pullImages }, task) => {
         const containers = Object.values(docker.getContainers());
+
+        if (pullImages) {
+            return task.newListr(
+                containers
+                    .reduce(remoteImageReducer, [])
+                    .map((image) => {
+                        const [repo, tag = 'latest'] = image.split(':');
+
+                        return { repo, tag };
+                    })
+                    .reduce(
+                        (acc, val) => acc.concat(
+                            acc.some(
+                                (c) => c.repo === val.repo
+                                && c.tag === val.tag
+                            )
+                                ? []
+                                : val
+                        ),
+                        []
+                    )
+                    .map(({ repo, tag }) => ({
+                        title: `Pulling ${ logger.style.file(`${repo}:${tag}`) } image`,
+                        task: () => pull(`${repo}:${tag}`)
+                    })), {
+                    concurrent: true,
+                    exitOnError: true
+                }
+            );
+        }
+
         const imagesFilter = containers
             .reduce(remoteImageReducer, [])
             .map((image) => `reference='${image}'`);

package/lib/tasks/docker/index.js

@@ -1,5 +1,7 @@
 const containers = require('./containers');
 const network = require('./network');
+const volume = require('./volume');
+const dockerApi = require('./api');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
@@ -19,13 +21,16 @@ const startServices = () => ({
  * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
 const stopServices = () => ({
+    title: 'Stopping Docker services',
     task: (ctx, task) => task.newListr([
         containers.stopContainers(),
+        volume.removeLocalVolumes(),
         network.tasks.removeNetwork()
     ])
 });
 
 module.exports = {
     startServices,
-    stopServices
+    stopServices,
+    dockerApi
 };

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

@@ -27,13 +27,13 @@ const getEnabledExtensionsFromImage = async (imageWithTag) => {
         .reduce((acc, [name, version]) => ({ ...acc, [name]: version }), {});
 };
 
-const addExtensionToBuilder = (builder, ctx) => ([extensionName, extensionInstructions]) => {
+const addExtensionToBuilder = (builder, ctx) => async ([extensionName, extensionInstructions]) => {
     const { command, ...extensionInstructionsWithoutCommand } = extensionInstructions;
     let runCommand = '';
     if (typeof command === 'string') {
         runCommand += ` ${command}`;
-    } else if (typeof command === 'function') {
-        runCommand += ` ${command({ ...extensionInstructionsWithoutCommand, ctx })}`;
+    } else if (typeof command === 'function' || command instanceof Promise) {
+        runCommand += ` ${await Promise.resolve(command({ ...extensionInstructionsWithoutCommand, ctx }))}`;
     } else {
         runCommand += ` docker-php-ext-install ${extensionInstructionsWithoutCommand.name}`;
     }
@@ -68,10 +68,6 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         .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 || [])
@@ -79,7 +75,9 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
             .reduce((acc, val) => acc.concat(val.filter((ex) => !acc.includes(ex))), []);
 
         dockerFileInstructions.run(`apk add --no-cache ${allDependencies.join(' ')}`);
-        missingExtensions.forEach(addExtensionToBuilder(dockerFileInstructions, ctx));
+        for (const missingExtensionInstructions of missingExtensions) {
+            await addExtensionToBuilder(dockerFileInstructions, ctx)(missingExtensionInstructions);
+        }
     }
 
     const composerVersion = /^\d$/.test(composer.version)

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

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

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

@@ -1,5 +1,6 @@
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
-const { create } = require('./volume-api');
+const fs = require('fs');
+const pathExists = require('../../../util/path-exists');
+const volumeApi = require('./volume-api');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -7,10 +8,12 @@ const { create } = require('./volume-api');
 const createVolumes = () => ({
     title: 'Creating volumes',
     task: async ({ config: { docker } }, task) => {
-        const volumeList = (await execAsyncSpawn('docker volume ls --format "{{.Name}}"')).split('\n');
+        const volumeList = await volumeApi.ls({
+            formatToJSON: true
+        });
 
         const missingVolumes = Object.values(docker.volumes).filter(
-            ({ name }) => !volumeList.includes(name)
+            ({ name }) => !volumeList.some((v) => v.Name === name)
         );
 
         if (missingVolumes.length === 0) {
@@ -18,7 +21,15 @@ const createVolumes = () => ({
             return;
         }
 
-        await Promise.all(missingVolumes.map((volume) => create(volume)));
+        await Promise.all(missingVolumes.map(async (volume) => {
+            if (volume.opt && volume.opt.device && !await pathExists(volume.opt.device)) {
+                await fs.promises.mkdir(volume.opt.device, {
+                    recursive: true
+                });
+            }
+        }));
+
+        await Promise.all(missingVolumes.map((volume) => volumeApi.create(volume)));
     }
 });
 
@@ -28,10 +39,12 @@ const createVolumes = () => ({
 const removeVolumes = () => ({
     title: 'Removing volumes',
     task: async ({ config: { docker } }, task) => {
-        const volumeList = (await execAsyncSpawn('docker volume ls --format "{{.Name}}"')).split('\n');
+        const volumeList = await volumeApi.ls({
+            formatToJSON: true
+        });
 
         const deployedVolumes = Object.values(docker.volumes).filter(
-            ({ name }) => volumeList.includes(name)
+            ({ name }) => volumeList.some((v) => v.Name === name)
         );
 
         if (deployedVolumes.length === 0) {
@@ -39,11 +52,43 @@ const removeVolumes = () => ({
             return;
         }
 
-        await execAsyncSpawn(`docker volume rm ${deployedVolumes.map(({ name }) => name).join(' ')}`);
+        await volumeApi.rm({
+            volumes: deployedVolumes.map(({ name }) => name)
+        });
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const removeLocalVolumes = () => ({
+    title: 'Removing local volumes',
+    task: async (ctx, task) => {
+        const volumeList = await volumeApi.ls({
+            formatToJSON: true
+        });
+        const { volumes } = ctx.config.docker;
+
+        const localVolumes = Object.values(volumes).filter(
+            (volume) => volume.opt && volume.opt.device
+        );
+
+        const existingLocalVolumes = localVolumes.filter(
+            (volume) => volumeList.some((v) => v.Name === volume.name)
+        );
+
+        if (existingLocalVolumes.length > 0) {
+            await volumeApi.rm({
+                volumes: existingLocalVolumes.map((volume) => volume.name)
+            });
+        } else {
+            task.skip();
+        }
     }
 });
 
 module.exports = {
     createVolumes,
-    removeVolumes
+    removeVolumes,
+    removeLocalVolumes
 };

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

@@ -37,3 +37,13 @@ export function create(
     options?: VolumeCreateOptions,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<string>
+
+export interface VolumeRmOptions {
+    force?: boolean
+    volumes: string[]
+}
+
+export function rm(
+    options?: VolumeRmOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>

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

@@ -60,7 +60,31 @@ const ls = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker volume ls ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./volume-api').VolumeRmOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const rm = async (options, execOptions = {}) => {
+    const {
+        force,
+        volumes
+    } = options;
+
+    const forceArg = force && '--force';
+
+    const command = [
+        'docker',
+        'volume',
+        'rm',
+        forceArg,
+        ...volumes
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(command, execOptions);
+};
+
 module.exports = {
     create,
-    ls
+    ls,
+    rm
 };

package/lib/tasks/execute.js

@@ -0,0 +1,100 @@
+const { Listr } = require('listr2');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const { checkRequirements } = require('./requirements');
+const getMagentoVersionConfig = require('../config/get-magento-version-config');
+const checkConfigurationFile = require('../config/check-configuration-file');
+const getProjectConfiguration = require('../config/get-project-configuration');
+const { getCachedPorts } = require('../config/get-port-config');
+const { executeInContainer, runInContainer } = require('../util/execute-in-container');
+const { containerApi } = require('./docker/containers');
+const dockerNetwork = require('./docker/network');
+const KnownError = require('../errors/known-error');
+
+/**
+ *
+ * @param {{ containername: string, commands?: string[] }} argv
+ * @returns
+ */
+const executeTask = async (argv) => {
+    const tasks = new Listr([
+        checkRequirements(),
+        getMagentoVersionConfig(),
+        checkConfigurationFile(),
+        getProjectConfiguration(),
+        getCachedPorts(),
+        dockerNetwork.tasks.createNetwork()
+    ], {
+        concurrent: false,
+        exitOnError: true,
+        ctx: { throwMagentoVersionMissing: true },
+        rendererOptions: { collapse: false, clearOutput: true }
+    });
+
+    let ctx;
+    try {
+        ctx = await tasks.run();
+    } catch (e) {
+        logger.error(e.message || e);
+        process.exit(1);
+    }
+    const containers = ctx.config.docker.getContainers(ctx.ports);
+    const services = Object.keys(containers);
+
+    if (services.includes(argv.containername) || services.some((service) => service.includes(argv.containername))) {
+        /**
+         * @type {import('./docker/containers/container-api').ContainerRunOptions}
+         */
+        const container = containers[argv.containername]
+            ? containers[argv.containername]
+            : Object.entries(containers).find(([key]) => key.includes(argv.containername))[1];
+
+        if (argv.commands.length === 0) {
+        // if we have default connect command then use it
+            if (container.connectCommand) {
+            // eslint-disable-next-line no-param-reassign
+                argv.commands = container.connectCommand;
+            } else {
+            // otherwise fall back to bash (if it exists inside container)
+                argv.commands.push('bash');
+            }
+        }
+
+        const containerList = await containerApi.ls({
+            formatToJSON: true,
+            all: true,
+            filter: `name=${container.name}`
+        });
+
+        if (containerList.length > 0) {
+            logger.logN(`Executing container ${logger.style.misc(container._)} (command: ${logger.style.command(argv.commands.join(' '))})`);
+            const result = await executeInContainer({
+                containerName: container.name,
+                commands: argv.commands,
+                isDockerDesktop: ctx.isDockerDesktop
+            });
+
+            return result;
+        }
+
+        if (container.name.endsWith('php')) {
+            logger.logN(`Starting container ${logger.style.misc(container._)} with command: ${logger.style.command(argv.commands.join(' '))}`);
+            const result = await runInContainer(
+                {
+                    ...container,
+                    name: `${container.name}_exec-${Date.now()}`
+                },
+                argv.commands
+            );
+
+            return result;
+        }
+
+        throw new KnownError(`Container ${container.name} is not running!`);
+    }
+
+    logger.error(`No container found "${argv.containername}"`);
+};
+
+module.exports = {
+    executeTask
+};

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

@@ -14,7 +14,7 @@ const createNginxConfig = () => ({
                 overridenConfiguration,
                 baseConfig
             },
-            isWsl
+            isDockerDesktop
         } = ctx;
 
         const {
@@ -23,10 +23,8 @@ const createNginxConfig = () => ({
             }
         } = overridenConfiguration;
 
-        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;
+        const hostMachine = !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal';
+        const hostPort = !isDockerDesktop ? ports.app : 80;
 
         try {
             await setConfigFile({

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

@@ -1,7 +1,5 @@
-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>}
@@ -9,32 +7,13 @@ const { getEnabledExtensionsFromImage } = require('../docker/project-image-build
 const createPhpConfig = () => ({
     title: 'Setting PHP config',
     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';
+        const { config: { php } } = ctx;
 
         try {
             await setConfigFile({
                 configPathname: php.iniPath,
                 template: php.iniTemplatePath,
-                overwrite: true,
-                templateArgs: {
-                    debug,
-                    mageRoot: baseConfig.containerMagentoDir,
-                    isXDebug2,
-                    hostMachine
-                }
+                overwrite: true
             });
         } catch (e) {
             throw new UnknownError(`Unexpected error accrued during php.ini config creation\n\n${e}`);

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

@@ -0,0 +1,45 @@
+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 createPhpDebugConfig = () => ({
+    title: 'Setting PHP XDebug config',
+    skip: (ctx) => !ctx.debug,
+    task: async (ctx) => {
+        const {
+            config: {
+                php,
+                baseConfig
+            },
+            debug,
+            isDockerDesktop
+        } = ctx;
+        const containers = ctx.config.docker.getContainers(ctx.ports);
+        const phpExtensions = await getEnabledExtensionsFromImage(containers.php.debugImage);
+        const isXDebug2 = semver.satisfies(phpExtensions.xdebug, '2');
+
+        const hostMachine = !isDockerDesktop ? '127.0.0.1' : 'host.docker.internal';
+
+        try {
+            await setConfigFile({
+                configPathname: php.debugIniPath,
+                template: php.debugTemplatePath,
+                overwrite: true,
+                templateArgs: {
+                    debug,
+                    mageRoot: baseConfig.containerMagentoDir,
+                    isXDebug2,
+                    hostMachine
+                }
+            });
+        } catch (e) {
+            throw new UnknownError(`Unexpected error accrued during xdebug.ini config creation\n\n${e}`);
+        }
+    }
+});
+
+module.exports = createPhpDebugConfig;

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

@@ -7,10 +7,8 @@ const setConfigFile = require('../../util/set-config');
 const createPhpFpmConfig = () => ({
     title: 'Setting php-fpm config',
     task: async (ctx) => {
-        const { config: { php } } = ctx;
-        const isLinux = ctx.platform === 'linux';
-        const isNativeLinux = isLinux && !ctx.isWsl;
-        const port = isNativeLinux ? ctx.ports.fpm : 9000;
+        const { config: { php }, isDockerDesktop } = ctx;
+        const port = !isDockerDesktop ? ctx.ports.fpm : 9000;
 
         try {
             await setConfigFile({