http-micro/lib/context.js

Micro-framework on top of node's http module

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const url = require("url");
const route_context_1 = require("./route-context");
const bodyParser = require("./body-parser");
const error_utils_1 = require("./error-utils");
const context_utils_1 = require("./context-utils");
const httpError = require("http-errors");
class Context {
    constructor(app, req, res, requestParser) {
        this.app = app;
        this.req = req;
        this.res = res;
        this._url = null;
        this._ipAddresses = null;
        this._routeContext = null;
        this._bodyParseTask = null;
        if (requestParser !== undefined)
            this.requestParser = requestParser;
        if (this.requestParser === undefined)
            this.requestParser = bodyParser.anyBodyParserFactory();
    }
    getItem(key) {
        if (this.items) {
            let res = this.items.get(key);
            if (res !== undefined)
                return res;
        }
        let appItems = this.app.items;
        if (appItems) {
            let res = appItems.get(key);
            if (res !== undefined)
                return res;
        }
        return null;
    }
    setItem(key, value) {
        if (!this.items) {
            this.items = new Map();
        }
        this.items.set(key, value);
    }
    hasItem(key) {
        if (this.items) {
            let res = this.items.has(key);
            if (res)
                return res;
        }
        let appItems = this.app.items;
        if (appItems) {
            let res = appItems.get(key);
            if (res)
                return res;
        }
        return false;
    }
    getUrl() {
        if (this._url === null) {
            this._url = url.parse(this.req.url);
        }
        return this._url;
    }
    getRouteContext() {
        return this._routeContext || (this._routeContext = new route_context_1.RouteContext(this.getUrl().pathname));
    }
    getRouteParams() {
        return this.getRouteContext().params;
    }
    getHttpMethod() {
        return this.req.method;
    }
    getRequestStream() {
        // TODO: Do request stream pre-processing, like 
        // Content-Encoding, Transfer-Encoding of gzip, etc.
        return this.req;
    }
    getResponseStream() {
        // TODO: Do post processing of stream, like 
        // Content-Encoding, Transfer-Encoding of gzip, etc.
        return this.res;
    }
    getRequestBody(parser) {
        if (this._bodyParseTask === null) {
            let task = bodyParser.parseBody(this.getRequestStream(), null, parser || this.requestParser);
            this._bodyParseTask = task;
            return task;
        }
        return this._bodyParseTask;
    }
    getContentType() {
        if (this._contentType !== undefined)
            return this._contentType;
        return (this._contentType = context_utils_1.RequestUtils.getContentType(this.req));
    }
    getClientIpAddress() {
        return this.getUpstreamIpAddresses()[0];
    }
    getUpstreamIpAddresses() {
        let existing = this._ipAddresses;
        if (existing)
            return existing;
        return this._ipAddresses = context_utils_1.RequestUtils.getUpstreamIpAddresses(this.req);
    }
    getHost() {
        return context_utils_1.RequestUtils.getHost(this.req);
    }
    getProtocol() {
        return context_utils_1.RequestUtils.getProtocol(this.req);
    }
    isEncrypted() {
        return context_utils_1.RequestUtils.isEncrypted(this.req);
    }
    setHeader(key, value, replace = true) {
        return context_utils_1.ResponseUtils.setHeader(this.res, key, value, replace);
    }
    setHeaders(headers) {
        context_utils_1.ResponseUtils.setHeaders(this.res, headers);
    }
    appendHeaderValue(key, value, forceAppend = false) {
        context_utils_1.ResponseUtils.appendHeaderValue(this.res, key, value, forceAppend);
    }
    removeHeaderValue(key, value, removeHeaderIfEmpty = true) {
        context_utils_1.ResponseUtils.removeHeaderValue(this.res, key, value, removeHeaderIfEmpty);
    }
    setContentType(value, force = false) {
        context_utils_1.ResponseUtils.setContentType(this.res, value, force);
    }
    setStatus(code, message) {
        context_utils_1.ResponseUtils.setStatus(this.res, code, message);
    }
    sendStatus(code, message, headers) {
        context_utils_1.ResponseUtils.sendStatus(this.res, code, message, headers);
    }
    send(body, headers, code = 200) {
        context_utils_1.ResponseUtils.send(this.res, body, headers, code);
    }
    sendText(text) {
        context_utils_1.ResponseUtils.sendText(this.res, text);
    }
    sendAsJson(data, replacer, spaces) {
        context_utils_1.ResponseUtils.sendAsJson(this.res, data, replacer, spaces);
    }
    sendNoContent(headers) {
        context_utils_1.ResponseUtils.sendNoContent(this.res, headers);
    }
    sendResetContent(headers) {
        context_utils_1.ResponseUtils.sendResetContent(this.res, headers);
    }
    sendBadRequest(body, headers) {
        context_utils_1.ResponseUtils.sendBadRequest(this.res, body, headers);
    }
    sendNotFound(reason = null, headers) {
        context_utils_1.ResponseUtils.sendNotFound(this.res, reason, headers);
    }
    sendForbidden(reason, headers) {
        context_utils_1.ResponseUtils.sendForbidden(this.res, reason, headers);
    }
    sendMethodNotAllowed(allowedMethods, reason = null, headers) {
        context_utils_1.ResponseUtils.sendMethodNotAllowed(this.res, allowedMethods, reason, headers);
    }
    throw(arg1, arg2) {
        if (typeof arg1 !== "number") {
            let status = arg1;
            throw error_utils_1.intoHttpError(status);
        }
        let status = arg1;
        if (!arg2 || typeof arg2 === "string") {
            let msg = arg2;
            throw httpError(status, msg);
        }
        let error = arg2;
        throw error_utils_1.intoHttpError(error, status, true);
    }
}
exports.Context = Context;
function contextFactory(app, req, res, parser) {
    return new Context(app, req, res, parser);
}
exports.contextFactory = contextFactory;