@3g/request-proxy/lib/index.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const request = require("request-promise");
const BASE_JSON_OPTIONS = {
    json: true,
};
class RequestWrapper {
    constructor(baseUrl) {
        this.buildJsonRequest = (path, method = 'GET', options, context) => {
            return Object.assign({}, BASE_JSON_OPTIONS, {
                url: RequestWrapper.buildUrl(this.baseUrl, path),
                method,
            }, RequestWrapper.getMergedOptions(options, context));
        };
        this.baseUrl = baseUrl;
    }
    /**
     * Proxy standard JSON request
     * @param path relative URL path
     * @param method HTTP method
     * @param options request options
     * @deprecated Since 1.2.0. Use proxyCorrelatedJsonRequest<T> instead.
     */
    proxyJsonRequest(path, method = 'GET', options) {
        return __awaiter(this, void 0, void 0, function* () {
            return request(this.buildJsonRequest(path, method, options)).catch(RequestWrapper.interceptRequestError);
        });
    }
    /**
     * Proxy standard JSON request
     * @param path relative URL path
     * @param method HTTP method
     * @param context request context
     * @param options request options
     */
    proxyCorrelatedJsonRequest(path, method = 'GET', context, options) {
        return __awaiter(this, void 0, void 0, function* () {
            return request(this.buildJsonRequest(path, method, options, context)).catch(RequestWrapper.interceptRequestError);
        });
    }
}
RequestWrapper.buildUrl = (baseUrl, path) => {
    return `${baseUrl}${path}`;
};
RequestWrapper.interceptRequestError = error => {
    // Append request url to error message
    error.message = `${error.message} - ${error.options.url}`;
    throw error;
};
RequestWrapper.getMergedOptions = (options, context) => {
    if (!context || !options) {
        return options;
    }
    // Merge required options with tracing from request context
    return Object.assign({}, options, {
        headers: Object.assign({}, options.headers ? options.headers : {}, {
            'x-request-id': context.request.headers['x-request-id'],
            'x-b3-traceid': context.request.headers['x-b3-traceid'],
            'x-b3-spanid': context.request.headers['x-b3-spanid'],
            'x-b3-parentspanid': context.request.headers['x-b3-parentspanid'],
            'x-b3-sampled': context.request.headers['x-b3-sampled'],
            'x-b3-flags': context.request.headers['x-b3-flags'],
            'x-ot-span-context': context.request.headers['x-ot-span-context'],
        }),
    });
};
exports.RequestWrapper = RequestWrapper;
function createWrapper(baseUrl) {
    return new RequestWrapper(baseUrl);
}
exports.createWrapper = createWrapper;