chore: merge hoppscotch/main into hoppscotch/release/2023.12.0

packages/hoppscotch-common/src/services/__tests__/interceptor.service.spec.ts

@@ -72,6 +72,61 @@ describe("InterceptorService", () => {
     expect(service.currentInterceptorID.value).not.toEqual("unknown")
   })
 
+  it("currentInterceptor points to the instance of the currently selected interceptor", () => {
+    const container = new TestContainer()
+
+    const service = container.bind(InterceptorService)
+
+    const interceptor = {
+      interceptorID: "test",
+      name: () => "test interceptor",
+      selectable: { type: "selectable" as const },
+      runRequest: () => {
+        throw new Error("not implemented")
+      },
+    }
+
+    service.registerInterceptor(interceptor)
+    service.currentInterceptorID.value = "test"
+
+    expect(service.currentInterceptor.value).toBe(interceptor)
+  })
+
+  it("currentInterceptor updates when the currentInterceptorID changes", () => {
+    const container = new TestContainer()
+
+    const service = container.bind(InterceptorService)
+
+    const interceptor = {
+      interceptorID: "test",
+      name: () => "test interceptor",
+      selectable: { type: "selectable" as const },
+      runRequest: () => {
+        throw new Error("not implemented")
+      },
+    }
+
+    const interceptor_2 = {
+      interceptorID: "test2",
+      name: () => "test interceptor",
+      selectable: { type: "selectable" as const },
+      runRequest: () => {
+        throw new Error("not implemented")
+      },
+    }
+
+    service.registerInterceptor(interceptor)
+    service.registerInterceptor(interceptor_2)
+
+    service.currentInterceptorID.value = "test"
+
+    expect(service.currentInterceptor.value).toBe(interceptor)
+
+    service.currentInterceptorID.value = "test2"
+    expect(service.currentInterceptor.value).not.toBe(interceptor)
+    expect(service.currentInterceptor.value).toBe(interceptor_2)
+  })
+
   describe("registerInterceptor", () => {
     it("should register the interceptor", () => {
       const container = new TestContainer()

packages/hoppscotch-common/src/services/cookie-jar.service.ts

@@ -0,0 +1,69 @@
+import { Service } from "dioc"
+import { ref } from "vue"
+import { parseString as setCookieParse } from "set-cookie-parser-es"
+
+export type CookieDef = {
+  name: string
+  value: string
+  domain: string
+  path: string
+  expires: string
+}
+
+export class CookieJarService extends Service {
+  public static readonly ID = "COOKIE_JAR_SERVICE"
+
+  /**
+   * The cookie jar that stores all relevant cookie info.
+   * The keys correspond to the domain of the cookie.
+   * The cookie strings are stored as an array of strings corresponding to the domain
+   */
+  public cookieJar = ref(new Map<string, string[]>())
+
+  constructor() {
+    super()
+  }
+
+  public parseSetCookieString(setCookieString: string) {
+    return setCookieParse(setCookieString)
+  }
+
+  public bulkApplyCookiesToDomain(cookies: string[], domain: string) {
+    const existingDomainEntries = this.cookieJar.value.get(domain) ?? []
+    existingDomainEntries.push(...cookies)
+
+    this.cookieJar.value.set(domain, existingDomainEntries)
+  }
+
+  public getCookiesForURL(url: URL) {
+    const relevantDomains = Array.from(this.cookieJar.value.keys()).filter(
+      (domain) => url.hostname.endsWith(domain)
+    )
+
+    return relevantDomains
+      .flatMap((domain) => {
+        // Assemble the list of cookie entries from all the relevant domains
+
+        const cookieStrings = this.cookieJar.value.get(domain)! // We know not nullable from how we filter above
+
+        return cookieStrings.map((cookieString) =>
+          this.parseSetCookieString(cookieString)
+        )
+      })
+      .filter((cookie) => {
+        // Perform the required checks on the cookies
+
+        const passesPathCheck = url.pathname.startsWith(cookie.path ?? "/")
+
+        const passesExpiresCheck = !cookie.expires
+          ? true
+          : cookie.expires.getTime() >= new Date().getTime()
+
+        const passesSecureCheck = !cookie.secure
+          ? true
+          : url.protocol === "https:"
+
+        return passesPathCheck && passesExpiresCheck && passesSecureCheck
+      })
+  }
+}

packages/hoppscotch-common/src/services/inspection/inspectors/__tests__/header.inspector.spec.ts

@@ -4,6 +4,7 @@ import { HeaderInspectorService } from "../header.inspector"
 import { InspectionService } from "../../index"
 import { getDefaultRESTRequest } from "~/helpers/rest/default"
 import { ref } from "vue"
+import { InterceptorService } from "~/services/interceptor.service"
 
 vi.mock("~/modules/i18n", () => ({
   __esModule: true,
@@ -58,5 +59,48 @@ describe("HeaderInspectorService", () => {
 
       expect(result.value).toHaveLength(0)
     })
+
+    it("should return an empty array when headers contain cookies but interceptor supports cookies", () => {
+      const container = new TestContainer()
+
+      container.bindMock(InterceptorService, {
+        currentInterceptor: ref({ supportsCookies: true }) as any,
+      })
+
+      const headerInspector = container.bind(HeaderInspectorService)
+
+      const req = ref({
+        ...getDefaultRESTRequest(),
+        endpoint: "http://example.com/api/data",
+        headers: [{ key: "Cookie", value: "some-cookie", active: true }],
+      })
+
+      const result = headerInspector.getInspections(req)
+
+      expect(result.value).toHaveLength(0)
+    })
+
+    it("should return an inspector result when headers contain cookies and the current interceptor doesn't support cookies", () => {
+      const container = new TestContainer()
+
+      container.bindMock(InterceptorService, {
+        currentInterceptor: ref({ supportsCookies: false }) as any,
+      })
+
+      const headerInspector = container.bind(HeaderInspectorService)
+
+      const req = ref({
+        ...getDefaultRESTRequest(),
+        endpoint: "http://example.com/api/data",
+        headers: [{ key: "Cookie", value: "some-cookie", active: true }],
+      })
+
+      const result = headerInspector.getInspections(req)
+
+      expect(result.value).not.toHaveLength(0)
+      expect(result.value).toContainEqual(
+        expect.objectContaining({ id: "header", isApplicable: true })
+      )
+    })
   })
 })

packages/hoppscotch-common/src/services/inspection/inspectors/header.inspector.ts

@@ -4,6 +4,7 @@ import { getI18n } from "~/modules/i18n"
 import { HoppRESTRequest } from "@hoppscotch/data"
 import { Ref, computed, markRaw } from "vue"
 import IconAlertTriangle from "~icons/lucide/alert-triangle"
+import { InterceptorService } from "~/services/interceptor.service"
 
 /**
  * This inspector is responsible for inspecting the header of a request.
@@ -19,6 +20,7 @@ export class HeaderInspectorService extends Service implements Inspector {
   public readonly inspectorID = "header"
 
   private readonly inspection = this.bind(InspectionService)
+  private readonly interceptorService = this.bind(InterceptorService)
 
   constructor() {
     super()
@@ -42,7 +44,10 @@ export class HeaderInspectorService extends Service implements Inspector {
 
       const isContainCookies = headerKeys.includes("Cookie")
 
-      if (isContainCookies) {
+      if (
+        isContainCookies &&
+        !this.interceptorService.currentInterceptor.value?.supportsCookies
+      ) {
         headerKeys.forEach((headerKey, index) => {
           if (this.cookiesCheck(headerKey)) {
             results.push({

packages/hoppscotch-common/src/services/interceptor.service.ts

@@ -29,6 +29,7 @@ export type InterceptorError =
         description: (t: ReturnType<typeof getI18n>) => string
       }
       error?: unknown
+      component?: Component
     }
 
 /**
@@ -85,6 +86,12 @@ export type Interceptor<Err extends InterceptorError = InterceptorError> = {
    */
   name: (t: ReturnType<typeof getI18n>) => MaybeRef<string>
 
+  /**
+   * Defines whether the interceptor has support for cookies.
+   * If this field is undefined, it is assumed as not supporting cookies.
+   */
+  supportsCookies?: boolean
+
   /**
    * Defines what to render in the Interceptor section of the Settings page.
    * Use this space to define interceptor specific settings.
@@ -161,6 +168,16 @@ export class InterceptorService extends Service {
     Array.from(this.interceptors.values())
   )
 
+  /**
+   * Gives an instance to the current interceptor.
+   *  NOTE: Do not update from here, this is only for reading.
+   */
+  public currentInterceptor = computed(() => {
+    if (this.currentInterceptorID.value === null) return null
+
+    return this.interceptors.get(this.currentInterceptorID.value)
+  })
+
   constructor() {
     super()