@teclone/r-server/build/cjs/modules/Response.js

A lightweight, extensible web-server with inbuilt routing-engine, static file server, file upload handler, request body parser, middleware support and lots more

'use strict';

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

var _createClass = require('@babel/runtime/helpers/createClass');
var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
var _inherits = require('@babel/runtime/helpers/inherits');
var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
var http = require('http');
var http2 = require('http2');
var utils = require('@teclone/utils');
var Utils = require('./Utils');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
var createResponseClass = function createResponseClass(BaseResponseClass) {
  var ResponseClass = BaseResponseClass;
  var parentEnd = BaseResponseClass.prototype.end;
  var parentSetHeader = BaseResponseClass.prototype.setHeader;
  var parentRemoveHeader = BaseResponseClass.prototype.removeHeader;

  // end
  ResponseClass.prototype.end = function (data, encoding, cb) {
    var _this = this;
    var resolvedData = '';
    var resolvedEncoding;
    var resolvedCb = null;

    // first implementation
    if (utils.isCallable(data)) {
      resolvedCb = data;
    } else {
      resolvedData = data;
    }
    if (typeof encoding === 'string') {
      resolvedEncoding = encoding;
    } else if (utils.isCallable(encoding)) {
      resolvedCb = encoding;
    }
    if (utils.isCallable(cb)) {
      resolvedCb = cb;
    }
    if (resolvedData && !Buffer.isBuffer(resolvedData) && !utils.isString(resolvedData)) {
      resolvedData = JSON.stringify(resolvedData);
    }
    return new Promise(function (resolve) {
      var resolvePromise = function resolvePromise() {
        resolve(true);
        if (resolvedCb) {
          resolvedCb();
        }
      };
      if (encoding) {
        parentEnd.call(_this, resolvedData, resolvedEncoding, resolvePromise);
      } else {
        parentEnd.call(_this, resolvedData, resolvePromise);
      }
    });
  };
  ResponseClass.prototype.setHeader = function (name, value) {
    parentSetHeader.call(this, name, value);
    return this;
  };
  ResponseClass.prototype.setHeaders = function (headers) {
    var _this2 = this;
    Object.keys(headers || {}).forEach(function (key) {
      _this2.setHeader(key, headers[key]);
    });
    return this;
  };
  ResponseClass.prototype.removeHeader = function (name) {
    parentRemoveHeader.call(this, name);
    return this;
  };
  ResponseClass.prototype.removeHeaders = function () {
    var _this3 = this;
    for (var _len = arguments.length, names = new Array(_len), _key = 0; _key < _len; _key++) {
      names[_key] = arguments[_key];
    }
    names.forEach(function (name) {
      _this3.removeHeader(name);
    });
    return this;
  };
  ResponseClass.prototype.status = function (code, message) {
    this.statusCode = code;
    if (message) {
      this.statusMessage = message;
    }
    return this;
  };
  ResponseClass.prototype.redirect = function (path) {
    var status = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 302;
    return this.status(status).setHeader('Location', path).end();
  };
  ResponseClass.prototype.download = function (filePath, filename) {
    return this.fileServer.serveDownload(filePath, this, filename);
  };
  ResponseClass.prototype.json = function (data) {
    var resolvedData = typeof data === 'string' ? data : JSON.stringify(data || '');
    return this.setHeader('Content-Type', 'application/json').end(resolvedData);
  };
  ResponseClass.prototype.jsonError = function (response) {
    var _ref = response || {},
      headers = _ref.headers,
      message = _ref.message,
      _ref$errors = _ref.errors,
      errors = _ref$errors === void 0 ? null : _ref$errors,
      statusCode = _ref.statusCode;
    return this.status(statusCode || 400, message).setHeaders(headers).json(errors);
  };
  ResponseClass.prototype.jsonSuccess = function (response) {
    var _ref2 = response || {},
      _ref2$statusCode = _ref2.statusCode,
      statusCode = _ref2$statusCode === void 0 ? 200 : _ref2$statusCode,
      headers = _ref2.headers,
      message = _ref2.message,
      _ref2$data = _ref2.data,
      data = _ref2$data === void 0 ? null : _ref2$data,
      errors = _ref2.errors;
    if (statusCode >= 300 || errors) {
      return this.jsonError(response);
    }
    return this.status(statusCode, message).setHeaders(headers).json(data);
  };
  ResponseClass.prototype.wait = function (time) {
    var _this4 = this;
    return new Promise(function (resolve) {
      setTimeout(function () {
        resolve(_this4);
      }, time);
    });
  };
  ResponseClass.prototype.processRouteResponse = function (responsePromise) {
    var _this5 = this;
    return responsePromise.then(function (response) {
      return _this5.jsonSuccess(response);
    })["catch"](function (err) {
      if (err instanceof Error) {
        return Utils.handleError(err, _this5);
      }
      return _this5.jsonError(err);
    });
  };
  return ResponseClass;
};

// HTTP1 Response
var HTTP1BaseResponse = /*#__PURE__*/function (_Http1ServerResponse) {
  _inherits__default["default"](HTTP1BaseResponse, _Http1ServerResponse);
  var _super = _createSuper(HTTP1BaseResponse);
  function HTTP1BaseResponse(req) {
    var _this6;
    _classCallCheck__default["default"](this, HTTP1BaseResponse);
    _this6 = _super.call(this, req);
    // @ts-ignore
    _this6.req = req;
    return _this6;
  }
  return _createClass__default["default"](HTTP1BaseResponse);
}(http.ServerResponse);
var Http1Response = createResponseClass(HTTP1BaseResponse);

// HTTP2 Response
var HTTP2BaseResponse = /*#__PURE__*/function (_Http2ServerResponse) {
  _inherits__default["default"](HTTP2BaseResponse, _Http2ServerResponse);
  var _super2 = _createSuper(HTTP2BaseResponse);
  function HTTP2BaseResponse() {
    _classCallCheck__default["default"](this, HTTP2BaseResponse);
    return _super2.apply(this, arguments);
  }
  return _createClass__default["default"](HTTP2BaseResponse);
}(http2.Http2ServerResponse);
var Http2Response = createResponseClass(HTTP2BaseResponse);

exports.Http1Response = Http1Response;
exports.Http2Response = Http2Response;
//# sourceMappingURL=Response.js.map