@mswjs/interceptors 0.32.2 → 0.33.0

package/src/glossary.ts

@@ -1,4 +1,4 @@
-import type { InteractiveRequest } from './utils/toInteractiveRequest'
+import type { RequestController } from './RequestController'
 
 export const IS_PATCHED_MODULE: unique symbol = Symbol('isPatchedModule')
 
@@ -7,8 +7,9 @@ export type RequestCredentials = 'omit' | 'include' | 'same-origin'
 export type HttpRequestEventMap = {
   request: [
     args: {
-      request: InteractiveRequest
+      request: Request
       requestId: string
+      controller: RequestController
     }
   ]
   response: [
@@ -24,10 +25,7 @@ export type HttpRequestEventMap = {
       error: unknown
       request: Request
       requestId: string
-      controller: {
-        respondWith(response: Response): void
-        errorWith(error?: Error): void
-      }
+      controller: RequestController
     }
   ]
 }

package/src/interceptors/ClientRequest/MockHttpSocket.ts

@@ -378,7 +378,7 @@ export class MockHttpSocket extends MockSocket {
   /**
    * Close this socket connection with the given error.
    */
-  public errorWith(error: Error): void {
+  public errorWith(error?: Error): void {
     this.destroy(error)
   }
 

package/src/interceptors/ClientRequest/index.test.ts

@@ -30,43 +30,12 @@ afterAll(async () => {
   await httpServer.close()
 })
 
-it('forbids calling "respondWith" multiple times for the same request', async () => {
-  const requestUrl = httpServer.http.url('/')
-
-  interceptor.on('request', function firstRequestListener({ request }) {
-    request.respondWith(new Response())
-  })
-
-  const secondRequestEmitted = new DeferredPromise<void>()
-  interceptor.on('request', function secondRequestListener({ request }) {
-    expect(() =>
-      request.respondWith(new Response(null, { status: 301 }))
-    ).toThrow(
-      `Failed to respond to "GET ${requestUrl}" request: the "request" event has already been responded to.`
-    )
-
-    secondRequestEmitted.resolve()
-  })
-
-  const request = http.get(requestUrl)
-  await secondRequestEmitted
-
-  const responseReceived = new DeferredPromise<http.IncomingMessage>()
-  request.on('response', (response) => {
-    responseReceived.resolve(response)
-  })
-
-  const response = await responseReceived
-  expect(response.statusCode).toBe(200)
-  expect(response.statusMessage).toBe('OK')
-})
-
 it('abort the request if the abort signal is emitted', async () => {
   const requestUrl = httpServer.http.url('/')
 
-  interceptor.on('request', async function delayedResponse({ request }) {
+  interceptor.on('request', async function delayedResponse({ controller }) {
     await sleep(1_000)
-    request.respondWith(new Response())
+    controller.respondWith(new Response())
   })
 
   const abortController = new AbortController()

package/src/interceptors/ClientRequest/index.ts

@@ -1,6 +1,5 @@
 import http from 'node:http'
 import https from 'node:https'
-import { until } from '@open-draft/until'
 import { Interceptor } from '../../Interceptor'
 import type { HttpRequestEventMap } from '../../glossary'
 import {
@@ -9,11 +8,10 @@ import {
   MockHttpSocketResponseCallback,
 } from './MockHttpSocket'
 import { MockAgent, MockHttpsAgent } from './agents'
+import { RequestController } from '../../RequestController'
 import { emitAsync } from '../../utils/emitAsync'
-import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
-import { isNodeLikeError } from '../../utils/isNodeLikeError'
-import { createServerErrorResponse } from '../../utils/responseUtils'
+import { handleRequest } from '../../utils/handleRequest'
 import {
   recordRawFetchHeaders,
   restoreHeadersPrototype,
@@ -129,88 +127,29 @@ export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
     socket,
   }) => {
     const requestId = Reflect.get(request, kRequestId)
-    const { interactiveRequest, requestController } =
-      toInteractiveRequest(request)
-
-    // TODO: Abstract this bit. We are using it everywhere.
-    this.emitter.once('request', ({ requestId: pendingRequestId }) => {
-      if (pendingRequestId !== requestId) {
-        return
-      }
-
-      if (requestController.responsePromise.state === 'pending') {
-        this.logger.info(
-          'request has not been handled in listeners, executing fail-safe listener...'
-        )
-
-        requestController.responsePromise.resolve(undefined)
-      }
-    })
+    const controller = new RequestController(request)
 
-    const listenerResult = await until(async () => {
-      await emitAsync(this.emitter, 'request', {
-        requestId,
-        request: interactiveRequest,
-      })
-
-      return await requestController.responsePromise
-    })
-
-    if (listenerResult.error) {
-      // Treat thrown Responses as mocked responses.
-      if (listenerResult.error instanceof Response) {
-        socket.respondWith(listenerResult.error)
-        return
-      }
-
-      // Allow mocking Node-like errors.
-      if (isNodeLikeError(listenerResult.error)) {
-        socket.errorWith(listenerResult.error)
-        return
-      }
-
-      // Emit the "unhandledException" event to allow the client
-      //  to opt-out from the default handling of exceptions
-      // as 500 error responses.
-      if (this.emitter.listenerCount('unhandledException') > 0) {
-        await emitAsync(this.emitter, 'unhandledException', {
-          error: listenerResult.error,
-          request,
-          requestId,
-          controller: {
-            respondWith: socket.respondWith.bind(socket),
-            errorWith: socket.errorWith.bind(socket),
-          },
-        })
-
-        // After the listeners are done, if the socket is
-        // not connecting anymore, the response was mocked.
-        // If the socket has been destroyed, the error was mocked.
-        // Treat both as the result of the listener's call.
-        if (!socket.connecting || socket.destroyed) {
-          return
+    const isRequestHandled = await handleRequest({
+      request,
+      requestId,
+      controller,
+      emitter: this.emitter,
+      onResponse: (response) => {
+        socket.respondWith(response)
+      },
+      onRequestError: (response) => {
+        socket.respondWith(response)
+      },
+      onError: (error) => {
+        if (error instanceof Error) {
+          socket.errorWith(error)
         }
-      }
-
-      // Unhandled exceptions in the request listeners are
-      // synonymous to unhandled exceptions on the server.
-      // Those are represented as 500 error responses.
-      socket.respondWith(createServerErrorResponse(listenerResult.error))
-      return
-    }
-
-    const mockedResponse = listenerResult.data
+      },
+    })
 
-    if (mockedResponse) {
-      /**
-       * @note The `.respondWith()` method will handle "Response.error()".
-       * Maybe we should make all interceptors do that?
-       */
-      socket.respondWith(mockedResponse)
-      return
+    if (!isRequestHandled) {
+      return socket.passthrough()
     }
-
-    socket.passthrough()
   }
 
   public onResponse: MockHttpSocketResponseCallback = async ({

package/src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts

@@ -481,7 +481,7 @@ export class XMLHttpRequestController {
     return null
   }
 
-  public errorWith(error: Error): void {
+  public errorWith(error?: Error): void {
     this.logger.info('responding with an error')
 
     this.setReadyState(this.request.DONE)

package/src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts

@@ -1,13 +1,8 @@
-import { until } from '@open-draft/until'
 import type { Logger } from '@open-draft/logger'
 import { XMLHttpRequestEmitter } from '.'
-import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
-import { emitAsync } from '../../utils/emitAsync'
+import { RequestController } from '../../RequestController'
 import { XMLHttpRequestController } from './XMLHttpRequestController'
-import {
-  createServerErrorResponse,
-  isResponseError,
-} from '../../utils/responseUtils'
+import { handleRequest } from '../../utils/handleRequest'
 
 export interface XMLHttpRequestProxyOptions {
   emitter: XMLHttpRequestEmitter
@@ -57,116 +52,40 @@ export function createXMLHttpRequestProxy({
       )
 
       xhrRequestController.onRequest = async function ({ request, requestId }) {
-        const { interactiveRequest, requestController } =
-          toInteractiveRequest(request)
+        const controller = new RequestController(request)
 
         this.logger.info('awaiting mocked response...')
 
-        emitter.once('request', ({ requestId: pendingRequestId }) => {
-          if (pendingRequestId !== requestId) {
-            return
-          }
-
-          if (requestController.responsePromise.state === 'pending') {
-            requestController.respondWith(undefined)
-          }
-        })
-
-        const resolverResult = await until(async () => {
-          this.logger.info(
-            'emitting the "request" event for %s listener(s)...',
-            emitter.listenerCount('request')
-          )
-
-          await emitAsync(emitter, 'request', {
-            request: interactiveRequest,
-            requestId,
-          })
-
-          this.logger.info('all "request" listeners settled!')
-
-          const mockedResponse = await requestController.responsePromise
-
-          this.logger.info('event.respondWith called with:', mockedResponse)
-
-          return mockedResponse
-        })
-
-        if (resolverResult.error) {
-          this.logger.info(
-            'request listener threw an exception, aborting request...',
-            resolverResult.error
-          )
-
-          // Treat thrown Responses as mocked responses.
-          if (resolverResult.error instanceof Response) {
-            if (isResponseError(resolverResult.error)) {
-              xhrRequestController.errorWith(new TypeError('Network error'))
-            } else {
-              this.respondWith(resolverResult.error)
-            }
-
-            return
-          }
-
-          if (emitter.listenerCount('unhandledException') > 0) {
-            // Emit the "unhandledException" event so the client can opt-out
-            // from the default exception handling (producing 500 error responses).
-            await emitAsync(emitter, 'unhandledException', {
-              error: resolverResult.error,
-              request,
-              requestId,
-              controller: {
-                respondWith:
-                  xhrRequestController.respondWith.bind(xhrRequestController),
-                errorWith:
-                  xhrRequestController.errorWith.bind(xhrRequestController),
-              },
-            })
+        this.logger.info(
+          'emitting the "request" event for %s listener(s)...',
+          emitter.listenerCount('request')
+        )
 
-            // If any of the "unhandledException" listeners handled the request,
-            // do nothing. Note that mocked responses will dispatch
-            // HEADERS_RECEIVED (2), then LOADING (3), and DONE (4) can take
-            // time as the mocked response body finishes streaming.
-            if (originalRequest.readyState > XMLHttpRequest.OPENED) {
-              return
+        const isRequestHandled = await handleRequest({
+          request,
+          requestId,
+          controller,
+          emitter,
+          onResponse: (response) => {
+            this.respondWith(response)
+          },
+          onRequestError: () => {
+            this.errorWith(new TypeError('Network error'))
+          },
+          onError: (error) => {
+            this.logger.info('request errored!', { error })
+
+            if (error instanceof Error) {
+              this.errorWith(error)
             }
-          }
-
-          // Unhandled exceptions in the request listeners are
-          // synonymous to unhandled exceptions on the server.
-          // Those are represented as 500 error responses.
-          xhrRequestController.respondWith(
-            createServerErrorResponse(resolverResult.error)
-          )
-
-          return
-        }
-
-        const mockedResponse = resolverResult.data
+          },
+        })
 
-        if (typeof mockedResponse !== 'undefined') {
+        if (!isRequestHandled) {
           this.logger.info(
-            'received mocked response: %d %s',
-            mockedResponse.status,
-            mockedResponse.statusText
+            'no mocked response received, performing request as-is...'
           )
-
-          if (isResponseError(mockedResponse)) {
-            this.logger.info(
-              'received a network error response, rejecting the request promise...'
-            )
-
-            xhrRequestController.errorWith(new TypeError('Network error'))
-            return
-          }
-
-          return xhrRequestController.respondWith(mockedResponse)
         }
-
-        this.logger.info(
-          'no mocked response received, performing request as-is...'
-        )
       }
 
       xhrRequestController.onResponse = async function ({

package/src/interceptors/XMLHttpRequest/index.ts

@@ -1,15 +1,9 @@
 import { invariant } from 'outvariant'
 import { Emitter } from 'strict-event-emitter'
 import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
-import { InteractiveRequest } from '../../utils/toInteractiveRequest'
 import { Interceptor } from '../../Interceptor'
 import { createXMLHttpRequestProxy } from './XMLHttpRequestProxy'
 
-export type XMLHttpRequestEventListener = (args: {
-  request: InteractiveRequest
-  requestId: string
-}) => Promise<void> | void
-
 export type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>
 
 export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {

package/src/interceptors/fetch/index.ts

@@ -1,16 +1,12 @@
 import { invariant } from 'outvariant'
 import { DeferredPromise } from '@open-draft/deferred-promise'
-import { until } from '@open-draft/until'
 import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
-import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
+import { RequestController } from '../../RequestController'
 import { emitAsync } from '../../utils/emitAsync'
+import { handleRequest } from '../../utils/handleRequest'
 import { canParseUrl } from '../../utils/canParseUrl'
 import { createRequestId } from '../../createRequestId'
-import {
-  createServerErrorResponse,
-  isResponseError,
-} from '../../utils/responseUtils'
 
 export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol('fetch')
@@ -51,185 +47,72 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
           : input
 
       const request = new Request(resolvedInput, init)
+      const responsePromise = new DeferredPromise<Response>()
+      const controller = new RequestController(request)
 
       this.logger.info('[%s] %s', request.method, request.url)
-
-      const { interactiveRequest, requestController } =
-        toInteractiveRequest(request)
+      this.logger.info('awaiting for the mocked response...')
 
       this.logger.info(
-        'emitting the "request" event for %d listener(s)...',
+        'emitting the "request" event for %s listener(s)...',
         this.emitter.listenerCount('request')
       )
 
-      this.emitter.once('request', ({ requestId: pendingRequestId }) => {
-        if (pendingRequestId !== requestId) {
-          return
-        }
-
-        if (requestController.responsePromise.state === 'pending') {
-          requestController.responsePromise.resolve(undefined)
-        }
-      })
-
-      this.logger.info('awaiting for the mocked response...')
-
-      const signal = interactiveRequest.signal
-      const requestAborted = new DeferredPromise()
-
-      // Signal isn't always defined in react-native.
-      if (signal) {
-        signal.addEventListener(
-          'abort',
-          () => {
-            requestAborted.reject(signal.reason)
-          },
-          { once: true }
-        )
-      }
-
-      const responsePromise = new DeferredPromise<Response>()
-
-      const respondWith = (response: Response): void => {
-        this.logger.info('responding with a mock response:', response)
-
-        if (this.emitter.listenerCount('response') > 0) {
-          this.logger.info('emitting the "response" event...')
-
-          // Clone the mocked response for the "response" event listener.
-          // This way, the listener can read the response and not lock its body
-          // for the actual fetch consumer.
-          const responseClone = response.clone()
-
-          this.emitter.emit('response', {
-            response: responseClone,
-            isMockedResponse: true,
-            request: interactiveRequest,
-            requestId,
-          })
-        }
-
-        // Set the "response.url" property to equal the intercepted request URL.
-        Object.defineProperty(response, 'url', {
-          writable: false,
-          enumerable: true,
-          configurable: false,
-          value: request.url,
-        })
-
-        responsePromise.resolve(response)
-      }
-
-      const errorWith = (reason: unknown): void => {
-        responsePromise.reject(reason)
-      }
-
-      const resolverResult = await until<unknown, Response | undefined>(
-        async () => {
-          const listenersFinished = emitAsync(this.emitter, 'request', {
-            request: interactiveRequest,
-            requestId,
+      const isRequestHandled = await handleRequest({
+        request,
+        requestId,
+        emitter: this.emitter,
+        controller,
+        onResponse: async (response) => {
+          this.logger.info('received mocked response!', {
+            response,
           })
 
-          await Promise.race([
-            requestAborted,
-            // Put the listeners invocation Promise in the same race condition
-            // with the request abort Promise because otherwise awaiting the listeners
-            // would always yield some response (or undefined).
-            listenersFinished,
-            requestController.responsePromise,
-          ])
-
-          this.logger.info('all request listeners have been resolved!')
-
-          const mockedResponse = await requestController.responsePromise
-          this.logger.info('event.respondWith called with:', mockedResponse)
-
-          return mockedResponse
-        }
-      )
-
-      if (requestAborted.state === 'rejected') {
-        this.logger.info(
-          'request has been aborted:',
-          requestAborted.rejectionReason
-        )
-
-        responsePromise.reject(requestAborted.rejectionReason)
-        return responsePromise
-      }
-
-      if (resolverResult.error) {
-        this.logger.info(
-          'request listerner threw an error:',
-          resolverResult.error
-        )
-
-        // Treat thrown Responses as mocked responses.
-        if (resolverResult.error instanceof Response) {
-          // Treat thrown Response.error() as a request error.
-          if (isResponseError(resolverResult.error)) {
-            errorWith(createNetworkError(resolverResult.error))
-          } else {
-            // Treat the rest of thrown Responses as mocked responses.
-            respondWith(resolverResult.error)
+          if (this.emitter.listenerCount('response') > 0) {
+            this.logger.info('emitting the "response" event...')
+
+            // Await the response listeners to finish before resolving
+            // the response promise. This ensures all your logic finishes
+            // before the interceptor resolves the pending response.
+            await emitAsync(this.emitter, 'response', {
+              // Clone the mocked response for the "response" event listener.
+              // This way, the listener can read the response and not lock its body
+              // for the actual fetch consumer.
+              response: response.clone(),
+              isMockedResponse: true,
+              request,
+              requestId,
+            })
           }
-        }
 
-        // Emit the "unhandledException" interceptor event so the client
-        // can opt-out from exceptions translating to 500 error responses.
-
-        if (this.emitter.listenerCount('unhandledException') > 0) {
-          await emitAsync(this.emitter, 'unhandledException', {
-            error: resolverResult.error,
-            request,
-            requestId,
-            controller: {
-              respondWith,
-              errorWith,
-            },
+          // Set the "response.url" property to equal the intercepted request URL.
+          Object.defineProperty(response, 'url', {
+            writable: false,
+            enumerable: true,
+            configurable: false,
+            value: request.url,
           })
 
-          if (responsePromise.state !== 'pending') {
-            return responsePromise
-          }
-        }
-
-        // Unhandled exceptions in the request listeners are
-        // synonymous to unhandled exceptions on the server.
-        // Those are represented as 500 error responses.
-        respondWith(createServerErrorResponse(resolverResult.error))
-        return responsePromise
-      }
-
-      const mockedResponse = resolverResult.data
-
-      if (mockedResponse && !request.signal?.aborted) {
-        this.logger.info('received mocked response:', mockedResponse)
-
-        // Reject the request Promise on mocked "Response.error" responses.
-        if (isResponseError(mockedResponse)) {
-          this.logger.info(
-            'received a network error response, rejecting the request promise...'
-          )
-
-          /**
-           * Set the cause of the request promise rejection to the
-           * network error Response instance. This differs from Undici.
-           * Undici will forward the "response.error" custom property
-           * as the rejection reason but for "Response.error()" static method
-           * "response.error" will equal to undefined, making "cause" an empty Error.
-           * @see https://github.com/nodejs/undici/blob/83cb522ae0157a19d149d72c7d03d46e34510d0a/lib/fetch/response.js#L344
-           */
-          errorWith(createNetworkError(mockedResponse))
-        } else {
-          respondWith(mockedResponse)
-        }
+          responsePromise.resolve(response)
+        },
+        onRequestError: (response) => {
+          this.logger.info('request has errored!', { response })
+          responsePromise.reject(createNetworkError(response))
+        },
+        onError: (error) => {
+          this.logger.info('request has been aborted!', { error })
+          responsePromise.reject(error)
+        },
+      })
 
+      if (isRequestHandled) {
+        this.logger.info('request has been handled, returning mock promise...')
         return responsePromise
       }
 
-      this.logger.info('no mocked response received!')
+      this.logger.info(
+        'no mocked response received, performing request as-is...'
+      )
 
       return pureFetch(request).then((response) => {
         this.logger.info('original fetch performed', response)
@@ -242,7 +125,7 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
           this.emitter.emit('response', {
             response: responseClone,
             isMockedResponse: false,
-            request: interactiveRequest,
+            request,
             requestId,
           })
         }