@scandipwa/magento-scripts 2.0.3 → 2.0.4

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

@@ -6,192 +6,208 @@ const buildInstructions = (instructions) => {
     /**
      * @type {string[]}
      */
-    const dockerFileInstructions = [];
+    const dockerFileInstructions = []
 
     for (const instruction of instructions) {
         switch (instruction.type) {
-        case 'COPY':
-        case 'ADD': {
-            let addInstruction = 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;
+                if (instruction.type === 'COPY' && instruction.from) {
+                    addInstruction += ` --from=${instruction.from}`
+                }
 
-            argInstruction += ` ${instruction.name}`;
+                if (instruction.chown) {
+                    addInstruction += ` --chown=${instruction.chown}`
+                }
 
-            if (instruction.defaultValue) {
-                argInstruction += `=${instruction.defaultValue}`;
-            }
+                addInstruction += ` ${instruction.src.join(' ')}`
+                addInstruction += ` ${instruction.dest}`
 
-            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(addInstruction)
+                break
             }
+            case 'ARG': {
+                let argInstruction = instruction.type
 
-            dockerFileInstructions.push(cmdInstruction);
-            break;
-        }
+                argInstruction += ` ${instruction.name}`
 
-        case 'COMMENT': {
-            const commentInstruction = `# ${instruction.comment}`;
+                if (instruction.defaultValue) {
+                    argInstruction += `=${instruction.defaultValue}`
+                }
 
-            dockerFileInstructions.push(commentInstruction);
-            break;
-        }
-        case 'ENV': {
-            let envInstruction = instruction.type;
-
-            envInstruction += ` ${instruction.name}="${instruction.value}"`;
+                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
+            }
 
-            dockerFileInstructions.push(envInstruction);
-            break;
-        }
-        case 'EXPOSE': {
-            let exposeInstruction = instruction.type;
+            case 'COMMENT': {
+                const commentInstruction = `# ${instruction.comment}`
 
-            if (instruction.protocol) {
-                exposeInstruction += ` ${instruction.port}/${instruction.protocol}`;
-            } else {
-                exposeInstruction += ` ${instruction.port}`;
+                dockerFileInstructions.push(commentInstruction)
+                break
             }
+            case 'ENV': {
+                let envInstruction = instruction.type
 
-            dockerFileInstructions.push(exposeInstruction);
-            break;
-        }
-        case 'FROM': {
-            let fromInstruction = instruction.type;
+                envInstruction += ` ${instruction.name}="${instruction.value}"`
 
-            if (instruction.platform) {
-                fromInstruction += ` --platform=${instruction.platform}`;
+                dockerFileInstructions.push(envInstruction)
+                break
             }
+            case 'EXPOSE': {
+                let exposeInstruction = instruction.type
 
-            fromInstruction += ` ${instruction.image}:${instruction.tag || 'latest'}`;
+                if (instruction.protocol) {
+                    exposeInstruction += ` ${instruction.port}/${instruction.protocol}`
+                } else {
+                    exposeInstruction += ` ${instruction.port}`
+                }
 
-            if (instruction.name) {
-                fromInstruction += ` AS ${instruction.name}`;
+                dockerFileInstructions.push(exposeInstruction)
+                break
             }
+            case 'FROM': {
+                let fromInstruction = instruction.type
 
-            dockerFileInstructions.push(fromInstruction);
-            break;
-        }
-        case 'HEALTHCHECK': {
-            let healthCheckInstruction = instruction.type;
+                if (instruction.platform) {
+                    fromInstruction += ` --platform=${instruction.platform}`
+                }
 
-            if (instruction.interval) {
-                healthCheckInstruction += ` --interval=${instruction.interval}`;
-            }
+                fromInstruction += ` ${instruction.image}:${
+                    instruction.tag || 'latest'
+                }`
 
-            if (instruction.retries) {
-                healthCheckInstruction += ` --retries=${instruction.retries}`;
-            }
+                if (instruction.name) {
+                    fromInstruction += ` AS ${instruction.name}`
+                }
 
-            if (instruction.startPeriod) {
-                healthCheckInstruction += ` --start-period=${instruction.startPeriod}`;
+                dockerFileInstructions.push(fromInstruction)
+                break
             }
+            case 'HEALTHCHECK': {
+                let healthCheckInstruction = instruction.type
 
-            if (instruction.timeout) {
-                healthCheckInstruction += ` --timeout=${instruction.timeout}`;
-            }
+                if (instruction.interval) {
+                    healthCheckInstruction += ` --interval=${instruction.interval}`
+                }
 
-            healthCheckInstruction += ` ${instruction.command}`;
+                if (instruction.retries) {
+                    healthCheckInstruction += ` --retries=${instruction.retries}`
+                }
 
-            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;
+                if (instruction.startPeriod) {
+                    healthCheckInstruction += ` --start-period=${instruction.startPeriod}`
+                }
 
-            onBuildInstruction += ` ${instruction.instruction}`;
+                if (instruction.timeout) {
+                    healthCheckInstruction += ` --timeout=${instruction.timeout}`
+                }
 
-            dockerFileInstructions.push(onBuildInstruction);
-            break;
-        }
-        case 'SHELL': {
-            let shellInstruction = instruction.type;
+                healthCheckInstruction += ` ${instruction.command}`
 
-            shellInstruction += ` ["${instruction.exec.join('", "')}"]`;
+                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
 
-            dockerFileInstructions.push(shellInstruction);
-            break;
-        }
-        case 'STOPSIGNAL': {
-            let stopSignalInstruction = instruction.type;
+                onBuildInstruction += ` ${instruction.instruction}`
 
-            stopSignalInstruction += ` ${instruction.signal}`;
+                dockerFileInstructions.push(onBuildInstruction)
+                break
+            }
+            case 'SHELL': {
+                let shellInstruction = instruction.type
 
-            dockerFileInstructions.push(stopSignalInstruction);
-            break;
-        }
-        case 'USER': {
-            let userInstruction = instruction.type;
+                shellInstruction += ` ["${instruction.exec.join('", "')}"]`
 
-            userInstruction += ` ${instruction.user}`;
+                dockerFileInstructions.push(shellInstruction)
+                break
+            }
+            case 'STOPSIGNAL': {
+                let stopSignalInstruction = instruction.type
 
-            dockerFileInstructions.push(userInstruction);
-            break;
-        }
-        case 'VOLUME': {
-            let volumeInstruction = instruction.type;
+                stopSignalInstruction += ` ${instruction.signal}`
 
-            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(stopSignalInstruction)
+                break
             }
+            case 'USER': {
+                let userInstruction = instruction.type
 
-            dockerFileInstructions.push(volumeInstruction);
-            break;
-        }
-        case 'WORKDIR': {
-            const workDirInstruction = `${instruction.type} ${instruction.workdir}`;
+                userInstruction += ` ${instruction.user}`
 
-            dockerFileInstructions.push(workDirInstruction);
-            break;
-        }
-        default: {
-            throw new Error(`I don't know instruction with type ${instruction.type}`);
-        }
+                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');
-};
+    return dockerFileInstructions.join('\n')
+}
 
 module.exports = {
     buildInstructions
-};
+}

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

@@ -1,30 +1,25 @@
-const { buildInstructions } = require('./build-instructions');
+const { buildInstructions } = require('./build-instructions')
 
 class DockerFileBuilder {
     /**
      * @type {import('./types').DockerfileInstruction[]}
      */
-    instructions = [];
+    instructions = []
 
     /**
      * @param {Omit<import('./types').FromInstruction, 'type'>} param0
      * @returns {this}
      */
-    from({
-        image,
-        tag = 'latest',
-        platform,
-        name
-    }) {
+    from({ image, tag = 'latest', platform, name }) {
         this.instructions.push({
             type: 'FROM',
             image,
             tag,
             platform,
             name
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -34,9 +29,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'RUN',
             command
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -46,9 +41,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'CMD',
             command
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -58,25 +53,22 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'LABEL',
             labels
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
      * @param {Omit<import('./types').ExposeInstruction, 'type'>} param0
      */
-    expose({
-        port,
-        protocol
-    }) {
+    expose({ port, protocol }) {
         this.instructions.push({
             type: 'EXPOSE',
             port,
             protocol
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -88,48 +80,39 @@ class DockerFileBuilder {
                 type: 'ENV',
                 name,
                 value
-            });
-        });
+            })
+        })
 
-        return this;
+        return this
     }
 
     /**
      * @param {Omit<import('./types').AddInstruction, 'type'>} param0
      */
-    add({
-        src,
-        dest,
-        chown
-    }) {
+    add({ src, dest, chown }) {
         this.instructions.push({
             type: 'ADD',
             src,
             dest,
             chown
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
      * @param {Omit<import('./types').CopyInstruction, 'type'>} param0
      */
-    copy({
-        src,
-        dest,
-        chown,
-        from
-    }) {
+    copy({ src, dest, chown, from }) {
         this.instructions.push({
             type: 'COPY',
             src,
             dest,
             chown,
             from
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -139,9 +122,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'ENTRYPOINT',
             command
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -151,9 +134,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'VOLUME',
             volume
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -163,9 +146,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'USER',
             user
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -175,25 +158,22 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'WORKDIR',
             workdir
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
      * @param {Omit<import('./types').ArgInstruction, 'type'>} param0
      */
-    arg({
-        name,
-        defaultValue
-    }) {
+    arg({ name, defaultValue }) {
         this.instructions.push({
             type: 'ARG',
             name,
             defaultValue
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -203,9 +183,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'ONBUILD',
             instruction
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -215,21 +195,15 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'STOPSIGNAL',
             signal
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
      * @param {Omit<import('./types').HealthCheckInstruction, 'type'>} param0
      */
-    healthCheck({
-        command,
-        interval,
-        timeout,
-        startPeriod,
-        retries
-    }) {
+    healthCheck({ command, interval, timeout, startPeriod, retries }) {
         this.instructions.push({
             type: 'HEALTHCHECK',
             command,
@@ -237,9 +211,9 @@ class DockerFileBuilder {
             retries,
             startPeriod,
             timeout
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -249,9 +223,9 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'SHELL',
             exec
-        });
+        })
 
-        return this;
+        return this
     }
 
     /**
@@ -261,16 +235,16 @@ class DockerFileBuilder {
         this.instructions.push({
             type: 'COMMENT',
             comment
-        });
+        })
 
-        return this;
+        return this
     }
 
     build() {
-        return buildInstructions(this.instructions);
+        return buildInstructions(this.instructions)
     }
 }
 
 module.exports = {
     DockerFileBuilder
-};
+}

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

@@ -103,7 +103,8 @@ export interface CommentInstruction {
     comment: string
 }
 
-export type DockerfileInstruction = FromInstruction
+export type DockerfileInstruction =
+    | FromInstruction
     | RunInstruction
     | CmdInstruction
     | LabelInstruction