feat: global state inside proxy and dynamic request and response rules (#46)

* feat: support for custom state inside proxy and request/response rules

* refactor: rename state interface attributes for external use

* fix: fix typos that should have been avoided when copying code from response_processor to request_processor

* refactor: reduce state drilling by creating singleton - GlobalStateProvider

* refactor:
- separate function generation and execution logic (to avoid random dataflow of sharedState as args across the code)
- rename the exposed sharedState variable

* refactor: make redundant sharedstate refs logic more readable

Author: nsrCodes

src/components/interfaces/state.ts

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

src/components/proxy-middleware/index.js

@@ -29,6 +29,7 @@ export const MIDDLEWARE_TYPE = {
   RULES: "RULES",
   LOGGER: "LOGGER",
   SSL_CERT: "SSL_CERT",
+  GLOBAL_STATE: "GLOBAL_STATE", // SEEMS UNUSUED, BUT ADDING FOR COMPLETENESS
 };
 
 class ProxyMiddlewareManager {
@@ -37,7 +38,7 @@ class ProxyMiddlewareManager {
     proxyConfig,
     rulesHelper,
     loggerService,
-    sslConfigFetcher
+    sslConfigFetcher,
   ) {
     /*
     {
@@ -59,6 +60,7 @@ class ProxyMiddlewareManager {
     // this.sslProxyingManager = new SSLProxyingManager(sslConfigFetcher);
   }
 
+  /* NOT USEFUL */
   init_config = (config = {}) => {
     Object.keys(MIDDLEWARE_TYPE).map((middleware_key) => {
       this.config[middleware_key] =

src/components/proxy-middleware/middlewares/state.d.ts

@@ -0,0 +1,17 @@
+import IInitialGlobalState from '../../interfaces/state';
+
+declare class GlobalState {
+    private state: IInitialGlobalState;
+    constructor(initialState?: IInitialGlobalState);
+
+    setSharedState(newSharedState: Record<string, any>): void;
+    getSharedStateRef(): Record<string, any>;
+    getSharedStateCopy(): Record<string, any>;
+    setVariables(newVariables: Record<string, any>): void;
+    getVariablesRef(): Record<string, any>;
+    getVariablesCopy(): Record<string, any>;
+}
+
+declare const ProxyGlobal: GlobalState;
+
+export { GlobalState as default, ProxyGlobal };

src/components/proxy-middleware/middlewares/state.ts

@@ -0,0 +1,59 @@
+import {cloneDeep} from 'lodash';
+
+interface IState extends Record<string, any> {
+    sharedState?: Record<string, any>;
+    variables?: Record<string, any>;
+}
+
+export class State {
+    private state: IState;
+    constructor(sharedState: Record<string, any>, envVars: Record<string, any>) {
+        this.state = {
+            variables: envVars,
+            sharedState,
+        };
+    }
+
+    setSharedState(newSharedState: Record<string, any>) {
+        this.state.sharedState = newSharedState;
+    }
+
+    getSharedStateRef() {
+        return this.state.sharedState;
+    }
+
+    getSharedStateCopy() {
+        return cloneDeep(this.state.sharedState);
+    }
+
+    setVariables(newVariables: Record<string, any>) {
+        this.state.variables = newVariables;
+    }
+
+    getVariablesRef() {
+        return this.state.variables;
+    }
+
+    getVariablesCopy() {
+        return cloneDeep(this.state.variables);
+    }
+}
+
+export default class GlobalStateProvider {
+    private static instance: State
+    static initInstance(sharedState: Record<string, any> = {}, envVars: Record<string, any> = {}) {
+        if (!GlobalStateProvider.instance) {
+            GlobalStateProvider.instance = new State(sharedState ?? {}, envVars ?? {});
+        }
+
+        return GlobalStateProvider.instance;
+    }
+
+    static getInstance() {
+        if (!GlobalStateProvider.instance) {
+          console.error("[GlobalStateProvider]", "Init first");
+        }
+
+        return GlobalStateProvider.instance;
+    }
+}

src/components/proxy-middleware/rule_action_processor/processors/modify_request_processor.js

@@ -5,10 +5,7 @@ import {
 } from "@requestly/requestly-core";
 import { get_request_url } from "../../helpers/proxy_ctx_helper";
 import { build_action_processor_response } from "../utils";
-import ConsoleCapture from "capture-console-logs";
-import { getFunctionFromString } from "../../../../utils";
-
-const { types } = require("util");
+import { executeUserFunction, getFunctionFromString } from "../../../../utils";
 
 const process_modify_request_action = (action, ctx) => {
   const allowed_handlers = [PROXY_HANDLER_TYPE.ON_REQUEST_END];
@@ -76,24 +73,7 @@ const modify_request_using_code = async (action, ctx) => {
       /*Do nothing -- could not parse body as JSON */
     }
 
-    const consoleCapture = new ConsoleCapture()
-    consoleCapture.start(true)
-
-    finalRequest = userFunction(args);
-
-    if (types.isPromise(finalRequest)) {
-      finalRequest = await 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 = await executeUserFunction(ctx, userFunction, args)
 
     if (finalRequest && typeof finalRequest === "string") {
       return modify_request(ctx, finalRequest);

src/components/proxy-middleware/rule_action_processor/processors/modify_response_processor.js

@@ -7,12 +7,9 @@ import { getResponseContentTypeHeader, getResponseHeaders, get_request_url } fro
 import { build_action_processor_response, build_post_process_data } from "../utils";
 import fs from "fs";
 import { getContentType, parseJsonBody } from "../../helpers/http_helpers";
-import ConsoleCapture from "capture-console-logs";
-import { getFunctionFromString } from "../../../../utils";
+import { executeUserFunction, getFunctionFromString } from "../../../../utils";
 import { RQ_INTERCEPTED_CONTENT_TYPES } from "../../constants";
 
-const { types } = require("util");
-
 const process_modify_response_action = async (action, ctx) => {
   const allowed_handlers = [PROXY_HANDLER_TYPE.ON_REQUEST,PROXY_HANDLER_TYPE.ON_RESPONSE_END, PROXY_HANDLER_TYPE.ON_ERROR];
 
@@ -144,23 +141,7 @@ const modify_response_using_code = async (action, ctx) => {
       /*Do nothing -- could not parse body as JSON */
     }
 
-    const consoleCapture = new ConsoleCapture()
-    consoleCapture.start(true)
-
-    finalResponse = userFunction(args);
-
-    if (types.isPromise(finalResponse)) {
-      finalResponse = await finalResponse;
-    }
-
-    consoleCapture.stop()
-    const consoleLogs = consoleCapture.getCaptures()
-    
-    ctx.rq.consoleLogs.push(...consoleLogs)
-
-    if (typeof finalResponse === "object") {
-      finalResponse = JSON.stringify(finalResponse);
-    }
+    finalResponse = await executeUserFunction(ctx, action.response, args)
 
     if (finalResponse && typeof finalResponse === "string") {
       return modify_response(ctx, finalResponse, action.statusCode);

src/rq-proxy-provider.ts

@@ -1,14 +1,15 @@
 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";
 
 class RQProxyProvider {
     static rqProxyInstance:any = null;
 
     // TODO: rulesDataSource can be static here
-    static createInstance = (proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService) => {
-        RQProxyProvider.rqProxyInstance = new RQProxy(proxyConfig, rulesDataSource, loggerService);
+    static createInstance = (proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService, initialGlobalState?: IInitialState) => {
+        RQProxyProvider.rqProxyInstance = new RQProxy(proxyConfig, rulesDataSource, loggerService, initialGlobalState);
     }
 
     static getInstance = (): RQProxy => {

src/rq-proxy.ts

@@ -4,6 +4,8 @@ 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 GlobalStateProvider, {State} from "./components/proxy-middleware/middlewares/state";
 
 
 class RQProxy {
@@ -12,12 +14,19 @@ class RQProxy {
 
     rulesHelper: RulesHelper;
     loggerService: ILoggerService;
+    globalState: State;
 
-    constructor(proxyConfig: ProxyConfig, rulesDataSource: IRulesDataSource, loggerService: ILoggerService) {
+    constructor(
+        proxyConfig: ProxyConfig, 
+        rulesDataSource: IRulesDataSource, 
+        loggerService: ILoggerService,
+        initialGlobalState?: IInitialState
+    ) {
         this.initProxy(proxyConfig);
 
         this.rulesHelper = new RulesHelper(rulesDataSource);
         this.loggerService = loggerService;
+        this.globalState = GlobalStateProvider.initInstance(initialGlobalState?.sharedState ?? {}, initialGlobalState?.variables ?? {});
     }
 
     initProxy = (proxyConfig: ProxyConfig) => {

src/utils/index.ts

@@ -1,3 +1,54 @@
+import { types } from "util";
+import ConsoleCapture from "capture-console-logs";
+import GlobalStateProvider from "../components/proxy-middleware/middlewares/state";
+
+// Only used for verification now. For execution, we regenerate the function in executeUserFunction with the sharedState
 export const getFunctionFromString = function (functionStringEscaped) {
-    return new Function("return " + functionStringEscaped)();
+    return new Function(`return ${functionStringEscaped}`)();
 };
+
+
+/* Expects that the functionString has already been validated to be representing a proper function */
+export async function executeUserFunction(ctx, functionString: string, args) {
+
+    const generateFunctionWithSharedState = function (functionStringEscaped) {
+
+		const SHARED_STATE_VAR_NAME = "$sharedState";
+		
+		const sharedState = GlobalStateProvider.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 ConsoleCapture()
+    consoleCapture.start(true)
+
+    let finalResponse = generatedFunction(args);
+
+    if (types.isPromise(finalResponse)) {
+      finalResponse = await 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.
+     */
+    GlobalStateProvider.getInstance().setSharedState(updatedSharedState);
+
+    if (typeof finalResponse === "object") {
+        finalResponse = JSON.stringify(finalResponse);
+      }
+
+    return finalResponse;
+}