msw 2.7.2 → 2.7.4

package/lib/mockServiceWorker.js

@@ -8,7 +8,7 @@
  * - Please do NOT serve this file on production.
  */
 
-const PACKAGE_VERSION = '2.7.2'
+const PACKAGE_VERSION = '2.7.4'
 const INTEGRITY_CHECKSUM = '00729d72e3b82faf54ca8b9621dbb96f'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.7.2",
+  "version": "2.7.4",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "./lib/core/index.js",
   "module": "./lib/core/index.mjs",

package/src/browser/utils/getAbsoluteWorkerUrl.test.ts

@@ -1,6 +1,4 @@
-/**
- * @vitest-environment jsdom
- */
+// @vitest-environment jsdom
 import { getAbsoluteWorkerUrl } from './getAbsoluteWorkerUrl'
 
 const rawLocation = window.location

package/src/core/handlers/GraphQLHandler.ts

@@ -72,6 +72,7 @@ export type GraphQLResponseBody<BodyType extends DefaultBodyType> =
   | {
       data?: BodyType | null
       errors?: readonly Partial<GraphQLError>[] | null
+      extensions?: Record<string, any>
     }
   | null
   | undefined

package/src/core/index.ts

@@ -62,6 +62,7 @@ export * from './HttpResponse'
 export * from './delay'
 export { bypass } from './bypass'
 export { passthrough } from './passthrough'
+export { isCommonAssetRequest } from './isCommonAssetRequest'
 
 // Validate environmental globals before executing any code.
 // This ensures that the library gives user-friendly errors

package/src/core/isCommonAssetRequest.ts

@@ -0,0 +1,45 @@
+/**
+ * Determines if the given request is a static asset request.
+ * Useful when deciding which unhandled requests to ignore.
+ * @note Despite being ignored, you can still intercept and mock
+ * static assets by creating request handlers for them.
+ *
+ * @example
+ * import { isCommonAssetRequest } from 'msw'
+ *
+ * await worker.start({
+ *   onUnhandledRequest(request, print) {
+ *     if (!isCommonAssetRequest(request)) {
+ *       print.warning()
+ *     }
+ *   }
+ * })
+ */
+export function isCommonAssetRequest(request: Request): boolean {
+  const url = new URL(request.url)
+
+  // Ignore certain protocols.
+  if (url.protocol === 'file:') {
+    return true
+  }
+
+  // Ignore static assets hosts.
+  if (/(fonts\.googleapis\.com)/.test(url.hostname)) {
+    return true
+  }
+
+  // Ignore node modules served over HTTP.
+  if (/node_modules/.test(url.pathname)) {
+    return true
+  }
+
+  // Ignore internal Vite requests, like "/@vite/client".
+  if (url.pathname.includes('@vite')) {
+    return true
+  }
+
+  // Ignore common static assets.
+  return /\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(
+    url.pathname,
+  )
+}

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

@@ -1,6 +1,4 @@
-/**
- * @vitest-environment jsdom
- */
+// @vitest-environment jsdom
 import {
   onUnhandledRequest,
   UnhandledRequestCallback,
@@ -90,7 +88,7 @@ test('supports the "error" request strategy', async () => {
 })
 
 test('supports a custom callback function', async () => {
-  const callback = vi.fn<Parameters<UnhandledRequestCallback>>((request) => {
+  const callback = vi.fn<UnhandledRequestCallback>((request) => {
     console.warn(`callback: ${request.method} ${request.url}`)
   })
   const request = new Request(new URL('/user', 'http://localhost:3000'))
@@ -109,12 +107,10 @@ test('supports a custom callback function', async () => {
 })
 
 test('supports calling default strategies from the custom callback function', async () => {
-  const callback = vi.fn<Parameters<UnhandledRequestCallback>>(
-    (request, print) => {
-      // Call the default "error" strategy.
-      print.error()
-    },
-  )
+  const callback = vi.fn<UnhandledRequestCallback>((request, print) => {
+    // Call the default "error" strategy.
+    print.error()
+  })
   const request = new Request(new URL('http://localhost/api'))
   await expect(onUnhandledRequest(request, callback)).rejects.toThrow(
     `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.`,
@@ -171,3 +167,62 @@ test('prints with an absolute URL and search params', async () => {
     fixtures.warningWithoutSuggestions(`https://mswjs.io/api?foo=boo`),
   )
 })
+
+test('ignores common static assets when using the "warn" strategy', async () => {
+  await Promise.allSettled([
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/main.css')),
+      'warn',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/index.mjs')),
+      'warn',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/node_modules/abc-123')),
+      'warn',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://fonts.googleapis.com/some-font')),
+      'warn',
+    ),
+  ])
+
+  expect(console.warn).not.toHaveBeenCalled()
+})
+
+test('ignores common static assets when using the "error" strategy', async () => {
+  await Promise.allSettled([
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/main.css')),
+      'error',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/index.mjs')),
+      'error',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://example.com/node_modules/abc-123')),
+      'error',
+    ),
+    onUnhandledRequest(
+      new Request(new URL('https://fonts.googleapis.com/some-font')),
+      'error',
+    ),
+  ])
+
+  expect(console.error).not.toHaveBeenCalled()
+})
+
+test('exposes common static assets to the explicit callback', async () => {
+  let callbackRequest!: Request
+  await onUnhandledRequest(
+    new Request(new URL('https://example.com/main.css')),
+    (request) => {
+      callbackRequest = request
+    },
+  )
+
+  expect(callbackRequest).toBeInstanceOf(Request)
+  expect(callbackRequest.url).toBe('https://example.com/main.css')
+})

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

@@ -1,5 +1,6 @@
 import { toPublicUrl } from './toPublicUrl'
 import { InternalError, devUtils } from '../internal/devUtils'
+import { isCommonAssetRequest } from '../../isCommonAssetRequest'
 
 export interface UnhandledRequestPrint {
   warning(): void
@@ -71,15 +72,10 @@ export async function onUnhandledRequest(
     return
   }
 
-  /**
-   * @note Ignore "file://" requests.
-   * Those often are an implementation detail of modern tooling
-   * that fetches modules via HTTP. Developers don't issue those
-   * requests and so they mustn't be warned about them.
-   */
-  if (url.protocol === 'file:') {
-    return
+  // Ignore common static asset requests when using a built-in strategy.
+  // There's a slight overhead here because this utility will create a request URL
+  // instance again despite us having done so previously in this function.
+  if (!isCommonAssetRequest(request)) {
+    applyStrategy(strategy)
   }
-
-  applyStrategy(strategy)
 }

package/src/core/utils/url/getAbsoluteUrl.test.ts

@@ -1,29 +1,47 @@
-/**
- * @vitest-environment jsdom
- */
+// @vitest-environment jsdom
 import { getAbsoluteUrl } from './getAbsoluteUrl'
 
-it('rebases a relative URL against the current "baseURI" (default)', () => {
-  expect(getAbsoluteUrl('/reviews')).toEqual('http://localhost/reviews')
+const rawLocation = window.location
+
+afterAll(() => {
+  Object.defineProperty(window, 'location', {
+    value: rawLocation,
+  })
+})
+
+it('resolves a relative URL against the current location (default)', () => {
+  expect(getAbsoluteUrl('/reviews')).toBe('http://localhost/reviews')
+})
+
+it('supports relative URLs starting with search parameters', () => {
+  Object.defineProperty(window, 'location', {
+    value: {
+      href: 'http://localhost/nested',
+    },
+  })
+
+  expect(getAbsoluteUrl('?resourceId=abc-123')).toBe(
+    'http://localhost/nested?resourceId=abc-123',
+  )
 })
 
-it('rebases a relative URL against a custom base URL', () => {
-  expect(getAbsoluteUrl('/user', 'https://api.github.com')).toEqual(
+it('resolves a relative URL against a custom base URL', () => {
+  expect(getAbsoluteUrl('/user', 'https://api.github.com')).toBe(
     'https://api.github.com/user',
   )
 })
 
 it('returns a given absolute URL as-is', () => {
-  expect(getAbsoluteUrl('https://api.mswjs.io/users')).toEqual(
+  expect(getAbsoluteUrl('https://api.mswjs.io/users')).toBe(
     'https://api.mswjs.io/users',
   )
 })
 
 it('returns an absolute URL given a relative path without a leading slash', () => {
-  expect(getAbsoluteUrl('users')).toEqual('http://localhost/users')
+  expect(getAbsoluteUrl('users')).toBe('http://localhost/users')
 })
 
 it('returns a path with a pattern as-is', () => {
-  expect(getAbsoluteUrl(':api/user')).toEqual('http://localhost/:api/user')
-  expect(getAbsoluteUrl('*/resource/*')).toEqual('*/resource/*')
+  expect(getAbsoluteUrl(':api/user')).toBe('http://localhost/:api/user')
+  expect(getAbsoluteUrl('*/resource/*')).toBe('*/resource/*')
 })

package/src/core/utils/url/getAbsoluteUrl.ts

@@ -16,8 +16,7 @@ export function getAbsoluteUrl(path: string, baseUrl?: string): string {
 
   // Resolve a relative request URL against a given custom "baseUrl"
   // or the document baseURI (in the case of browser/browser-like environments).
-  const origin =
-    baseUrl || (typeof document !== 'undefined' && document.baseURI)
+  const origin = baseUrl || (typeof location !== 'undefined' && location.href)
 
   return origin
     ? // Encode and decode the path to preserve escaped characters.