msw 2.12.11 → 2.12.13

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.12.11'
+const PACKAGE_VERSION = '2.12.13'
 const INTEGRITY_CHECKSUM = '4db4a41e972cec1b64cc569c66952d82'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.12.11",
+  "version": "2.12.13",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "type": "commonjs",
   "main": "./lib/core/index.js",
@@ -285,7 +285,7 @@
     "vitest-environment-miniflare": "^2.14.4",
     "webpack": "^5.95.0",
     "webpack-http-server": "^0.5.0",
-    "msw": "2.12.11"
+    "msw": "2.12.13"
   },
   "peerDependencies": {
     "typescript": ">= 4.8.x"

package/src/core/HttpResponse.test.ts

@@ -2,14 +2,14 @@
  * @vitest-environment node
  */
 import { TextEncoder } from 'util'
-import { HttpResponse } from './HttpResponse'
+import { HttpResponse, kDefaultContentType } from './HttpResponse'
 
 it('creates a plain response', async () => {
   const response = new HttpResponse(null, { status: 301 })
   expect(response.status).toBe(301)
   expect(response.statusText).toBe('Moved Permanently')
   expect(response.body).toBe(null)
-  expect(await response.text()).toBe('')
+  await expect(response.text()).resolves.toBe('')
   expect(Object.fromEntries(response.headers.entries())).toEqual({})
 })
 
@@ -24,11 +24,12 @@ describe('HttpResponse.text()', () => {
     expect(response.status).toBe(201)
     expect(response.statusText).toBe('Created')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('hello world')
+    await expect(response.text()).resolves.toBe('hello world')
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-length': '11',
       'content-type': 'text/plain',
     })
+    expect(kDefaultContentType in response).toBe(true)
   })
 
   it('creates a text response with special characters', async () => {
@@ -37,7 +38,7 @@ describe('HttpResponse.text()', () => {
     expect(response.status).toBe(201)
     expect(response.statusText).toBe('Created')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('안녕 세상')
+    await expect(response.text()).resolves.toBe('안녕 세상')
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-length': '13',
       'content-type': 'text/plain',
@@ -52,11 +53,12 @@ describe('HttpResponse.text()', () => {
     expect(response.status).toBe(200)
     expect(response.statusText).toBe('OK')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('hello world')
+    await expect(response.text()).resolves.toBe('hello world')
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-length': '11',
       'content-type': 'text/plain; charset=utf-8',
     })
+    expect(kDefaultContentType in response).toBe(false)
   })
 
   it('allows overriding the "Content-Length" response header', async () => {
@@ -83,6 +85,7 @@ describe('HttpResponse.json()', () => {
       'content-length': '20',
       'content-type': 'application/json',
     })
+    expect(kDefaultContentType in response).toBe(true)
   })
 
   it('creates a json response given an object with special characters', async () => {
@@ -172,6 +175,7 @@ describe('HttpResponse.json()', () => {
       },
     )
 
+    expect(kDefaultContentType in response).toBe(false)
     expect(response.status).toBe(200)
     expect(response.statusText).toBe('OK')
     expect(response.body).toBeInstanceOf(ReadableStream)
@@ -201,13 +205,15 @@ describe('HttpResponse.xml()', () => {
   it('creates an xml response', async () => {
     const response = HttpResponse.xml('<user name="John" />')
 
+    expect(kDefaultContentType in response).toBe(true)
     expect(response.status).toBe(200)
     expect(response.statusText).toBe('OK')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('<user name="John" />')
+    await expect(response.text()).resolves.toBe('<user name="John" />')
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-type': 'text/xml',
     })
+    expect(kDefaultContentType in response).toBe(true)
   })
 
   it('allows overriding the "Content-Type" response header', async () => {
@@ -220,10 +226,11 @@ describe('HttpResponse.xml()', () => {
     expect(response.status).toBe(200)
     expect(response.statusText).toBe('OK')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('<user name="John" />')
+    await expect(response.text()).resolves.toBe('<user name="John" />')
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-type': 'text/xml; charset=utf-8',
     })
+    expect(kDefaultContentType in response).toBe(false)
   })
 })
 
@@ -234,10 +241,13 @@ describe('HttpResponse.html()', () => {
     expect(response.status).toBe(200)
     expect(response.statusText).toBe('OK')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('<p class="author">Jane Doe</p>')
+    await expect(response.text()).resolves.toBe(
+      '<p class="author">Jane Doe</p>',
+    )
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-type': 'text/html',
     })
+    expect(kDefaultContentType in response).toBe(true)
   })
 
   it('allows overriding the "Content-Type" response header', async () => {
@@ -250,10 +260,13 @@ describe('HttpResponse.html()', () => {
     expect(response.status).toBe(200)
     expect(response.statusText).toBe('OK')
     expect(response.body).toBeInstanceOf(ReadableStream)
-    expect(await response.text()).toBe('<p class="author">Jane Doe</p>')
+    await expect(response.text()).resolves.toBe(
+      '<p class="author">Jane Doe</p>',
+    )
     expect(Object.fromEntries(response.headers.entries())).toEqual({
       'content-type': 'text/html; charset=utf-8',
     })
+    expect(kDefaultContentType in response).toBe(false)
   })
 })
 
@@ -272,6 +285,7 @@ describe('HttpResponse.arrayBuffer()', () => {
       'content-length': '11',
       'content-type': 'application/octet-stream',
     })
+    expect(kDefaultContentType in response).toBe(true)
   })
 
   it('allows overriding the "Content-Type" response header', async () => {
@@ -292,6 +306,7 @@ describe('HttpResponse.arrayBuffer()', () => {
       'content-length': '11',
       'content-type': 'text/plain; charset=utf-8',
     })
+    expect(kDefaultContentType in response).toBe(false)
   })
 
   it('creates an array buffer response from a shared array buffer', async () => {
@@ -340,6 +355,7 @@ describe('HttpResponse.arrayBuffer()', () => {
       'content-length': '11',
       'content-type': 'text/plain; charset=utf-8',
     })
+    expect(kDefaultContentType in response).toBe(false)
   })
 })
 

package/src/core/HttpResponse.ts

@@ -28,6 +28,8 @@ export interface StrictRequest<BodyType extends JsonBodyType> extends Request {
 export type StrictResponse<BodyType extends DefaultBodyType> =
   HttpResponse<BodyType>
 
+export const kDefaultContentType = Symbol.for('kDefaultContentType')
+
 /**
  * A drop-in replacement for the standard `Response` class
  * to allow additional features, like mocking the response `Set-Cookie` header.
@@ -65,8 +67,9 @@ export class HttpResponse<
     init?: HttpResponseInit,
   ): HttpResponse<BodyType> {
     const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
 
-    if (!responseInit.headers.has('Content-Type')) {
+    if (!hasExplicitContentType) {
       responseInit.headers.set('Content-Type', 'text/plain')
     }
 
@@ -80,7 +83,16 @@ export class HttpResponse<
       )
     }
 
-    return new HttpResponse(body, responseInit)
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response
   }
 
   /**
@@ -94,8 +106,9 @@ export class HttpResponse<
     init?: HttpResponseInit,
   ): HttpResponse<BodyType> {
     const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
 
-    if (!responseInit.headers.has('Content-Type')) {
+    if (!hasExplicitContentType) {
       responseInit.headers.set('Content-Type', 'application/json')
     }
 
@@ -112,7 +125,16 @@ export class HttpResponse<
       )
     }
 
-    return new HttpResponse(responseText as BodyType, responseInit)
+    const response = new HttpResponse(responseText, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
   }
 
   /**
@@ -126,12 +148,22 @@ export class HttpResponse<
     init?: HttpResponseInit,
   ): HttpResponse<BodyType> {
     const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
 
-    if (!responseInit.headers.has('Content-Type')) {
+    if (!hasExplicitContentType) {
       responseInit.headers.set('Content-Type', 'text/xml')
     }
 
-    return new HttpResponse(body, responseInit)
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
   }
 
   /**
@@ -145,12 +177,22 @@ export class HttpResponse<
     init?: HttpResponseInit,
   ): HttpResponse<BodyType> {
     const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
 
-    if (!responseInit.headers.has('Content-Type')) {
+    if (!hasExplicitContentType) {
       responseInit.headers.set('Content-Type', 'text/html')
     }
 
-    return new HttpResponse(body, responseInit)
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
   }
 
   /**
@@ -167,8 +209,9 @@ export class HttpResponse<
     init?: HttpResponseInit,
   ): HttpResponse<BodyType> {
     const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
 
-    if (!responseInit.headers.has('Content-Type')) {
+    if (!hasExplicitContentType) {
       responseInit.headers.set('Content-Type', 'application/octet-stream')
     }
 
@@ -176,7 +219,16 @@ export class HttpResponse<
       responseInit.headers.set('Content-Length', body.byteLength.toString())
     }
 
-    return new HttpResponse(body, responseInit)
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
   }
 
   /**

package/src/core/handlers/GraphQLHandler.ts

@@ -1,3 +1,4 @@
+import { invariant } from 'outvariant'
 import {
   parse,
   type DocumentNode,
@@ -8,6 +9,7 @@ import {
   DefaultBodyType,
   RequestHandler,
   RequestHandlerDefaultInfo,
+  RequestHandlerExecutionResult,
   RequestHandlerOptions,
   ResponseResolver,
 } from './RequestHandler'
@@ -26,7 +28,9 @@ import {
 import { toPublicUrl } from '../utils/request/toPublicUrl'
 import { devUtils } from '../utils/internal/devUtils'
 import { getAllRequestCookies } from '../utils/request/getRequestCookies'
-import { invariant } from 'outvariant'
+import { ResponseResolutionContext } from 'src/iife'
+import { kDefaultContentType, StrictRequest } from '../HttpResponse'
+import { getAllAcceptedMimeTypes } from '../utils/request/getAllAcceptedMimeTypes'
 
 export interface DocumentTypeDecoration<
   Result = { [key: string]: any },
@@ -120,7 +124,7 @@ export function isDocumentNode(
 }
 
 function isDocumentTypeDecoration(
-  value: any,
+  value: unknown,
 ): value is DocumentTypeDecoration<any, any> {
   return value instanceof String
 }
@@ -309,6 +313,54 @@ Consider naming this operation or using "graphql.operation()" request handler to
     )
   }
 
+  public async run(args: {
+    request: StrictRequest<any>
+    requestId: string
+    resolutionContext?: ResponseResolutionContext
+  }): Promise<RequestHandlerExecutionResult<GraphQLRequestParsedResult> | null> {
+    const result = await super.run(args)
+
+    if (result?.response == null) {
+      return result
+    }
+
+    if (!(kDefaultContentType in result.response)) {
+      return result
+    }
+
+    const acceptedMimeTypes = getAllAcceptedMimeTypes(
+      args.request.headers.get('accept'),
+    )
+
+    if (acceptedMimeTypes.length === 0) {
+      return result
+    }
+
+    const graphqlResponseIndex = acceptedMimeTypes.indexOf(
+      'application/graphql-response+json',
+    )
+    const jsonIndex = acceptedMimeTypes.indexOf('application/json')
+
+    /**
+     * Use the "application/graphql-response+json" response content type
+     * only when the client accepts it AND prefers it over "application/json"
+     * (i.e. it appears earlier in the precedence-sorted list, or "application/json"
+     * is not listed at all).
+     * @see https://github.com/graphql/graphql-over-http/blob/4d1df1fb829ec2dd3ecbf3c6aa4025bd356c270d/spec/GraphQLOverHTTP.md#accept
+     */
+    if (
+      graphqlResponseIndex !== -1 &&
+      (jsonIndex === -1 || graphqlResponseIndex <= jsonIndex)
+    ) {
+      result.response.headers.set(
+        'content-type',
+        'application/graphql-response+json',
+      )
+    }
+
+    return result
+  }
+
   private async matchOperationName(args: {
     request: Request
     parsedResult: GraphQLRequestParsedResult

package/src/core/handlers/RequestHandler.ts

@@ -113,7 +113,7 @@ export interface RequestHandlerOptions {
 }
 
 export interface RequestHandlerExecutionResult<
-  ParsedResult extends Record<string, unknown> | undefined,
+  ParsedResult extends object | undefined,
 > {
   handler: RequestHandler
   parsedResult?: ParsedResult

package/src/core/index.ts

@@ -34,7 +34,7 @@ export type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler
 
 /* Utils */
 export { matchRequestUrl } from './utils/matching/matchRequestUrl'
-export * from './utils/handleRequest'
+export { handleRequest, type HandleRequestOptions } from './utils/handleRequest'
 export {
   onUnhandledRequest,
   type UnhandledRequestStrategy,
@@ -92,8 +92,13 @@ export type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'
 export type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'
 export type { ResponseResolutionContext } from './utils/executeHandlers'
 
-export * from './HttpResponse'
-export * from './delay'
+export {
+  HttpResponse,
+  type HttpResponseInit,
+  type StrictRequest,
+  type StrictResponse,
+} from './HttpResponse'
+export { delay, type DelayMode } from './delay'
 export { bypass } from './bypass'
 export { passthrough } from './passthrough'
 export { isCommonAssetRequest } from './isCommonAssetRequest'

package/src/core/sse.ts

@@ -333,7 +333,7 @@ class ServerSentEventClient<
     }
 
     if (message.event) {
-      frames.push(`event:${message.event?.toString()}`)
+      frames.push(`event:${message.event.toString()}`)
     }
 
     if (message.data != null) {

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

@@ -84,7 +84,7 @@ function extractMultipartVariables<VariablesType extends GraphQLVariables>(
 
       for (const path of paths) {
         if (!(path in target)) {
-          throw new Error(`Property '${paths}' is not in operations.`)
+          throw new Error(`Property '${path}' is not in operations.`)
         }
 
         target = target[path]

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

@@ -62,7 +62,9 @@ export function parseMultipartData<T extends DefaultRequestMultipartBody>(
     return undefined
   }
 
-  const boundaryRegExp = new RegExp(`--+${boundary}`)
+  const boundaryRegExp = new RegExp(
+    `--+${boundary.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`,
+  )
   const fields = data
     .split(boundaryRegExp)
     .filter((chunk) => chunk.startsWith('\r\n') && chunk.endsWith('\r\n'))

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

@@ -0,0 +1,86 @@
+import { getAllAcceptedMimeTypes } from './getAllAcceptedMimeTypes'
+
+it('returns an empty array for null accept header', () => {
+  expect(getAllAcceptedMimeTypes(null)).toEqual([])
+})
+
+it('returns a single mime type as-is', () => {
+  expect(getAllAcceptedMimeTypes('application/json')).toEqual([
+    'application/json',
+  ])
+})
+
+it('returns multiple mime types in order', () => {
+  expect(getAllAcceptedMimeTypes('text/html, application/json')).toEqual([
+    'text/html',
+    'application/json',
+  ])
+})
+
+it('sorts by quality value (q parameter)', () => {
+  expect(
+    getAllAcceptedMimeTypes('text/plain;q=0.5, application/json;q=0.9'),
+  ).toEqual(['application/json', 'text/plain'])
+})
+
+it('excludes types with q=0', () => {
+  expect(getAllAcceptedMimeTypes('text/html, text/plain;q=0')).toEqual([
+    'text/html',
+  ])
+})
+
+it('returns an empty array when all types have q=0', () => {
+  expect(getAllAcceptedMimeTypes('text/html;q=0, text/plain;q=0')).toEqual([])
+})
+
+it('treats missing q as q=1 (default)', () => {
+  expect(getAllAcceptedMimeTypes('text/plain;q=0.5, application/json')).toEqual(
+    ['application/json', 'text/plain'],
+  )
+})
+
+it('sorts by specificity when quality is equal (type/subtype > type/* > */*)', () => {
+  expect(getAllAcceptedMimeTypes('*/*, text/*, text/html')).toEqual([
+    'text/html',
+    'text/*',
+    '*/*',
+  ])
+})
+
+it('sorts by parameter count when quality and specificity are equal', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'text/plain;format=fixed;charset=utf-8, text/plain;charset=utf-8',
+    ),
+  ).toEqual(['text/plain', 'text/plain'])
+})
+
+it('applies full precedence: quality > specificity > parameter count', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'text/*;q=0.8, application/json, text/html;q=0.8, */*;q=0.1',
+    ),
+  ).toEqual(['application/json', 'text/html', 'text/*', '*/*'])
+})
+
+it('handles whitespace around values', () => {
+  expect(
+    getAllAcceptedMimeTypes('  text/html  ,  application/json ; q=0.9  '),
+  ).toEqual(['text/html', 'application/json'])
+})
+
+it('handles a realistic browser accept header', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8',
+    ),
+  ).toEqual(['text/html', 'application/xhtml+xml', 'application/xml', '*/*'])
+})
+
+it('handles the graphql-over-http accept header', () => {
+  expect(
+    getAllAcceptedMimeTypes(
+      'application/graphql-response+json, application/json',
+    ),
+  ).toEqual(['application/graphql-response+json', 'application/json'])
+})

package/src/core/utils/request/getAllAcceptedMimeTypes.ts

@@ -0,0 +1,70 @@
+/**
+ * Returns all accepted mime types, ordered by precedence as defined
+ * in [RFC 7231 Section 5.3.2](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2).
+ *
+ * Precedence rules (highest to lowest):
+ * 1. Quality value (`q` parameter, default 1).
+ * 2. Specificity: `type/subtype` > `type/*` > `*\/*`.
+ * 3. Number of media type parameters (more = more specific).
+ *
+ * Types with `q=0` are excluded (explicitly not acceptable).
+ */
+export function getAllAcceptedMimeTypes(
+  acceptHeader: string | null,
+): Array<string> {
+  if (acceptHeader == null) {
+    return []
+  }
+
+  const accepted: Array<{
+    type: string
+    quality: number
+    specificity: number
+    parameterCount: number
+  }> = []
+
+  for (const part of acceptHeader.split(',')) {
+    const [type, ...params] = part.split(';').map((v) => v.trim())
+
+    let quality = 1
+    let parameterCount = 0
+
+    for (const param of params) {
+      const [key, value] = param.split('=').map((v) => v.trim())
+
+      if (key === 'q') {
+        quality = Number(value)
+      } else {
+        parameterCount++
+      }
+    }
+
+    // RFC 7231: a quality value of 0 indicates "not acceptable".
+    if (quality === 0) {
+      continue
+    }
+
+    const [mediaType, mediaSubtype] = type.split('/')
+    const specificity = mediaType === '*' ? 0 : mediaSubtype === '*' ? 1 : 2
+
+    accepted.push({ type, quality, specificity, parameterCount })
+  }
+
+  if (!accepted.length) {
+    return []
+  }
+
+  return accepted
+    .sort((left, right) => {
+      if (right.quality !== left.quality) {
+        return right.quality - left.quality
+      }
+
+      if (right.specificity !== left.specificity) {
+        return right.specificity - left.specificity
+      }
+
+      return right.parameterCount - left.parameterCount
+    })
+    .map((entry) => entry.type)
+}

package/src/core/ws/WebSocketIndexedDBClientStore.ts

@@ -56,8 +56,7 @@ export class WebSocketIndexedDBClientStore implements WebSocketClientStore {
       promise.resolve(request.result)
     }
     request.onerror = () => {
-      // eslint-disable-next-line no-console
-      console.log(request.error)
+      console.error(request.error)
       promise.reject(
         new Error(
           `Failed to get all WebSocket clients. There is likely an additional output above.`,