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

package/lib/tasks/stop.js

@@ -1,6 +1,5 @@
 const { stopServices } = require('./docker');
 const getMagentoVersionConfig = require('../config/get-magento-version-config');
-const { stopPhpFpm } = require('./php-fpm');
 const getProjectConfiguration = require('../config/get-project-configuration');
 const checkConfigurationFile = require('../config/check-configuration-file');
 
@@ -13,7 +12,6 @@ const stop = () => ({
         getMagentoVersionConfig(),
         checkConfigurationFile(),
         getProjectConfiguration(),
-        stopPhpFpm(),
         stopServices()
     ], {
         concurrent: false,

package/lib/tasks/theme/install-theme.js

@@ -18,7 +18,7 @@ const installTheme = (theme) => ({
         }
 
         try {
-            await runComposerCommand(`require ${theme.composerData.name}`, {
+            await runComposerCommand(ctx, `require ${theme.composerData.name}`, {
                 magentoVersion,
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;

package/lib/tasks/theme/symlink-theme.js

@@ -9,7 +9,7 @@ const runComposerCommand = require('../../util/run-composer');
 const symlinkTheme = (theme) => ({
     title: 'Setting symbolic link for theme in composer.json',
     task: async (ctx, task) => {
-        const { magentoVersion, verbose = false } = ctx;
+        const { verbose = false } = ctx;
         const composerJsonData = await getJsonfileData(path.join(process.cwd(), 'composer.json'));
 
         if (!composerJsonData.repositories) {
@@ -27,8 +27,7 @@ const symlinkTheme = (theme) => ({
         }
 
         try {
-            await runComposerCommand(`config repo.scandipwa path ${theme.absoluteThemePath}`, {
-                magentoVersion,
+            await runComposerCommand(ctx, `config repo.scandipwa path ${theme.absoluteThemePath}`, {
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;
                 }

package/lib/util/config-php-json.js

@@ -1,10 +1,19 @@
 const path = require('path');
 const UnknownError = require('../errors/unknown-error');
-const runPhpCode = require('./run-php');
+const { runPHPContainerCommand } = require('../tasks/php/php-container');
+const pathExists = require('./path-exists');
 
-const configPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) => {
-    const { code, result } = await runPhpCode(`-r "echo json_encode(require '${path.join(projectPath, 'app', 'etc', 'config.php')}');"`, {
-        magentoVersion
+/**
+ * @param {import('../../typings/context').ListrContext} ctx
+ */
+const configPhpToJson = async (ctx) => {
+    const configPhpOnSystemPath = path.join(ctx.config.baseConfig.magentoDir, 'app', 'etc', 'config.php');
+    const configPhpInContainerPath = path.join(ctx.config.baseConfig.containerMagentoDir, 'app', 'etc', 'config.php');
+    if (!await pathExists(configPhpOnSystemPath)) {
+        return null;
+    }
+    const { code, result } = await runPHPContainerCommand(ctx, `php -r "echo json_encode(require '${configPhpInContainerPath}');"`, {
+        withCode: true
     });
 
     if (code !== 0) {

package/lib/util/dockerfile-builder/build-instructions.js

@@ -0,0 +1,197 @@
+/**
+ *
+ * @param {import('./types').DockerfileInstruction[]} instructions
+ */
+const buildInstructions = (instructions) => {
+    /**
+     * @type {string[]}
+     */
+    const dockerFileInstructions = [];
+
+    for (const instruction of instructions) {
+        switch (instruction.type) {
+        case 'COPY':
+        case 'ADD': {
+            let addInstruction = instruction.type;
+
+            if (instruction.type === 'COPY' && instruction.from) {
+                addInstruction += ` --from=${instruction.from}`;
+            }
+
+            if (instruction.chown) {
+                addInstruction += ` --chown=${instruction.chown}`;
+            }
+
+            addInstruction += ` ${instruction.src.join(' ')}`;
+            addInstruction += ` ${instruction.dest}`;
+
+            dockerFileInstructions.push(addInstruction);
+            break;
+        }
+        case 'ARG': {
+            let argInstruction = instruction.type;
+
+            argInstruction += ` ${instruction.name}`;
+
+            if (instruction.defaultValue) {
+                argInstruction += `=${instruction.defaultValue}`;
+            }
+
+            dockerFileInstructions.push(argInstruction);
+            break;
+        }
+        case 'RUN':
+        case 'ENTRYPOINT':
+        case 'CMD': {
+            let cmdInstruction = instruction.type;
+
+            if (typeof instruction.command === 'string') {
+                cmdInstruction += ` ${instruction.command}`;
+            } else if (Array.isArray(instruction.command) && instruction.command.every((c) => typeof c === 'string')) {
+                cmdInstruction += ` ["${instruction.command.join('", "')}"]`;
+            } else {
+                throw new Error(`Unknown command type, it must be string or array of strings! ${instruction.command}`);
+            }
+
+            dockerFileInstructions.push(cmdInstruction);
+            break;
+        }
+
+        case 'COMMENT': {
+            const commentInstruction = `# ${instruction.comment}`;
+
+            dockerFileInstructions.push(commentInstruction);
+            break;
+        }
+        case 'ENV': {
+            let envInstruction = instruction.type;
+
+            envInstruction += ` ${instruction.name}="${instruction.value}"`;
+
+            dockerFileInstructions.push(envInstruction);
+            break;
+        }
+        case 'EXPOSE': {
+            let exposeInstruction = instruction.type;
+
+            if (instruction.protocol) {
+                exposeInstruction += ` ${instruction.port}/${instruction.protocol}`;
+            } else {
+                exposeInstruction += ` ${instruction.port}`;
+            }
+
+            dockerFileInstructions.push(exposeInstruction);
+            break;
+        }
+        case 'FROM': {
+            let fromInstruction = instruction.type;
+
+            if (instruction.platform) {
+                fromInstruction += ` --platform=${instruction.platform}`;
+            }
+
+            fromInstruction += ` ${instruction.image}:${instruction.tag || 'latest'}`;
+
+            if (instruction.name) {
+                fromInstruction += ` AS ${instruction.name}`;
+            }
+
+            dockerFileInstructions.push(fromInstruction);
+            break;
+        }
+        case 'HEALTHCHECK': {
+            let healthCheckInstruction = instruction.type;
+
+            if (instruction.interval) {
+                healthCheckInstruction += ` --interval=${instruction.interval}`;
+            }
+
+            if (instruction.retries) {
+                healthCheckInstruction += ` --retries=${instruction.retries}`;
+            }
+
+            if (instruction.startPeriod) {
+                healthCheckInstruction += ` --start-period=${instruction.startPeriod}`;
+            }
+
+            if (instruction.timeout) {
+                healthCheckInstruction += ` --timeout=${instruction.timeout}`;
+            }
+
+            healthCheckInstruction += ` ${instruction.command}`;
+
+            dockerFileInstructions.push(healthCheckInstruction);
+            break;
+        }
+        case 'LABEL': {
+            Object.entries(instruction.labels).forEach(([name, value]) => {
+                let labelInstruction = instruction.type;
+                labelInstruction += ` "${name}"="${value}"`;
+                dockerFileInstructions.push(labelInstruction);
+            });
+            break;
+        }
+        case 'ONBUILD': {
+            let onBuildInstruction = instruction.type;
+
+            onBuildInstruction += ` ${instruction.instruction}`;
+
+            dockerFileInstructions.push(onBuildInstruction);
+            break;
+        }
+        case 'SHELL': {
+            let shellInstruction = instruction.type;
+
+            shellInstruction += ` ["${instruction.exec.join('", "')}"]`;
+
+            dockerFileInstructions.push(shellInstruction);
+            break;
+        }
+        case 'STOPSIGNAL': {
+            let stopSignalInstruction = instruction.type;
+
+            stopSignalInstruction += ` ${instruction.signal}`;
+
+            dockerFileInstructions.push(stopSignalInstruction);
+            break;
+        }
+        case 'USER': {
+            let userInstruction = instruction.type;
+
+            userInstruction += ` ${instruction.user}`;
+
+            dockerFileInstructions.push(userInstruction);
+            break;
+        }
+        case 'VOLUME': {
+            let volumeInstruction = instruction.type;
+
+            if (typeof instruction.volume === 'string') {
+                volumeInstruction += ` ${instruction.volume}`;
+            } else if (Array.isArray(instruction.volume) && instruction.volume.every((c) => typeof c === 'string')) {
+                volumeInstruction += ` ["${instruction.volume.join('", "')}"]`;
+            } else {
+                throw new Error(`Unknown volume type, it must be string or array of strings! ${instruction.volume}`);
+            }
+
+            dockerFileInstructions.push(volumeInstruction);
+            break;
+        }
+        case 'WORKDIR': {
+            const workDirInstruction = `${instruction.type} ${instruction.workdir}`;
+
+            dockerFileInstructions.push(workDirInstruction);
+            break;
+        }
+        default: {
+            throw new Error(`I don't know instruction with type ${instruction.type}`);
+        }
+        }
+    }
+
+    return dockerFileInstructions.join('\n');
+};
+
+module.exports = {
+    buildInstructions
+};

package/lib/util/dockerfile-builder/index.js

@@ -0,0 +1,276 @@
+const { buildInstructions } = require('./build-instructions');
+
+class DockerFileBuilder {
+    /**
+     * @type {import('./types').DockerfileInstruction[]}
+     */
+    instructions = [];
+
+    /**
+     * @param {Omit<import('./types').FromInstruction, 'type'>} param0
+     * @returns {this}
+     */
+    from({
+        image,
+        tag = 'latest',
+        platform,
+        name
+    }) {
+        this.instructions.push({
+            type: 'FROM',
+            image,
+            tag,
+            platform,
+            name
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').RunInstruction['command']} command
+     */
+    run(command) {
+        this.instructions.push({
+            type: 'RUN',
+            command
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').CmdInstruction['command']} command
+     */
+    cmd(command) {
+        this.instructions.push({
+            type: 'CMD',
+            command
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').LabelInstruction['labels']} labels
+     */
+    label(labels) {
+        this.instructions.push({
+            type: 'LABEL',
+            labels
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {Omit<import('./types').ExposeInstruction, 'type'>} param0
+     */
+    expose({
+        port,
+        protocol
+    }) {
+        this.instructions.push({
+            type: 'EXPOSE',
+            port,
+            protocol
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {Record<string, string>} env
+     */
+    env(env) {
+        Object.entries(env).forEach(([name, value]) => {
+            this.instructions.push({
+                type: 'ENV',
+                name,
+                value
+            });
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {Omit<import('./types').AddInstruction, 'type'>} param0
+     */
+    add({
+        src,
+        dest,
+        chown
+    }) {
+        this.instructions.push({
+            type: 'ADD',
+            src,
+            dest,
+            chown
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {Omit<import('./types').CopyInstruction, 'type'>} param0
+     */
+    copy({
+        src,
+        dest,
+        chown,
+        from
+    }) {
+        this.instructions.push({
+            type: 'COPY',
+            src,
+            dest,
+            chown,
+            from
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').EntrypointInstruction['command']} command
+     */
+    entrypoint(command) {
+        this.instructions.push({
+            type: 'ENTRYPOINT',
+            command
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').VolumeInstruction['volume']} volume
+     */
+    volume(volume) {
+        this.instructions.push({
+            type: 'VOLUME',
+            volume
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').UserInstruction['user']} user
+     */
+    user(user) {
+        this.instructions.push({
+            type: 'USER',
+            user
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').WorkDirInstruction['workdir']} workdir
+     */
+    workDir(workdir) {
+        this.instructions.push({
+            type: 'WORKDIR',
+            workdir
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {Omit<import('./types').ArgInstruction, 'type'>} param0
+     */
+    arg({
+        name,
+        defaultValue
+    }) {
+        this.instructions.push({
+            type: 'ARG',
+            name,
+            defaultValue
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').OnBuildInstruction['instruction']} instruction
+     */
+    onBuild(instruction) {
+        this.instructions.push({
+            type: 'ONBUILD',
+            instruction
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').StopSignalInstruction['signal']} signal
+     */
+    stopSignal(signal) {
+        this.instructions.push({
+            type: 'STOPSIGNAL',
+            signal
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {Omit<import('./types').HealthCheckInstruction, 'type'>} param0
+     */
+    healthCheck({
+        command,
+        interval,
+        timeout,
+        startPeriod,
+        retries
+    }) {
+        this.instructions.push({
+            type: 'HEALTHCHECK',
+            command,
+            interval,
+            retries,
+            startPeriod,
+            timeout
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').ShellInstruction['exec']} exec
+     */
+    shell(exec) {
+        this.instructions.push({
+            type: 'SHELL',
+            exec
+        });
+
+        return this;
+    }
+
+    /**
+     * @param {import('./types').CommentInstruction['comment']} comment
+     */
+    comment(comment) {
+        this.instructions.push({
+            type: 'COMMENT',
+            comment
+        });
+
+        return this;
+    }
+
+    build() {
+        return buildInstructions(this.instructions);
+    }
+}
+
+module.exports = {
+    DockerFileBuilder
+};

package/lib/util/dockerfile-builder/types.d.ts

@@ -0,0 +1,123 @@
+export interface FromInstruction {
+    type: 'FROM'
+    image: string
+    tag?: string
+    platform?: string
+    name?: string
+}
+
+export interface RunInstruction {
+    type: 'RUN'
+    command: string | string[]
+}
+
+export interface CmdInstruction {
+    type: 'CMD'
+    command: string | string[]
+}
+
+export interface LabelInstruction {
+    type: 'LABEL'
+    labels: Record<string, string>
+}
+
+export interface ExposeInstruction {
+    type: 'EXPOSE'
+    port: number
+    protocol?: 'udp' | 'tcp'
+}
+
+export interface EnvInstruction {
+    type: 'ENV'
+    name: string
+    value: string
+}
+
+export interface AddInstruction {
+    type: 'ADD'
+    src: string[]
+    dest: string
+    chown?: string
+}
+
+export interface CopyInstruction {
+    type: 'COPY'
+    src: string[]
+    dest: string
+    chown?: string
+    from?: string
+}
+
+export interface EntrypointInstruction {
+    type: 'ENTRYPOINT'
+    command: string | string[]
+}
+
+export interface VolumeInstruction {
+    type: 'VOLUME'
+    volume: string | string[]
+}
+
+export interface UserInstruction {
+    type: 'USER'
+    user: string
+}
+
+export interface WorkDirInstruction {
+    type: 'WORKDIR'
+    workdir: string
+}
+
+export interface ArgInstruction {
+    type: 'ARG'
+    name: string
+    defaultValue?: string
+}
+
+export interface OnBuildInstruction {
+    type: 'ONBUILD'
+    instruction: string
+}
+
+export interface StopSignalInstruction {
+    type: 'STOPSIGNAL'
+    signal: string
+}
+
+export interface HealthCheckInstruction {
+    type: 'HEALTHCHECK'
+    command: string
+    interval?: string
+    timeout?: string
+    startPeriod?: string
+    retries?: number
+}
+
+export interface ShellInstruction {
+    type: 'SHELL'
+    exec: string[]
+}
+
+export interface CommentInstruction {
+    type: 'COMMENT'
+    comment: string
+}
+
+export type DockerfileInstruction = FromInstruction
+    | RunInstruction
+    | CmdInstruction
+    | LabelInstruction
+    | ExposeInstruction
+    | EnvInstruction
+    | AddInstruction
+    | CopyInstruction
+    | EntrypointInstruction
+    | VolumeInstruction
+    | UserInstruction
+    | WorkDirInstruction
+    | ArgInstruction
+    | OnBuildInstruction
+    | StopSignalInstruction
+    | HealthCheckInstruction
+    | ShellInstruction
+    | CommentInstruction

package/lib/util/env-php-json.js

@@ -1,15 +1,19 @@
 const path = require('path');
 const UnknownError = require('../errors/unknown-error');
+const { runPHPContainerCommand } = require('../tasks/php/php-container');
 const pathExists = require('./path-exists');
-const runPhpCode = require('./run-php');
 
-const envPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) => {
-    const envPhpPath = path.join(projectPath, 'app', 'etc', 'env.php');
-    if (!await pathExists(envPhpPath)) {
+/**
+ * @param {import('../../typings/context').ListrContext} ctx
+ */
+const envPhpToJson = async (ctx) => {
+    const envPhpOnSystemPath = path.join(ctx.config.baseConfig.magentoDir, 'app', 'etc', 'env.php');
+    const envPhpInContainerPath = path.join(ctx.config.baseConfig.containerMagentoDir, 'app', 'etc', 'env.php');
+    if (!await pathExists(envPhpOnSystemPath)) {
         return null;
     }
-    const { code, result } = await runPhpCode(`-r "echo json_encode(require '${envPhpPath}');"`, {
-        magentoVersion
+    const { code, result } = await runPHPContainerCommand(ctx, `php -r "echo json_encode(require '${envPhpInContainerPath}');"`, {
+        withCode: true
     });
 
     if (code !== 0) {