[ENGG-1696] MV3: support for rq_request_initiator_origin() predefined function

app/src/modules/extension/ruleParser/parseHeadersRule.ts

@@ -3,41 +3,53 @@ import { ExtensionRule, ExtensionRuleAction, HeadersRuleOperation, ModifyHeaderI
 import { parseConditionFromSource } from "./utils";
 
 const parseHeaders = (headers: HeadersRuleModificationData[]): ModifyHeaderInfo[] => {
-  return headers.map((header) => {
-    if (header.type === HeaderRuleActionType.REMOVE) {
-      return {
-        header: header.header,
-        operation: "remove" as HeadersRuleOperation,
-      };
-    } else {
-      return {
-        header: header.header,
-        value: header.value,
-        operation: "set" as HeadersRuleOperation,
-      };
-    }
-  });
+  return headers
+    .map((header) => {
+      if (header.value === "rq_request_initiator_origin()") {
+        return null;
+      }
+
+      if (header.type === HeaderRuleActionType.REMOVE) {
+        return {
+          header: header.header,
+          operation: "remove" as HeadersRuleOperation,
+        };
+      } else {
+        return {
+          header: header.header,
+          value: header.value,
+          operation: "set" as HeadersRuleOperation,
+        };
+      }
+    })
+    .filter(Boolean);
 };
 
 const parseHeadersRule = (rule: HeadersRule): ExtensionRule[] => {
-  return rule.pairs.map(
-    (rulePair): ExtensionRule => {
-      const condition = parseConditionFromSource(rulePair.source);
-      const action: ExtensionRuleAction = {
-        type: RuleActionType.MODIFY_HEADERS,
-      };
-
-      if (rulePair.modifications?.Request?.length) {
-        action.requestHeaders = parseHeaders(rulePair.modifications?.Request);
-      }
+  return rule.pairs
+    .map(
+      (rulePair): ExtensionRule => {
+        const condition = parseConditionFromSource(rulePair.source);
+        const action: ExtensionRuleAction = {
+          type: RuleActionType.MODIFY_HEADERS,
+        };
 
-      if (rulePair.modifications?.Response?.length) {
-        action.responseHeaders = parseHeaders(rulePair.modifications?.Response);
-      }
+        if (rulePair.modifications?.Request?.length) {
+          action.requestHeaders = parseHeaders(rulePair.modifications?.Request);
+        }
+
+        if (rulePair.modifications?.Response?.length) {
+          action.responseHeaders = parseHeaders(rulePair.modifications?.Response);
+        }
 
-      return { action, condition };
-    }
-  );
+        if (!(action.requestHeaders?.length || action.responseHeaders?.length)) {
+          return null;
+        }
+
+        return { action, condition };
+      }
+    )
+    .filter(Boolean);
 };
 
 export default parseHeadersRule;

browser-extension/mv3/src/service-worker/services/requestProcessor/handleInitiatorDomainFunction.ts

@@ -0,0 +1,83 @@
+import { Rule } from "common/types";
+import { findMatchingRule } from "../ruleMatcher";
+import { updateRequestSpecificRules } from "../rulesManager";
+import { AJAXRequestDetails, SessionRuleType } from "./types";
+
+const INITIATOR_DOMAIN_FUNCTION = "rq_request_initiator_origin()";
+
+export const handleInitiatorDomainFunction = async (
+  tabId: number,
+  requestDetails: AJAXRequestDetails,
+  rules: Rule[]
+) => {
+  const { isApplied, matchedPair } = findMatchingRule(rules, requestDetails) ?? {};
+
+  if (!isApplied) {
+    return;
+  }
+
+  const headerKeyValueMap: Record<"Response" | "Request", Record<string, string>> = {
+    Request: {},
+    Response: {},
+  };
+
+  if (matchedPair.modifications?.Request?.length) {
+    matchedPair.modifications.Request.forEach((header: { header: string; type: string; value: string }) => {
+      if (header.value === INITIATOR_DOMAIN_FUNCTION) {
+        headerKeyValueMap.Request[header.header] = requestDetails.initiatorDomain;
+      }
+    });
+  }
+
+  if (matchedPair.modifications?.Response?.length) {
+    matchedPair.modifications.Response.forEach((header: { header: string; type: string; value: string }) => {
+      if (header.value === INITIATOR_DOMAIN_FUNCTION) {
+        headerKeyValueMap.Response[header.header] = requestDetails.initiatorDomain;
+      }
+    });
+  }
+
+  const ruleAction: {
+    requestHeaders?: chrome.declarativeNetRequest.RuleAction["requestHeaders"];
+    responseHeaders?: chrome.declarativeNetRequest.RuleAction["responseHeaders"];
+  } = {};
+
+  if (Object.keys(headerKeyValueMap.Request).length) {
+    ruleAction.requestHeaders = Object.entries(headerKeyValueMap.Request).map(([header, value]) => ({
+      header,
+      value,
+      operation: chrome.declarativeNetRequest.HeaderOperation.SET,
+    }));
+  }
+
+  if (Object.keys(headerKeyValueMap.Response).length) {
+    ruleAction.responseHeaders = Object.entries(headerKeyValueMap.Response).map(([header, value]) => ({
+      header,
+      value,
+      operation: chrome.declarativeNetRequest.HeaderOperation.SET,
+    }));
+  }
+
+  if (!Object.keys(ruleAction).length) {
+    return;
+  }
+
+  await updateRequestSpecificRules(
+    tabId,
+    requestDetails.url,
+    {
+      action: {
+        ...ruleAction,
+        type: chrome.declarativeNetRequest.RuleActionType.MODIFY_HEADERS,
+      },
+      condition: {
+        urlFilter: `|${requestDetails.url}|`,
+        resourceTypes: [chrome.declarativeNetRequest.ResourceType.XMLHTTPREQUEST],
+        tabIds: [tabId],
+        requestMethods: [requestDetails.method.toLowerCase() as chrome.declarativeNetRequest.RequestMethod],
+        excludedInitiatorDomains: ["requestly.io", "requestly.com"],
+      },
+    },
+    SessionRuleType.INITIATOR_DOMAIN
+  );
+};

browser-extension/mv3/src/service-worker/services/requestProcessor/index.ts

@@ -2,16 +2,19 @@ import { getEnabledRules, onRuleOrGroupChange } from "common/rulesStore";
 import { Rule, RuleType } from "common/types";
 import { AJAXRequestDetails } from "./types";
 import { forwardHeadersOnRedirect } from "./handleHeadersOnRedirect";
+import { handleInitiatorDomainFunction } from "./handleInitiatorDomainFunction";
 
 class RequestProcessor {
   cachedRules: Record<string, Rule[]> = {
     redirectRules: [],
     replaceRules: [],
+    headerRules: [],
   };
 
   private updateCachedRules = async () => {
     this.cachedRules.redirectRules = await getEnabledRules(RuleType.REDIRECT);
     this.cachedRules.replaceRules = await getEnabledRules(RuleType.REPLACE);
+    this.cachedRules.headerRules = await getEnabledRules(RuleType.HEADERS);
   };
 
   constructor() {
@@ -28,6 +31,8 @@ class RequestProcessor {
       ...requestProcessor.cachedRules.redirectRules,
       ...requestProcessor.cachedRules.replaceRules,
     ]);
+
+    await handleInitiatorDomainFunction(tabId, requestDetails, requestProcessor.cachedRules.headerRules);
   };
 }
 

browser-extension/mv3/src/service-worker/services/requestProcessor/types.ts

@@ -8,4 +8,5 @@ export interface AJAXRequestDetails {
 
 export enum SessionRuleType {
   FORWARD_IGNORED_HEADERS = "forwardIgnoredHeaders",
+  INITIATOR_DOMAIN = "initiatorDomain",
 }

browser-extension/mv3/src/service-worker/services/ruleMatcher.ts

@@ -124,7 +124,9 @@ export const matchRuleWithRequest = function (rule: Rule, requestDetails: AJAXRe
   );
 
   if (!matchedPair) {
-    return null;
+    return {
+      isApplied: false,
+    };
   }
 
   const destinationUrl = populateRedirectedUrl(matchedPair, rule.ruleType, requestDetails);
@@ -203,7 +205,7 @@ export const populateRedirectedUrl = (rulePair: RulePair, ruleType: RuleType, re
 export const findMatchingRule = (rules: Rule[], requestDetails: AJAXRequestDetails) => {
   for (const rule of rules) {
     const matchedRule = matchRuleWithRequest(rule, requestDetails);
-    if (matchedRule) {
+    if (matchedRule.isApplied) {
       return matchedRule;
     }
   }