@mswjs/interceptors 0.41.9 → 0.42.0

package/src/interceptors/XMLHttpRequest/node.ts

@@ -0,0 +1,104 @@
+import { requestContext } from '#/src/request-context'
+import { hasConfigurableGlobal } from '#/src/utils/has-configurable-global'
+import { Interceptor } from '#/src/interceptor'
+import { forwardHttpEvents } from '#/src/interceptors/http/forward-events'
+import { NodeHttpRequestSource } from '#/src/interceptors/http/source'
+import { patchesRegistry } from '#/src/utils/patches-registry'
+import { FetchRequest } from '#/src/utils/fetch-utils'
+import { HttpRequestEventMap } from '#/src/events/http'
+import { createLogger } from '#/src/utils/logger'
+
+const logger = createLogger('xhr')
+
+export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol = Symbol.for('xhr-interceptor')
+
+  protected predicate() {
+    return hasConfigurableGlobal('XMLHttpRequest')
+  }
+
+  protected setup(): void {
+    const requestSource = Interceptor.singleton(NodeHttpRequestSource)
+    requestSource.apply(this)
+    this.subscriptions.push(() => {
+      requestSource.dispose(this)
+    })
+
+    this.subscriptions.push(
+      forwardHttpEvents({
+        source: requestSource,
+        emitter: this.emitter,
+        predicate: (initiator) => {
+          return initiator instanceof XMLHttpRequest
+        },
+      })
+    )
+
+    logger.verbose('patching global "XMLHttpRequest"...')
+
+    const prepareRequest = this.#transformRequest.bind(this)
+    const requestLogger = this.logger
+
+    this.subscriptions.push(
+      patchesRegistry.applyPatch(
+        globalThis,
+        'XMLHttpRequest',
+        (realXMLHttpRequest) => {
+          return new Proxy(realXMLHttpRequest, {
+            construct(target, args, newTarget) {
+              const xmlHttpRequest = Reflect.construct(target, args, newTarget)
+
+              /**
+               * @note Scope the request context to the `send()` call.
+               * XHR in JSDOM is implemented via `http`/`https`, and the
+               * underlying `http.ClientRequest` is created within `send()`,
+               * so the initiator cascading keeps working. Binding the
+               * context to the caller's scope instead (e.g. `enterWith`)
+               * would attribute unrelated requests performed after this
+               * XMLHttpRequest to it.
+               */
+              const realSend = xmlHttpRequest.send
+              xmlHttpRequest.send = (
+                ...sendArgs: Parameters<XMLHttpRequest['send']>
+              ) => {
+                return requestContext.run(
+                  {
+                    initiator: xmlHttpRequest,
+                    logger: requestLogger,
+                    transformRequest: (request) => {
+                      return prepareRequest(request, xmlHttpRequest)
+                    },
+                  },
+                  () => realSend.apply(xmlHttpRequest, sendArgs)
+                )
+              }
+
+              return xmlHttpRequest
+            },
+          })
+        }
+      )
+    )
+
+    logger.verbose('global "XMLHttpRequest" patched!')
+  }
+
+  #transformRequest(request: Request, initiator: XMLHttpRequest): Request {
+    const expectedCredentials = initiator.withCredentials
+      ? 'include'
+      : 'same-origin'
+
+    if (request.credentials === expectedCredentials) {
+      return request
+    }
+
+    return new FetchRequest(request.url, {
+      ...request,
+      method: request.method,
+      headers: request.headers,
+      credentials: expectedCredentials,
+      body: request.body,
+      signal: request.signal,
+    })
+  }
+}

package/src/interceptors/XMLHttpRequest/polyfills/{ProgressEventPolyfill.ts → progress-event-polyfill.ts}

@@ -1,4 +1,4 @@
-import { EventPolyfill } from './EventPolyfill'
+import { EventPolyfill } from './event-polyfill'
 
 export class ProgressEventPolyfill extends EventPolyfill {
   readonly lengthComputable: boolean

package/src/interceptors/XMLHttpRequest/utils/{concateArrayBuffer.test.ts → concat-array-buffer.test.ts}

@@ -1,5 +1,4 @@
-import { it, expect } from 'vitest'
-import { concatArrayBuffer } from './concatArrayBuffer'
+import { concatArrayBuffer } from './concat-array-buffer'
 
 const encoder = new TextEncoder()
 

package/src/interceptors/XMLHttpRequest/utils/{concatArrayBuffer.ts → concat-array-buffer.ts}

@@ -4,7 +4,7 @@
 export function concatArrayBuffer(
   left: Uint8Array,
   right: Uint8Array
-): Uint8Array {
+) {
   const result = new Uint8Array(left.byteLength + right.byteLength)
   result.set(left, 0)
   result.set(right, left.byteLength)

package/src/interceptors/XMLHttpRequest/utils/{createEvent.test.ts → create-event.test.ts}

@@ -1,7 +1,6 @@
-// @vitest-environment jsdom
-import { it, expect } from 'vitest'
-import { createEvent } from './createEvent'
-import { EventPolyfill } from '../polyfills/EventPolyfill'
+// @vitest-environment happy-dom
+import { createEvent } from './create-event'
+import { EventPolyfill } from '../polyfills/event-polyfill'
 
 const request = new XMLHttpRequest()
 request.open('POST', '/user')

package/src/interceptors/XMLHttpRequest/utils/{createEvent.ts → create-event.ts}

@@ -1,5 +1,5 @@
-import { EventPolyfill } from '../polyfills/EventPolyfill'
-import { ProgressEventPolyfill } from '../polyfills/ProgressEventPolyfill'
+import { EventPolyfill } from '../polyfills/event-polyfill'
+import { ProgressEventPolyfill } from '../polyfills/progress-event-polyfill'
 
 const SUPPORTS_PROGRESS_EVENT = typeof ProgressEvent !== 'undefined'
 

package/src/interceptors/XMLHttpRequest/utils/{createResponse.ts → create-response.ts}

@@ -1,4 +1,4 @@
-import { FetchResponse } from '../../../utils/fetchUtils'
+import { FetchResponse } from '../../../utils/fetch-utils'
 
 /**
  * Creates a Fetch API `Response` instance from the given

package/src/interceptors/XMLHttpRequest/utils/{getBodyByteLength.test.ts → get-body-byte-length.test.ts}

@@ -1,6 +1,5 @@
 // @vitest-environment node
-import { it, expect } from 'vitest'
-import { getBodyByteLength } from './getBodyByteLength'
+import { getBodyByteLength } from './get-body-byte-length'
 
 const url = 'http://localhost'
 

package/src/interceptors/XMLHttpRequest/web.ts

@@ -0,0 +1,34 @@
+import { HttpRequestEventMap } from '../../events/http'
+import { Interceptor } from '../../interceptor'
+import { createXMLHttpRequestProxy } from './xml-http-request-proxy'
+import { hasConfigurableGlobal } from '../../utils/has-configurable-global'
+import { patchesRegistry } from '../../utils/patches-registry'
+import { createLogger } from '../../utils/logger'
+
+const logger = createLogger('xhr')
+
+export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol = Symbol.for('xhr-interceptor')
+
+  protected predicate() {
+    return hasConfigurableGlobal('XMLHttpRequest')
+  }
+
+  protected setup() {
+    logger.verbose('patching "XMLHttpRequest"...')
+
+    this.subscriptions.push(
+      patchesRegistry.applyPatch(globalThis, 'XMLHttpRequest', () => {
+        return createXMLHttpRequestProxy({
+          emitter: this.emitter,
+          logger,
+        })
+      })
+    )
+
+    logger.verbose(
+      'global "XMLHttpRequest" patched!',
+      globalThis.XMLHttpRequest.name
+    )
+  }
+}