@dazejs/framework/dist/http/proxy/proxy.js

Daze.js - A powerful web framework for Node.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HttpProxy = void 0;
const http_proxy_1 = require("http-proxy");
const querystring_1 = __importDefault(require("querystring"));
const fs_1 = __importDefault(require("fs"));
const form_data_1 = __importDefault(require("form-data"));
const helpers_1 = require("../../helpers");
class HttpProxy {
    constructor(option) {
        this.option = {
            changeOrigin: true,
            secure: false
        };
        if (option)
            this.option = option;
        this._server = (0, http_proxy_1.createProxyServer)();
    }
    on(event, listener) {
        this._server.on(event, listener);
        return this;
    }
    once(event, listener) {
        this._server.once(event, listener);
        return this;
    }
    getServer() {
        return this._server;
    }
    changeOrigin(flag = true) {
        this.option.changeOrigin = flag;
        return this;
    }
    ws(flag = true) {
        this.option.ws = flag;
        return this;
    }
    secure(flag = true) {
        this.option.ws = flag;
        return this;
    }
    target(target) {
        this.option.target = target;
        return this;
    }
    rewrite(fn) {
        this.rewriteFn = fn;
        return this;
    }
    headers(headers) {
        this.option.headers = Object.assign(Object.assign({}, this.option.headers), headers);
        return this;
    }
    output(request) {
        var _a, _b;
        if (typeof this.rewriteFn === 'function') {
            let formatUrl = (_a = request.url) !== null && _a !== void 0 ? _a : '';
            formatUrl = formatUrl.replace((0, helpers_1.config)().get('app.baseUrl', ''), '');
            request.url = (_b = this.rewriteFn(formatUrl)) !== null && _b !== void 0 ? _b : formatUrl;
        }
        this._server.on('proxyReq', (proxyReq, req) => {
            const requestBody = req.body;
            const contentType = proxyReq.getHeader('Content-Type');
            if (requestBody) {
                const writeBody = (bodyData) => {
                    proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
                    proxyReq.write(bodyData);
                };
                if (contentType && ~contentType.indexOf('application/json')) {
                    writeBody(JSON.stringify(requestBody));
                }
                else if (contentType && ~contentType.indexOf('application/x-www-form-urlencoded')) {
                    writeBody(querystring_1.default.stringify(requestBody));
                }
                else if (contentType && ~contentType.indexOf('multipart/form-data')) {
                    const files = req.files;
                    const fd = new form_data_1.default();
                    for (const key of Object.keys(files)) {
                        fd.append(key, fs_1.default.readFileSync(files[key].path), {
                            filename: files[key].name,
                            contentType: files[key].contentType
                        });
                    }
                    for (const key of Object.keys(requestBody)) {
                        fd.append(key, requestBody[key]);
                    }
                    for (const key of Object.keys(fd.getHeaders())) {
                        proxyReq.setHeader(key, fd.getHeaders()[key]);
                    }
                    const buf = fd.getBuffer();
                    proxyReq.setHeader('Content-Length', Buffer.byteLength(buf));
                    proxyReq.write(buf);
                }
                else {
                    writeBody(JSON.stringify(requestBody));
                }
            }
        });
        return new Promise((resolve, reject) => {
            this._server.on('end', () => {
                resolve();
            });
            this._server.web(request.getReq(), request.getRes(), this.option, (err) => {
                reject(err);
            });
        });
    }
}
exports.HttpProxy = HttpProxy;
//# sourceMappingURL=proxy.js.map