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

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) {

package/lib/util/exec-async-command.js

@@ -2,7 +2,7 @@ const os = require('os');
 const logger = require('@scandipwa/scandipwa-dev-utils/logger');
 const { spawn } = require('child_process');
 const { getArchSync } = require('./arch');
-const compileOptions = require('../tasks/php/compile-options');
+const UnknownError = require('../errors/unknown-error');
 
 const execAsyncSpawn = (command, {
     callback = () => {},
@@ -31,13 +31,7 @@ const execAsyncSpawn = (command, {
             'arch',
             // eslint-disable-next-line max-len
             ['-x86_64', 'bash', '-c', command],
-            {
-                ...spawnOptions,
-                env: {
-                    ...process.env,
-                    PATH: compileOptions.darwin.env.PATH
-                }
-            }
+            spawnOptions
         );
     } else {
         childProcess = spawn(
@@ -79,7 +73,7 @@ const execAsyncSpawn = (command, {
                 return;
             }
             if (code > 0) {
-                reject(result);
+                reject(new UnknownError(result));
             } else {
                 resolve(result);
             }

package/lib/util/macos-version.js

@@ -0,0 +1,20 @@
+const semver = require('semver');
+const macosVersion = require('macos-version');
+const { execAsyncSpawn } = require('./exec-async-command');
+
+const getMacOSVersion = async () => {
+    const { code, result } = await execAsyncSpawn('sw_vers -productVersion',
+        {
+            withCode: true
+        });
+
+    if (code !== 0) {
+        return macosVersion();
+    }
+
+    return semver.coerce(result).version;
+};
+
+module.exports = {
+    getMacOSVersion
+};

package/lib/util/magento-task.js

@@ -8,13 +8,12 @@ const runMagentoCommand = require('./run-magento');
  */
 const magentoTask = (command, options = {}) => ({
     title: `Running command 'magento ${command}'`,
-    task: async ({ magentoVersion, verbose }, task) => {
+    task: async (ctx, task) => {
         try {
-            await runMagentoCommand(command, {
-                callback: !verbose ? undefined : (t) => {
+            await runMagentoCommand(ctx, command, {
+                callback: !ctx.verbose ? undefined : (t) => {
                     task.output = t;
                 },
-                magentoVersion,
                 throwNonZeroCode: true
             });
         } catch (e) {

package/lib/util/nginx-logs-parser.js

@@ -0,0 +1,122 @@
+/* eslint-disable no-bitwise */
+/* eslint-disable max-len */
+class NginxParser {
+    constructor(format) {
+        this.directives = {};
+
+        const prefix = format.match(/^[^$]*/);
+        if (prefix) {
+            format = this.escape(prefix[0]) + format.slice(prefix[0].length);
+        }
+
+        this.parser = format;
+
+        const directive = /\$([a-z_]+)(.)?([^$]+)?/g;
+        let match;
+        let regex;
+        let boundary;
+        let i = 1;
+
+        // eslint-disable-next-line no-cond-assign
+        while ((match = directive.exec(format))) {
+            this.directives[match[1]] = i++;
+            if (match[2]) {
+                boundary = this.escape(match[2]);
+                regex = `([^${ boundary }]*?)${ boundary}`;
+                if (match[3]) {
+                    regex += this.escape(match[3]);
+                }
+            } else {
+                regex = '(.+)$';
+            }
+            this.parser = this.parser.replace(match[0], regex);
+        }
+
+        this.parser = new RegExp(this.parser);
+    }
+
+    /**
+     * Parse a log line.
+     *
+     * @param {String} line
+     * @returns {Record<'msec' | 'time_iso8601' | 'remote_addr' | 'query_string' | 'http_x_forwarded_for' | 'http_user_agent' | 'http_referer' | 'time_local' | 'request' | 'status' | 'request_time' | 'request_length' | 'pipe' | 'connection' | 'bytes_sent' | 'body_bytes_sent' | 'date' | 'timestamp' | 'ip' | 'ip_str', string>}
+     */
+    parseLine(line) {
+        const match = line.match(this.parser);
+        if (!match) {
+            return;
+        }
+
+        const row = {
+            msec: null,
+            time_iso8601: null,
+            remote_addr: null,
+            query_string: null,
+            http_x_forwarded_for: null,
+            http_user_agent: null,
+            http_referer: null,
+            time_local: null,
+            request: null,
+            status: null,
+            request_time: null,
+            request_length: null,
+            pipe: null,
+            connection: null,
+            bytes_sent: null,
+            body_bytes_sent: null,
+
+            date: null,
+            timestamp: null,
+            ip: null,
+            ip_str: null
+        };
+
+        // eslint-disable-next-line guard-for-in
+        for (const key in this.directives) {
+            row[key] = match[this.directives[key]];
+            if (row[key] === '-') {
+                row[key] = null;
+            }
+        }
+
+        // Parse the timestamp
+        if (row.time_iso8601) {
+            row.date = new Date(row.time_iso8601);
+        } else if (row.msec) {
+            row.date = new Date(Number(row.msec.replace('.', '')));
+        }
+        if (row.date) {
+            row.timestamp = row.date.getTime();
+        }
+
+        // Parse the user's IP
+        if (row.http_x_forwarded_for) {
+            row.ip_str = row.http_x_forwarded_for;
+        } else if (row.remote_addr) {
+            row.ip_str = row.remote_addr;
+        }
+        if (row.ip_str) {
+            const ip = row.ip_str.split('.', 4);
+            row.ip = Number(ip[0]) * (2 << 23)
+                + Number(ip[1]) * (2 << 15)
+                + Number(ip[2]) * (2 << 7)
+                + Number(ip[3]);
+        }
+
+        return row;
+    }
+
+    /**
+     * Escape regular expression tokens.
+     *
+     * @param {String} str
+     * @return {String}
+     */
+    escape(str) {
+        return str.replace(new RegExp('[.*+?|()\\[\\]{}]', 'g'), '\\$&');
+    }
+}
+
+module.exports = {
+    NginxParser
+};

package/lib/util/php-task.js

@@ -1,4 +1,4 @@
-const runPhpCode = require('./run-php');
+const { runPHPContainerCommand } = require('../tasks/php/php-container');
 
 /**
  * @param {String} command
@@ -7,14 +7,11 @@ const runPhpCode = require('./run-php');
  */
 const phpTask = (command, options = {}) => ({
     title: !options.noTitle ? `Running command 'php ${command}` : undefined,
-    task: (ctx, task) => runPhpCode(command, {
+    task: (ctx, task) => runPHPContainerCommand(ctx, command, {
         callback: (t) => {
             task.output = t;
         },
-        throwNonZeroCode: true,
-        magentoVersion: ctx.magentoVersion,
-        env: options.env,
-        useRosettaOnMac: ctx.arch === 'arm64' && ctx.platform === 'darwin'
+        throwNonZeroCode: true
     })
 });
 

package/lib/util/run-composer.js

@@ -1,28 +1,20 @@
-const { execAsyncSpawn } = require('./exec-async-command');
-const { getConfigFromMagentoVersion, defaultConfiguration } = require('../config');
 const UnknownError = require('../errors/unknown-error');
+const { runPHPContainerCommand } = require('../tasks/php/php-container');
 /**
  * Execute composer command
+ * @param {import('../../typings/context').ListrContext} ctx
  * @param {String} command composer command
  * @param {Object} options
  * @param {Boolean} options.throwNonZeroCode Throw if command return non 0 code.
  * @param {String} options.magentoVersion Magento version for config
  */
-const runComposerCommand = async (command, options = {}) => {
+const runComposerCommand = async (ctx, command, options = {}) => {
     const {
-        throwNonZeroCode = true,
-        magentoVersion = defaultConfiguration.name
+        throwNonZeroCode = true
     } = options;
-    const {
-        php,
-        composer,
-        baseConfig: { magentoDir }
-    } = await getConfigFromMagentoVersion(magentoVersion);
-    const { code, result } = await execAsyncSpawn(`${php.binPath} -c ${php.iniPath} ${composer.binPath} ${command}`, {
+    const { code, result } = await runPHPContainerCommand(ctx, `composer ${command}`, {
         ...options,
-        cwd: magentoDir,
-        withCode: true,
-        useRosetta2: true
+        withCode: true
     });
 
     if (throwNonZeroCode && code !== 0) {

package/lib/util/run-container-image.js

@@ -0,0 +1,17 @@
+const { execAsyncSpawn } = require('./exec-async-command');
+
+const runContainerImage = async (imageWithTag, command) => execAsyncSpawn(`docker run --rm ${imageWithTag} ${command}`);
+
+/**
+ * @param {string} imageWithTag
+ * @param {string} command
+ * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ */
+const runContainerImageTask = (imageWithTag, command) => ({
+    task: () => runContainerImage(imageWithTag, command)
+});
+
+module.exports = {
+    runContainerImage,
+    runContainerImageTask
+};