@depup/msw 2.15.0-depup.8 → 3.0.0-depup.0

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

@@ -1,88 +0,0 @@
-import {
-  parse as parseCookie,
-  serialize as serializeCookie,
-} from '../../../shims/cookie'
-import { cookieStore } from '../cookieStore'
-
-function parseCookies(input: string): Record<string, string> {
-  const parsedCookies = parseCookie(input)
-  const cookies: Record<string, string> = {}
-
-  for (const cookieName in parsedCookies) {
-    if (typeof parsedCookies[cookieName] !== 'undefined') {
-      cookies[cookieName] = parsedCookies[cookieName]
-    }
-  }
-
-  return cookies
-}
-
-function getAllDocumentCookies() {
-  return parseCookies(document.cookie)
-}
-
-function getDocumentCookies(request: Request): Record<string, string> {
-  if (typeof document === 'undefined' || typeof location === 'undefined') {
-    return {}
-  }
-
-  switch (request.credentials) {
-    case 'same-origin': {
-      const requestUrl = new URL(request.url)
-
-      // Return document cookies only when requested a resource
-      // from the same origin as the current document.
-      return location.origin === requestUrl.origin
-        ? getAllDocumentCookies()
-        : {}
-    }
-
-    case 'include': {
-      // Return all document cookies.
-      return getAllDocumentCookies()
-    }
-
-    default: {
-      return {}
-    }
-  }
-}
-
-export function getAllRequestCookies(request: Request): Record<string, string> {
-  /**
-   * @note While the "cookie" header is a forbidden header field
-   * in the browser, you can read it in Node.js. We need to respect
-   * it for mocking in Node.js.
-   */
-  const requestCookieHeader = request.headers.get('cookie')
-  const cookiesFromHeaders = requestCookieHeader
-    ? parseCookies(requestCookieHeader)
-    : {}
-
-  const cookiesFromDocument = getDocumentCookies(request)
-
-  // Forward the document cookies to the request headers.
-  for (const name in cookiesFromDocument) {
-    request.headers.append(
-      'cookie',
-      serializeCookie(name, cookiesFromDocument[name]),
-    )
-  }
-
-  const cookiesFromStore = cookieStore.getCookies(request.url)
-  const storedCookiesObject = Object.fromEntries(
-    cookiesFromStore.map((cookie) => [cookie.key, cookie.value]),
-  )
-
-  // Forward the raw stored cookies to request headers
-  // so they contain metadata like "expires", "secure", etc.
-  for (const cookie of cookiesFromStore) {
-    request.headers.append('cookie', cookie.toString())
-  }
-
-  return {
-    ...cookiesFromDocument,
-    ...storedCookiesObject,
-    ...cookiesFromHeaders,
-  }
-}

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

@@ -1,62 +0,0 @@
-// @vitest-environment node
-import { onUnhandledRequest } from './onUnhandledRequest'
-
-const fixtures = {
-  warningWithoutSuggestions: (url = `/api`) => `\
-[MSW] Warning: intercepted a request without a matching request handler:
-
-  • GET ${url}
-
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/http/intercepting-requests`,
-  warningWithResponseBody: (url = `/api`) => `\
-[MSW] Warning: intercepted a request without a matching request handler:
-
-  • POST ${url}
-
-  • Request body: {"variables":{"id":"abc-123"},"query":"query UserName($id: String!) { user(id: $id) { name } }"}
-
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/http/intercepting-requests`,
-
-  errorWithoutSuggestions: `\
-[MSW] Error: intercepted a request without a matching request handler:
-
-  • GET /api
-
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/http/intercepting-requests`,
-}
-
-beforeAll(() => {
-  vi.spyOn(console, 'warn').mockImplementation(() => void 0)
-  vi.spyOn(console, 'error').mockImplementation(() => void 0)
-})
-
-afterEach(() => {
-  vi.clearAllMocks()
-})
-
-afterAll(() => {
-  vi.restoreAllMocks()
-})
-
-test('prints with an absolute URL and search params', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('https://mswjs.io/api?foo=boo')),
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithoutSuggestions(`https://mswjs.io/api?foo=boo`),
-  )
-
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api?foo=boo')),
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithoutSuggestions(`http://localhost/api?foo=boo`),
-  )
-})

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

@@ -1,226 +0,0 @@
-// @vitest-environment jsdom
-import type { UnhandledRequestCallback } from './onUnhandledRequest'
-import { onUnhandledRequest } from './onUnhandledRequest'
-
-const fixtures = {
-  warningWithoutSuggestions: (url = `/api`) => `\
-[MSW] Warning: intercepted a request without a matching request handler:
-
-  • GET ${url}
-
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/http/intercepting-requests`,
-  warningWithResponseBody: (url = `/api`) => `\
-[MSW] Warning: intercepted a request without a matching request handler:
-
-  • POST ${url}
-
-  • Request body: {"variables":{"id":"abc-123"},"query":"query UserName($id: String!) { user(id: $id) { name } }"}
-
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/http/intercepting-requests`,
-
-  errorWithoutSuggestions: `\
-[MSW] Error: intercepted a request without a matching request handler:
-
-  • GET /api
-
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/http/intercepting-requests`,
-}
-
-beforeEach(() => {
-  vi.spyOn(console, 'warn').mockImplementation(() => void 0)
-  vi.spyOn(console, 'error').mockImplementation(() => void 0)
-})
-
-afterEach(() => {
-  vi.restoreAllMocks()
-})
-
-test('supports the "bypass" request strategy', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    'bypass',
-  )
-
-  expect(console.warn).not.toHaveBeenCalled()
-  expect(console.error).not.toHaveBeenCalled()
-})
-
-test('supports the "warn" request strategy', async () => {
-  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithoutSuggestions(),
-  )
-})
-
-test('supports the "warn" request strategy with request body', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api'), {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        variables: {
-          id: 'abc-123',
-        },
-        query: 'query UserName($id: String!) { user(id: $id) { name } }',
-      }),
-    }),
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithResponseBody())
-})
-
-test('supports the "error" request strategy', async () => {
-  await expect(
-    onUnhandledRequest(new Request(new URL('http://localhost/api')), 'error'),
-  ).rejects.toThrow(
-    '[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
-  )
-
-  expect(console.error).toHaveBeenCalledWith(fixtures.errorWithoutSuggestions)
-})
-
-test('supports a custom callback function', async () => {
-  const callback = vi.fn<UnhandledRequestCallback>((request) => {
-    console.warn(`callback: ${request.method} ${request.url}`)
-  })
-  const request = new Request(new URL('/user', 'http://localhost:3000'))
-  await onUnhandledRequest(request, callback)
-
-  expect(callback).toHaveBeenCalledTimes(1)
-  expect(callback).toHaveBeenCalledWith(request, {
-    warning: expect.any(Function),
-    error: expect.any(Function),
-  })
-
-  // Check that the custom logic in the callback was called.
-  expect(console.warn).toHaveBeenCalledWith(
-    `callback: GET http://localhost:3000/user`,
-  )
-})
-
-test('supports calling default strategies from the custom callback function', async () => {
-  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.`,
-  )
-
-  expect(callback).toHaveBeenCalledTimes(1)
-  expect(callback).toHaveBeenCalledWith(request, {
-    warning: expect.any(Function),
-    error: expect.any(Function),
-  })
-
-  // Check that the default strategy was called.
-  expect(console.error).toHaveBeenCalledWith(fixtures.errorWithoutSuggestions)
-})
-
-test('does not print any suggestions given no handlers to suggest', async () => {
-  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithoutSuggestions(),
-  )
-})
-
-test('throws an exception given unknown request strategy', async () => {
-  await expect(
-    onUnhandledRequest(
-      new Request(new URL('http://localhost/api')),
-      // @ts-expect-error Intentional unknown strategy.
-      'invalid-strategy',
-    ),
-  ).rejects.toThrow(
-    '[MSW] Failed to react to an unhandled request: unknown strategy "invalid-strategy". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
-  )
-})
-
-test('prints with a relative URL and search params', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api?foo=boo')),
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithoutSuggestions(`/api?foo=boo`),
-  )
-})
-
-test('prints with an absolute URL and search params', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('https://mswjs.io/api?foo=boo')),
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    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,81 +0,0 @@
-import { toPublicUrl } from './toPublicUrl'
-import { InternalError, devUtils } from '../internal/devUtils'
-import { isCommonAssetRequest } from '../../isCommonAssetRequest'
-
-export interface UnhandledRequestPrint {
-  warning: () => void
-  error: () => void
-}
-
-export type UnhandledRequestCallback = (
-  request: Request,
-  print: UnhandledRequestPrint,
-) => void
-
-export type UnhandledRequestStrategy =
-  | 'bypass'
-  | 'warn'
-  | 'error'
-  | UnhandledRequestCallback
-
-export async function onUnhandledRequest(
-  request: Request,
-  strategy: UnhandledRequestStrategy = 'warn',
-): Promise<void> {
-  const url = new URL(request.url)
-  const publicUrl = toPublicUrl(url) + url.search
-
-  const requestBody =
-    request.method === 'HEAD' || request.method === 'GET'
-      ? null
-      : await request.clone().text()
-  const messageDetails = `\n\n  \u2022 ${request.method} ${publicUrl}\n\n${requestBody ? `  \u2022 Request body: ${requestBody}\n\n` : ''}`
-  const unhandledRequestMessage = `intercepted a request without a matching request handler:${messageDetails}If you still wish to intercept this unhandled request, please create a request handler for it.\nRead more: https://mswjs.io/docs/http/intercepting-requests`
-
-  function applyStrategy(strategy: UnhandledRequestStrategy) {
-    switch (strategy) {
-      case 'error': {
-        // Print a developer-friendly error.
-        devUtils.error('Error: %s', unhandledRequestMessage)
-
-        // Throw an exception to halt request processing and not perform the original request.
-        throw new InternalError(
-          devUtils.formatMessage(
-            'Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.',
-          ),
-        )
-      }
-
-      case 'warn': {
-        devUtils.warn('Warning: %s', unhandledRequestMessage)
-        break
-      }
-
-      case 'bypass':
-        break
-
-      default:
-        throw new InternalError(
-          devUtils.formatMessage(
-            'Failed to react to an unhandled request: unknown strategy "%s". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
-            strategy,
-          ),
-        )
-    }
-  }
-
-  if (typeof strategy === 'function') {
-    strategy(request, {
-      warning: applyStrategy.bind(null, 'warn'),
-      error: applyStrategy.bind(null, 'error'),
-    })
-    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)
-  }
-}

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

@@ -1,15 +0,0 @@
-import { cookieStore } from '../cookieStore'
-import { getRawSetCookie } from '../HttpResponse/decorators'
-
-export async function storeResponseCookies(
-  request: Request,
-  response: Response,
-): Promise<void> {
-  // Grab the raw "Set-Cookie" response header provided
-  // in the HeadersInit for this mocked response.
-  const responseCookies = getRawSetCookie(response)
-
-  if (responseCookies) {
-    await cookieStore.setCookie(responseCookies, request.url)
-  }
-}

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

@@ -1,22 +0,0 @@
-import { cleanUrl } from './cleanUrl'
-
-it('removes query parameters from a URL string', () => {
-  expect(cleanUrl('/user?id=123')).toEqual('/user')
-  expect(cleanUrl('/user?id=123&id=456')).toEqual('/user')
-  expect(cleanUrl('/user?id=123&role=admin')).toEqual('/user')
-})
-
-it('removes hashes from a URL string', () => {
-  expect(cleanUrl('/user#hash')).toEqual('/user')
-  expect(cleanUrl('/user#hash-with-dashes')).toEqual('/user')
-})
-
-it('removes both query parameters and hashes from a URL string', () => {
-  expect(cleanUrl('/user?id=123#some')).toEqual('/user')
-  expect(cleanUrl('/user?id=123&role=admin#some')).toEqual('/user')
-})
-
-it('preserves optional path parameters', () => {
-  expect(cleanUrl('/user/:id?')).toEqual('/user/:id?')
-  expect(cleanUrl('/user/:id?/:messageId?')).toEqual('/user/:id?/:messageId?')
-})

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

@@ -1,16 +0,0 @@
-const REDUNDANT_CHARACTERS_EXP = /[?|#].*$/g
-
-/**
- * Removes search parameters and the fragment
- * from a given URL string.
- */
-export function cleanUrl(path: string): string {
-  // If the path ends with an optional path parameter,
-  // return it as-is.
-  if (path.endsWith('?')) {
-    return path
-  }
-
-  // Otherwise, remove the search and fragment from it.
-  return path.replace(REDUNDANT_CHARACTERS_EXP, '')
-}

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

@@ -1,32 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { isAbsoluteUrl } from './isAbsoluteUrl'
-
-it('returns true for the "http" scheme', () => {
-  expect(isAbsoluteUrl('http://www.domain.com')).toEqual(true)
-})
-
-it('returns true for the "https" scheme', () => {
-  expect(isAbsoluteUrl('https://www.domain.com')).toEqual(true)
-})
-
-it('returns true for the "ws" scheme', () => {
-  expect(isAbsoluteUrl('ws://www.domain.com')).toEqual(true)
-})
-
-it('returns true for the "ftp" scheme', () => {
-  expect(isAbsoluteUrl('ftp://www.domain.com')).toEqual(true)
-})
-
-it('returns true for the custom scheme', () => {
-  expect(isAbsoluteUrl('web+my://www.example.com')).toEqual(true)
-})
-
-it('returns false for the relative URL', () => {
-  expect(isAbsoluteUrl('/test')).toEqual(false)
-})
-
-it('returns false for the relative URL without a leading slash', () => {
-  expect(isAbsoluteUrl('test')).toEqual(false)
-})

package/src/core/ws/handleWebSocketEvent.ts

@@ -1,68 +0,0 @@
-import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
-import type { RequestHandler } from '../handlers/RequestHandler'
-import type { WebSocketHandler } from '../handlers/WebSocketHandler'
-import { webSocketInterceptor } from './webSocketInterceptor'
-import {
-  onUnhandledRequest,
-  type UnhandledRequestStrategy,
-} from '../utils/request/onUnhandledRequest'
-import { isHandlerKind } from '../utils/internal/isHandlerKind'
-
-interface HandleWebSocketEventOptions {
-  getUnhandledRequestStrategy: () => UnhandledRequestStrategy
-  getHandlers: () => Array<RequestHandler | WebSocketHandler>
-  onMockedConnection: (connection: WebSocketConnectionData) => void
-  onPassthroughConnection: (onnection: WebSocketConnectionData) => void
-}
-
-export function handleWebSocketEvent(options: HandleWebSocketEventOptions) {
-  webSocketInterceptor.on('connection', async (connection) => {
-    /**
-     * @todo @fixme Reference the handlers controller here and use `.getHandlersByKind`.
-     * That one relies on the pre-grouped handlers map and will be more performant.
-     */
-    const handlers = options.getHandlers().filter(isHandlerKind('websocket'))
-
-    // Ignore this connection if the user hasn't defined any handlers.
-    if (handlers.length > 0) {
-      options?.onMockedConnection(connection)
-
-      await Promise.all(
-        handlers.map((handler) => {
-          // Iterate over the handlers and forward the connection
-          // event to WebSocket event handlers. This is equivalent
-          // to dispatching that event onto multiple listeners.
-          return handler.run(connection)
-        }),
-      )
-
-      return
-    }
-
-    // Construct a request representing this WebSocket connection.
-    const request = new Request(connection.client.url, {
-      headers: {
-        upgrade: 'websocket',
-        connection: 'upgrade',
-      },
-    })
-    await onUnhandledRequest(
-      request,
-      options.getUnhandledRequestStrategy(),
-    ).catch((error) => {
-      const errorEvent = new Event('error')
-      Object.defineProperty(errorEvent, 'cause', {
-        enumerable: true,
-        configurable: false,
-        value: error,
-      })
-      connection.client.socket.dispatchEvent(errorEvent)
-    })
-
-    options?.onPassthroughConnection(connection)
-
-    // If none of the "ws" handlers matched,
-    // establish the WebSocket connection as-is.
-    connection.server.connect()
-  })
-}

package/src/core/ws/utils/getPublicData.ts

@@ -1,18 +0,0 @@
-import type { WebSocketData } from '@mswjs/interceptors/WebSocket'
-import { isObject } from '../../utils/internal/isObject'
-import { truncateMessage } from './truncateMessage'
-
-export async function getPublicData(data: WebSocketData): Promise<string> {
-  if (data instanceof Blob) {
-    const text = await data.text()
-    return `Blob(${truncateMessage(text)})`
-  }
-
-  // Handle all ArrayBuffer-like objects.
-  if (isObject(data)) {
-    const text = new TextDecoder().decode(data as ArrayBuffer)
-    return `ArrayBuffer(${truncateMessage(text)})`
-  }
-
-  return truncateMessage(data)
-}

package/src/core/ws/webSocketInterceptor.ts

@@ -1,3 +0,0 @@
-import { WebSocketInterceptor } from '@mswjs/interceptors/WebSocket'
-
-export const webSocketInterceptor = new WebSocketInterceptor()

package/src/native/index.ts

@@ -1,44 +0,0 @@
-import type { Interceptor } from '@mswjs/interceptors'
-import { FetchInterceptor } from '@mswjs/interceptors/fetch'
-import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
-import type { AnyHandler } from '#core/experimental/handlers-controller'
-import {
-  defineNetwork,
-  type DefineNetworkOptions,
-} from '#core/experimental/define-network'
-import { InterceptorSource } from '#core/experimental/sources/interceptor-source'
-import { type SetupServerCommon } from '../node/glossary'
-import { defineSetupServerApi } from '../node/setup-server-common'
-
-const defaultInterceptors: Array<Interceptor<any>> = [
-  new FetchInterceptor(),
-  new XMLHttpRequestInterceptor(),
-]
-
-export const defaultNetworkOptions: DefineNetworkOptions<[InterceptorSource]> =
-  {
-    sources: [
-      new InterceptorSource({
-        interceptors: defaultInterceptors,
-      }),
-    ],
-    onUnhandledFrame: 'warn',
-    context: {
-      quiet: true,
-    },
-  }
-
-/**
- * Sets up a requests interception in React Native with the given request handlers.
- * @param {Array<AnyHandler>} handlers List of request handlers.
- *
- * @see {@link https://mswjs.io/docs/api/setup-server `setupServer()` API reference}
- */
-export function setupServer(...handlers: Array<AnyHandler>): SetupServerCommon {
-  const network = defineNetwork({
-    ...defaultNetworkOptions,
-    handlers,
-  })
-
-  return defineSetupServerApi(network)
-}

package/src/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}