msw 2.7.3 → 2.7.5

package/lib/mockServiceWorker.js

@@ -8,7 +8,7 @@
  * - Please do NOT serve this file on production.
  */
 
-const PACKAGE_VERSION = '2.7.3'
+const PACKAGE_VERSION = '2.7.5'
 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.3",
+  "version": "2.7.5",
   "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/handlers/WebSocketHandler.test.ts

@@ -0,0 +1,160 @@
+import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
+import { WebSocketHandler } from './WebSocketHandler'
+
+describe('parse', () => {
+  it('matches an exact url', () => {
+    expect(
+      new WebSocketHandler('ws://localhost:3000').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL('ws://localhost:3000'),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {},
+      },
+    })
+  })
+
+  it('ignores trailing slash', () => {
+    expect(
+      new WebSocketHandler('ws://localhost:3000').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL('ws://localhost:3000/'),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {},
+      },
+    })
+
+    expect(
+      new WebSocketHandler('ws://localhost:3000/').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL('ws://localhost:3000'),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {},
+      },
+    })
+  })
+
+  it('supports path parameters', () => {
+    expect(
+      new WebSocketHandler('ws://localhost:3000/:serviceName').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL('ws://localhost:3000/auth'),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {
+          serviceName: 'auth',
+        },
+      },
+    })
+  })
+
+  it('ignores "/socket.io/" prefix in the client url', () => {
+    expect(
+      new WebSocketHandler('ws://localhost:3000').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL(
+                'ws://localhost:3000/socket.io/?EIO=4&transport=websocket',
+              ),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {},
+      },
+    })
+
+    expect(
+      new WebSocketHandler('ws://localhost:3000/non-matching').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL(
+                'ws://localhost:3000/socket.io/?EIO=4&transport=websocket',
+              ),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: false,
+        params: {},
+      },
+    })
+  })
+
+  it('preserves non-prefix "/socket.io/" path segment', () => {
+    /**
+     * @note It is highly unlikely but we still shouldn't modify the
+     * WebSocket client URL if it contains a user-defined "socket.io" segment.
+     */
+    expect(
+      new WebSocketHandler('ws://localhost:3000/clients/socket.io/123').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL('ws://localhost:3000/clients/socket.io/123'),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {},
+      },
+    })
+
+    expect(
+      new WebSocketHandler('ws://localhost:3000').parse({
+        event: new MessageEvent('connection', {
+          data: {
+            client: {
+              url: new URL('ws://localhost:3000/clients/socket.io/123'),
+            },
+          } as WebSocketConnectionData,
+        }),
+      }),
+    ).toEqual({
+      match: {
+        matches: false,
+        params: {},
+      },
+    })
+  })
+})

package/src/core/handlers/WebSocketHandler.ts

@@ -47,8 +47,17 @@ export class WebSocketHandler {
   public parse(args: {
     event: MessageEvent<WebSocketConnectionData>
   }): WebSocketHandlerParsedResult {
-    const connection = args.event.data
-    const match = matchRequestUrl(connection.client.url, this.url)
+    const { data: connection } = args.event
+    const { url: clientUrl } = connection.client
+
+    /**
+     * @note Remove the Socket.IO path prefix from the WebSocket
+     * client URL. This is an exception to keep the users from
+     * including the implementation details in their handlers.
+     */
+    clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, '/')
+
+    const match = matchRequestUrl(clientUrl, this.url)
 
     return {
       match,

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.