@requestly/requestly-proxy 1.0.0

package/dist/rq-proxy-provider.d.ts

@@ -0,0 +1,10 @@
+import RQProxy from "./rq-proxy";
+import ILoggerService from "./components/interfaces/logger-service";
+import IRulesDataSource from "./components/interfaces/rules-data-source";
+import { ProxyConfig } from "./types";
+declare class RQProxyProvider {
+    static rqProxyInstance: any;
+    static createInstance: (proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService) => void;
+    static getInstance: () => RQProxy;
+}
+export default RQProxyProvider;

package/dist/rq-proxy-provider.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rq_proxy_1 = __importDefault(require("./rq-proxy"));
+class RQProxyProvider {
+}
+RQProxyProvider.rqProxyInstance = null;
+// TODO: rulesDataSource can be static here
+RQProxyProvider.createInstance = (proxyConfig, rulesDataSource, loggerService) => {
+    RQProxyProvider.rqProxyInstance = new rq_proxy_1.default(proxyConfig, rulesDataSource, loggerService);
+};
+RQProxyProvider.getInstance = () => {
+    if (!RQProxyProvider.rqProxyInstance) {
+        console.error("Instance need to be created first");
+    }
+    return RQProxyProvider.rqProxyInstance;
+};
+exports.default = RQProxyProvider;

package/dist/rq-proxy.d.ts

@@ -0,0 +1,15 @@
+import IRulesDataSource from "./components/interfaces/rules-data-source";
+import { ProxyConfig } from "./types";
+import RulesHelper from "./utils/helpers/rules-helper";
+import ProxyMiddlewareManager from "./components/proxy-middleware";
+import ILoggerService from "./components/interfaces/logger-service";
+declare class RQProxy {
+    proxy: any;
+    proxyMiddlewareManager: ProxyMiddlewareManager;
+    rulesHelper: RulesHelper;
+    loggerService: ILoggerService;
+    constructor(proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService);
+    initProxy: (proxyConfig: ProxyConfig) => void;
+    doSomething: () => void;
+}
+export default RQProxy;

package/dist/rq-proxy.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const proxy_1 = __importDefault(require("./lib/proxy"));
+const rules_helper_1 = __importDefault(require("./utils/helpers/rules-helper"));
+const proxy_middleware_1 = __importDefault(require("./components/proxy-middleware"));
+class RQProxy {
+    constructor(proxyConfig, rulesDataSource, loggerService) {
+        this.initProxy = (proxyConfig) => {
+            console.log("initProxy");
+            console.log(proxyConfig);
+            // @ts-ignore
+            this.proxy = new proxy_1.default();
+            // console.log(this.proxy);
+            this.proxy.listen({
+                port: proxyConfig.port,
+                sslCaDir: proxyConfig.certPath,
+                host: "0.0.0.0",
+            }, (err) => {
+                console.log("Proxy Listen");
+                if (err) {
+                    console.log(err);
+                }
+                else {
+                    console.log("Proxy Started");
+                    this.proxyMiddlewareManager = new proxy_middleware_1.default(this.proxy, proxyConfig, this.rulesHelper, this.loggerService, null);
+                    this.proxyMiddlewareManager.init();
+                }
+            });
+            // For Testing //
+            this.proxy.onRequest(function (ctx, callback) {
+                if (ctx.clientToProxyRequest.headers.host == 'example.com') {
+                    ctx.use(proxy_1.default.gunzip);
+                    ctx.onResponseData(function (ctx, chunk, callback) {
+                        chunk = new Buffer("<h1>Hello There</h1>");
+                        return callback(null, chunk);
+                    });
+                }
+                return callback();
+            });
+            //
+        };
+        this.doSomething = () => {
+            console.log("do something");
+        };
+        this.initProxy(proxyConfig);
+        this.rulesHelper = new rules_helper_1.default(rulesDataSource);
+        this.loggerService = loggerService;
+    }
+}
+exports.default = RQProxy;

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,111 @@
+"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 axios_1 = __importDefault(require("axios"));
+const rq_proxy_provider_1 = __importDefault(require("./rq-proxy-provider"));
+console.log("start");
+const proxyConfig = {
+    port: 8281,
+    // @ts-ignore
+    certPath: "/Users/sahilgupta/Library/Application\\ Support/Electron/.requestly-certs-temp",
+    // TODO: MOVE THIS IN RQ PROXY
+    rootCertPath: "/Users/sahilgupta/Library/Application\\ Support/Electron/.requestly-certs-temp/certs/ca.pem"
+};
+class RulesDataSource {
+    constructor() {
+        this.getRules = (requestHeaders) => __awaiter(this, void 0, void 0, function* () {
+            return [
+                {
+                    "creationDate": 1648800254537,
+                    "description": "",
+                    "groupId": "",
+                    "id": "Headers_br050",
+                    "isSample": false,
+                    "name": "Test Header Rule",
+                    "objectType": "rule",
+                    "pairs": [
+                        {
+                            "header": "abc",
+                            "value": "abc value",
+                            "type": "Add",
+                            "target": "Request",
+                            "source": {
+                                "filters": {},
+                                "key": "Url",
+                                "operator": "Contains",
+                                "value": "example"
+                            },
+                            "id": "lussg"
+                        },
+                        {
+                            "header": "abc",
+                            "value": "bac value",
+                            "type": "Add",
+                            "target": "Response",
+                            "source": {
+                                "filters": {},
+                                "key": "Url",
+                                "operator": "Contains",
+                                "value": "example"
+                            },
+                            "id": "be1k6"
+                        }
+                    ],
+                    "ruleType": "Headers",
+                    "status": "Active",
+                    "createdBy": "9cxfwgyBXKQxj9lU14GiTO5KTNY2",
+                    "currentOwner": "9cxfwgyBXKQxj9lU14GiTO5KTNY2",
+                    "lastModifiedBy": "9cxfwgyBXKQxj9lU14GiTO5KTNY2",
+                    "modificationDate": 1648800283699,
+                    "lastModified": 1648800283699
+                }
+            ];
+        });
+        this.getGroups = (requestHeaders) => __awaiter(this, void 0, void 0, function* () {
+            return [
+                {
+                    id: "1",
+                    status: "Inactive"
+                }
+            ];
+        });
+    }
+}
+class LoggerService {
+    constructor() {
+        this.addLog = (log, requestHeaders) => {
+            console.log(JSON.stringify(log, null, 4));
+            const headers = {
+                "device_id": "test_device",
+                "sdk_id": "7jcFc1g5j7ozfSXe7lc6",
+            };
+            // TODO: Keeping this as Strong for now to avoid changes in UI
+            log.finalHar = JSON.stringify(log.finalHar);
+            (0, axios_1.default)({
+                method: "post",
+                url: "http://localhost:5001/requestly-dev/us-central1/addSdkLog",
+                headers,
+                data: log
+            }).then(() => {
+                console.log("Successfully added log");
+            }).catch(error => {
+                console.log(`Could not add Log`);
+            });
+        };
+    }
+}
+// RQProxyProvider.getInstance().doSomething();
+rq_proxy_provider_1.default.createInstance(proxyConfig, new RulesDataSource(), new LoggerService());
+rq_proxy_provider_1.default.getInstance().doSomething();
+console.log("end");

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export interface ProxyConfig {
+    port: Number;
+    certPath: String;
+    rootCertPath: String;
+}
+export interface Rule {
+    id: string;
+}
+export interface RuleGroup {
+    id: String;
+    status: String;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/circularQueue.d.ts

@@ -0,0 +1,2 @@
+declare const Queue: any;
+export default Queue;

package/dist/utils/circularQueue.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Queue = function (maxSize) {
+    this.reset = function () {
+        this.head = -1;
+        this.queue = [];
+    };
+    this.reset();
+    this.maxSize = maxSize || Queue.MAX_SIZE;
+    this.increment = function (number) {
+        return (number + 1) % this.maxSize;
+    };
+};
+Queue.MAX_SIZE = Math.pow(2, 53) - 1;
+Queue.prototype.enQueue = function (record) {
+    this.head = this.increment(this.head);
+    this.queue[this.head] = record;
+};
+/**
+ * @param record Record to look for
+ * @returns Number Position of record in the queue otherwise -1
+ */
+Queue.prototype.getElementIndex = function (record) {
+    return this.queue.indexOf(record);
+};
+Queue.prototype.print = function () {
+    for (var i = 0; i <= this.head; i++) {
+        console.log(this.queue[i]);
+    }
+};
+exports.default = Queue;

package/dist/utils/helpers/rules-helper.d.ts

@@ -0,0 +1,11 @@
+import IRulesDataSource from "../../components/interfaces/rules-data-source";
+declare class RulesHelper {
+    rulesDataSource: IRulesDataSource;
+    constructor(rulesDataSource: IRulesDataSource);
+    is_group_active: (group: any) => boolean;
+    is_rule_active: (rule: any, active_group_ids?: any[]) => boolean;
+    get_groups: (is_active?: boolean, requestHeaders?: {}) => Promise<import("../../types").RuleGroup[]>;
+    get_group_ids: (is_active?: boolean, requestHeaders?: {}) => Promise<String[]>;
+    get_rules: (is_active?: boolean, requestHeaders?: {}) => Promise<import("../../types").Rule[]>;
+}
+export default RulesHelper;

package/dist/utils/helpers/rules-helper.js

@@ -0,0 +1,59 @@
+"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 });
+class RulesHelper {
+    // TODO: this can be static class too
+    constructor(rulesDataSource) {
+        this.is_group_active = (group) => {
+            if (!group) {
+                return false;
+            }
+            return group.status == "Active";
+        };
+        this.is_rule_active = (rule, active_group_ids = []) => {
+            if (!rule) {
+                return false;
+            }
+            let status = false;
+            status = rule.status == "Active";
+            // No group case || active group case
+            if (rule.groupId == "" || active_group_ids.includes(rule.groupId)) {
+                return status;
+            }
+            return false;
+        };
+        this.get_groups = (is_active = false, requestHeaders = {}) => __awaiter(this, void 0, void 0, function* () {
+            let groups = (yield this.rulesDataSource.getGroups(requestHeaders)) || [];
+            if (is_active === true) {
+                groups = groups.filter((group) => this.is_group_active(group));
+            }
+            return groups;
+        });
+        this.get_group_ids = (is_active = false, requestHeaders = {}) => __awaiter(this, void 0, void 0, function* () {
+            const groups = yield this.get_groups(is_active, requestHeaders);
+            return groups.map((group) => group.id);
+        });
+        this.get_rules = (is_active = false, requestHeaders = {}) => __awaiter(this, void 0, void 0, function* () {
+            let rules = (yield this.rulesDataSource.getRules(requestHeaders)) || [];
+            let active_group_ids = (yield this.get_group_ids(true, requestHeaders)) || [];
+            if (is_active === true) {
+                rules = rules.filter((rule) => this.is_rule_active(rule, active_group_ids));
+            }
+            // Sorting Rules By id asc
+            rules = rules.sort((rule1, rule2) => {
+                return ("" + rule1.id).localeCompare(rule2.id);
+            });
+            return rules;
+        });
+        this.rulesDataSource = rulesDataSource;
+    }
+}
+exports.default = RulesHelper;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@requestly/requestly-proxy",
+  "version": "1.0.0",
+  "description": "Proxy that gives superpowers to all the Requestly clients",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "nodemon src/test.ts",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/requestly/rq-proxy.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@requestly/requestly-core": "^1.0.0",
+    "@sentry/browser": "^6.19.2",
+    "async": "^3.2.1",
+    "axios": "^0.26.1",
+    "charset": "^1.0.1",
+    "debug": "^4.3.2",
+    "httpsnippet": "^2.0.0",
+    "lodash": "^4.17.21",
+    "mime-types": "^2.1.35",
+    "mkdirp": "^0.5.5",
+    "node-forge": "^1.3.0",
+    "semaphore": "^1.1.0",
+    "ua-parser-js": "^1.0.2",
+    "url": "^0.11.0",
+    "uuid": "^8.3.2",
+    "ws": "^8.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^17.0.23",
+    "nodemon": "^2.0.15",
+    "typescript": "^4.6.3"
+  },
+  "files": [
+    "dist"
+  ]
+}