@36node/whisper/dist/index.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _events = require("events");

var _events2 = _interopRequireDefault(_events);

var _net = require("net");

var _net2 = _interopRequireDefault(_net);

var _util = require("util");

var _util2 = _interopRequireDefault(_util);

var _stream = require("stream");

var _stream2 = _interopRequireDefault(_stream);

var _koaCompose = require("koa-compose");

var _koaCompose2 = _interopRequireDefault(_koaCompose);

var _debug = require("debug");

var _debug2 = _interopRequireDefault(_debug);

var _only = require("only");

var _only2 = _interopRequireDefault(_only);

var _session = require("./session");

var _session2 = _interopRequireDefault(_session);

var _context = require("./context");

var _context2 = _interopRequireDefault(_context);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var debug = new _debug2.default("whisper");

/**
 * Expose `Application` class.
 * Inherits from `Emitter.prototype`.
 */

var Application = function (_Emitter) {
  _inherits(Application, _Emitter);

  /**
   * Initialize a new `Application`.
   *
   * @api public
   */

  function Application() {
    _classCallCheck(this, Application);

    var _this = _possibleConstructorReturn(this, (Application.__proto__ || Object.getPrototypeOf(Application)).call(this));

    _this.middleware = [];
    _this.env = process.env.NODE_ENV || "development";

    if (_util2.default.inspect.custom) {
      _this[_util2.default.inspect.custom] = _this.inspect;
    }
    return _this;
  }

  /**
   * Shorthand for:
   *
   *    net.createServer(app.callback()).listen(...)
   *
   * @param {Mixed} ...
   * @return {Server}
   * @api public
   */

  _createClass(Application, [{
    key: "listen",
    value: function listen() {
      debug("listen");
      var server = _net2.default.createServer(this.callback());
      return server.listen.apply(server, arguments);
    }

    /**
     * Return JSON representation.
     * We only bother showing settings.
     *
     * @return {Object}
     * @api public
     */

  }, {
    key: "toJSON",
    value: function toJSON() {
      return (0, _only2.default)(this, ["env"]);
    }

    /**
     * Inspect implementation.
     *
     * @return {Object}
     * @api public
     */

  }, {
    key: "inspect",
    value: function inspect() {
      return this.toJSON();
    }

    /**
     * Use the given middleware `fn`.
     *
     * Old-style middleware will be converted.
     *
     * @param {Function} fn
     * @return {Application} self
     * @api public
     */

  }, {
    key: "use",
    value: function use(fn) {
      if (typeof fn !== "function") throw new TypeError("middleware must be a function!");
      debug("use %s", fn._name || fn.name || "-");
      this.middleware.push(fn);
      return this;
    }

    /**
     * Return a socket handler callback
     * for node's net server.
     *
     * @return {Function}
     * @api public
     */

  }, {
    key: "callback",
    value: function callback() {
      var _this2 = this;

      var fn = (0, _koaCompose2.default)(this.middleware);

      if (!this.listenerCount("error")) this.on("error", this.onerror);

      var handleConnect = function handleConnect(socket) {
        // create session while new connection
        var session = new _session2.default(_this2, socket);
        socket.on("data", function (data) {
          var ctx = new _context2.default(session, data);
          _this2.handleRequest(ctx, fn);
        });
      };

      return handleConnect;
    }

    /**
     * Handle request in callback.
     *
     * @api private
     */

  }, {
    key: "handleRequest",
    value: function handleRequest(ctx, fnMiddleware) {
      debug("data comming with seq %s", ctx.seq);
      debug(ctx.data);

      var onerror = function onerror(err) {
        return ctx.onerror(err);
      };
      var handleResponse = function handleResponse() {
        return respond(ctx);
      };
      return fnMiddleware(ctx).then(handleResponse).catch(onerror);
    }

    /**
     * Default error handler.
     *
     * @param {Error} err
     * @api private
     */

  }, {
    key: "onerror",
    value: function onerror(err) {
      if (!(err instanceof Error)) throw new TypeError(_util2.default.format("non-error thrown: %j", err));

      if (this.silent) return;

      var msg = err.stack || err.toString();
      console.error();
      console.error(msg.replace(/^/gm, "  "));
      console.error();
    }
  }]);

  return Application;
}(_events2.default);

/**
 * Response helper.
 */

exports.default = Application;
function respond(ctx) {
  var socket = ctx.socket,
      dumb = ctx.dumb,
      body = ctx.body;

  // allow bypassing whisper

  if (dumb) return;

  // socket close
  if (!socket.writable) return;

  // no body
  if (!body) {
    return debug("no body");
  }

  debug("respond body");
  debug(body);

  // responses
  if (Buffer.isBuffer(body)) return socket.write(body);
  if ("string" === typeof body) return socket.write(body);
  if (body instanceof _stream2.default) return body.pipe(socket);

  // body: json
  var str = JSON.stringify(body);
  socket.write(str);
}