@requestly/requestly-proxy 1.2.3 → 1.3.0

package/dist/components/interfaces/state.d.ts

@@ -0,0 +1,4 @@
+export default interface IInitialState extends Record<string, any> {
+    sharedState?: Record<string, any>;
+    variables?: Record<string, any>;
+}

package/dist/components/interfaces/state.js

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

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

@@ -3,6 +3,7 @@ export namespace MIDDLEWARE_TYPE {
     const RULES: string;
     const LOGGER: string;
     const SSL_CERT: string;
+    const GLOBAL_STATE: string;
 }
 export default ProxyMiddlewareManager;
 declare class ProxyMiddlewareManager {

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

@@ -33,9 +33,11 @@ exports.MIDDLEWARE_TYPE = {
     RULES: "RULES",
     LOGGER: "LOGGER",
     SSL_CERT: "SSL_CERT",
+    GLOBAL_STATE: "GLOBAL_STATE", // SEEMS UNUSUED, BUT ADDING FOR COMPLETENESS
 };
 class ProxyMiddlewareManager {
     constructor(proxy, proxyConfig, rulesHelper, loggerService, sslConfigFetcher) {
+        /* NOT USEFUL */
         this.init_config = (config = {}) => {
             Object.keys(exports.MIDDLEWARE_TYPE).map((middleware_key) => {
                 this.config[middleware_key] =

package/dist/components/proxy-middleware/middlewares/state.d.ts

@@ -0,0 +1,15 @@
+export declare class State {
+    private state;
+    constructor(sharedState: Record<string, any>, envVars: Record<string, any>);
+    setSharedState(newSharedState: Record<string, any>): void;
+    getSharedStateRef(): Record<string, any>;
+    getSharedStateCopy(): any;
+    setVariables(newVariables: Record<string, any>): void;
+    getVariablesRef(): Record<string, any>;
+    getVariablesCopy(): any;
+}
+export default class GlobalStateProvider {
+    private static instance;
+    static initInstance(sharedState?: Record<string, any>, envVars?: Record<string, any>): State;
+    static getInstance(): State;
+}

package/dist/components/proxy-middleware/middlewares/state.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+const lodash_1 = require("lodash");
+class State {
+    constructor(sharedState, envVars) {
+        this.state = {
+            variables: envVars,
+            sharedState,
+        };
+    }
+    setSharedState(newSharedState) {
+        this.state.sharedState = newSharedState;
+    }
+    getSharedStateRef() {
+        return this.state.sharedState;
+    }
+    getSharedStateCopy() {
+        return (0, lodash_1.cloneDeep)(this.state.sharedState);
+    }
+    setVariables(newVariables) {
+        this.state.variables = newVariables;
+    }
+    getVariablesRef() {
+        return this.state.variables;
+    }
+    getVariablesCopy() {
+        return (0, lodash_1.cloneDeep)(this.state.variables);
+    }
+}
+exports.State = State;
+class GlobalStateProvider {
+    static initInstance(sharedState = {}, envVars = {}) {
+        if (!GlobalStateProvider.instance) {
+            GlobalStateProvider.instance = new State(sharedState !== null && sharedState !== void 0 ? sharedState : {}, envVars !== null && envVars !== void 0 ? envVars : {});
+        }
+        return GlobalStateProvider.instance;
+    }
+    static getInstance() {
+        if (!GlobalStateProvider.instance) {
+            console.error("[GlobalStateProvider]", "Init first");
+        }
+        return GlobalStateProvider.instance;
+    }
+}
+exports.default = GlobalStateProvider;

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

@@ -8,17 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 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 capture_console_logs_1 = __importDefault(require("capture-console-logs"));
 const utils_2 = 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)) {
@@ -72,19 +67,7 @@ const modify_request_using_code = (action, ctx) => __awaiter(void 0, void 0, voi
         catch (_a) {
             /*Do nothing -- could not parse body as JSON */
         }
-        const consoleCapture = new capture_console_logs_1.default();
-        consoleCapture.start(true);
-        finalRequest = userFunction(args);
-        if (types.isPromise(finalRequest)) {
-            finalRequest = yield finalRequest;
-        }
-        consoleCapture.stop();
-        const consoleLogs = consoleCapture.getCaptures();
-        ctx.rq.consoleLogs.push(...consoleLogs);
-        const isRequestJSON = !!args.bodyAsJson;
-        if (typeof finalRequest === "object" && isRequestJSON) {
-            finalRequest = JSON.stringify(finalRequest);
-        }
+        finalRequest = yield (0, utils_2.executeUserFunction)(ctx, userFunction, args);
         if (finalRequest && typeof finalRequest === "string") {
             return modify_request(ctx, finalRequest);
         }

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

@@ -18,10 +18,8 @@ const proxy_ctx_helper_1 = require("../../helpers/proxy_ctx_helper");
 const utils_1 = require("../utils");
 const fs_1 = __importDefault(require("fs"));
 const http_helpers_1 = require("../../helpers/http_helpers");
-const capture_console_logs_1 = __importDefault(require("capture-console-logs"));
 const utils_2 = require("../../../../utils");
 const constants_1 = require("../../constants");
-const { types } = require("util");
 const process_modify_response_action = (action, ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const allowed_handlers = [proxy_1.PROXY_HANDLER_TYPE.ON_REQUEST, proxy_1.PROXY_HANDLER_TYPE.ON_RESPONSE_END, proxy_1.PROXY_HANDLER_TYPE.ON_ERROR];
     if (!allowed_handlers.includes(ctx.currentHandler)) {
@@ -125,18 +123,7 @@ const modify_response_using_code = (action, ctx) => __awaiter(void 0, void 0, vo
         catch (_f) {
             /*Do nothing -- could not parse body as JSON */
         }
-        const consoleCapture = new capture_console_logs_1.default();
-        consoleCapture.start(true);
-        finalResponse = userFunction(args);
-        if (types.isPromise(finalResponse)) {
-            finalResponse = yield finalResponse;
-        }
-        consoleCapture.stop();
-        const consoleLogs = consoleCapture.getCaptures();
-        ctx.rq.consoleLogs.push(...consoleLogs);
-        if (typeof finalResponse === "object") {
-            finalResponse = JSON.stringify(finalResponse);
-        }
+        finalResponse = yield (0, utils_2.executeUserFunction)(ctx, action.response, args);
         if (finalResponse && typeof finalResponse === "string") {
             return modify_response(ctx, finalResponse, action.statusCode);
         }

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

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

package/dist/rq-proxy-provider.js

@@ -8,8 +8,8 @@ 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.createInstance = (proxyConfig, rulesDataSource, loggerService, initialGlobalState) => {
+    RQProxyProvider.rqProxyInstance = new rq_proxy_1.default(proxyConfig, rulesDataSource, loggerService, initialGlobalState);
 };
 RQProxyProvider.getInstance = () => {
     if (!RQProxyProvider.rqProxyInstance) {

package/dist/rq-proxy.d.ts

@@ -3,12 +3,15 @@ import { ProxyConfig } from "./types";
 import RulesHelper from "./utils/helpers/rules-helper";
 import ProxyMiddlewareManager from "./components/proxy-middleware";
 import ILoggerService from "./components/interfaces/logger-service";
+import IInitialState from "./components/interfaces/state";
+import { State } from "./components/proxy-middleware/middlewares/state";
 declare class RQProxy {
     proxy: any;
     proxyMiddlewareManager: ProxyMiddlewareManager;
     rulesHelper: RulesHelper;
     loggerService: ILoggerService;
-    constructor(proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService);
+    globalState: State;
+    constructor(proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService, initialGlobalState?: IInitialState);
     initProxy: (proxyConfig: ProxyConfig) => void;
     doSomething: () => void;
 }

package/dist/rq-proxy.js

@@ -6,8 +6,10 @@ 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"));
+const state_1 = __importDefault(require("./components/proxy-middleware/middlewares/state"));
 class RQProxy {
-    constructor(proxyConfig, rulesDataSource, loggerService) {
+    constructor(proxyConfig, rulesDataSource, loggerService, initialGlobalState) {
+        var _a, _b;
         this.initProxy = (proxyConfig) => {
             console.log("initProxy");
             console.log(proxyConfig);
@@ -51,6 +53,7 @@ class RQProxy {
         this.initProxy(proxyConfig);
         this.rulesHelper = new rules_helper_1.default(rulesDataSource);
         this.loggerService = loggerService;
+        this.globalState = state_1.default.initInstance((_a = initialGlobalState === null || initialGlobalState === void 0 ? void 0 : initialGlobalState.sharedState) !== null && _a !== void 0 ? _a : {}, (_b = initialGlobalState === null || initialGlobalState === void 0 ? void 0 : initialGlobalState.variables) !== null && _b !== void 0 ? _b : {});
     }
 }
 exports.default = RQProxy;

package/dist/utils/index.d.ts

@@ -1 +1,2 @@
 export declare const getFunctionFromString: (functionStringEscaped: any) => any;
+export declare function executeUserFunction(ctx: any, functionString: string, args: any): Promise<any>;

package/dist/utils/index.js

@@ -1,7 +1,57 @@
 "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 });
-exports.getFunctionFromString = void 0;
+exports.executeUserFunction = exports.getFunctionFromString = void 0;
+const util_1 = require("util");
+const capture_console_logs_1 = __importDefault(require("capture-console-logs"));
+const state_1 = __importDefault(require("../components/proxy-middleware/middlewares/state"));
+// Only used for verification now. For execution, we regenerate the function in executeUserFunction with the sharedState
 const getFunctionFromString = function (functionStringEscaped) {
-    return new Function("return " + functionStringEscaped)();
+    return new Function(`return ${functionStringEscaped}`)();
 };
 exports.getFunctionFromString = getFunctionFromString;
+/* Expects that the functionString has already been validated to be representing a proper function */
+function executeUserFunction(ctx, functionString, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const generateFunctionWithSharedState = function (functionStringEscaped) {
+            const SHARED_STATE_VAR_NAME = "$sharedState";
+            const sharedState = state_1.default.getInstance().getSharedStateCopy();
+            return new Function(`${SHARED_STATE_VAR_NAME}`, `return { func: ${functionStringEscaped}, updatedSharedState: ${SHARED_STATE_VAR_NAME}}`)(sharedState);
+        };
+        const { func: generatedFunction, updatedSharedState } = generateFunctionWithSharedState(functionString);
+        const consoleCapture = new capture_console_logs_1.default();
+        consoleCapture.start(true);
+        let finalResponse = generatedFunction(args);
+        if (util_1.types.isPromise(finalResponse)) {
+            finalResponse = yield finalResponse;
+        }
+        consoleCapture.stop();
+        const consoleLogs = consoleCapture.getCaptures();
+        ctx.rq.consoleLogs.push(...consoleLogs);
+        /**
+         * If we use GlobalState.getSharedStateRef instead of GlobalState.getSharedStateCopy
+         * then this update is completely unnecessary.
+         * Because then the function gets a reference to the global states,
+         * and any changes made inside the userFunction will directly be reflected there.
+         *
+         * But we are using it here to make the data flow obvious as we read this code.
+         */
+        state_1.default.getInstance().setSharedState(updatedSharedState);
+        if (typeof finalResponse === "object") {
+            finalResponse = JSON.stringify(finalResponse);
+        }
+        return finalResponse;
+    });
+}
+exports.executeUserFunction = executeUserFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@requestly/requestly-proxy",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Proxy that gives superpowers to all the Requestly clients",
   "main": "dist/index.js",
   "scripts": {