Shell script to build executable from node.js

Question

I'm trying ompile archive node.js executable into one executable using node-packer. For my all packages, executables of node.js are in {projectRoot}/node_modedules/.bin

The project structure as follow:

|- node_modules
|   |-- .bin
|       |--- executable with source code 
|- compiled-bin
|   |-- compiled executable

I wrote a shell script to do it.
Hope you can review it:

#!/bin/bash
for filepath in ./node_modules/.bin/*; do
    export baseName="${filepath##*/}"
    nodec $filepath --clean-tmpdir --make-args=-j10 --output=./compile-bin/$baseName.out  
    chmod +x ./compile-bin/$baseName.out 
done

This is dockerfile, I used to run the above script in container:

FROM node:8.3.0 as package

WORKDIR /usr/src/app
COPY . /usr/src/app

# Install dependencies
RUN apt-get update
RUN apt-get install -y -q --no-install-recommends \
  build-essential \
  python \
  make \
  squashfs-tools \
  gcc \
  g++ \
  clang-3.5 \
  clang++-3.5

# Install nodec compiler
RUN curl -L http://enclose.io/nodec/nodec-linux-x64.gz | gunzip > /usr/local/bin/nodec
RUN chmod +x /usr/local/bin/nodec

# Install npm packages
RUN npm i --no-optional \
  && ls -lh 

# Run build scripts
RUN mkdir compile-bin \
  && chmod +x ./build-script \
  && sync \
  && ./build-script

Answer 1

The shellscript you have seems simple enough. It looks fairly nice, though the use of export is unnecessary.

The dockerfile is a bit of a different story. It's not fully clear whether you intend to use the built application from within the docker container you are setting up there or whether the container is only used to build the executables that are later moved elsewhere.

For now I am assuming that the docker container you create there is the final artifact, and I highly recommend looking into multi-stage builds to slim down the final result.

In addition to that, it feels quite peculiar to install four different C/C++ compilers. It could make sense to separate the dependencies of your application into two categories and keep a package_list (and make_package_list) that can be used to set up the application.
This dovetails nicely with my next suggestion: Make use of docker's caching mechanism.

Currently this Docker container will be rebuilt from scratch every single codechange. That is because you are first COPYing all the source files into the container. Instead of doing that, you want to take advantage of caching and perform steps that rarely change first:

FROM node:8.3.0 AS package

WORKDIR /usr/src/app

RUN apt-get update

# install building time dependencies
COPY make_package_list .
RUN make_package_list > xargs apt-get install -y -q --no-install-recommends
# install nodec compiler
RUN curl -L http://enclose.io/nodec/nodec-linux-x64.gz | gunzip > /usr/local/bin/nodec
RUN chmod +x /usr/local/bin/nodec

# install runtime dependencies
COPY package_list .
RUN package_list > xargs apt-get install -y -q --no-install-recommends

# NOW we copy the source files and start the build process
COPY . .
RUN npm i --no-optional \
  && ls -lh

# Run build scripts
RUN mkdir compile-bin \
  && chmod +x ./build-script \
  && sync \
  && ./build-script

This setup should make the build a bit quicker after the first run, so long as none of the dependencies for your application change. That does not work for the npm-dependencies, though.

It would be possible to change that, too (by copying the package-lock and running npm -i before copying the remainder of the source files), but since you are copying the complete local directory, the current script will use your local package-cache.
While that will be a faster build, it can introduce subtle issues with stale packages and will take a smidge more time during the COPY operation.

Answer 2

This script doesn't need Bash. Plain POSIX shell should be fine.

It's probably a good idea to set -e and -u shell flags to ensure we exit with a failure status if any of the commands fail.

Does baseName really need exporting in the environment? It looks as if a plain variable should be fine. The quotes don't add anything in this context. Perhaps include the target path (though we can drop the redundant initial ./), to avoid repeating that for the two subsequent expansions.

Do remember to quote expansions of variables, particularly those that come from filename globs.

---

Improved code

#!/bin/sh
set -eu

for filepath in node_modules/.bin/*
do
    outFile=compile-bin/${filepath##*/}
    nodec "$filepath" --clean-tmpdir --make-args=-j10 --output="$outFile" 
    chmod +x "$outFile"
done

---

Perhaps instead of chmod +x ./build-script && ./build-script we could simply sh build-script.

---

As mentioned in the other answer, copying the whole working directory as first layer will cause everything subsequent to be built each time. But we probably don't want to copy our sources into the image. It's generally better to volume-mount into the container, so the run command becomes:

docker run -v "$(pwd):/usr/src/app" $build_image sh build-script

Then you can use the build image many times, compiling different versions of your code as needed.