babel-watch.js

#!/usr/bin/env node

'use strict';

const chokidar = require('chokidar');
const path = require('path');
const babel = require('babel-core');
const fs = require('fs');
const os = require('os');
const util = require('util');
const fork = require('child_process').fork;
const execSync = require('child_process').execSync;
const commander = require('commander');
const debounce = require('lodash.debounce')

const RESTART_COMMAND = 'rs';

const program = new commander.Command("babel-watch");

function collect(val, memo) {
  memo.push(val);
  return memo;
}

program.option('-d, --debug [port]', 'Set debugger port')
program.option('-B, --debug-brk', 'Enable debug break mode')
program.option('-I, --inspect', 'Enable inspect mode')
program.option('-o, --only [globs]', 'Matching files will be transpiled');
program.option('-i, --ignore [globs]', 'Matching files will not be transpiled');
program.option('-e, --extensions [extensions]', 'List of extensions to hook into [.es6,.js,.es,.jsx]');
program.option('-p, --plugins [string]', '', babel.util.list);
program.option('-b, --presets [string]', '', babel.util.list);
program.option('-w, --watch [dir]', 'Watch directory "dir" or files. Use once for each directory or file to watch', collect, []);
program.option('-x, --exclude [dir]', 'Exclude matching directory/files from watcher. Use once for each directory or file.', collect, []);
program.option('-L, --use-polling', 'In some filesystems watch events may not work correcly. This option enables "polling" which should mitigate this type of issues');
program.option('-D, --disable-autowatch', 'Don\'t automatically start watching changes in files "required" by the program');
program.option('-H, --disable-ex-handler', 'Disable source-map-enhanced uncaught exception handler. (you may want to use this option in case your app registers a custom uncaught exception handler)');
program.option('-m, --message [string]', 'Set custom message displayed on restart (default is ">>> RESTARTING <<<")');
program.option('-c, --change-interval [number]', 'Coalesce change events happening more of then given amount of milliseconds. [300]')

const pkg = require('./package.json');
program.version(pkg.version);
program.usage('[options] [script.js] [args]');
program.description('babel-watch is a babel-js node app runner that lets you reload the app on JS source file changes.');
program.on('--help', () => {
  console.log(`\
  About "autowatch":

  "Autowatch" is the default behavior in babel-watch. Thanks to that mechanism babel-watch will automatically
  detect files that are "required" (or "imported") by your program and start to watch for changes on those files.
  It means that you no longer need to specify -w (--watch) option with a list of directories you are willing to
  monitor changes in. You can disable "autowatch" with -D option or limit the list of files it will be enabled for
  using the option -x (--exclude).

  Babel.js configuration:

  You may use some of the options listed above to customize plugins/presets and matching files that babel.js
  is going to use while transpiling your app's source files but we recommend that you use .babelrc file as
  babel-watch works with .babelrc just fine.

  IMPORTANT:

  babel-watch is meant to **only** be used during development. In order to support fast reload cycles it uses more
  memory than plain node process. We recommend that when you deploy your app to production you pre-transpile source
  files and run your application using node directly (avoid babel-node too for the same reasons).

  Examples:

    $ babel-watch server.js
    $ babel-watch -x templates server.js
    $ babel-watch --presets es2015 server.js --port 8080

  See more:

  https://github.com/kmagiera/babel-watch
  `);
});
program.parse(process.argv);

const cwd = process.cwd();

let only, ignore;

if (program.only != null) only = babel.util.arrayify(program.only, babel.util.regexify);
if (program.ignore != null) ignore = babel.util.arrayify(program.ignore, babel.util.regexify);

let transpileExtensions = babel.util.canCompile.EXTENSIONS;
const restartDebounceInterval = ~~program.changeInterval || 300;

if (program.extensions) {
  transpileExtensions = transpileExtensions.concat(babel.util.arrayify(program.extensions));
}

const mainModule = program.args[0];
if (!mainModule) {
  console.error('Main script not specified');
  process.exit(1);
}
if (!mainModule.startsWith('.') && !mainModule.startsWith('/')) {
  program.args[0] = path.join(cwd, mainModule);
}

const transformOpts = {
  plugins: program.plugins,
  presets: program.presets,
};

let childApp, pipeFd, pipeFilename;

const cache = {};
const errors = {};

const watcher = chokidar.watch(program.watch, {
  persistent: true,
  ignored: program.exclude,
  ignoreInitial: true,
  usePolling: program.usePolling,
});
let watcherInitialized = (program.watch.length === 0);

process.on('SIGINT', function() {
  watcher.close();
  process.exit(1);
});

const restartApp = debounce(_restartApp, restartDebounceInterval)

watcher.on('change', handleChange);
watcher.on('add', handleChange);
watcher.on('unlink', handleChange);

watcher.on('ready', () => {
  if (!watcherInitialized) {
    watcherInitialized = true;
    restartApp();
  }
});

watcher.on('error', error => {
  console.error('Watcher failure', error);
  process.exit(1);
});

// Restart the app when a sequence of keys has been pressed ('rs' by refault)
const stdin = process.stdin;
stdin.setEncoding('utf8');
stdin.on('data', (data) => {
  if (String(data).trim() === RESTART_COMMAND) {
    restartApp();
  }
});

function handleChange(file) {
  // fix watching only working once per file inside Docker container
  watcher.unwatch(file);
  watcher.add(file);

  const absoluteFile = file.startsWith('/') ? file : path.join(cwd, file);
  delete cache[absoluteFile];
  delete errors[absoluteFile];

  // file is in use by the app, let's restart!
  restartApp();
}

function generateTempFilename() {
  const now = new Date();
  return path.join(os.tmpdir(), [
    now.getYear(), now.getMonth(), now.getDate(),
    '-',
    process.pid,
    '-',
    (Math.random() * 0x100000000 + 1).toString(36),
  ].join(''));
}

function handleFileLoad(filename, callback) {
  const cached = cache[filename];
  if (cached) {
    const stats = fs.statSync(filename);
    if (stats.mtime.getTime() === cached.mtime) {
      callback(cache[filename].code, cache[filename].map);
      return;
    }
  }
  if (!shouldIgnore(filename)) {
    compile(filename, (err, result) => {
      if (err) {
        console.error('Babel compilation error', err.stack);
        errors[filename] = true;
        return;
      }
      const stats = fs.statSync(filename);
      cache[filename] = {
        code: result.code,
        map: result.map,
        mtime: stats.mtime.getTime(),
      };
      delete errors[filename];
      callback(result.code, result.map);
    });
  } else {
    callback();
  }
}

function killChildProcess(childProcess) {
  return new Promise((resolve, reject) => {
    let done = false
    childProcess.on('exit', () => {
      if (done) return
      done = true
      resolve()
    })

    setTimeout(() => {
      if (done) return
      console.log('Child process is HUP resistant, using SIGKILL')
      childProcess.kill('SIGKILL');
    }, 2000)

    setTimeout(() => {
      if (done) return
      done = true
      reject(new Error('Could not kill child process with SIGKILL'))

    }, 4000)
    childProcess.kill('SIGHUP');
  })
}

function killApp() {
  if (childApp) {
    killChildProcess(childApp).then(restartAppInternal,
      (e) => {
        console.log('Could not kill subprocess, aborting', e)
        process.exit(1)
      })
  }
}

function prepareRestart() {
  if (watcherInitialized && childApp) {
    // kill app early as `compile` may take a while
    var restartMessage = program.message ? program.message : ">>> RESTARTING <<<";
    console.log(restartMessage);
    killApp();
  } else {
    restartAppInternal();
  }
}

function _restartApp() {
  if (!watcherInitialized) return;
  prepareRestart();
}

function restartAppInternal() {
  if (Object.keys(errors).length != 0) {
    // There were some transpilation errors, don't start unless solved or invalid file is removed
    return;
  }

  pipeFilename = generateTempFilename();

  if (os.platform() === 'win32') {
    try {
      execSync(`echo. > ${pipeFilename}`);
    } catch (e) {
      console.error(`Unable to create file ${pipeFilename}`);
      process.exit(1);
    }
  } else {
    try {
      execSync(`mkfifo -m 0666 ${pipeFilename}`);
    } catch (e) {
      console.error('Unable to create named pipe with mkfifo. Are you on linux/OSX?');
      process.exit(1);
    }
  }

  // Support for --debug option
  const runnerExecArgv = process.execArgv.slice();
  if (program.debug) {
    runnerExecArgv.push('--debug=' + program.debug);
  }
  // Support for --inspect option
  if (program.inspect) {
    runnerExecArgv.push('--inspect');
  }
  // Support for --debug-brk
  if(program.debugBrk) {
    runnerExecArgv.push('--debug-brk');
  }

  const app = fork(path.resolve(__dirname, 'runner.js'), { execArgv: runnerExecArgv });

  app.on('error', (err) => {
    console.log("Runner error: ", err);
    process.exit(1);
  });

  app.on('exit', (code, signal) => {

    if (pipeFd) {
      fs.closeSync(pipeFd); // silently close pipe fd
    }
    if (pipeFilename) {
      fs.unlinkSync(pipeFilename); // silently remove old pipe file
    }
    pipeFd = undefined;
    pipeFilename = undefined;
    childApp = undefined;

    // Exit code is non-null when the runner exits on it's own
    if (code !== null) {
      console.log('Runner crashed, restarting...')
      restartApp();
    }
  });

  app.on('message', (data) => {
    const filename = data.filename;
    if (!program.disableAutowatch) {
      // use relative path for watch.add as it would let chokidar reconsile exclude patterns
      const relativeFilename = path.relative(cwd, filename);
      watcher.add(relativeFilename);
    }
    handleFileLoad(filename, (source, sourceMap) => {
      const sourceBuf = new Buffer(source || 0);
      const mapBuf = new Buffer(sourceMap ? JSON.stringify(sourceMap) : 0);
      const lenBuf = new Buffer(4);
      try {
        lenBuf.writeUInt32BE(sourceBuf.length, 0);
        fs.writeSync(pipeFd, lenBuf, 0, 4);
        sourceBuf.length && fs.writeSync(pipeFd, sourceBuf, 0, sourceBuf.length);

        lenBuf.writeUInt32BE(mapBuf.length, 0);
        fs.writeSync(pipeFd, lenBuf, 0, 4);
        mapBuf.length && fs.writeSync(pipeFd, mapBuf, 0, mapBuf.length);
      } catch (error) {
        // EPIPE means `pipeFd` has been closed. We can ignore this
        if (error.code !== 'EPIPE') {
          throw error;
        }
      }
    });
  });

  app.send({
    pipe: pipeFilename,
    args: program.args,
    handleUncaughtExceptions: !program.disableExHandler,
    transpileExtensions: transpileExtensions,
  });
  pipeFd = fs.openSync(pipeFilename, 'w');
  childApp = app;
}

function shouldIgnore(filename) {
  if (transpileExtensions.indexOf(path.extname(filename)) < 0) {
    return true;
  } else if (!ignore && !only) {
    // Ignore node_modules by default
    return path.relative(cwd, filename).split(path.sep).indexOf('node_modules') >= 0;
  } else {
    return babel.util.shouldIgnore(filename, ignore || [], only);
  }
}

function compile(filename, callback) {
  const optsManager = new babel.OptionManager;

  // merge in base options and resolve all the plugins and presets relative to this file
  optsManager.mergeOptions({
    options: transformOpts,
    alias: 'base',
    loc: path.dirname(filename)
  });

  const opts = optsManager.init({ filename });
  // Do not process config files since has already been done with the OptionManager
  // calls above and would introduce duplicates.
  opts.babelrc = false;
  opts.sourceMap = true;
  opts.ast = false;

  return babel.transformFile(filename, opts, (err, result) => {
    callback(err, result);
  });
}

restartApp();