msw 2.14.6 → 2.15.0

package/src/core/utils/HttpResponse/decorators.ts

@@ -1,5 +1,5 @@
 import statuses from '../../../shims/statuses'
-import type { HttpResponseInit } from '../../HttpResponse'
+import type { HttpResponse, HttpResponseInit } from '../../HttpResponse'
 
 const { message } = statuses
 
@@ -27,7 +27,7 @@ export function normalizeResponseInit(
 }
 
 export function decorateResponse(
-  response: Response,
+  response: HttpResponse<any>,
   init: HttpResponseDecoratedInit,
 ): Response {
   // Allow mocking the response type.
@@ -59,3 +59,24 @@ export function decorateResponse(
 export function getRawSetCookie(response: Response): string | undefined {
   return Reflect.get(response, kSetCookie)
 }
+
+/**
+ * Copy the given response own properties, like internal symbols,
+ * onto another response. Used for faithful internal copying of responses.
+ */
+export function copyResponseOwnProperties(
+  source: Response,
+  target: Response,
+): void {
+  for (const propertyName of Reflect.ownKeys(source)) {
+    const descriptor = Object.getOwnPropertyDescriptor(source, propertyName)
+    const existingDescriptor = Object.getOwnPropertyDescriptor(
+      target,
+      propertyName,
+    )
+
+    if (descriptor && existingDescriptor == null) {
+      Object.defineProperty(target, propertyName, descriptor)
+    }
+  }
+}

package/src/core/utils/internal/observe-response-body-stream.test.ts

@@ -0,0 +1,64 @@
+import { observeResponseBodyStream } from './observe-response-body-stream'
+
+it('returns null for a response without a body', () => {
+  expect(observeResponseBodyStream(new Response(null))).toBeNull()
+})
+
+it('returns null for a response whose body is already used', async () => {
+  const response = new Response('hello')
+  await response.text()
+
+  expect(observeResponseBodyStream(response)).toBeNull()
+})
+
+it('returns null for a response whose body is locked', () => {
+  const response = new Response('hello')
+  response.body?.getReader()
+
+  expect(observeResponseBodyStream(response)).toBeNull()
+})
+
+it('resolves "settled" when the response body is read to completion', async () => {
+  const observed = observeResponseBodyStream(new Response('hello'))
+  expect(observed).not.toBeNull()
+
+  await expect(observed?.response.text()).resolves.toBe('hello')
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+it('resolves "settled" when the response body errors', async () => {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.error(new Error('stream error'))
+    },
+  })
+  const observed = observeResponseBodyStream(new Response(stream))
+  expect(observed).not.toBeNull()
+
+  await expect(observed?.response.text()).rejects.toThrow('stream error')
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+it('resolves "settled" when the response body is canceled', async () => {
+  const stream = new ReadableStream({
+    pull(controller) {
+      controller.enqueue(new TextEncoder().encode('ping'))
+    },
+  })
+  const observed = observeResponseBodyStream(new Response(stream))
+  const reader = observed?.response.body?.getReader()
+  expect(reader).toBeDefined()
+
+  await reader?.read()
+  await reader?.cancel(new Error('client disconnected'))
+
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+it('resolves "settled" when the response body is consumed via piping', async () => {
+  const observed = observeResponseBodyStream(new Response('hello'))
+  expect(observed).not.toBeNull()
+
+  await observed?.response.body?.pipeTo(new WritableStream())
+  await expect(observed?.settled).resolves.toBeUndefined()
+})

package/src/core/utils/internal/observe-response-body-stream.ts

@@ -0,0 +1,77 @@
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { FetchResponse } from '@mswjs/interceptors'
+import { copyResponseOwnProperties } from '../HttpResponse/decorators'
+
+export interface ObservedResponse {
+  response: Response
+  /**
+   * A promise that resolves once the response body stream has settled:
+   * it was closed, errored, or canceled, and will not be used anymore.
+   */
+  settled: Promise<void>
+}
+
+/**
+ * Observe the `ReadableStream` body of the given response.
+ * Returns a copy of that response whose body reports when it has
+ * settled (was read to completion, errored, or canceled by the consumer).
+ * Returns `null` for responses whose body cannot be observed
+ * (no body, already used, or locked).
+ */
+export function observeResponseBodyStream(
+  response: Response,
+): ObservedResponse | null {
+  if (response.body == null || response.bodyUsed || response.body.locked) {
+    return null
+  }
+
+  const settled = new DeferredPromise<void>()
+  const reader = response.body.getReader()
+
+  /**
+   * @note Relay the body through a manual underlying source instead of
+   * `.pipeThrough(new TransformStream({ flush, cancel }))`. The `cancel`
+   * transformer callback is not implemented in Chromium, which loses
+   * the stream error/cancelation signals there entirely.
+   */
+  const observedStream = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const readResult = await reader.read()
+
+        if (readResult.done) {
+          settled.resolve()
+          controller.close()
+          return
+        }
+
+        controller.enqueue(readResult.value)
+      } catch (error) {
+        settled.resolve()
+        throw error
+      }
+    },
+    async cancel(reason) {
+      settled.resolve()
+      await reader.cancel(reason)
+    },
+  })
+
+  /**
+   * @note Reconstruct the response because the body of an existing
+   * response cannot be replaced. Use `FetchResponse` to support
+   * non-standard response status codes (e.g. 101).
+   */
+  const observedResponse = new FetchResponse(observedStream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  })
+
+  copyResponseOwnProperties(response, observedResponse)
+
+  return {
+    response: observedResponse,
+    settled,
+  }
+}

package/src/mockServiceWorker.js

@@ -137,8 +137,18 @@ async function handleRequest(event, requestId, requestInterceptedAt) {
   if (client && activeClientIds.has(client.id)) {
     const serializedRequest = await serializeRequest(requestCloneForEvents)
 
+    // Omit the body of server-sent event stream responses.
+    // Cloning such responses would prevent client-side stream cancelations
+    // from reaching the original stream (a teed stream only cancels its
+    // source once both of its branches cancel) and would buffer the
+    // entire stream into the unconsumed clone indefinitely.
+    const isEventStreamResponse = response.headers
+      .get('content-type')
+      ?.toLowerCase()
+      .startsWith('text/event-stream')
+
     // Clone the response so both the client and the library could consume it.
-    const responseClone = response.clone()
+    const responseClone = isEventStreamResponse ? null : response.clone()
 
     sendToClient(
       client,
@@ -151,15 +161,17 @@ async function handleRequest(event, requestId, requestInterceptedAt) {
             ...serializedRequest,
           },
           response: {
-            type: responseClone.type,
-            status: responseClone.status,
-            statusText: responseClone.statusText,
-            headers: Object.fromEntries(responseClone.headers.entries()),
-            body: responseClone.body,
+            type: response.type,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: responseClone ? responseClone.body : null,
           },
         },
       },
-      responseClone.body ? [serializedRequest.body, responseClone.body] : [],
+      responseClone && responseClone.body
+        ? [serializedRequest.body, responseClone.body]
+        : [],
     )
   }