@requestly/requestly-proxy 1.0.0

package/dist/components/proxy-middleware/rule_action_processor/handle_mixed_response.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios = require("axios");
+const parser = require("ua-parser-js");
+const Sentry = __importStar(require("@sentry/browser"));
+const handleMixedResponse = (ctx, destinationUrl) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    // Handling mixed response from safari
+    let user_agent_str = null;
+    user_agent_str = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.clientToProxyRequest) === null || _a === void 0 ? void 0 : _a.headers["user-agent"];
+    const user_agent = (_c = (_b = parser(user_agent_str)) === null || _b === void 0 ? void 0 : _b.browser) === null || _c === void 0 ? void 0 : _c.name;
+    const LOCAL_DOMAINS = ["localhost", "127.0.0.1"];
+    if (ctx.isSSL && destinationUrl.includes("http:")) {
+        if (user_agent === "Safari" ||
+            !LOCAL_DOMAINS.some((domain) => destinationUrl.includes(domain))) {
+            try {
+                const resp = yield axios.get(destinationUrl, {
+                    headers: {
+                        "Cache-Control": "no-cache",
+                    },
+                });
+                return {
+                    status: true,
+                    response_data: {
+                        headers: { "Cache-Control": "no-cache" },
+                        status_code: 200,
+                        body: resp.data,
+                    },
+                };
+            }
+            catch (e) {
+                Sentry.captureException(e);
+                return {
+                    status: true,
+                    response_data: {
+                        headers: { "Cache-Control": "no-cache" },
+                        status_code: 502,
+                        body: e.response ? e.response.data : null,
+                    },
+                };
+            }
+        }
+    }
+    return { status: false };
+});
+exports.default = handleMixedResponse;

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

@@ -0,0 +1,13 @@
+export default RuleActionProcessor;
+declare class RuleActionProcessor {
+    process_actions: (rule_actions: any, ctx: any) => Promise<{
+        action_result_objs: any[];
+        continue_request: boolean;
+    }>;
+    post_process_actions: (action_result_objs: any, ctx: any) => boolean;
+    process_action: (rule_action: any, ctx: any) => Promise<{
+        action: any;
+        success: boolean;
+        post_process_data: any;
+    }>;
+}

package/dist/components/proxy-middleware/rule_action_processor/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const redirect_processor_1 = __importDefault(require("./processors/redirect_processor"));
+const modify_header_processor_1 = __importDefault(require("./processors/modify_header_processor"));
+const modify_user_agent_processor_1 = __importDefault(require("./processors/modify_user_agent_processor"));
+const delay_processor_1 = __importDefault(require("./processors/delay_processor"));
+const block_processor_1 = __importDefault(require("./processors/block_processor"));
+const modify_response_processor_1 = __importDefault(require("./processors/modify_response_processor"));
+const modify_request_processor_1 = __importDefault(require("./processors/modify_request_processor"));
+const insert_processor_1 = __importDefault(require("./processors/insert_processor"));
+const utils_1 = require("./utils");
+class RuleActionProcessor {
+    constructor() {
+        /*
+        @return: Whether to continue with the proxy callback. & of all the continue_request from actions
+        */
+        this.process_actions = (rule_actions, ctx) => __awaiter(this, void 0, void 0, function* () {
+            /*
+              action_result_objs = [{action: {}, result: {}}}]
+            */
+            const action_result_objs = yield Promise.all(rule_actions.map((action) => __awaiter(this, void 0, void 0, function* () {
+                let action_result_obj = yield this.process_action(action, ctx);
+                return action_result_obj;
+            })));
+            let continue_request = true;
+            continue_request = this.post_process_actions(action_result_objs, ctx);
+            return { action_result_objs, continue_request };
+        });
+        this.post_process_actions = (action_result_objs, ctx) => {
+            let continue_request = true;
+            action_result_objs.forEach((action_result) => {
+                if (!continue_request)
+                    return; // Already finished the request
+                if (!action_result.post_process_data)
+                    return; // No post processing
+                const status_code = action_result.post_process_data.status_code || 200;
+                const headers = action_result.post_process_data.headers || {};
+                const body = action_result.post_process_data.body || null;
+                // console.log("Log", ctx.rq.original_request);
+                ctx.proxyToClientResponse.writeHead(status_code, headers).end(body);
+                ctx.rq.set_final_response({
+                    status_code: status_code,
+                    headers: headers,
+                    body: body,
+                });
+                continue_request = false;
+            });
+            return continue_request;
+        };
+        /*
+        @return: Whether to continue with the proxy callback
+        */
+        this.process_action = (rule_action, ctx) => __awaiter(this, void 0, void 0, function* () {
+            let action_result = (0, utils_1.build_action_processor_response)(rule_action, false);
+            if (!rule_action) {
+                return action_result;
+            }
+            switch (rule_action.action) {
+                case constants_1.RULE_ACTION.REDIRECT:
+                    action_result = (0, redirect_processor_1.default)(rule_action, ctx);
+                    break;
+                case constants_1.RULE_ACTION.MODIFY_HEADERS:
+                    action_result = (0, modify_header_processor_1.default)(rule_action, ctx);
+                    break;
+                case constants_1.RULE_ACTION.MODIFY_USER_AGENT:
+                    action_result = (0, modify_user_agent_processor_1.default)(rule_action, ctx);
+                case constants_1.RULE_ACTION.DELAY:
+                    action_result = yield (0, delay_processor_1.default)(rule_action, ctx);
+                    break;
+                case constants_1.RULE_ACTION.BLOCK:
+                    action_result = (0, block_processor_1.default)(rule_action, ctx);
+                    break;
+                case constants_1.RULE_ACTION.MODIFY_REQUEST:
+                    action_result = (0, modify_request_processor_1.default)(rule_action, ctx);
+                    break;
+                case constants_1.RULE_ACTION.MODIFY_RESPONSE:
+                    action_result = (0, modify_response_processor_1.default)(rule_action, ctx);
+                    break;
+                case constants_1.RULE_ACTION.INSERT:
+                    action_result = (0, insert_processor_1.default)(rule_action, ctx);
+                default:
+                    break;
+            }
+            return action_result;
+        });
+    }
+}
+exports.default = RuleActionProcessor;

package/dist/components/proxy-middleware/rule_action_processor/modified_requests_pool.d.ts

@@ -0,0 +1,7 @@
+export default modifiedRequestsPool;
+declare const modifiedRequestsPool: ModifiedRequestsPool;
+declare class ModifiedRequestsPool {
+    queue: any;
+    add(url: any): void;
+    isURLModified(url: any): boolean;
+}

package/dist/components/proxy-middleware/rule_action_processor/modified_requests_pool.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const circularQueue_1 = __importDefault(require("../../../utils/circularQueue"));
+class ModifiedRequestsPool {
+    constructor() {
+        this.queue = new circularQueue_1.default(100);
+    }
+    add(url) {
+        url = url.replace(/www\./g, "");
+        this.queue.enQueue(url);
+        //    logger.log(this.queue);
+    }
+    isURLModified(url) {
+        if (!url)
+            return false;
+        // logger.log("Current Url : ", url);
+        // logger.log(JSON.stringify(this.queue), "Looper");
+        let tempUrl = url;
+        if (url.endsWith("/")) {
+            tempUrl = tempUrl.slice(0, tempUrl.length - 1);
+        }
+        else {
+            tempUrl = tempUrl + "/";
+        }
+        // logger.log(tempUrl);
+        return (this.queue.getElementIndex(url) >= 0 ||
+            this.queue.getElementIndex(tempUrl) >= 0);
+    }
+}
+const modifiedRequestsPool = new ModifiedRequestsPool();
+exports.default = modifiedRequestsPool;

package/dist/components/proxy-middleware/rule_action_processor/processors/block_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_block_action;
+declare function process_block_action(action: any, ctx: any): Promise<{
+    action: any;
+    success: boolean;
+    post_process_data: any;
+}>;

package/dist/components/proxy-middleware/rule_action_processor/processors/block_processor.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = require("../../../../lib/proxy");
+const utils_1 = require("../utils");
+const process_block_action = (action, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    return (0, utils_1.build_action_processor_response)(action, true, (0, utils_1.build_post_process_data)(418 /** Move this to temporarily out of coffee (503) if causes issues in someone production use case. // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/418 */, { "Cache-Control": "no-cache" }, "Access to this URL has been blocked by Requestly"));
+});
+exports.default = process_block_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/delay_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_delay_action;
+declare function process_delay_action(action: any, ctx: any): Promise<{
+    action: any;
+    success: boolean;
+    post_process_data: any;
+}>;

package/dist/components/proxy-middleware/rule_action_processor/processors/delay_processor.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = require("../../../../lib/proxy");
+const utils_1 = require("../utils");
+const resolveAfterDelay = (durationInMs) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve("resolved");
+        }, durationInMs);
+    });
+});
+const process_delay_action = (action, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    yield resolveAfterDelay(action.delay);
+    return (0, utils_1.build_action_processor_response)(action, true);
+});
+exports.default = process_delay_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/insert_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_insert_action;
+declare function process_insert_action(action: any, ctx: any): {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+};

package/dist/components/proxy-middleware/rule_action_processor/processors/insert_processor.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = require("../../../../lib/proxy");
+const requestly_core_1 = require("@requestly/requestly-core");
+const response_helper_1 = require("../../helpers/response_helper");
+const utils_1 = require("../utils");
+const process_insert_action = (action, ctx) => {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_RESPONSE_END];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    const success = insert_scripts(ctx, action);
+    return (0, utils_1.build_action_processor_response)(action, success);
+};
+const modify_response = (ctx, new_resp) => {
+    ctx.rq_response_body = new_resp;
+};
+const insert_scripts = (ctx, action) => {
+    if ((0, response_helper_1.isResponseHTML)(ctx)) {
+        const fullResponseBodyString = ctx.rq_response_body;
+        // Double check to ensure content is HTML
+        if (/<\/?[a-z][\s\S]*>/i.test(fullResponseBodyString)) {
+            // Parse Response body (string) to DOM
+            let incomingDOM = (0, response_helper_1.parseStringToDOM)(fullResponseBodyString);
+            // Modify DOM to inject scripts
+            handleCSSScripts(action.data.cssScripts, incomingDOM);
+            handleJSLibraries(action.data.libraries, incomingDOM);
+            handleJSScripts(action.data.jsScripts, incomingDOM);
+            // Parse back DOM to String to forward client as response body
+            const final_response_body = (0, response_helper_1.parseDOMToString)(incomingDOM);
+            modify_response(ctx, final_response_body);
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Handles all CSS Scripts
+ */
+const handleCSSScripts = (cssScripts, incomingDOM) => {
+    cssScripts.forEach((script) => {
+        includeCSS(script, incomingDOM);
+    });
+};
+/**
+ * Prepares to inject a CSS Scripts
+ * @returns {string} HTML Content
+ */
+const includeCSS = (script, incomingDOM) => {
+    if (script.type === requestly_core_1.CONSTANTS.SCRIPT_TYPES.URL) {
+        addRemoteCSS(script.value, incomingDOM);
+    }
+    else if (script.type === requestly_core_1.CONSTANTS.SCRIPT_TYPES.CODE) {
+        embedCSS(script.value, incomingDOM);
+    }
+};
+const addRemoteCSS = (src, incomingDOM) => {
+    var link = incomingDOM.createElement("link");
+    link.href = src;
+    link.type = "text/css";
+    link.rel = "stylesheet";
+    link.className = getScriptClassAttribute();
+    (incomingDOM.head || incomingDOM.documentElement).appendChild(link);
+};
+const getScriptClassAttribute = () => {
+    return requestly_core_1.CONSTANTS.PUBLIC_NAMESPACE + "SCRIPT";
+};
+const embedCSS = (css, incomingDOM) => {
+    var style = incomingDOM.createElement("style");
+    style.type = "text/css";
+    style.appendChild(incomingDOM.createTextNode(css));
+    style.className = getScriptClassAttribute();
+    (incomingDOM.head || incomingDOM.documentElement).appendChild(style);
+};
+const handleJSLibraries = (libraries, incomingDOM) => {
+    addLibraries(libraries, null, incomingDOM);
+};
+const addLibraries = (libraries, indexArg, incomingDOM) => {
+    var index = indexArg || 0;
+    if (index >= libraries.length) {
+        return;
+    }
+    var libraryKey = libraries[index];
+    var library = requestly_core_1.CONSTANTS.SCRIPT_LIBRARIES[libraryKey];
+    var addNextLibraries = () => {
+        addLibraries(libraries, index + 1, incomingDOM);
+    };
+    if (library) {
+        addRemoteJS(library.src, addNextLibraries, incomingDOM);
+    }
+    else {
+        addNextLibraries();
+    }
+};
+const addRemoteJS = (src, callback, incomingDOM) => {
+    var script = incomingDOM.createElement("script");
+    // NOT WORKING
+    // if (typeof callback === "function") {
+    // script.onload = callback
+    // }
+    script.type = "text/javascript";
+    script.src = src;
+    script.className = getScriptClassAttribute();
+    (incomingDOM.head || incomingDOM.documentElement).appendChild(script);
+    // HOTFIX
+    callback();
+};
+const handleJSScripts = (jsScripts, incomingDOM) => {
+    var prePageLoadScripts = [];
+    var postPageLoadScripts = [];
+    jsScripts.forEach((script) => {
+        if (script.loadTime === requestly_core_1.CONSTANTS.SCRIPT_LOAD_TIME.BEFORE_PAGE_LOAD) {
+            prePageLoadScripts.push(script);
+        }
+        else {
+            postPageLoadScripts.push(script);
+        }
+    });
+    includeJSScriptsInOrder(prePageLoadScripts, () => {
+        includeJSScriptsInOrder(postPageLoadScripts, null, null, incomingDOM);
+    }, null, incomingDOM);
+};
+const includeJSScriptsInOrder = (scripts, callback, indexArg, incomingDOM) => {
+    var index = indexArg || 0;
+    if (index >= scripts.length) {
+        typeof callback === "function" && callback();
+        return;
+    }
+    includeJS(scripts[index], () => {
+        includeJSScriptsInOrder(scripts, callback, index + 1, incomingDOM);
+    }, incomingDOM);
+};
+const includeJS = (script, callback, incomingDOM) => {
+    if (script.type === requestly_core_1.CONSTANTS.SCRIPT_TYPES.URL) {
+        addRemoteJS(script.value, callback, incomingDOM);
+        return;
+    }
+    if (script.type === requestly_core_1.CONSTANTS.SCRIPT_TYPES.CODE) {
+        executeJS(script.value, null, incomingDOM);
+    }
+    typeof callback === "function" && callback();
+};
+const executeJS = (code, shouldRemove, incomingDOM) => {
+    const script = incomingDOM.createElement("script");
+    script.type = "text/javascript";
+    script.className = getScriptClassAttribute();
+    script.appendChild(incomingDOM.createTextNode(code));
+    const parent = incomingDOM.head || incomingDOM.documentElement;
+    parent.appendChild(script);
+    if (shouldRemove) {
+        parent.removeChild(script);
+    }
+};
+exports.default = process_insert_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_header_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_modify_header_action;
+declare function process_modify_header_action(action: any, ctx: any): {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+};

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_header_processor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = require("../../../../lib/proxy");
+const proxy_ctx_helper_1 = require("../../helpers/proxy_ctx_helper");
+const utils_1 = require("../utils");
+const process_modify_header_action = (action, ctx) => {
+    const allowed_handlers = [
+        proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST,
+        proxy_1.PROXY_HANDLER_TYPE.ON_RESPONSE,
+    ];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    if (ctx.currentHandler == proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST) {
+        modify_request_headers(action, ctx);
+    }
+    else if (ctx.currentHandler == proxy_1.PROXY_HANDLER_TYPE.ON_RESPONSE) {
+        modify_response_headers(action, ctx);
+    }
+    return (0, utils_1.build_action_processor_response)(action, true);
+};
+const modify_request_headers = (action, ctx) => {
+    const newRequestHeaders = action.newHeaders;
+    for (var headerName in ctx.proxyToServerRequestOptions.headers) {
+        if (ctx.proxyToServerRequestOptions.headers.hasOwnProperty(headerName)) {
+            delete ctx.proxyToServerRequestOptions.headers[headerName];
+        }
+    }
+    // Set Request Headers
+    newRequestHeaders.forEach((pair) => (ctx.proxyToServerRequestOptions.headers[pair.name] = pair.value));
+};
+const modify_response_headers = (action, ctx) => {
+    // {"header1":"val1", "header2":"val2"}
+    const originalResponseHeadersObject = ctx.serverToProxyResponse.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 requestURL = (0, proxy_ctx_helper_1.get_request_url)(ctx);
+    const getRequestOrigin = () => {
+        // array [{ name: header_name,value: header_val }] -> {headerName1:"value1",headerName2 :"value2"}
+        const originalRequestHeadersConvertedObject = Object.assign({}, ...originalRequestHeaders.map((header) => ({
+            [header.name]: header.value,
+        })));
+        if (originalRequestHeadersConvertedObject["Origin"])
+            return originalRequestHeadersConvertedObject["Origin"];
+        if (originalRequestHeadersConvertedObject["origin"])
+            return originalRequestHeadersConvertedObject["origin"];
+        if (originalRequestHeadersConvertedObject["ORIGIN"])
+            return originalRequestHeadersConvertedObject["ORIGIN"];
+        return "*";
+    };
+    const { newHeaders: newResponseHeaders } = action;
+    // Set Response headers
+    // Clear all existing Response headers (to handle "remove header" case)
+    for (var headerName in ctx.serverToProxyResponse.headers) {
+        if (ctx.serverToProxyResponse.headers.hasOwnProperty(headerName)) {
+            delete ctx.serverToProxyResponse.headers[headerName];
+        }
+    }
+    // Set new values
+    newResponseHeaders.forEach((pair) => (ctx.serverToProxyResponse.headers[pair.name] = pair.value));
+};
+exports.default = process_modify_header_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_request_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_modify_request_action;
+declare function process_modify_request_action(action: any, ctx: any): {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+};

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_request_processor.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = require("../../../../lib/proxy");
+const requestly_core_1 = require("@requestly/requestly-core");
+const proxy_ctx_helper_1 = require("../../helpers/proxy_ctx_helper");
+const utils_1 = require("../utils");
+const { types } = require("util");
+const process_modify_request_action = (action, ctx) => {
+    const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST_END];
+    if (!allowed_handlers.includes(ctx.currentHandler)) {
+        return (0, utils_1.build_action_processor_response)(action, false);
+    }
+    if (action.requestType &&
+        action.requestType === requestly_core_1.CONSTANTS.REQUEST_BODY_TYPES.CODE) {
+        modify_request_using_code(action, ctx);
+        return (0, utils_1.build_action_processor_response)(action, true);
+    }
+    else {
+        modify_request(ctx, action.request);
+        return (0, utils_1.build_action_processor_response)(action, true);
+    }
+};
+const modify_request = (ctx, new_req) => {
+    if (new_req)
+        ctx.rq_request_body = new_req;
+};
+const modify_request_using_code = (action, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    let userFunction = null;
+    try {
+        userFunction = requestly_core_1.UTILS.GET_FUNCTION_FROM_STRING(action.request);
+    }
+    catch (error) {
+        // User has provided an invalid function
+        return modify_request(ctx, "Can't parse Requestly function. Please recheck. Error Code 7201. Actual Error: " +
+            error.message);
+    }
+    if (!userFunction || typeof userFunction !== "function") {
+        // User has provided an invalid function
+        return modify_request(ctx, "Can't parse Requestly function. Please recheck. Error Code 944.");
+    }
+    // Everything good so far. Now try to execute user's function
+    let finalRequest = null;
+    try {
+        const args = {
+            method: ctx.clientToProxyRequest
+                ? ctx.clientToProxyRequest.method
+                    ? ctx.clientToProxyRequest.method
+                    : null
+                : null,
+            request: ctx.rq_request_body,
+            url: (0, proxy_ctx_helper_1.get_request_url)(ctx),
+            requestHeaders: ctx.clientToProxyRequest.headers,
+        };
+        try {
+            args.requestJSON = JSON.parse(args.request);
+        }
+        catch (_a) {
+            /*Do nothing -- could not parse body as JSON */
+        }
+        finalRequest = userFunction(args);
+        if (types.isPromise(finalRequest)) {
+            finalRequest = yield finalRequest;
+        }
+        const isRequestJSON = !!args.requestJSON;
+        if (typeof finalRequest === "object" && isRequestJSON) {
+            finalRequest = JSON.stringify(finalRequest);
+        }
+        if (finalRequest && typeof finalRequest === "string") {
+            return modify_request(ctx, finalRequest);
+        }
+        else
+            throw new Error("Returned value is not a string");
+    }
+    catch (error) {
+        // Function parsed but failed to execute
+        return modify_request(ctx, "Can't execute Requestly function. Please recheck. Error Code 187. Actual Error: " +
+            error.message);
+    }
+});
+exports.default = process_modify_request_action;

package/dist/components/proxy-middleware/rule_action_processor/processors/modify_response_processor.d.ts

@@ -0,0 +1,6 @@
+export default process_modify_response_action;
+declare function process_modify_response_action(action: any, ctx: any): {
+    action: any;
+    success: boolean;
+    post_process_data: any;
+};