msw 2.13.2 → 2.13.4

package/src/core/graphql.ts

@@ -1,16 +1,16 @@
 import type { OperationTypeNode } from 'graphql'
 import {
-  ResponseResolver,
-  RequestHandlerOptions,
+  type ResponseResolver,
+  type RequestHandlerOptions,
 } from './handlers/RequestHandler'
 import {
   GraphQLHandler,
-  GraphQLVariables,
-  GraphQLOperationType,
-  GraphQLResolverExtras,
-  GraphQLResponseBody,
-  GraphQLQuery,
-  GraphQLPredicate,
+  type GraphQLVariables,
+  type GraphQLOperationType,
+  type GraphQLResolverExtras,
+  type GraphQLResponseBody,
+  type GraphQLQuery,
+  type GraphQLPredicate,
 } from './handlers/GraphQLHandler'
 import type { Path } from './utils/matching/matchRequestUrl'
 

package/src/core/handlers/GraphQLHandler.test.ts

@@ -1,14 +1,13 @@
 // @vitest-environment jsdom
 import { createRequestId, encodeBuffer } from '@mswjs/interceptors'
 import { OperationTypeNode, parse } from 'graphql'
-import {
-  GraphQLHandler,
+import type {
   GraphQLRequestBody,
   GraphQLResolverExtras,
-  isDocumentNode,
 } from './GraphQLHandler'
+import { GraphQLHandler, isDocumentNode } from './GraphQLHandler'
 import { HttpResponse } from '../HttpResponse'
-import { ResponseResolver } from './RequestHandler'
+import type { ResponseResolver } from './RequestHandler'
 
 const resolver: ResponseResolver<GraphQLResolverExtras<{ userId: string }>> = ({
   variables,

package/src/core/handlers/GraphQLHandler.ts

@@ -6,30 +6,34 @@ import {
   type OperationTypeNode,
 } from 'graphql'
 import {
-  DefaultBodyType,
   RequestHandler,
-  RequestHandlerDefaultInfo,
-  RequestHandlerExecutionResult,
-  RequestHandlerOptions,
-  ResponseResolver,
+  type DefaultBodyType,
+  type RequestHandlerDefaultInfo,
+  type RequestHandlerExecutionResult,
+  type RequestHandlerOptions,
+  type ResponseResolver,
 } from './RequestHandler'
 import { getTimestamp } from '../utils/logging/getTimestamp'
 import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor'
 import { serializeRequest } from '../utils/logging/serializeRequest'
 import { serializeResponse } from '../utils/logging/serializeResponse'
-import { Match, matchRequestUrl, Path } from '../utils/matching/matchRequestUrl'
 import {
-  ParsedGraphQLRequest,
-  GraphQLMultipartRequestBody,
+  type Match,
+  matchRequestUrl,
+  type Path,
+} from '../utils/matching/matchRequestUrl'
+import {
+  type ParsedGraphQLRequest,
+  type GraphQLMultipartRequestBody,
   parseGraphQLRequest,
   parseDocumentNode,
-  ParsedGraphQLQuery,
+  type ParsedGraphQLQuery,
 } from '../utils/internal/parseGraphQLRequest'
 import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { devUtils } from '../utils/internal/devUtils'
 import { getAllRequestCookies } from '../utils/request/getRequestCookies'
-import { ResponseResolutionContext } from 'src/iife'
-import { kDefaultContentType, StrictRequest } from '../HttpResponse'
+import { type ResponseResolutionContext } from '../utils/executeHandlers'
+import { kDefaultContentType, type StrictRequest } from '../HttpResponse'
 import { getAllAcceptedMimeTypes } from '../utils/request/getAllAcceptedMimeTypes'
 
 export interface DocumentTypeDecoration<

package/src/core/handlers/HttpHandler.test.ts

@@ -1,8 +1,9 @@
 // @vitest-environment jsdom
 import { createRequestId } from '@mswjs/interceptors'
-import { HttpHandler, HttpRequestResolverExtras } from './HttpHandler'
+import type { HttpRequestResolverExtras } from './HttpHandler'
+import { HttpHandler } from './HttpHandler'
 import { HttpResponse } from '..'
-import { ResponseResolver } from './RequestHandler'
+import type { ResponseResolver } from './RequestHandler'
 
 const resolver: ResponseResolver<
   HttpRequestResolverExtras<{ userId: string }>

package/src/core/handlers/HttpHandler.ts

@@ -1,4 +1,4 @@
-import { ResponseResolutionContext } from '../utils/executeHandlers'
+import { type ResponseResolutionContext } from '../utils/executeHandlers'
 import { devUtils } from '../utils/internal/devUtils'
 import { isStringEqual } from '../utils/internal/isStringEqual'
 import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor'
@@ -7,18 +7,18 @@ import { serializeRequest } from '../utils/logging/serializeRequest'
 import { serializeResponse } from '../utils/logging/serializeResponse'
 import {
   matchRequestUrl,
-  Match,
-  Path,
-  PathParams,
+  type Match,
+  type Path,
+  type PathParams,
 } from '../utils/matching/matchRequestUrl'
 import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { getAllRequestCookies } from '../utils/request/getRequestCookies'
 import { cleanUrl } from '../utils/url/cleanUrl'
 import {
   RequestHandler,
-  RequestHandlerDefaultInfo,
-  RequestHandlerOptions,
-  ResponseResolver,
+  type RequestHandlerDefaultInfo,
+  type RequestHandlerOptions,
+  type ResponseResolver,
 } from './RequestHandler'
 
 export type HttpHandlerMethod = string | RegExp

package/src/core/handlers/RequestHandler.ts

@@ -1,15 +1,15 @@
 import { getCallFrame } from '../utils/internal/getCallFrame'
 import {
-  AsyncIterable,
-  Iterable,
   isIterable,
+  type AsyncIterable,
+  type Iterable,
 } from '../utils/internal/isIterable'
 import type { ResponseResolutionContext } from '../utils/executeHandlers'
 import type { MaybePromise } from '../typeUtils'
+import type { HttpResponse } from '../HttpResponse'
 import {
-  StrictRequest,
-  HttpResponse,
-  DefaultUnsafeFetchResponse,
+  type StrictRequest,
+  type DefaultUnsafeFetchResponse,
 } from '../HttpResponse'
 import type { GraphQLRequestBody } from './GraphQLHandler'
 

package/src/core/http.ts

@@ -1,13 +1,13 @@
 import {
-  DefaultBodyType,
-  RequestHandlerOptions,
-  ResponseResolver,
+  type DefaultBodyType,
+  type RequestHandlerOptions,
+  type ResponseResolver,
 } from './handlers/RequestHandler'
 import {
   HttpMethods,
   HttpHandler,
-  HttpRequestResolverExtras,
-  HttpRequestPredicate,
+  type HttpRequestResolverExtras,
+  type HttpRequestPredicate,
 } from './handlers/HttpHandler'
 import type { PathParams } from './utils/matching/matchRequestUrl'
 

package/src/core/sse.ts

@@ -1,4 +1,5 @@
 import { invariant } from 'outvariant'
+import { DeferredPromise } from '@open-draft/deferred-promise'
 import { Emitter } from 'strict-event-emitter'
 import type { ResponseResolver } from './handlers/RequestHandler'
 import {
@@ -89,26 +90,19 @@ class ServerSentEventHandler<
     )
 
     super('GET', path, async (info) => {
-      const stream = new ReadableStream({
-        start: async (controller) => {
-          const client = new ServerSentEventClient<EventMap>({
-            controller,
-            emitter: this.#emitter,
-          })
-          const server = new ServerSentEventServer({
-            request: info.request,
-            client,
-          })
-
-          await resolver({
-            ...info,
-            client,
-            server,
-          })
-        },
+      const { client, server, response } = createEventStream<EventMap>(
+        info.request,
+      )
+
+      client[kClientEmitter] = this.#emitter
+
+      await resolver({
+        ...info,
+        client,
+        server,
       })
 
-      return new Response(stream, SSE_RESPONSE_INIT)
+      return response
     })
 
     this.#emitter = new Emitter<ServerSentEventClientEventMap>()
@@ -222,32 +216,24 @@ type ToEventDiscriminatedUnion<T> = Values<{
 }>
 
 type ServerSentEventClientEventMap = {
-  message: [
-    payload: {
-      id?: string
-      event: string
-      data?: unknown
-      frames: Array<string>
-    },
-  ]
+  message: [payload: EventStreamMessage]
   error: []
   close: []
 }
 
+const kClientEmitter = Symbol.for('kClientEmitter')
+
 class ServerSentEventClient<
   EventMap extends EventMapConstraint = { message: unknown },
 > {
+  private [kClientEmitter]?: Emitter<ServerSentEventClientEventMap>
+
   #encoder: TextEncoder
-  #controller: ReadableStreamDefaultController
-  #emitter: Emitter<ServerSentEventClientEventMap>
+  #writer: WritableStreamDefaultWriter
 
-  constructor(args: {
-    controller: ReadableStreamDefaultController
-    emitter: Emitter<ServerSentEventClientEventMap>
-  }) {
+  constructor(writable: WritableStream) {
     this.#encoder = new TextEncoder()
-    this.#controller = args.controller
-    this.#emitter = args.emitter
+    this.#writer = writable.getWriter()
   }
 
   /**
@@ -303,22 +289,37 @@ class ServerSentEventClient<
    * error.
    */
   public error(): void {
-    this.#controller.error()
-    this.#emitter.emit('error')
+    this.#writer.abort().catch((error) => {
+      console.error(error)
+      devUtils.error(
+        'Failed to abort server-side EventSource. Please see the original error above.',
+      )
+    })
+    this[kClientEmitter]?.emit('error')
   }
 
   /**
    * Closes the underlying `EventSource`, closing the connection.
    */
   public close(): void {
-    this.#controller.close()
-    this.#emitter.emit('close')
+    this.#writer.close().catch((error) => {
+      console.error(error)
+      devUtils.error(
+        'Failed to close server-side EventSource. Please see the original error above.',
+      )
+    })
+    this[kClientEmitter]?.emit('close')
   }
 
   #sendRetry(retry: number): void {
-    if (typeof retry === 'number') {
-      this.#controller.enqueue(this.#encoder.encode(`retry:${retry}\n\n`))
-    }
+    this.#writer
+      .write(this.#encoder.encode(`retry:${retry}\n\n`))
+      .catch((error) => {
+        console.error(error)
+        devUtils.error(
+          'Failed to send a retry packet to server-side EventSource. Please see the original error above.',
+        )
+      })
   }
 
   #sendMessage(message: {
@@ -349,9 +350,16 @@ class ServerSentEventClient<
 
     frames.push('', '')
 
-    this.#controller.enqueue(this.#encoder.encode(frames.join('\n')))
+    this.#writer
+      .write(this.#encoder.encode(frames.join('\n')))
+      .catch((error) => {
+        console.error(error)
+        devUtils.error(
+          'Failed to send a message to server-side EventSource. Please see the original error above.',
+        )
+      })
 
-    this.#emitter.emit('message', {
+    this[kClientEmitter]?.emit('message', {
       id: message.id,
       event: message.event?.toString() || 'message',
       data: message.data,
@@ -383,6 +391,7 @@ class ServerSentEventServer {
          */
         accept: 'msw/passthrough',
       },
+      signal: this.#request.signal,
     })
 
     source[kOnAnyMessage] = (event) => {
@@ -429,6 +438,7 @@ class ServerSentEventServer {
 
 interface ObservableEventSourceInit extends EventSourceInit {
   headers?: HeadersInit
+  signal?: AbortSignal
 }
 
 type EventHandler<EventType extends Event> = (
@@ -489,6 +499,18 @@ class ObservableEventSource extends EventTarget implements EventSource {
       signal: this[kAbortController].signal,
     })
 
+    if (init?.signal) {
+      if (init.signal.aborted) {
+        this.close()
+        return
+      }
+
+      init.signal.addEventListener('abort', () => this.close(), {
+        once: true,
+        signal: this[kAbortController].signal,
+      })
+    }
+
     this.connect()
   }
 
@@ -518,7 +540,7 @@ class ObservableEventSource extends EventTarget implements EventSource {
   get onerror(): EventHandler<Event> | null {
     return this[kOnError]
   }
-  set oneerror(handler: EventHandler<Event>) {
+  set onerror(handler: EventHandler<Event>) {
     if (this[kOnError]) {
       this.removeEventListener('error', { handleEvent: this[kOnError] })
     }
@@ -642,10 +664,6 @@ class ObservableEventSource extends EventTarget implements EventSource {
           this[kLastEventId] = message.id
         }
 
-        if (message.retry) {
-          this[kReconnectionTime] = message.retry
-        }
-
         const messageEvent = new MessageEvent(
           message.event ? message.event : 'message',
           {
@@ -659,6 +677,9 @@ class ObservableEventSource extends EventTarget implements EventSource {
         this[kOnAnyMessage]?.(messageEvent)
         this.dispatchEvent(messageEvent)
       },
+      retry: (reconnectionTime) => {
+        this[kReconnectionTime] = reconnectionTime
+      },
       abort: () => {
         throw new Error('Stream abort is not implemented')
       },
@@ -693,7 +714,25 @@ class ObservableEventSource extends EventTarget implements EventSource {
       this.dispatchEvent(new Event('error'))
     })
 
-    await delay(this[kReconnectionTime])
+    const signal = this[kAbortController].signal
+
+    if (signal.aborted) {
+      return
+    }
+
+    const aborted = new DeferredPromise<void>()
+    const onAbort = () => aborted.resolve()
+    signal.addEventListener('abort', onAbort, { once: true })
+
+    await Promise.race([delay(this[kReconnectionTime]), aborted]).finally(
+      () => {
+        signal.removeEventListener('abort', onAbort)
+      },
+    )
+
+    if (signal.aborted) {
+      return
+    }
 
     queueMicrotask(async () => {
       if (this.readyState !== this.CONNECTING) {
@@ -743,7 +782,6 @@ interface EventSourceMessage {
   id?: string
   event?: string
   data?: string
-  retry?: number
 }
 
 class EventSourceParsingStream extends WritableStream {
@@ -758,12 +796,12 @@ class EventSourceParsingStream extends WritableStream {
     id: undefined,
     event: undefined,
     data: undefined,
-    retry: undefined,
   }
 
   constructor(
     private underlyingSink: {
       message: (message: EventSourceMessage) => void
+      retry?: (reconnectionTime: number) => void
       abort?: (reason: any) => void
       close?: () => void
     },
@@ -789,7 +827,6 @@ class EventSourceParsingStream extends WritableStream {
       id: undefined,
       event: undefined,
       data: undefined,
-      retry: undefined,
     }
   }
 
@@ -903,10 +940,12 @@ class EventSourceParsingStream extends WritableStream {
         }
 
         case 'retry': {
-          const retry = parseInt(value, 10)
-
-          if (!isNaN(retry)) {
-            this.message.retry = retry
+          /**
+           * Apply the retry immediately. Don't buffer onto the current message.
+           * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+           */
+          if (/^\d+$/.test(value)) {
+            this.underlyingSink.retry?.(parseInt(value, 10))
           }
           break
         }
@@ -914,3 +953,65 @@ class EventSourceParsingStream extends WritableStream {
     }
   }
 }
+
+interface EventStreamMessage {
+  id?: string
+  event: string
+  data?: unknown
+  frames: Array<string>
+}
+
+interface EventStream<EventMap extends EventMapConstraint> {
+  client: ServerSentEventClient<EventMap>
+  server: ServerSentEventServer
+  response: Response
+}
+
+/**
+ * Create an event stream out of the given Fetch API `Request`.
+ * Returns the following properties:
+ * - `client`, to operate on the intercepted request;
+ * - `server`, to establish and manage the actual server connection;
+ * - `response`, a `Response` to use as the mock response's body.
+ *
+ * @example
+ * http.post('/resource', ({ request }) => {
+ *   const { client, server, response } = createEventStream(request)
+ *   client.send({ data: 'hello world' })
+ *   return response
+ * })
+ */
+function createEventStream<EventMap extends EventMapConstraint>(
+  request: Request,
+): EventStream<EventMap> {
+  invariant(
+    !request.signal.aborted,
+    'Failed to call "createEventStream" on the "%s %s" request: request aborted',
+    request.method,
+    request.url,
+  )
+
+  const { readable, writable } = new TransformStream()
+
+  const client = new ServerSentEventClient<EventMap>(writable)
+  const server = new ServerSentEventServer({
+    request,
+    client,
+  })
+
+  const response = new Response(readable, SSE_RESPONSE_INIT)
+
+  request.signal.addEventListener(
+    'abort',
+    () => {
+      client.close()
+    },
+    { once: true },
+  )
+
+  return {
+    client,
+    server,
+    response,
+  }
+}

package/src/core/utils/cookieStore.ts

@@ -4,7 +4,7 @@ import {
   Cookie,
   CookieJar,
   MemoryCookieStore,
-  SerializedCookie,
+  type SerializedCookie,
   type MemoryCookieStoreIndex,
 } from 'tough-cookie'
 import { jsonParse } from './internal/jsonParse'

package/src/core/utils/executeHandlers.ts

@@ -1,7 +1,5 @@
-import {
-  RequestHandler,
-  type RequestHandlerExecutionResult,
-} from '../handlers/RequestHandler'
+import type { RequestHandler } from '../handlers/RequestHandler'
+import { type RequestHandlerExecutionResult } from '../handlers/RequestHandler'
 
 export interface HandlersExecutionResult {
   handler: RequestHandler

package/src/core/utils/handleRequest.test.ts

@@ -1,11 +1,12 @@
 // @vitest-environment jsdom
 import { Emitter } from 'strict-event-emitter'
 import { createRequestId } from '@mswjs/interceptors'
-import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
-import { RequestHandler } from '../handlers/RequestHandler'
+import type { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
+import type { RequestHandler } from '../handlers/RequestHandler'
 import { http } from '../http'
-import { handleRequest, HandleRequestOptions } from './handleRequest'
-import { RequiredDeep } from '../typeUtils'
+import type { HandleRequestOptions } from './handleRequest'
+import { handleRequest } from './handleRequest'
+import type { RequiredDeep } from '../typeUtils'
 import { HttpResponse } from '../HttpResponse'
 import { passthrough } from '../passthrough'
 

package/src/core/utils/handleRequest.ts

@@ -1,7 +1,7 @@
 import { until } from 'until-async'
-import { Emitter } from 'strict-event-emitter'
-import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
-import { RequiredDeep } from '../typeUtils'
+import type { Emitter } from 'strict-event-emitter'
+import type { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
+import type { RequiredDeep } from '../typeUtils'
 import type { RequestHandler } from '../handlers/RequestHandler'
 import {
   type HandlersExecutionResult,

package/src/core/utils/internal/parseGraphQLRequest.test.ts

@@ -3,10 +3,8 @@
  */
 import { encodeBuffer } from '@mswjs/interceptors'
 import { OperationTypeNode } from 'graphql'
-import {
-  ParsedGraphQLRequest,
-  parseGraphQLRequest,
-} from './parseGraphQLRequest'
+import type { ParsedGraphQLRequest } from './parseGraphQLRequest'
+import { parseGraphQLRequest } from './parseGraphQLRequest'
 
 test('returns true given a GraphQL-compatible request', async () => {
   const getRequest = new Request(

package/src/core/utils/internal/parseMultipartData.ts

@@ -1,5 +1,5 @@
 import { stringToHeaders } from 'headers-polyfill'
-import { DefaultRequestMultipartBody } from '../../handlers/RequestHandler'
+import { type DefaultRequestMultipartBody } from '../../handlers/RequestHandler'
 
 interface ParsedContentHeaders {
   name: string

package/src/core/utils/internal/pipeEvents.ts

@@ -1,4 +1,5 @@
-import { Emitter, EventMap } from 'strict-event-emitter'
+import type { Emitter } from 'strict-event-emitter'
+import { type EventMap } from 'strict-event-emitter'
 
 /**
  * Pipes all emitted events from one emitter to another.

package/src/core/utils/internal/requestHandlerUtils.ts

@@ -1,4 +1,4 @@
-import { RequestHandler } from '../../handlers/RequestHandler'
+import type { RequestHandler } from '../../handlers/RequestHandler'
 
 export function use(
   currentHandlers: Array<RequestHandler>,

package/src/core/utils/request/onUnhandledRequest.test.ts

@@ -1,8 +1,6 @@
 // @vitest-environment jsdom
-import {
-  onUnhandledRequest,
-  UnhandledRequestCallback,
-} from './onUnhandledRequest'
+import type { UnhandledRequestCallback } from './onUnhandledRequest'
+import { onUnhandledRequest } from './onUnhandledRequest'
 
 const fixtures = {
   warningWithoutSuggestions: (url = `/api`) => `\

package/src/core/ws/WebSocketClientManager.test.ts

@@ -1,10 +1,8 @@
 // @vitest-environment node-websocket
 import { setMaxListeners } from 'node:events'
 import { WebSocketClientConnection } from '@mswjs/interceptors/WebSocket'
-import {
-  WebSocketClientManager,
-  WebSocketBroadcastChannelMessage,
-} from './WebSocketClientManager'
+import type { WebSocketBroadcastChannelMessage } from './WebSocketClientManager'
+import { WebSocketClientManager } from './WebSocketClientManager'
 import { TestWebSocketTransport } from '../../../test/support/ws-test-utils'
 
 const channel = new BroadcastChannel('test:channel')

package/src/core/ws/WebSocketClientManager.ts

@@ -3,7 +3,7 @@ import type {
   WebSocketClientConnectionProtocol,
   WebSocketClientEventMap,
 } from '@mswjs/interceptors/WebSocket'
-import { WebSocketClientStore } from './WebSocketClientStore'
+import type { WebSocketClientStore } from './WebSocketClientStore'
 import { WebSocketMemoryClientStore } from './WebSocketMemoryClientStore'
 import { WebSocketIndexedDBClientStore } from './WebSocketIndexedDBClientStore'
 

package/src/core/ws/WebSocketIndexedDBClientStore.ts

@@ -1,9 +1,7 @@
 import { DeferredPromise } from '@open-draft/deferred-promise'
-import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
-import {
-  type SerializedWebSocketClient,
-  WebSocketClientStore,
-} from './WebSocketClientStore'
+import type { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
+import type { WebSocketClientStore } from './WebSocketClientStore'
+import { type SerializedWebSocketClient } from './WebSocketClientStore'
 
 const DB_NAME = 'msw-websocket-clients'
 const DB_STORE_NAME = 'clients'