msw 2.12.14 → 2.13.1

package/src/browser/setupWorker/start/utils/prepareStartHandler.ts

@@ -1,44 +0,0 @@
-import { RequiredDeep } from '~/core/typeUtils'
-import { mergeRight } from '~/core/utils/internal/mergeRight'
-import {
-  SetupWorker,
-  SetupWorkerInternalContext,
-  StartHandler,
-  StartOptions,
-} from '../../glossary'
-
-export const DEFAULT_START_OPTIONS: RequiredDeep<StartOptions> = {
-  serviceWorker: {
-    url: '/mockServiceWorker.js',
-    options: null as any,
-  },
-  quiet: false,
-  waitUntilReady: true,
-  onUnhandledRequest: 'warn',
-  findWorker(scriptURL, mockServiceWorkerUrl) {
-    return scriptURL === mockServiceWorkerUrl
-  },
-}
-
-/**
- * Returns resolved worker start options, merging the default options
- * with the given custom options.
- */
-export function resolveStartOptions(
-  initialOptions?: StartOptions,
-): RequiredDeep<StartOptions> {
-  return mergeRight(
-    DEFAULT_START_OPTIONS,
-    initialOptions || {},
-  ) as RequiredDeep<StartOptions>
-}
-
-export function prepareStartHandler(
-  handler: StartHandler,
-  context: SetupWorkerInternalContext,
-): SetupWorker['start'] {
-  return (initialOptions) => {
-    context.startOptions = resolveStartOptions(initialOptions)
-    return handler(context.startOptions, initialOptions || {})
-  }
-}

package/src/browser/setupWorker/start/utils/printStartMessage.test.ts

@@ -1,84 +0,0 @@
-import { printStartMessage } from './printStartMessage'
-
-beforeEach(() => {
-  vi.spyOn(console, 'groupCollapsed').mockImplementation(() => void 0)
-  vi.spyOn(console, 'log').mockImplementation(() => void 0)
-})
-
-afterEach(() => {
-  vi.restoreAllMocks()
-})
-
-test('prints out a default start message into console', () => {
-  printStartMessage({
-    workerScope: 'http://localhost:3000/',
-    workerUrl: 'http://localhost:3000/worker.js',
-  })
-
-  expect(console.groupCollapsed).toHaveBeenCalledWith(
-    '%c[MSW] Mocking enabled.',
-    expect.anything(),
-  )
-
-  // Includes a link to the documentation.
-  expect(console.log).toHaveBeenCalledWith(
-    '%cDocumentation: %chttps://mswjs.io/docs',
-    expect.anything(),
-    expect.anything(),
-  )
-
-  // Includes a link to the GitHub issues page.
-  expect(console.log).toHaveBeenCalledWith(
-    'Found an issue? https://github.com/mswjs/msw/issues',
-  )
-
-  // Includes service worker scope.
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker scope:',
-    'http://localhost:3000/',
-  )
-
-  // Includes service worker script location.
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker script URL:',
-    'http://localhost:3000/worker.js',
-  )
-})
-
-test('supports printing a custom start message', () => {
-  printStartMessage({ message: 'Custom start message' })
-
-  expect(console.groupCollapsed).toHaveBeenCalledWith(
-    '%c[MSW] Custom start message',
-    expect.anything(),
-  )
-})
-
-test('does not print any messages when log level is quiet', () => {
-  printStartMessage({ quiet: true })
-
-  expect(console.groupCollapsed).not.toHaveBeenCalled()
-  expect(console.log).not.toHaveBeenCalled()
-})
-
-test('prints a worker scope in the start message', () => {
-  printStartMessage({
-    workerScope: 'http://localhost:3000/user',
-  })
-
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker scope:',
-    'http://localhost:3000/user',
-  )
-})
-
-test('prints a worker script url in the start message', () => {
-  printStartMessage({
-    workerUrl: 'http://localhost:3000/mockServiceWorker.js',
-  })
-
-  expect(console.log).toHaveBeenCalledWith(
-    'Worker script URL:',
-    'http://localhost:3000/mockServiceWorker.js',
-  )
-})

package/src/browser/setupWorker/start/utils/printStartMessage.ts

@@ -1,51 +0,0 @@
-import type { ServiceWorkerIncomingEventsMap } from '../../glossary'
-import { devUtils } from '~/core/utils/internal/devUtils'
-
-interface PrintStartMessageArgs {
-  quiet?: boolean
-  message?: string
-  workerUrl?: string
-  workerScope?: string
-  client?: ServiceWorkerIncomingEventsMap['MOCKING_ENABLED']['client']
-}
-
-/**
- * Prints a worker activation message in the browser's console.
- */
-export function printStartMessage(args: PrintStartMessageArgs = {}) {
-  if (args.quiet) {
-    return
-  }
-
-  const message = args.message || 'Mocking enabled.'
-
-  console.groupCollapsed(
-    `%c${devUtils.formatMessage(message)}`,
-    'color:orangered;font-weight:bold;',
-  )
-  // eslint-disable-next-line no-console
-  console.log(
-    '%cDocumentation: %chttps://mswjs.io/docs',
-    'font-weight:bold',
-    'font-weight:normal',
-  )
-  // eslint-disable-next-line no-console
-  console.log('Found an issue? https://github.com/mswjs/msw/issues')
-
-  if (args.workerUrl) {
-    // eslint-disable-next-line no-console
-    console.log('Worker script URL:', args.workerUrl)
-  }
-
-  if (args.workerScope) {
-    // eslint-disable-next-line no-console
-    console.log('Worker scope:', args.workerScope)
-  }
-
-  if (args.client) {
-    // eslint-disable-next-line no-console
-    console.log('Client ID: %s (%s)', args.client.id, args.client.frameType)
-  }
-
-  console.groupEnd()
-}

package/src/browser/setupWorker/start/utils/validateWorkerScope.ts

@@ -1,18 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-import { StartOptions } from '../../glossary'
-
-export function validateWorkerScope(
-  registration: ServiceWorkerRegistration,
-  options?: StartOptions,
-): void {
-  if (!options?.quiet && !location.href.startsWith(registration.scope)) {
-    devUtils.warn(
-      `\
-Cannot intercept requests on this page because it's outside of the worker's scope ("${registration.scope}"). If you wish to mock API requests on this page, you must resolve this scope issue.
-
-- (Recommended) Register the worker at the root level ("/") of your application.
-- Set the "Service-Worker-Allowed" response header to allow out-of-scope workers.\
-`,
-    )
-  }
-}

package/src/browser/setupWorker/stop/utils/printStopMessage.test.ts

@@ -1,26 +0,0 @@
-import { printStopMessage } from './printStopMessage'
-
-beforeAll(() => {
-  vi.spyOn(global.console, 'log').mockImplementation(() => void 0)
-})
-
-afterEach(() => {
-  vi.resetAllMocks()
-})
-
-afterAll(() => {
-  vi.restoreAllMocks()
-})
-
-test('prints a stop message to the console', () => {
-  printStopMessage()
-  expect(console.log).toHaveBeenCalledWith(
-    '%c[MSW] Mocking disabled.',
-    'color:orangered;font-weight:bold;',
-  )
-})
-
-test('does not print any message when log level is quiet', () => {
-  printStopMessage({ quiet: true })
-  expect(console.log).not.toHaveBeenCalled()
-})

package/src/browser/setupWorker/stop/utils/printStopMessage.ts

@@ -1,13 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-
-export function printStopMessage(args: { quiet?: boolean } = {}): void {
-  if (args.quiet) {
-    return
-  }
-
-  // eslint-disable-next-line no-console
-  console.log(
-    `%c${devUtils.formatMessage('Mocking disabled.')}`,
-    'color:orangered;font-weight:bold;',
-  )
-}

package/src/browser/utils/checkWorkerIntegrity.ts

@@ -1,42 +0,0 @@
-import { devUtils } from '~/core/utils/internal/devUtils'
-import type { SetupWorkerInternalContext } from '../setupWorker/glossary'
-import { DeferredPromise } from '@open-draft/deferred-promise'
-
-/**
- * Check whether the registered Service Worker has been
- * generated by the installed version of the library.
- * Prints a warning message if the worker scripts mismatch.
- */
-export function checkWorkerIntegrity(
-  context: SetupWorkerInternalContext,
-): Promise<void> {
-  const integrityCheckPromise = new DeferredPromise<void>()
-
-  // Request the integrity checksum from the registered worker.
-  context.workerChannel.postMessage('INTEGRITY_CHECK_REQUEST')
-  context.workerChannel.once('INTEGRITY_CHECK_RESPONSE', (event) => {
-    const { checksum, packageVersion } = event.data
-
-    // Compare the response from the Service Worker and the
-    // global variable set during the build.
-
-    // The integrity is validated based on the worker script's checksum
-    // that's derived from its minified content during the build.
-    // The "SERVICE_WORKER_CHECKSUM" global variable is injected by the build.
-    if (checksum !== SERVICE_WORKER_CHECKSUM) {
-      devUtils.warn(
-        `The currently registered Service Worker has been generated by a different version of MSW (${packageVersion}) and may not be fully compatible with the installed version.
-
-It's recommended you update your worker script by running this command:
-
-  \u2022 npx msw init <PUBLIC_DIR>
-
-You can also automate this process and make the worker script update automatically upon the library installations. Read more: https://mswjs.io/docs/cli/init.`,
-      )
-    }
-
-    integrityCheckPromise.resolve()
-  })
-
-  return integrityCheckPromise
-}

package/src/core/SetupApi.ts

@@ -1,127 +0,0 @@
-import { invariant } from 'outvariant'
-import { EventMap, Emitter } from 'strict-event-emitter'
-import { RequestHandler } from './handlers/RequestHandler'
-import { LifeCycleEventEmitter } from './sharedOptions'
-import { devUtils } from './utils/internal/devUtils'
-import { pipeEvents } from './utils/internal/pipeEvents'
-import { toReadonlyArray } from './utils/internal/toReadonlyArray'
-import { Disposable } from './utils/internal/Disposable'
-import type { WebSocketHandler } from './handlers/WebSocketHandler'
-
-export abstract class HandlersController {
-  abstract prepend(
-    runtimeHandlers: Array<RequestHandler | WebSocketHandler>,
-  ): void
-  abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void
-  abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>
-}
-
-export class InMemoryHandlersController implements HandlersController {
-  private handlers: Array<RequestHandler | WebSocketHandler>
-
-  constructor(
-    private initialHandlers: Array<RequestHandler | WebSocketHandler>,
-  ) {
-    this.handlers = [...initialHandlers]
-  }
-
-  public prepend(
-    runtimeHandles: Array<RequestHandler | WebSocketHandler>,
-  ): void {
-    this.handlers.unshift(...runtimeHandles)
-  }
-
-  public reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void {
-    this.handlers =
-      nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers]
-  }
-
-  public currentHandlers(): Array<RequestHandler | WebSocketHandler> {
-    return this.handlers
-  }
-}
-
-/**
- * Generic class for the mock API setup.
- */
-export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
-  protected handlersController: HandlersController
-  protected readonly emitter: Emitter<EventsMap>
-  protected readonly publicEmitter: Emitter<EventsMap>
-
-  public readonly events: LifeCycleEventEmitter<EventsMap>
-
-  constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>) {
-    super()
-
-    invariant(
-      this.validateHandlers(initialHandlers),
-      devUtils.formatMessage(
-        `Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`,
-      ),
-    )
-
-    this.handlersController = new InMemoryHandlersController(initialHandlers)
-
-    this.emitter = new Emitter<EventsMap>()
-    this.publicEmitter = new Emitter<EventsMap>()
-    pipeEvents(this.emitter, this.publicEmitter)
-
-    this.events = this.createLifeCycleEvents()
-
-    this.subscriptions.push(() => {
-      this.emitter.removeAllListeners()
-      this.publicEmitter.removeAllListeners()
-    })
-  }
-
-  private validateHandlers(handlers: ReadonlyArray<unknown>): boolean {
-    // Guard against incorrect call signature of the setup API.
-    return handlers.every((handler) => !Array.isArray(handler))
-  }
-
-  public use(
-    ...runtimeHandlers: Array<RequestHandler | WebSocketHandler>
-  ): void {
-    invariant(
-      this.validateHandlers(runtimeHandlers),
-      devUtils.formatMessage(
-        `Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?`,
-      ),
-    )
-
-    this.handlersController.prepend(runtimeHandlers)
-  }
-
-  public restoreHandlers(): void {
-    this.handlersController.currentHandlers().forEach((handler) => {
-      if ('isUsed' in handler) {
-        handler.isUsed = false
-      }
-    })
-  }
-
-  public resetHandlers(
-    ...nextHandlers: Array<RequestHandler | WebSocketHandler>
-  ): void {
-    this.handlersController.reset(nextHandlers)
-  }
-
-  public listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler> {
-    return toReadonlyArray(this.handlersController.currentHandlers())
-  }
-
-  private createLifeCycleEvents(): LifeCycleEventEmitter<EventsMap> {
-    return {
-      on: (...args: any[]) => {
-        return (this.publicEmitter.on as any)(...args)
-      },
-      removeListener: (...args: any[]) => {
-        return (this.publicEmitter.removeListener as any)(...args)
-      },
-      removeAllListeners: (...args: any[]) => {
-        return this.publicEmitter.removeAllListeners(...args)
-      },
-    }
-  }
-}

package/src/core/handlers/common.ts

@@ -1 +0,0 @@
-export type HandlerKind = 'RequestHandler' | 'EventHandler'

package/src/node/SetupServerApi.ts

@@ -1,87 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
-import type { HttpRequestEventMap, Interceptor } from '@mswjs/interceptors'
-import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
-import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
-import { FetchInterceptor } from '@mswjs/interceptors/fetch'
-import { HandlersController } from '~/core/SetupApi'
-import type { RequestHandler } from '~/core/handlers/RequestHandler'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
-import type { SetupServer } from './glossary'
-import { SetupServerCommonApi } from './SetupServerCommonApi'
-
-const store = new AsyncLocalStorage<RequestHandlersContext>()
-
-type RequestHandlersContext = {
-  initialHandlers: Array<RequestHandler | WebSocketHandler>
-  handlers: Array<RequestHandler | WebSocketHandler>
-}
-
-/**
- * A handlers controller that utilizes `AsyncLocalStorage` in Node.js
- * to prevent the request handlers list from being a shared state
- * across multiple tests.
- */
-class AsyncHandlersController implements HandlersController {
-  private rootContext: RequestHandlersContext
-
-  constructor(initialHandlers: Array<RequestHandler | WebSocketHandler>) {
-    this.rootContext = { initialHandlers, handlers: [] }
-  }
-
-  get context(): RequestHandlersContext {
-    return store.getStore() || this.rootContext
-  }
-
-  public prepend(runtimeHandlers: Array<RequestHandler | WebSocketHandler>) {
-    this.context.handlers.unshift(...runtimeHandlers)
-  }
-
-  public reset(nextHandlers: Array<RequestHandler | WebSocketHandler>) {
-    const context = this.context
-    context.handlers = []
-    context.initialHandlers =
-      nextHandlers.length > 0 ? nextHandlers : context.initialHandlers
-  }
-
-  public currentHandlers(): Array<RequestHandler | WebSocketHandler> {
-    const { initialHandlers, handlers } = this.context
-    return handlers.concat(initialHandlers)
-  }
-}
-export class SetupServerApi
-  extends SetupServerCommonApi
-  implements SetupServer
-{
-  constructor(
-    handlers: Array<RequestHandler | WebSocketHandler>,
-    interceptors: Array<Interceptor<HttpRequestEventMap>> = [
-      new ClientRequestInterceptor(),
-      new XMLHttpRequestInterceptor(),
-      new FetchInterceptor(),
-    ],
-  ) {
-    super(interceptors, handlers)
-
-    this.handlersController = new AsyncHandlersController(handlers)
-  }
-
-  public boundary<Args extends Array<any>, R>(
-    callback: (...args: Args) => R,
-  ): (...args: Args) => R {
-    return (...args: Args): R => {
-      return store.run<any, any>(
-        {
-          initialHandlers: this.handlersController.currentHandlers(),
-          handlers: [],
-        },
-        callback,
-        ...args,
-      )
-    }
-  }
-
-  public close(): void {
-    super.close()
-    store.disable()
-  }
-}

package/src/node/SetupServerCommonApi.ts

@@ -1,169 +0,0 @@
-/**
- * @note This API is extended by both "msw/node" and "msw/native"
- * so be minding about the things you import!
- */
-import type { RequiredDeep } from 'type-fest'
-import { invariant } from 'outvariant'
-import {
-  BatchInterceptor,
-  InterceptorReadyState,
-  type HttpRequestEventMap,
-  type Interceptor,
-} from '@mswjs/interceptors'
-import type { LifeCycleEventsMap, SharedOptions } from '~/core/sharedOptions'
-import { SetupApi } from '~/core/SetupApi'
-import { handleRequest } from '~/core/utils/handleRequest'
-import type { RequestHandler } from '~/core/handlers/RequestHandler'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
-import { mergeRight } from '~/core/utils/internal/mergeRight'
-import { InternalError, devUtils } from '~/core/utils/internal/devUtils'
-import type { SetupServerCommon } from './glossary'
-import { handleWebSocketEvent } from '~/core/ws/handleWebSocketEvent'
-import { webSocketInterceptor } from '~/core/ws/webSocketInterceptor'
-import { isHandlerKind } from '~/core/utils/internal/isHandlerKind'
-
-const DEFAULT_LISTEN_OPTIONS: RequiredDeep<SharedOptions> = {
-  onUnhandledRequest: 'warn',
-}
-
-export class SetupServerCommonApi
-  extends SetupApi<LifeCycleEventsMap>
-  implements SetupServerCommon
-{
-  protected readonly interceptor: BatchInterceptor<
-    Array<Interceptor<HttpRequestEventMap>>,
-    HttpRequestEventMap
-  >
-  private resolvedOptions: RequiredDeep<SharedOptions>
-
-  constructor(
-    interceptors: Array<Interceptor<HttpRequestEventMap>>,
-    handlers: Array<RequestHandler | WebSocketHandler>,
-  ) {
-    super(...handlers)
-
-    this.interceptor = new BatchInterceptor({
-      name: 'setup-server',
-      interceptors,
-    })
-
-    this.resolvedOptions = {} as RequiredDeep<SharedOptions>
-  }
-
-  /**
-   * Subscribe to all requests that are using the interceptor object
-   */
-  private init(): void {
-    this.interceptor.on(
-      'request',
-      async ({ request, requestId, controller }) => {
-        const response = await handleRequest(
-          request,
-          requestId,
-          this.handlersController
-            .currentHandlers()
-            .filter(isHandlerKind('RequestHandler')),
-          this.resolvedOptions,
-          this.emitter,
-          {
-            onPassthroughResponse(request) {
-              const acceptHeader = request.headers.get('accept')
-
-              /**
-               * @note Remove the internal bypass request header.
-               * In the browser, this is done by the worker script.
-               * In Node.js, it has to be done here.
-               */
-              if (acceptHeader) {
-                const nextAcceptHeader = acceptHeader.replace(
-                  /(,\s+)?msw\/passthrough/,
-                  '',
-                )
-
-                if (nextAcceptHeader) {
-                  request.headers.set('accept', nextAcceptHeader)
-                } else {
-                  request.headers.delete('accept')
-                }
-              }
-            },
-          },
-        )
-
-        if (response) {
-          controller.respondWith(response)
-        }
-
-        return
-      },
-    )
-
-    this.interceptor.on('unhandledException', ({ error }) => {
-      if (error instanceof InternalError) {
-        throw error
-      }
-    })
-
-    this.interceptor.on(
-      'response',
-      ({ response, isMockedResponse, request, requestId }) => {
-        this.emitter.emit(
-          isMockedResponse ? 'response:mocked' : 'response:bypass',
-          {
-            response,
-            request,
-            requestId,
-          },
-        )
-      },
-    )
-
-    // Preconfigure the WebSocket interception but don't enable it just yet.
-    // It will be enabled when the server starts.
-    handleWebSocketEvent({
-      getUnhandledRequestStrategy: () => {
-        return this.resolvedOptions.onUnhandledRequest
-      },
-      getHandlers: () => {
-        return this.handlersController.currentHandlers()
-      },
-      onMockedConnection: () => {},
-      onPassthroughConnection: () => {},
-    })
-  }
-
-  public listen(options: Partial<SharedOptions> = {}): void {
-    this.resolvedOptions = mergeRight(
-      DEFAULT_LISTEN_OPTIONS,
-      options,
-    ) as RequiredDeep<SharedOptions>
-
-    // Apply the interceptor when starting the server.
-    // Attach the event listeners to the interceptor here
-    // so they get re-attached whenever `.listen()` is called.
-    this.interceptor.apply()
-    this.init()
-    this.subscriptions.push(() => this.interceptor.dispose())
-
-    // Apply the WebSocket interception.
-    webSocketInterceptor.apply()
-    this.subscriptions.push(() => webSocketInterceptor.dispose())
-
-    // Assert that the interceptor has been applied successfully.
-    // Also guards us from forgetting to call "interceptor.apply()"
-    // as a part of the "listen" method.
-    invariant(
-      [InterceptorReadyState.APPLYING, InterceptorReadyState.APPLIED].includes(
-        this.interceptor.readyState,
-      ),
-      devUtils.formatMessage(
-        'Failed to start "setupServer": the interceptor failed to apply. This is likely an issue with the library and you should report it at "%s".',
-      ),
-      'https://github.com/mswjs/msw/issues/new/choose',
-    )
-  }
-
-  public close(): void {
-    this.dispose()
-  }
-}

package/src/node/setupServer.ts

@@ -1,15 +0,0 @@
-import type { RequestHandler } from '~/core/handlers/RequestHandler'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
-import { SetupServerApi } from './SetupServerApi'
-
-/**
- * Sets up a requests interception in Node.js with the given request handlers.
- * @param {RequestHandler[]} handlers List of request handlers.
- *
- * @see {@link https://mswjs.io/docs/api/setup-server `setupServer()` API reference}
- */
-export const setupServer = (
-  ...handlers: Array<RequestHandler | WebSocketHandler>
-): SetupServerApi => {
-  return new SetupServerApi(handlers)
-}