@scandipwa/magento-scripts 2.0.0-alpha.9 → 2.0.0

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

@@ -32,3 +32,47 @@ export function ls(
     options?: ImagesLsOptions<true>,
     execOptions?: ExecAsyncSpawnOptions<false>
 ): Promise<ImagesLsResult[]>
+
+export interface ImagesInspectOptions<T extends boolean = false> {
+    image: string
+    format?: string
+    formatToJSON?: T
+}
+
+export interface ImagesInspectResult {
+    Id: string
+    RepoTags: string[]
+    RepoDigests: string[]
+    Parent: string
+    Comment: string
+    Created: string
+    Container: string
+    ContainerConfig: unknown
+    DockerVersion: string
+    Author: string
+    Config: {
+        Env: string[],
+        Cmd: string[]
+        WorkingDir: string
+        Entrypoint: string[]
+        StopSignal: string
+    }
+    Architecture: string
+    Os: string
+    Size: number
+    VirtualSize: number
+    GraphDriver: unknown
+    RootFs: unknown
+    Metadata: Record<string, unknown>
+    CreatedTime: number
+    Container: Record<string, unknown>
+}
+
+export function inspect(
+    options?: ImagesInspectOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function inspect(
+    options?: ImagesInspectOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<ImagesInspectResult>

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

@@ -1,7 +1,6 @@
 const { execAsyncSpawn } = require('../../../util/exec-async-command');
 
 /**
- *
  * @param {import('./image-api').ImagesLsOptions} options
  * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
  */
@@ -44,6 +43,35 @@ const ls = async (options, execOptions = {}) => {
     return execAsyncSpawn(`docker image ls ${args}`, execOptions);
 };
 
+/**
+ * @param {import('./image-api').ImagesInspectOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const inspect = async (options, execOptions = {}) => {
+    const {
+        image,
+        format,
+        formatToJSON = false
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+
+    const args = [
+        formatArg,
+        image
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker image inspect ${args}`, execOptions);
+        return JSON.parse(result);
+    }
+
+    return execAsyncSpawn(`docker image inspect ${args}`, execOptions);
+};
+
 module.exports = {
-    ls
+    ls,
+    inspect
 };

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

@@ -1,8 +1,10 @@
+const path = require('path');
+const os = require('os');
 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');
+const { imageApi } = require('./image');
 
 /**
  * Get enabled extensions list with versions
@@ -27,15 +29,15 @@ 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}`;
+        runCommand += ` docker-php-ext-install ${extensionInstructionsWithoutCommand.name || extensionName}`;
     }
     builder
         .comment(`extension ${extensionName} installation command`)
@@ -49,6 +51,7 @@ const addExtensionToBuilder = (builder, ctx) => ([extensionName, extensionInstru
 const buildDockerFileInstructions = async (ctx, { image, tag }) => {
     const { composer } = ctx.config.overridenConfiguration.configuration;
     const existingPHPExtensions = await getEnabledExtensionsFromImage(`${image}:${tag}`);
+    const imageDetails = await imageApi.inspect({ image: `${image}:${tag}`, formatToJSON: true });
 
     const missingExtensions = Object.entries(
         ctx.config.overridenConfiguration.configuration.php.extensions
@@ -68,10 +71,6 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         .comment('project image')
         .from({ image, tag });
 
-    // install bash and patch in image
-    dockerFileInstructions
-        .run('apk add --no-cache bash patch');
-
     if (missingExtensions.length > 0) {
         const allDependencies = missingExtensions.map(
             ([_extensionName, extensionInstructions]) => (extensionInstructions.dependencies || [])
@@ -79,7 +78,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)
@@ -92,17 +93,39 @@ const buildDockerFileInstructions = async (ctx, { image, tag }) => {
         .comment('make composer executable')
         .run('chmod +x ./composer')
         .comment('move composer to bin directory')
-        .run('mv composer /usr/local/bin/composer');
+        .run('mv composer /usr/local/bin/composer')
+        .run('mkdir -p /composer/home/cache')
+        .env({
+            COMPOSER_HOME: '/composer/home',
+            COMPOSER_CACHE_DIR: '/composer/home/cache'
+        });
+
+    if (composer.plugins && Object.values(composer.plugins).length > 0) {
+        for (const [pluginName, pluginOptions] of Object.entries(composer.plugins)) {
+            if (pluginOptions.enabled) {
+                dockerFileInstructions
+                    .comment(`install ${pluginName} composer global package`)
+                    // eslint-disable-next-line max-len
+                    .run(`composer global require ${pluginName}${ pluginOptions.options ? ` ${pluginOptions.options}` : '' }${ pluginOptions.options ? ` ${pluginOptions.options}` : ''}`);
+            }
+        }
+    }
 
-    if (semver.satisfies(composer.version, '^1')) {
+    if (!ctx.isDockerDesktop) {
         dockerFileInstructions
-            .comment('install prestissimo composer plugin')
-            .run('composer global require hirak/prestissimo');
+            .run(`chown -R ${os.userInfo().uid}:${os.userInfo().gid} /composer/home`);
     }
 
     dockerFileInstructions
         .workDir(ctx.config.baseConfig.containerMagentoDir);
 
+    const imagePathEnv = imageDetails.Config.Env.find((env) => env.startsWith('PATH'));
+
+    dockerFileInstructions
+        .env({
+            PATH: `${ imagePathEnv.split('=').pop() }:${ path.join(ctx.config.baseConfig.containerMagentoDir, 'bin') }`
+        });
+
     return dockerFileInstructions;
 };
 

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

@@ -0,0 +1,5 @@
+const systemApi = require('./system-api');
+
+module.exports = {
+    systemApi
+};

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

@@ -0,0 +1,71 @@
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+
+export interface SystemDFOptions<T extends boolean = false> {
+    format?: string
+    formatToJSON?: T
+    verbose?: boolean
+}
+
+export interface SystemDFResult {
+    Images: {
+        Containers: string
+        CreatedAt: string
+        CreatedSince: string
+        Digest: string
+        ID: string
+        Repository: string
+        SharedSize: string
+        Size: string
+        Tag: string
+        UniqueSize: string
+        VirtualSize: string
+    }[]
+    Containers: {
+        Command: string
+        CreatedAt: string
+        ID: string
+        Image: string
+        Labels: string
+        LocalVolumes: string
+        Mounts: string
+        Names: string
+        Networks: string
+        Ports: StreamPipeOptions
+        RunningFor: string
+        Size: string
+        State: string
+        Status: string
+    }[]
+    Volumes: {
+        Driver: string
+        Labels: string
+        Links: string
+        Mountpoint: string
+        Name: string
+        Scope: string
+        Size: string
+    }[]
+    BuildCache: {
+        CacheType: string
+        CreatedAt: string
+        CreatedSince: string
+        Description: string
+        ID: string
+        InUse: string
+        LastUsedAt: string
+        LastUsedSince: string
+        Parent: string
+        Shared: string
+        Size: string
+        UsageCount: string
+    }[]
+}
+
+export function df(
+    options?: SystemDFOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function df(
+    options?: SystemDFOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<SystemDFResult>

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

@@ -0,0 +1,29 @@
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {import('./system-api').SystemDFOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const df = async (options, execOptions = {}) => {
+    const {
+        format,
+        formatToJSON,
+        verbose
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const verboseArg = verbose && '--verbose';
+
+    const args = [
+        formatArg,
+        verboseArg
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(`docker system df ${args}`, execOptions);
+};
+
+module.exports = {
+    df
+};

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,7 @@
-const { execAsyncSpawn } = require('../../../util/exec-async-command');
-const { create } = require('./volume-api');
+const fs = require('fs');
+const pathExists = require('../../../util/path-exists');
+const { containerApi } = require('../containers');
+const volumeApi = require('./volume-api');
 
 /**
  * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
@@ -7,10 +9,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 +22,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 +40,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 +53,55 @@ 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) {
+            const existingLocalVolumesDetails = await Promise.all(
+                existingLocalVolumes.map((v) => volumeApi.inspect({ volume: v.name, formatToJSON: true }))
+            );
+
+            await Promise.all(existingLocalVolumesDetails.map(async (v) => {
+                if (v.Containers && Object.entries(v.Containers).length > 0) {
+                    await Promise.all(Object.values(v.Containers).map(async (c) => {
+                        await containerApi.stop([c.Name]);
+                        await containerApi.rm([c.Name]);
+                    }));
+                }
+            }));
+            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,43 @@ 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>
+
+export interface VolumeInspectOptions<T extends boolean = false> {
+    volume: string
+    format?: string
+    formatToJSON?: T
+}
+
+export interface VolumeInspectResult {
+    CreatedAt: string
+    Driver: string
+    Labels: unknown
+    Mountpoint: string
+    Name: string
+    Options: unknown
+    Scope: string
+    CreatedTime: number
+    Containers: Record<string, {
+        Name: string
+        Destination: string
+    }>
+}
+
+export function inspect(
+    options?: VolumeInspectOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+export function inspect(
+    options?: VolumeInspectOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<VolumeInspectResult>

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

@@ -60,7 +60,60 @@ 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);
+};
+
+/**
+ * @param {import('./volume-api').VolumeInspectOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const inspect = async (options, execOptions = {}) => {
+    const {
+        volume,
+        format,
+        formatToJSON = false
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+
+    const args = [
+        formatArg,
+        volume
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker volume inspect ${args}`, execOptions);
+        return JSON.parse(result);
+    }
+
+    return execAsyncSpawn(`docker volume inspect ${args}`, execOptions);
+};
+
 module.exports = {
     create,
-    ls
+    ls,
+    rm,
+    inspect
 };

package/lib/tasks/execute.js

@@ -7,6 +7,7 @@ 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');
 
 /**
@@ -20,7 +21,8 @@ const executeTask = async (argv) => {
         getMagentoVersionConfig(),
         checkConfigurationFile(),
         getProjectConfiguration(),
-        getCachedPorts()
+        getCachedPorts(),
+        dockerNetwork.tasks.createNetwork()
     ], {
         concurrent: false,
         exitOnError: true,
@@ -67,7 +69,8 @@ const executeTask = async (argv) => {
             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
+                commands: argv.commands,
+                user: container.user
             });
 
             return result;

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}`);