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

package/lib/tasks/{mysql → database}/index.js

@@ -1,6 +1,6 @@
 module.exports = {
-    connectToMySQL: require('./connect-to-mysql'),
-    importDumpToMySQL: require('./import-dump-to-mysql'),
+    connectToDatabase: require('./connect-to-database'),
+    importDumpToDatabase: require('./import-dump-to-database'),
     fixDB: require('./fix-db'),
     dumpThemeConfig: require('./dump-theme-config'),
     restoreThemeConfig: require('./restore-theme-config')

package/lib/tasks/{mysql → database}/restore-theme-config.js

@@ -6,7 +6,7 @@ const { updateTableValues } = require('../../util/database');
 const restoreThemeConfig = () => ({
     title: 'Restoring themes and theme configuration',
     task: async (ctx, task) => {
-        const { themeDump, mysqlConnection } = ctx;
+        const { themeDump, databaseConnection } = ctx;
 
         const { themeIdConfig, themes } = themeDump;
 
@@ -22,7 +22,7 @@ const restoreThemeConfig = () => ({
                     path: themeIdConfig.path,
                     value: themeIdConfig.value
                 }
-            ], { mysqlConnection, task });
+            ], { databaseConnection, task });
         }
 
         if (themes.length === 0) {
@@ -31,10 +31,10 @@ const restoreThemeConfig = () => ({
 
         // restore themes
         const themeKeys = Object.keys(themes[0]);
-        await mysqlConnection.query('delete from theme;');
+        await databaseConnection.query('delete from theme;');
 
         for (const theme of themes) {
-            await mysqlConnection.query(`
+            await databaseConnection.query(`
                 insert into theme (${themeKeys.join(', ')})
                 values (${themeKeys.map(() => '?').join(', ')})
             `, Object.values(theme));

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

@@ -0,0 +1,71 @@
+import { ExecAsyncSpawnOptions } from '../../util/exec-async-command';
+
+export interface DockerVersionOptions<T extends boolean = false> {
+    format?: string
+    format?: string
+    formatToJSON?: T
+}
+
+export interface DockerClientDetails {
+    Platform: {
+        Name: string
+    }
+    CloudIntegration: string
+    Version: string
+    ApiVersion: string
+    DefaultAPIVersion: string
+    GitCommit: string
+    GoVersion: string
+    Os: string
+    Arch: string
+    BuildTime: string
+    Context: string
+    Experimental: boolean
+}
+
+export interface DockerServerComponent {
+    Name: string
+    Version: string
+    Details: {
+        ApiVersion?: string
+        Arch?: string
+        BuildTime?: string
+        Experimental?: string
+        GitCommit: string
+        GoVersion?: string
+        KernelVersion?: string
+        MinApiVersion?: string
+        Os?: string
+    }
+}
+
+export interface DockerServerDetails {
+    Platform: {
+        Name: string
+    }
+    Components: DockerServerComponent[]
+    Version: string
+    ApiVersion: string
+    MinAPIVersion: string
+    GitCommit: string
+    GoVersion: string
+    Os: string
+    Arch: string
+    KernelVersion: string
+    BuildTime: string
+}
+
+export interface DockerVersionResult {
+    Client: DockerClientDetails
+    Server: DockerServerDetails
+}
+
+export function version(
+    options: DockerVersionOptions,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<string>
+
+export function version(
+    options: DockerVersionOptions<true>,
+    execOptions?: ExecAsyncSpawnOptions<false>
+): Promise<DockerVersionResult>

package/lib/tasks/docker/api.js

@@ -0,0 +1,30 @@
+const { execAsyncSpawn } = require('../../util/exec-async-command');
+
+/**
+ * @param {import('./api').DockerVersionOptions} options
+ * @param {import('../../util/exec-async-command').ExecAsyncSpawnOptions} execOptions
+ */
+const version = async (options, execOptions = {}) => {
+    const {
+        format,
+        formatToJSON
+    } = options;
+
+    const formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const args = [
+        formatArg
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker version ${args}`, execOptions);
+        return JSON.parse(result);
+    }
+
+    return execAsyncSpawn(`docker version ${args}`, execOptions);
+};
+
+module.exports = {
+    version
+};

package/lib/tasks/docker/containers/container-api.d.ts

@@ -0,0 +1,132 @@
+/* eslint-disable max-len */
+import { ExecAsyncSpawnOptions } from '../../../util/exec-async-command';
+
+export interface ContainerLsOptions<T extends boolean = false> {
+    all?: boolean
+    filter?: string | string[]
+    format?: string
+    quiet?: boolean
+    noTrunc?: boolean
+    formatToJSON?: T
+    latest?: boolean
+}
+
+export interface ContainerLsResult {
+    Command: string
+    CreatedAt: string
+    ID: string
+    Image: string
+    Labels: string
+    LocalVolumes: string
+    Mounts: string
+    Names: string
+    Networks: string
+    Ports: string
+    RunningFor: string
+    Size: string
+    State: string
+    Status: string
+}
+
+export function ls(options?: ContainerLsOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<string>
+export function ls(options?: ContainerLsOptions<true>, execOptions?: ExecAsyncSpawnOptions<false>): Promise<ContainerLsResult[]>
+
+export interface ContainerExecOptions {
+    /**
+     * Set environment variables [docs](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file)
+     */
+    env?: Record<string, string>
+
+    /**
+     * Working directory inside the container
+     */
+    workdir?: string
+
+    /**
+     * Username or UID (format: <name|uid>[:<group|gid>])
+     */
+    user?: string
+
+    /**
+     * Allocate a pseudo-TTY
+     */
+    tty?: boolean
+}
+
+export function exec(command: string, container: string, options?: ContainerExecOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<string>
+
+export interface ContainerRunOptions {
+    /**
+     * Add a custom host-to-IP mapping (host:ip)
+     */
+    addHost?: string
+    /**
+     * Automatically remove the container when it exits
+     */
+    rm?: boolean
+
+    /**
+     * 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)
+     */
+    ports?: number[]
+
+    /**
+     * Add bind mounts or volumes using the --mount flag [docs](https://docs.docker.com/engine/reference/commandline/run/#add-bind-mounts-or-volumes-using-the---mount-flag)
+     */
+    mounts?: string[]
+
+    /**
+     * Mount volume [docs](https://docs.docker.com/engine/reference/commandline/run/#mount-volume--v---read-only)
+     */
+    mountVolumes?: string[]
+
+    /**
+     * Set environment variables [docs](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file)
+     */
+    env?: Record<string, string>
+    image?: string
+    /**
+     * Restart policies [docs](https://docs.docker.com/engine/reference/commandline/run/#restart-policies---restart)
+     */
+    restart?: string
+
+    /**
+     * Container name
+     */
+    name?: string
+
+    /**
+     * Container entrypoint
+     */
+    entrypoint?: string
+
+    /**
+     * Container command
+     */
+    command?: string
+
+    /**
+     * Container heathcheck properties
+     */
+    healthCheck?: Record<'cmd' | 'interval' | 'retries' | 'start-period' | 'timeout', string>
+
+    /**
+     * Security options [docs](https://docs.docker.com/engine/reference/commandline/run/#optional-security-options---security-opt)
+     */
+    securityOptions?: string[]
+    tmpfs?: string[]
+    /**
+     * Username or UID (format: <name|uid>[:<group|gid>])
+     */
+    user?: string
+}
+
+export function run(containerOptions: ContainerRunOptions, execOptions?: ExecAsyncSpawnOptions<false>): Promise<false>
+
+export function runCommand(options: ContainerRunOptions): string[]

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

@@ -0,0 +1,163 @@
+/* eslint-disable max-len */
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+/**
+ * @param {import('./container-api').ContainerRunOptions} options
+ * @returns {string[]}
+ */
+const runCommand = (options) => {
+    const {
+        addHost,
+        ports = [],
+        mounts = [],
+        mountVolumes = [],
+        env,
+        image,
+        restart,
+        network,
+        name,
+        entrypoint,
+        command = '',
+        healthCheck,
+        securityOptions = [],
+        tmpfs = [],
+        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 && 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,
+        networkArg,
+        restartArg,
+        portsArgs,
+        exposeArg,
+        mountsArgs,
+        mountVolumesArgs,
+        envArgs,
+        entrypointArg,
+        healthCheckArg,
+        securityArg,
+        tmpfsArg,
+        userArg,
+        addHostArg,
+        image,
+        command
+    ].filter(Boolean).filter((arg) => typeof arg === 'string');
+
+    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
+ * @param {import('./container-api').ContainerExecOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const exec = (command, container, options = {}, execOptions = {}) => {
+    const {
+        env,
+        tty,
+        user,
+        workdir
+    } = options;
+    const envArgs = !env ? '' : Object.entries(env).map(([key, value]) => `--env ${ key }='${ value }'`).join(' ');
+    const ttyArg = tty ? '--tty' : '';
+    const userArg = user ? `--user=${user}` : '';
+    const workdirArg = workdir ? `--workdir=${workdir}` : '';
+
+    const execCommand = [
+        'docker',
+        'container',
+        'exec',
+        envArgs,
+        ttyArg,
+        userArg,
+        workdirArg,
+        container,
+        command
+    ].filter(Boolean).join(' ');
+
+    return execAsyncSpawn(execCommand, execOptions);
+};
+
+/**
+ * @param {import('./container-api').ContainerLsOptions} options
+ * @param {import('../../../util/exec-async-command').ExecAsyncSpawnOptions<false>} execOptions
+ */
+const ls = async (options = {}, execOptions = {}) => {
+    const {
+        all,
+        filter,
+        format,
+        formatToJSON = false,
+        latest,
+        noTrunc,
+        quiet
+    } = options;
+
+    const allArg = all && '--all';
+    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 formatArg = !formatToJSON && format
+        ? `--format=${format}`
+        : formatToJSON && '--format=\'{{json .}}\'';
+    const latestArg = latest && '--latest';
+    const noTruncArg = noTrunc && '--no-trunc';
+    const quietArg = quiet && '--quiet';
+
+    const args = [
+        allArg,
+        filterArg,
+        formatArg,
+        latestArg,
+        noTruncArg,
+        quietArg
+    ].filter(Boolean).join(' ');
+
+    if (formatToJSON) {
+        const result = await execAsyncSpawn(`docker container ls ${args}`, execOptions);
+        return JSON.parse(`[${result.split('\n').join(', ')}]`);
+    }
+
+    return execAsyncSpawn(`docker container ls ${args}`, execOptions);
+};
+
+module.exports = {
+    run,
+    runCommand,
+    exec,
+    ls
+};

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

@@ -0,0 +1,19 @@
+const {
+    startContainers,
+    stopContainers,
+    pullImages,
+    statusContainers,
+    checkContainersAreRunning,
+    getContainerStatus
+} = require('./tasks');
+const containerApi = require('./container-api');
+
+module.exports = {
+    startContainers,
+    stopContainers,
+    pullImages,
+    statusContainers,
+    checkContainersAreRunning,
+    getContainerStatus,
+    containerApi
+};

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

@@ -0,0 +1,215 @@
+/* eslint-disable max-len */
+const sleep = require('../../../util/sleep');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const KnownError = require('../../../errors/known-error');
+const containerApi = require('./container-api');
+const { imageApi } = require('../image');
+const { execAsyncSpawn } = require('../../../util/exec-async-command');
+
+const stop = async (containers) => {
+    await execAsyncSpawn(`docker container stop ${containers.join(' ')}`);
+    await execAsyncSpawn(`docker container rm ${containers.join(' ')}`);
+};
+
+const pull = async (image) => execAsyncSpawn(`docker pull ${image}`);
+
+const remoteImageReducer = (acc, val) => {
+    if (Array.isArray(val.remoteImages) && val.remoteImages.every((image) => typeof image === 'string')) {
+        return acc.concat(val.remoteImages);
+    }
+
+    return acc.concat([val.image]);
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ */
+const pullImages = () => ({
+    title: 'Pulling container images',
+    task: async ({ config: { docker } }, task) => {
+        const containers = Object.values(docker.getContainers());
+        const imagesFilter = containers
+            .reduce(remoteImageReducer, [])
+            .map((image) => `reference='${image}'`);
+
+        const existingImages = await imageApi.ls({
+            formatToJSON: true,
+            filter: imagesFilter
+        });
+
+        const missingContainerImages = containers
+            .reduce(remoteImageReducer, [])
+            .map((image) => {
+                const [repo, tag = 'latest'] = image.split(':');
+
+                return { repo, tag };
+            })
+            .filter(
+                ({ repo, tag }) => !existingImages.some(
+                    (image) => image.Repository === repo
+                    && image.Tag === tag
+                )
+            )
+            .reduce(
+                (acc, val) => acc.concat(
+                    acc.some(
+                        (c) => c.repo === val.repo
+                        && c.tag === val.tag
+                    )
+                        ? []
+                        : val
+                ),
+                []
+            );
+
+        if (missingContainerImages.length === 0) {
+            task.skip();
+            return;
+        }
+
+        return task.newListr(
+            missingContainerImages.map(({ repo, tag }) => ({
+                title: `Pulling ${ logger.style.file(`${repo}:${tag}`) } image`,
+                task: () => pull(`${repo}:${tag}`)
+            })), {
+                concurrent: true,
+                exitOnError: true
+            }
+        );
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const startContainers = () => ({
+    title: 'Starting containers',
+    task: async ({ ports, config: { docker }, debug }, task) => {
+        const containerList = (await execAsyncSpawn('docker container ls --all --format="{{.Names}}"')).split('\n');
+
+        const missingContainers = Object.values(docker.getContainers(ports)).filter(
+            ({ name }) => !containerList.includes(name)
+        );
+
+        if (missingContainers.length === 0) {
+            task.skip();
+            return;
+        }
+
+        if (debug) {
+            await Promise.all(
+                missingContainers
+                    .map((container) => {
+                        if (container.debugImage) {
+                            container.image = container.debugImage;
+                        }
+
+                        return container;
+                    }).map((container) => containerApi.run(container).then((out) => {
+                        task.output = `From ${container._}: ${out}`;
+                    }))
+            );
+
+            return;
+        }
+
+        // TODO: we might stop containers here ?
+        await Promise.all(missingContainers.map((container) => containerApi.run(container).then((out) => {
+            task.output = `From ${container._}: ${out}`;
+        })));
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const stopContainers = () => ({
+    title: 'Stopping Docker containers',
+    task: async ({ config: { baseConfig: { prefix } } }, task) => {
+        const containerList = (await execAsyncSpawn('docker container ls --all --format="{{.Names}}"')).split('\n');
+
+        const runningContainers = containerList.filter((containerName) => containerName.startsWith(prefix));
+
+        if (runningContainers.length === 0) {
+            task.skip();
+            return;
+        }
+
+        await stop(runningContainers);
+    }
+});
+
+const getContainerStatus = async (containerName) => {
+    try {
+        return JSON.parse(await execAsyncSpawn(`docker inspect --format='{{json .State}}' ${containerName}`));
+    } catch {
+        return null;
+    }
+};
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const checkContainersAreRunning = () => ({
+    title: 'Checking container statuses',
+    task: async (ctx, task) => {
+        const { config: { docker }, ports } = ctx;
+        const containers = Object.values(docker.getContainers(ports));
+        let tries = 0;
+        while (tries < 3) {
+            const containersWithStatus = await Promise.all(
+                containers.map(async (container) => ({
+                    ...container,
+                    status: await getContainerStatus(container.name)
+                }))
+            );
+
+            if (containersWithStatus.some((c) => c.status.Status !== 'running')) {
+                if (tries === 2) {
+                    throw new KnownError(`${containersWithStatus.filter((c) => c.status.Status !== 'running').map((c) => c._).join(', ')} containers are not running! Please check container logs for more details!`);
+                } else {
+                    task.output = `${containersWithStatus.filter((c) => c.status.Status !== 'running').map((c) => c._).join(', ')} are not running, waiting if something will change...`;
+                    await sleep(2000);
+                    tries++;
+                }
+            } else {
+                break;
+            }
+        }
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+/**
+ * @type {() => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
+ */
+const statusContainers = () => ({
+    task: async (ctx) => {
+        const { config: { docker }, ports } = ctx;
+        const containers = Object.values(docker.getContainers(ports));
+
+        ctx.containers = await Promise.all(
+            containers.map(async (container) => ({
+                ...container,
+                status: await getContainerStatus(container.name)
+            }))
+        );
+    },
+    options: {
+        bottomBar: 10
+    }
+});
+
+module.exports = {
+    startContainers,
+    stopContainers,
+    pullImages,
+    statusContainers,
+    checkContainersAreRunning,
+    getContainerStatus
+};