promisify-child-process/index.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.promisifyChildProcess = promisifyChildProcess;
exports.spawn = spawn;
exports.fork = fork;
exports.execFile = exports.exec = void 0;

var _child_process = _interopRequireDefault(require("child_process"));

function joinChunks(chunks, encoding) {
  if (chunks[0] instanceof Buffer) {
    var buffer = Buffer.concat(chunks);
    if (encoding) return buffer.toString(encoding);
    return buffer;
  }

  return chunks.join('');
}

function promisifyChildProcess(child) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var _promise = new Promise(function (resolve, reject) {
    var encoding = options.encoding,
        killSignal = options.killSignal;
    var captureStdio = encoding != null || options.maxBuffer != null;
    var maxBuffer = options.maxBuffer || 200 * 1024;
    var error;
    var bufferSize = 0;
    var stdoutChunks = [];
    var stderrChunks = [];

    var capture = function capture(chunks) {
      return function (data) {
        var remaining = maxBuffer - bufferSize;

        if (data.length > remaining) {
          error = new Error("maxBuffer size exceeded"); // $FlowFixMe

          child.kill(killSignal ? killSignal : 'SIGTERM');
          data = data.slice(0, remaining);
        }

        bufferSize += data.length;
        chunks.push(data);
      };
    };

    if (captureStdio) {
      if (child.stdout) child.stdout.on('data', capture(stdoutChunks));
      if (child.stderr) child.stderr.on('data', capture(stderrChunks));
    }

    child.on('error', reject);

    function done(code, signal) {
      if (!error) {
        if (code != null && code !== 0) {
          error = new Error("Process exited with code ".concat(code));
        } else if (signal != null) {
          error = new Error("Process was killed with ".concat(signal));
        }
      }

      function defineOutputs(obj) {
        if (captureStdio) {
          obj.stdout = joinChunks(stdoutChunks, encoding);
          obj.stderr = joinChunks(stderrChunks, encoding);
        } else {
          /* eslint-disable no-console */
          Object.defineProperties(obj, {
            stdout: {
              configurable: true,
              enumerable: true,
              get: function get() {
                console.error(new Error("To get stdout from a spawned or forked process, set the `encoding` or `maxBuffer` option").stack.replace(/^Error/, 'Warning'));
                return null;
              }
            },
            stderr: {
              configurable: true,
              enumerable: true,
              get: function get() {
                console.error(new Error("To get stderr from a spawned or forked process, set the `encoding` or `maxBuffer` option").stack.replace(/^Error/, 'Warning'));
                return null;
              }
            }
          });
          /* eslint-enable no-console */
        }
      }

      var output = {};
      defineOutputs(output);
      var finalError = error;

      if (finalError) {
        finalError.code = code;
        finalError.signal = signal;
        defineOutputs(finalError);
        reject(finalError);
      } else {
        resolve(output);
      }
    }

    child.on('close', done);
    child.on('exit', done);
  });

  return Object.create(child, {
    then: {
      value: _promise.then.bind(_promise)
    },
    catch: {
      value: _promise.catch.bind(_promise)
    }
  });
}

function spawn(command, args, options) {
  return promisifyChildProcess(_child_process.default.spawn(command, args, options), Array.isArray(args) ? options : args);
}

function fork(module, args, options) {
  return promisifyChildProcess(_child_process.default.fork(module, args, options), Array.isArray(args) ? options : args);
}

function promisifyExecMethod(method) {
  return function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var child;

    var _promise = new Promise(function (resolve, reject) {
      child = method.apply(void 0, args.concat([function (err, stdout, stderr) {
        if (err) {
          err.stdout = stdout;
          err.stderr = stderr;
          reject(err);
        } else {
          resolve({
            stdout: stdout,
            stderr: stderr
          });
        }
      }]));
    });

    if (!child) {
      throw new Error('unexpected error: child has not been initialized');
    }

    return Object.create(child, {
      then: {
        value: _promise.then.bind(_promise)
      },
      catch: {
        value: _promise.catch.bind(_promise)
      }
    });
  };
}

var exec = promisifyExecMethod(_child_process.default.exec);
exports.exec = exec;
var execFile = promisifyExecMethod(_child_process.default.execFile);
exports.execFile = execFile;