msw 2.14.7 → 3.0.0

package/native/package.json

@@ -1,30 +0,0 @@
-{
-  "type": "commonjs",
-  "browser": null,
-  "main": "../lib/native/index.js",
-  "module": "../lib/native/index.mjs",
-  "types": "../lib/native/index.d.ts",
-  "exports": {
-    ".": {
-      "react-native": {
-        "import": {
-          "types": "./../lib/native/index.d.mts",
-          "default": "./../lib/native/index.mjs"
-        },
-        "default": {
-          "types": "./../lib/native/index.d.ts",
-          "default": "./../lib/native/index.js"
-        }
-      },
-      "browser": null,
-      "import": {
-        "types": "./../lib/native/index.d.mts",
-        "default": "./../lib/native/index.mjs"
-      },
-      "default": {
-        "types": "./../lib/native/index.d.ts",
-        "default": "./../lib/native/index.js"
-      }
-    }
-  }
-}

package/node/package.json

@@ -1,33 +0,0 @@
-{
-  "type": "commonjs",
-  "browser": null,
-  "main": "../lib/node/index.js",
-  "module": "../lib/node/index.mjs",
-  "types": "../lib/node/index.d.ts",
-  "exports": {
-    ".": {
-      "module-sync": {
-        "types": "./../lib/node/index.d.mts",
-        "default": "./../lib/node/index.mjs"
-      },
-      "module": {
-        "types": "./../lib/node/index.d.mts",
-        "default": "./../lib/node/index.mjs"
-      },
-      "node": {
-        "require": "./../lib/node/index.js",
-        "import": "./../lib/node/index.mjs"
-      },
-      "import": {
-        "types": "./../lib/node/index.d.mts",
-        "default": "./../lib/node/index.mjs"
-      },
-      "browser": null,
-      "react-native": null,
-      "default": {
-        "types": "./../lib/node/index.d.ts",
-        "default": "./../lib/node/index.js"
-      }
-    }
-  }
-}

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

@@ -1,51 +0,0 @@
-// @vitest-environment jsdom
-import { TextEncoder } from 'util'
-import { pruneGetRequestBody } from './pruneGetRequestBody'
-
-test('sets empty GET request body to undefined', () => {
-  expect(
-    pruneGetRequestBody({
-      method: 'GET',
-    }),
-  ).toBeUndefined()
-
-  expect(
-    pruneGetRequestBody({
-      method: 'GET',
-      // There's no such thing as a GET request with a body.
-      body: new ArrayBuffer(5),
-    }),
-  ).toBeUndefined()
-})
-
-test('sets HEAD request body to undefined', () => {
-  expect(
-    pruneGetRequestBody({
-      method: 'HEAD',
-    }),
-  ).toBeUndefined()
-
-  expect(
-    pruneGetRequestBody({
-      method: 'HEAD',
-      body: new ArrayBuffer(5),
-    }),
-  ).toBeUndefined()
-})
-
-test('ignores requests of the other methods than GET', () => {
-  const body = new TextEncoder().encode('hello world')
-  expect(
-    pruneGetRequestBody({
-      method: 'POST',
-      body,
-    }),
-  ).toEqual(body)
-
-  expect(
-    pruneGetRequestBody({
-      method: 'PUT',
-      body,
-    }),
-  ).toEqual(body)
-})

package/src/browser/utils/pruneGetRequestBody.ts

@@ -1,21 +0,0 @@
-import type { IncomingWorkerRequest } from './workerChannel'
-
-type Input = Pick<IncomingWorkerRequest, 'method' | 'body'>
-
-/**
- * Ensures that an empty GET request body is always represented as `undefined`.
- */
-export function pruneGetRequestBody(
-  request: Input,
-): IncomingWorkerRequest['body'] | undefined {
-  // Force HEAD/GET request body to always be empty.
-  // The worker reads any request's body as ArrayBuffer,
-  // and you cannot re-construct a GET/HEAD Request
-  // with an ArrayBuffer, even if empty. Also note that
-  // "request.body" is always undefined in the worker.
-  if (['HEAD', 'GET'].includes(request.method)) {
-    return undefined
-  }
-
-  return request.body
-}

package/src/core/experimental/compat.ts

@@ -1,50 +0,0 @@
-/**
- * Collection of helpers for bridging the compatibility between the old and the new APIs.
- */
-import { invariant } from 'outvariant'
-import { type UnhandledRequestStrategy } from '../utils/request/onUnhandledRequest'
-import {
-  executeUnhandledFrameHandle,
-  type UnhandledFrameCallback,
-} from './on-unhandled-frame'
-import { HttpNetworkFrame } from './frames/http-frame'
-import { WebSocketNetworkFrame } from './frames/websocket-frame'
-
-export function fromLegacyOnUnhandledRequest(
-  getLegacyValue: () => UnhandledRequestStrategy | undefined,
-): UnhandledFrameCallback {
-  return ({ frame, defaults }) => {
-    const legacyOnUnhandledRequestStrategy = getLegacyValue()
-
-    if (legacyOnUnhandledRequestStrategy == null) {
-      return
-    }
-
-    if (typeof legacyOnUnhandledRequestStrategy === 'function') {
-      const request =
-        frame instanceof HttpNetworkFrame
-          ? frame.data.request
-          : frame instanceof WebSocketNetworkFrame
-            ? new Request(frame.data.connection.client.url, {
-                headers: {
-                  connection: 'upgrade',
-                  upgrade: 'websocket',
-                },
-              })
-            : null
-
-      invariant(
-        request != null,
-        'Failed to coerce a network frame to a legacy `onUnhandledRequest` strategy: unknown frame protocol "%s"',
-        frame.protocol,
-      )
-
-      return legacyOnUnhandledRequestStrategy(request, {
-        warning: defaults.warn,
-        error: defaults.error,
-      })
-    }
-
-    return executeUnhandledFrameHandle(frame, legacyOnUnhandledRequestStrategy)
-  }
-}

package/src/core/experimental/setup-api.ts

@@ -1,55 +0,0 @@
-import { type DefaultEventMap, Emitter } from 'rettime'
-import { type LifeCycleEventEmitter } from '../sharedOptions'
-import type { HandlersController } from './handlers-controller'
-import {
-  InMemoryHandlersController,
-  type AnyHandler,
-} from './handlers-controller'
-import { Disposable } from '../utils/internal/Disposable'
-import { toReadonlyArray } from '../utils/internal/toReadonlyArray'
-
-/**
- * Generic class for the mock API setup.
- * Preserved only for backward compatibility.
- * @deprecated
- */
-export abstract class SetupApi<
-  EventMap extends DefaultEventMap,
-> extends Disposable {
-  protected handlersController: HandlersController
-  protected emitter: Emitter<EventMap>
-  protected publicEmitter: Emitter<EventMap>
-
-  public readonly events: LifeCycleEventEmitter<EventMap>
-
-  constructor(...initialHandlers: Array<AnyHandler>) {
-    super()
-
-    this.handlersController = new InMemoryHandlersController(initialHandlers)
-
-    this.emitter = new Emitter()
-    this.publicEmitter = new Emitter()
-    this.events = this.emitter
-
-    this.subscriptions.push(() => {
-      this.emitter.removeAllListeners()
-      this.publicEmitter.removeAllListeners()
-    })
-  }
-
-  public use(...runtimeHandlers: Array<AnyHandler>): void {
-    this.handlersController.use(runtimeHandlers)
-  }
-
-  public restoreHandlers(): void {
-    this.handlersController.restore()
-  }
-
-  public resetHandlers(...nextHandlers: Array<AnyHandler>): void {
-    this.handlersController.reset(nextHandlers)
-  }
-
-  public listHandlers(): ReadonlyArray<AnyHandler> {
-    return toReadonlyArray(this.handlersController.currentHandlers())
-  }
-}

package/src/core/graphql.test.ts

@@ -1,11 +0,0 @@
-import { graphql } from './graphql'
-
-test('exports supported GraphQL operation types', () => {
-  expect(graphql).toBeDefined()
-  expect(Object.keys(graphql)).toEqual([
-    'query',
-    'mutation',
-    'operation',
-    'link',
-  ])
-})

package/src/core/graphql.ts

@@ -1,136 +0,0 @@
-import type { OperationTypeNode } from 'graphql'
-import {
-  type ResponseResolver,
-  type RequestHandlerOptions,
-} from './handlers/RequestHandler'
-import {
-  GraphQLHandler,
-  type GraphQLVariables,
-  type GraphQLOperationType,
-  type GraphQLResolverExtras,
-  type GraphQLResponseBody,
-  type GraphQLQuery,
-  type GraphQLPredicate,
-} from './handlers/GraphQLHandler'
-import type { Path } from './utils/matching/matchRequestUrl'
-
-export type GraphQLRequestHandler = <
-  Query extends GraphQLQuery = GraphQLQuery,
-  Variables extends GraphQLVariables = GraphQLVariables,
->(
-  predicate: GraphQLPredicate<Query, Variables>,
-  resolver: GraphQLResponseResolver<
-    [Query] extends [never] ? GraphQLQuery : Query,
-    Variables
-  >,
-  options?: RequestHandlerOptions,
-) => GraphQLHandler
-
-export type GraphQLOperationHandler = <
-  Query extends GraphQLQuery = GraphQLQuery,
-  Variables extends GraphQLVariables = GraphQLVariables,
->(
-  resolver: GraphQLResponseResolver<
-    [Query] extends [never] ? GraphQLQuery : Query,
-    Variables
-  >,
-  options?: RequestHandlerOptions,
-) => GraphQLHandler
-
-export type GraphQLResponseResolver<
-  Query extends GraphQLQuery = GraphQLQuery,
-  Variables extends GraphQLVariables = GraphQLVariables,
-> = ResponseResolver<
-  GraphQLResolverExtras<Variables>,
-  null,
-  GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>
->
-
-function createScopedGraphQLHandler(
-  operationType: GraphQLOperationType,
-  url: Path,
-): GraphQLRequestHandler {
-  return (predicate, resolver, options = {}) => {
-    return new GraphQLHandler(operationType, predicate, url, resolver, options)
-  }
-}
-
-function createGraphQLOperationHandler(url: Path): GraphQLOperationHandler {
-  return (resolver, options) => {
-    return new GraphQLHandler('all', new RegExp('.*'), url, resolver, options)
-  }
-}
-
-export interface GraphQLLinkHandlers {
-  query: GraphQLRequestHandler
-  mutation: GraphQLRequestHandler
-  operation: GraphQLOperationHandler
-}
-
-/**
- * A namespace to intercept and mock GraphQL operations
- *
- * @example
- * graphql.query('GetUser', resolver)
- * graphql.mutation('DeletePost', resolver)
- *
- * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}
- */
-export const graphql = {
-  /**
-   * Intercepts a GraphQL query by a given name.
-   *
-   * @example
-   * graphql.query('GetUser', () => {
-   *   return HttpResponse.json({ data: { user: { name: 'John' } } })
-   * })
-   *
-   * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
-   */
-  query: createScopedGraphQLHandler('query' as OperationTypeNode, '*'),
-
-  /**
-   * Intercepts a GraphQL mutation by its name.
-   *
-   * @example
-   * graphql.mutation('SavePost', () => {
-   *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
-   * })
-   *
-   * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
-   *
-   */
-  mutation: createScopedGraphQLHandler('mutation' as OperationTypeNode, '*'),
-
-  /**
-   * Intercepts any GraphQL operation, regardless of its type or name.
-   *
-   * @example
-   * graphql.operation(() => {
-   *   return HttpResponse.json({ data: { name: 'John' } })
-   * })
-   *
-   * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
-   */
-  operation: createGraphQLOperationHandler('*'),
-
-  /**
-   * Intercepts GraphQL operations scoped by the given URL.
-   *
-   * @example
-   * const github = graphql.link('https://api.github.com/graphql')
-   * github.query('GetRepo', resolver)
-   *
-   * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
-   */
-  link(url: Path): GraphQLLinkHandlers {
-    return {
-      operation: createGraphQLOperationHandler(url),
-      query: createScopedGraphQLHandler('query' as OperationTypeNode, url),
-      mutation: createScopedGraphQLHandler(
-        'mutation' as OperationTypeNode,
-        url,
-      ),
-    }
-  },
-}

package/src/core/passthrough.test.ts

@@ -1,11 +0,0 @@
-// @vitest-environment node
-import { passthrough } from './passthrough'
-
-it('creates a 302 response with the intention header', () => {
-  const response = passthrough()
-
-  expect(response).toBeInstanceOf(Response)
-  expect(response.status).toBe(302)
-  expect(response.statusText).toBe('Passthrough')
-  expect(response.headers.get('x-msw-intention')).toBe('passthrough')
-})

package/src/core/passthrough.ts

@@ -1,25 +0,0 @@
-import type { HttpResponse } from './HttpResponse'
-
-/**
- * Performs the intercepted request as-is.
- *
- * This stops request handler lookup so no other handlers
- * can affect this request past this point.
- * Unlike `bypass()`, this will not trigger an additional request.
- *
- * @example
- * http.get('/resource', () => {
- *   return passthrough()
- * })
- *
- * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
- */
-export function passthrough(): HttpResponse<any> {
-  return new Response(null, {
-    status: 302,
-    statusText: 'Passthrough',
-    headers: {
-      'x-msw-intention': 'passthrough',
-    },
-  }) as HttpResponse<any>
-}

package/src/core/sharedOptions.ts

@@ -1,71 +0,0 @@
-import type { Emitter, DefaultEventMap } from 'rettime'
-import type { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest'
-
-export interface SharedOptions {
-  /**
-   * Specifies how to react to a request that has no corresponding
-   * request handler. Warns on unhandled requests by default.
-   *
-   * @example worker.start({ onUnhandledRequest: 'bypass' })
-   * @example worker.start({ onUnhandledRequest: 'warn' })
-   * @example server.listen({ onUnhandledRequest: 'error' })
-   */
-  onUnhandledRequest?: UnhandledRequestStrategy
-}
-
-/**
- * @deprecated
- * Please use `HttpNetworkFrameEventMap` or `WebSocketNetworkFrameEventMap` instead.
- */
-export type LifeCycleEventsMap = {
-  'request:start': [
-    args: {
-      request: Request
-      requestId: string
-    },
-  ]
-  'request:match': [
-    args: {
-      request: Request
-      requestId: string
-    },
-  ]
-  'request:unhandled': [
-    args: {
-      request: Request
-      requestId: string
-    },
-  ]
-  'request:end': [
-    args: {
-      request: Request
-      requestId: string
-    },
-  ]
-  'response:mocked': [
-    args: {
-      response: Response
-      request: Request
-      requestId: string
-    },
-  ]
-  'response:bypass': [
-    args: {
-      response: Response
-      request: Request
-      requestId: string
-    },
-  ]
-  unhandledException: [
-    args: {
-      error: Error
-      request: Request
-      requestId: string
-    },
-  ]
-}
-
-export type LifeCycleEventEmitter<EventMap extends DefaultEventMap> = Pick<
-  Emitter<EventMap>,
-  'on' | 'removeListener' | 'removeAllListeners'
->

package/src/core/typeUtils.ts

@@ -1,26 +0,0 @@
-type Fn = (...arg: any[]) => any
-
-export type MaybePromise<T> = T | Promise<T>
-
-export type RequiredDeep<
-  Type,
-  U extends Record<string, unknown> | Fn | undefined = undefined,
-> = Type extends Fn
-  ? Type
-  : /**
-     * @note The "Fn" type satisfies the predicate below.
-     * It must always come first, before the Record check.
-     */
-    Type extends Record<string, any>
-    ? {
-        [Key in keyof Type]-?: NonNullable<Type[Key]> extends NonNullable<U>
-          ? NonNullable<Type[Key]>
-          : RequiredDeep<NonNullable<Type[Key]>, U>
-      }
-    : Type
-
-/**
- * @fixme Remove this once TS 5.4 is the lowest supported version.
- * Because "NoInfer" is a built-in type utility there.
- */
-export type NoInfer<T> = [T][T extends any ? 0 : never]