@requestly/requestly-proxy 1.0.0

package/dist/components/proxy-middleware/helpers/harObectCreator.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarResponse = exports.createHarRequest = exports.createHarEntry = exports.createHar = exports.createRequestHarObject = void 0;
+const createHarHeaders = (request_headers_obj) => {
+    // convert headers obj to haar format
+    const headers = [];
+    if (request_headers_obj) {
+        for (const key in request_headers_obj) {
+            headers.push({
+                name: key,
+                value: request_headers_obj[key],
+            });
+        }
+    }
+    return headers;
+};
+const createHarQueryStrings = (path) => {
+    // TODO -> http://www.softwareishard.com/blog/har-12-spec/#queryString
+    return [];
+};
+const getContentType = (headers) => {
+    let contentType = null;
+    if (headers) {
+        headers.forEach((item) => {
+            if (item.name === "content-type") {
+                contentType = item.value;
+            }
+        });
+    }
+    return contentType;
+};
+const buildHarPostParams = (contentType, body) => {
+    if (contentType === "application/x-www-form-urlencoded") {
+        return body
+            .split("&") // Split by separators
+            .map((keyValue) => {
+            const [key, value] = keyValue.split("=");
+            return {
+                name: key,
+                value,
+            };
+        });
+    }
+    else {
+        // FormData has its own format
+        // TODO Complete form data case -> where file is uploaded
+        return {
+            name: contentType,
+            value: body,
+        };
+    }
+};
+const createHarPostData = (body, headers) => {
+    // http://www.softwareishard.com/blog/har-12-spec/#postData
+    if (!body) {
+        return undefined;
+    }
+    const contentType = getContentType(headers);
+    // if (!contentType) {
+    //   return undefined;
+    // }
+    // // console.log("contentType and Body", { contentType, body }, typeof body);
+    // if (
+    //   ["application/x-www-form-urlencoded", "multipart/form-data"].includes(
+    //     contentType
+    //   )
+    // ) {
+    //   return {
+    //     mimeType: contentType,
+    //     params: buildHarPostParams(contentType, body),
+    //   };
+    // }
+    return {
+        mimeType: contentType,
+        text: body,
+    };
+};
+// create standard request har object: http://www.softwareishard.com/blog/har-12-spec/#request
+// URL: https://github.com/hoppscotch/hoppscotch/blob/75ab7fdb00c0129ad42d45165bd3ad0af1faca2e/packages/hoppscotch-app/helpers/new-codegen/har.ts#L26
+const createRequestHarObject = (requestHarObject, proxyToServerRequestOptions) => {
+    const { method, host, path, body, headers, agent, } = proxyToServerRequestOptions;
+    return {
+        bodySize: -1,
+        headersSize: -1,
+        httpVersion: "HTTP/1.1",
+        cookies: [],
+        headers: requestHarObject.headers || createHarHeaders(headers),
+        method: requestHarObject.method || method,
+        queryString: requestHarObject.queryString || createHarQueryStrings(path),
+        url: requestHarObject.url || ((agent === null || agent === void 0 ? void 0 : agent.protocol) || "http:") + "//" + host + path,
+        postData: requestHarObject.postData ||
+            createHarPostData(body, requestHarObject.headers),
+    };
+};
+exports.createRequestHarObject = createRequestHarObject;
+const createHar = (requestHeaders, method, protocol, host, path, requestBody, responseStatusCode, response, responseHeaders) => {
+    return {
+        "log": {
+            "version": "1.2",
+            "creator": {},
+            "browser": {},
+            "pages": [],
+            "entries": [(0, exports.createHarEntry)(requestHeaders, method, protocol, host, path, requestBody, responseStatusCode, response, responseHeaders)],
+            "comment": ""
+        }
+    };
+};
+exports.createHar = createHar;
+const createHarEntry = (requestHeaders, method, protocol, host, path, requestBody, responseStatusCode, response, responseHeaders) => {
+    return {
+        // "pageref": "page_0",
+        "startedDateTime": new Date().toISOString(),
+        // "time": 50,
+        "request": (0, exports.createHarRequest)(requestHeaders, method, protocol, host, path, requestBody),
+        "response": (0, exports.createHarResponse)(responseStatusCode, response, responseHeaders),
+        "cache": {},
+        "timings": {},
+        // "serverIPAddress": "10.0.0.1",
+        // "connection": "52492",
+        "comment": ""
+    };
+};
+exports.createHarEntry = createHarEntry;
+const createHarRequest = (requestHeaders, method, protocol, host, path, requestBody) => {
+    return {
+        bodySize: -1,
+        headersSize: -1,
+        httpVersion: "HTTP/1.1",
+        cookies: [],
+        headers: createHarHeaders(requestHeaders),
+        method: method,
+        queryString: createHarQueryStrings(path),
+        url: protocol + "://" + host + path,
+        postData: createHarPostData(requestBody, createHarHeaders(requestHeaders)),
+    };
+};
+exports.createHarRequest = createHarRequest;
+const createHarResponse = (responseStatusCode, response, responseHeaders) => {
+    return {
+        "status": responseStatusCode,
+        // "statusText": "OK",
+        "httpVersion": "HTTP/1.1",
+        "cookies": [],
+        "headers": createHarHeaders(responseHeaders),
+        "content": {
+            "size": 33,
+            "compression": 0,
+            "mimeType": (responseHeaders && responseHeaders["content-type"]),
+            "text": response,
+            "comment": ""
+        },
+        // "redirectURL": "",
+        "headersSize": -1,
+        "bodySize": -1,
+        "comment": ""
+    };
+};
+exports.createHarResponse = createHarResponse;

package/dist/components/proxy-middleware/helpers/http_helpers.d.ts

@@ -0,0 +1,2 @@
+export function bodyParser(contentTypeHeader: any, buffer: any): any;
+export function getContentType(contentTypeHeader: any): any;

package/dist/components/proxy-middleware/helpers/http_helpers.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContentType = exports.bodyParser = void 0;
+const charset_1 = __importDefault(require("charset"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const bodyParser = (contentTypeHeader, buffer) => {
+    let inherentEncoding = (0, charset_1.default)(contentTypeHeader) || mime_types_1.default.charset(contentTypeHeader);
+    let str_buffer = null;
+    const isEncodingValid = (givenEncoding) => givenEncoding && Buffer.isEncoding(givenEncoding);
+    const setBufferString = (givenEncoding) => (str_buffer = buffer.toString(givenEncoding));
+    if (isEncodingValid(inherentEncoding)) {
+        setBufferString(inherentEncoding);
+    }
+    else {
+        const mostCommonEncodings = [
+            "utf8",
+            "utf16le",
+            "ascii",
+            "ucs2",
+            "base64",
+            "latin1",
+            "binary",
+            "hex",
+        ];
+        mostCommonEncodings.every((newPossibleEncoding) => {
+            if (isEncodingValid(newPossibleEncoding)) {
+                setBufferString(newPossibleEncoding);
+                return false;
+            }
+        });
+    }
+    return str_buffer;
+};
+exports.bodyParser = bodyParser;
+const getContentType = (contentTypeHeader) => {
+    if (!contentTypeHeader) {
+        return null;
+    }
+    let contentType = null;
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type
+    contentType = contentTypeHeader.split(";")[0];
+    return contentType;
+};
+exports.getContentType = getContentType;

package/dist/components/proxy-middleware/helpers/proxy_ctx_helper.d.ts

@@ -0,0 +1,14 @@
+export function get_request_url(ctx: any): string;
+export function get_original_request_headers(ctx: any): any;
+export function get_original_response_headers(ctx: any): any;
+export function is_request_preflight(ctx: any): boolean;
+export function get_response_options(ctx: any): {
+    status_code: any;
+    headers: any;
+};
+export function get_request_options(ctx: any): any;
+export function getRequestHeaders(ctx: any): any;
+export function getRequestContentTypeHeader(ctx: any): any;
+export function getResponseHeaders(ctx: any): any;
+export function getResponseContentTypeHeader(ctx: any): any;
+export function getResponseStatusCode(ctx: any): any;

package/dist/components/proxy-middleware/helpers/proxy_ctx_helper.js

@@ -0,0 +1,86 @@
+"use strict";
+// TODO: Removing this for now
+// import {
+//   extractUrlComponent,
+//   getQueryParamsMap,
+// } from "../../../../../../../common/components/utils/utils";
+// const CONSTANTS = require("../../../../../../../common/constants");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResponseStatusCode = exports.getResponseContentTypeHeader = exports.getResponseHeaders = exports.getRequestContentTypeHeader = exports.getRequestHeaders = exports.get_request_options = exports.get_response_options = exports.is_request_preflight = exports.get_original_response_headers = exports.get_original_request_headers = exports.get_request_url = void 0;
+const get_request_url = (ctx) => {
+    return ((ctx.isSSL ? "https://" : "http://") +
+        ctx.clientToProxyRequest.headers.host +
+        ctx.clientToProxyRequest.url);
+};
+exports.get_request_url = get_request_url;
+const get_original_request_headers = (ctx) => {
+    // TODO: This needs to be fetched from ctx.clientToProxy headers
+    return ctx.proxyToServerRequestOptions.headers;
+};
+exports.get_original_request_headers = get_original_request_headers;
+const get_original_response_headers = (ctx) => {
+    // TODO: This needs to be fetched from ctx.clientToProxy headers
+    return ctx.serverToProxyResponse.headers;
+};
+exports.get_original_response_headers = get_original_response_headers;
+const is_request_preflight = (ctx) => {
+    if (
+    // Request method is OPTIONS
+    ctx.clientToProxyRequest.method.toLowerCase() === "options" &&
+        // Has "origin" or "Origin" or "ORIGIN" header
+        (ctx.clientToProxyRequest.headers["Origin"] ||
+            ctx.clientToProxyRequest.headers["origin"] ||
+            ctx.clientToProxyRequest.headers["ORIGIN"]) &&
+        // Has Access-Control-Request-Method header
+        (ctx.clientToProxyRequest.headers["Access-Control-Request-Method"] ||
+            ctx.clientToProxyRequest.headers["access-control-request-method"] ||
+            ctx.clientToProxyRequest.headers["ACCESS-CONTROL-REQUEST-METHOD"]))
+        return true;
+    else
+        return false;
+};
+exports.is_request_preflight = is_request_preflight;
+const get_response_options = (ctx) => {
+    const options = {};
+    options.status_code = ctx.serverToProxyResponse.statusCode;
+    options.headers = ctx.serverToProxyResponse.headers;
+    return options;
+};
+exports.get_response_options = get_response_options;
+const get_request_options = (ctx) => {
+    return Object.assign({}, ctx.proxyToServerRequestOptions);
+};
+exports.get_request_options = get_request_options;
+// export const get_json_query_params = (ctx) => {
+//   const url = get_request_url(ctx);
+//   let queryString = extractUrlComponent(url, CONSTANTS.URL_COMPONENTS.QUERY);
+//   return getQueryParamsMap(queryString) || null;
+// };
+const getRequestHeaders = (ctx) => {
+    if (ctx && ctx.proxyToServerRequestOptions) {
+        return ctx.proxyToServerRequestOptions.headers || {};
+    }
+    return {};
+};
+exports.getRequestHeaders = getRequestHeaders;
+const getRequestContentTypeHeader = (ctx) => {
+    return (0, exports.getRequestHeaders)(ctx)["content-type"];
+};
+exports.getRequestContentTypeHeader = getRequestContentTypeHeader;
+const getResponseHeaders = (ctx) => {
+    if (ctx && ctx.serverToProxyResponse) {
+        return ctx.serverToProxyResponse.headers || {};
+    }
+    return {};
+};
+exports.getResponseHeaders = getResponseHeaders;
+const getResponseContentTypeHeader = (ctx) => {
+    return (0, exports.getResponseHeaders)(ctx)["content-type"];
+};
+exports.getResponseContentTypeHeader = getResponseContentTypeHeader;
+const getResponseStatusCode = (ctx) => {
+    if (ctx && ctx.serverToProxyResponse) {
+        return ctx.serverToProxyResponse.statusCode;
+    }
+};
+exports.getResponseStatusCode = getResponseStatusCode;

package/dist/components/proxy-middleware/helpers/response_helper.d.ts

@@ -0,0 +1,3 @@
+export function isResponseHTML(ctx: any): boolean;
+export function parseStringToDOM(string: any): Document;
+export function parseDOMToString(DOM: any): any;

package/dist/components/proxy-middleware/helpers/response_helper.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDOMToString = exports.parseStringToDOM = exports.isResponseHTML = void 0;
+const isResponseHTML = (ctx) => {
+    return (ctx.serverToProxyResponse.headers["content-type"] &&
+        ctx.serverToProxyResponse.headers["content-type"].indexOf("text/html") === 0);
+};
+exports.isResponseHTML = isResponseHTML;
+const parseStringToDOM = (string) => {
+    return new DOMParser().parseFromString(string, "text/html");
+};
+exports.parseStringToDOM = parseStringToDOM;
+const parseDOMToString = (DOM) => {
+    return DOM.documentElement.outerHTML;
+    // return new XMLSerializer().serializeToString(DOM);
+};
+exports.parseDOMToString = parseDOMToString;

package/dist/components/proxy-middleware/helpers/rule_processor_helper.d.ts

@@ -0,0 +1,17 @@
+export default RuleProcessorHelper;
+declare class RuleProcessorHelper {
+    constructor(request_data?: any, response_data?: any);
+    request_data: any;
+    response_data: any;
+    init_request_data: (request_data: any) => void;
+    init_response_data: (response_data: any) => void;
+    process_rules: (rules: any, is_response?: boolean) => any;
+    process_rule: (rule: any, is_response?: boolean) => any;
+    add_rule_details_to_action: (rule_action: any, rule: any) => any;
+    process_url_modification_rule: (rule_processor: any, rule: any) => any;
+    process_request_modification_rule: (rule_processor: any, rule: any) => any;
+    process_response_modification_rule: (rule_processor: any, rule: any) => any;
+    process_request_headers_modification_rule: (rule_processor: any, rule: any) => any;
+    process_response_headers_modification_rule: (rule_processor: any, rule: any) => any;
+    process_user_agent_modification_rule: (rule_processor: any, rule: any) => any;
+}

package/dist/components/proxy-middleware/helpers/rule_processor_helper.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const requestly_core_1 = require("@requestly/requestly-core");
+const requestly_core_2 = require("@requestly/requestly-core");
+class RuleProcessorHelper {
+    constructor(request_data = null, response_data = null) {
+        this.init_request_data = (request_data) => {
+            this.request_data = request_data;
+        };
+        this.init_response_data = (response_data) => {
+            this.response_data = response_data;
+        };
+        this.process_rules = (rules, is_response = false) => {
+            const rule_actions = rules.map((rule) => {
+                let rule_action = this.process_rule(rule, is_response);
+                return rule_action;
+            });
+            return rule_actions;
+        };
+        // Dont pass ctx here. Pass only readonly params from middleware
+        this.process_rule = (rule, is_response = false) => {
+            const rule_processor = requestly_core_1.RULE_PROCESSOR.getInstance(rule.ruleType);
+            let rule_action;
+            switch (rule.ruleType) {
+                case requestly_core_2.CONSTANTS.RULE_TYPES.REDIRECT:
+                case requestly_core_2.CONSTANTS.RULE_TYPES.REPLACE:
+                case requestly_core_2.CONSTANTS.RULE_TYPES.CANCEL:
+                case requestly_core_2.CONSTANTS.RULE_TYPES.QUERYPARAM:
+                case requestly_core_2.CONSTANTS.RULE_TYPES.SCRIPT:
+                case requestly_core_2.CONSTANTS.RULE_TYPES.DELAY:
+                    rule_action = this.process_url_modification_rule(rule_processor, rule);
+                    break;
+                case requestly_core_2.CONSTANTS.RULE_TYPES.REQUEST:
+                    rule_action = this.process_request_modification_rule(rule_processor, rule);
+                    break;
+                case requestly_core_2.CONSTANTS.RULE_TYPES.RESPONSE:
+                    rule_action = this.process_response_modification_rule(rule_processor, rule);
+                    break;
+                case requestly_core_2.CONSTANTS.RULE_TYPES.HEADERS:
+                    if (is_response) {
+                        rule_action = this.process_response_headers_modification_rule(rule_processor, rule);
+                    }
+                    else {
+                        rule_action = this.process_request_headers_modification_rule(rule_processor, rule);
+                    }
+                    break;
+                case requestly_core_2.CONSTANTS.RULE_TYPES.USERAGENT:
+                    rule_action = this.process_user_agent_modification_rule(rule_processor, rule);
+                    break;
+                default:
+                    break;
+            }
+            rule_action = this.add_rule_details_to_action(rule_action, rule);
+            return rule_action;
+        };
+        this.add_rule_details_to_action = (rule_action, rule) => {
+            if (rule_action) {
+                rule_action["rule_id"] = rule.id;
+                rule_action["rule_type"] = rule.ruleType;
+            }
+            return rule_action;
+        };
+        this.process_url_modification_rule = (rule_processor, rule) => {
+            const rule_action = rule_processor.process({
+                rule,
+                requestURL: this.request_data.request_url,
+            });
+            return rule_action;
+        };
+        this.process_request_modification_rule = (rule_processor, rule) => {
+            let requestData = {};
+            if (this.request_data.method == "POST") {
+                requestData = this.request_data.request_body;
+            }
+            else {
+                requestData = this.request_data.query_params;
+            }
+            const rule_action = rule_processor.process({
+                rule,
+                requestURL: this.request_data.request_url,
+                details: { requestData },
+            });
+            return rule_action;
+        };
+        this.process_response_modification_rule = (rule_processor, rule) => {
+            let requestData = {};
+            if (this.request_data.method == "POST") {
+                requestData = this.request_data.request_body;
+            }
+            else {
+                requestData = this.request_data.query_params;
+            }
+            const rule_action = rule_processor.process({
+                rule,
+                requestURL: this.request_data.request_url,
+                details: { requestData },
+            });
+            return rule_action;
+        };
+        this.process_request_headers_modification_rule = (rule_processor, rule) => {
+            // {"header1":"val1", "header2":"val2"}
+            const originalRequestHeadersObject = this.request_data.request_headers;
+            //  ["header1","header2"]
+            const originalRequestHeadersObjectKeys = Object.keys(originalRequestHeadersObject);
+            //  [{name:"header1", value:"val1"},{name:"header2", value:"val2"}]
+            const originalRequestHeadersObjectKeysValuePairs = originalRequestHeadersObjectKeys.map((key) => {
+                return {
+                    name: key,
+                    value: originalRequestHeadersObject[key],
+                };
+            });
+            const getRequestOrigin = () => {
+                if (originalRequestHeadersObject["Origin"])
+                    return originalRequestHeadersObject["Origin"];
+                if (originalRequestHeadersObject["origin"])
+                    return originalRequestHeadersObject["origin"];
+                if (originalRequestHeadersObject["ORIGIN"])
+                    return originalRequestHeadersObject["ORIGIN"];
+                return "*";
+            };
+            // This would return only Request headers after processing
+            const rule_action = rule_processor.process({
+                requestURL: this.request_data.request_url,
+                rule,
+                originalHeaders: originalRequestHeadersObjectKeysValuePairs,
+                typeOfHeaders: requestly_core_2.CONSTANTS.HEADERS_TARGET.REQUEST,
+                payload: {
+                    requestOrigin: getRequestOrigin(),
+                },
+            });
+            return rule_action;
+        };
+        this.process_response_headers_modification_rule = (rule_processor, rule) => {
+            // {"header1":"val1", "header2":"val2"}
+            const originalResponseHeadersObject = this.response_data.response_headers;
+            //  ["header1","header2"]
+            const originalResponseHeadersObjectKeys = Object.keys(originalResponseHeadersObject);
+            //  [{name:"header1", value:"val1"},{name:"header2", value:"val2"}]
+            const originalResponseHeadersObjectKeysValuePairs = originalResponseHeadersObjectKeys.map((key) => {
+                return {
+                    name: key,
+                    value: originalResponseHeadersObject[key],
+                };
+            });
+            const getRequestOrigin = () => {
+                // array [{ name: header_name,value: header_val }] -> {headerName1:"value1",headerName2 :"value2"}
+                const originalRequestHeadersConvertedObject = this.request_data.request_headers;
+                if (originalRequestHeadersConvertedObject["Origin"])
+                    return originalRequestHeadersConvertedObject["Origin"];
+                if (originalRequestHeadersConvertedObject["origin"])
+                    return originalRequestHeadersConvertedObject["origin"];
+                if (originalRequestHeadersConvertedObject["ORIGIN"])
+                    return originalRequestHeadersConvertedObject["ORIGIN"];
+                return "*";
+            };
+            // This would return only Request headers after processing
+            const rule_action = rule_processor.process({
+                requestURL: this.request_data.request_url,
+                rule,
+                originalHeaders: originalResponseHeadersObjectKeysValuePairs,
+                typeOfHeaders: requestly_core_2.CONSTANTS.HEADERS_TARGET.RESPONSE,
+                payload: {
+                    requestOrigin: getRequestOrigin(),
+                },
+            });
+            return rule_action;
+        };
+        this.process_user_agent_modification_rule = (rule_processor, rule) => {
+            /** REQUEST HEADERS */
+            // {"header1":"val1", "header2":"val2"}
+            const originalRequestHeadersObject = this.request_data.request_headers;
+            //  ["header1","header2"]
+            const originalRequestHeadersObjectKeys = Object.keys(originalRequestHeadersObject);
+            //  [{name:"header1", value:"val1"},{name:"header2", value:"val2"}]
+            const originalRequestHeadersObjectKeysValuePairs = originalRequestHeadersObjectKeys.map((key) => {
+                return {
+                    name: key,
+                    value: originalRequestHeadersObject[key],
+                };
+            });
+            const rule_action = rule_processor.process({
+                requestURL: this.request_data.request_url,
+                rule,
+                originalRequestHeaders: originalRequestHeadersObjectKeysValuePairs,
+            });
+            return rule_action;
+        };
+        this.request_data = request_data || {};
+        this.response_data = response_data || {};
+    }
+}
+exports.default = RuleProcessorHelper;

package/dist/components/proxy-middleware/index.d.ts

@@ -0,0 +1,25 @@
+export namespace MIDDLEWARE_TYPE {
+    const AMIUSING: string;
+    const RULES: string;
+    const LOGGER: string;
+    const SSL_CERT: string;
+}
+export default ProxyMiddlewareManager;
+declare class ProxyMiddlewareManager {
+    constructor(proxy: any, proxyConfig: any, rulesHelper: any, loggerService: any, sslConfigFetcher: any);
+    config: {};
+    proxy: any;
+    proxyConfig: any;
+    rulesHelper: any;
+    loggerService: any;
+    sslConfigFetcher: any;
+    init_config: (config?: {}) => void;
+    init: (config?: {}) => void;
+    request_handler_idx: number;
+    init_request_handler: (fn: any, is_detachable?: boolean) => number;
+    init_amiusing_handler: () => void;
+    init_ssl_cert_handler: () => void;
+    init_main_handler: () => void;
+    init_ssl_tunneling_handler: () => void;
+    init_handlers: () => void;
+}