@depup/msw 2.12.13-depup.0

package/src/core/HttpResponse.ts

@@ -0,0 +1,248 @@
+import { FetchResponse } from '@mswjs/interceptors'
+import type { DefaultBodyType, JsonBodyType } from './handlers/RequestHandler'
+import type { NoInfer } from './typeUtils'
+import {
+  decorateResponse,
+  normalizeResponseInit,
+} from './utils/HttpResponse/decorators'
+
+export interface HttpResponseInit extends ResponseInit {
+  type?: ResponseType
+}
+
+export const bodyType: unique symbol = Symbol('bodyType')
+export type DefaultUnsafeFetchResponse = Response & {
+  [bodyType]?: never
+}
+
+export interface StrictRequest<BodyType extends JsonBodyType> extends Request {
+  json(): Promise<BodyType>
+  clone(): StrictRequest<BodyType>
+}
+
+/**
+ * Opaque `Response` type that supports strict body type.
+ *
+ * @deprecated Please use {@link HttpResponse} instead.
+ */
+export type StrictResponse<BodyType extends DefaultBodyType> =
+  HttpResponse<BodyType>
+
+export const kDefaultContentType = Symbol.for('kDefaultContentType')
+
+/**
+ * A drop-in replacement for the standard `Response` class
+ * to allow additional features, like mocking the response `Set-Cookie` header.
+ *
+ * @example
+ * new HttpResponse('Hello world', { status: 201 })
+ * HttpResponse.json({ name: 'John' })
+ * HttpResponse.formData(form)
+ *
+ * @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
+ */
+export class HttpResponse<
+  BodyType extends DefaultBodyType,
+> extends FetchResponse {
+  readonly [bodyType]: BodyType = null as any
+
+  constructor(body?: NoInfer<BodyType> | null, init?: HttpResponseInit) {
+    const responseInit = normalizeResponseInit(init)
+    super(body as BodyInit, responseInit)
+    decorateResponse(this, responseInit)
+  }
+
+  static error(): HttpResponse<any> {
+    return super.error() as HttpResponse<any>
+  }
+
+  /**
+   * Create a `Response` with a `Content-Type: "text/plain"` body.
+   * @example
+   * HttpResponse.text('hello world')
+   * HttpResponse.text('Error', { status: 500 })
+   */
+  static text<BodyType extends string>(
+    body?: NoInfer<BodyType> | null,
+    init?: HttpResponseInit,
+  ): HttpResponse<BodyType> {
+    const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
+
+    if (!hasExplicitContentType) {
+      responseInit.headers.set('Content-Type', 'text/plain')
+    }
+
+    // Automatically set the "Content-Length" response header
+    // for non-empty text responses. This enforces consistency and
+    // brings mocked responses closer to production.
+    if (!responseInit.headers.has('Content-Length')) {
+      responseInit.headers.set(
+        'Content-Length',
+        body ? new Blob([body]).size.toString() : '0',
+      )
+    }
+
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response
+  }
+
+  /**
+   * Create a `Response` with a `Content-Type: "application/json"` body.
+   * @example
+   * HttpResponse.json({ firstName: 'John' })
+   * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+   */
+  static json<BodyType extends JsonBodyType>(
+    body?: NoInfer<BodyType> | null | undefined,
+    init?: HttpResponseInit,
+  ): HttpResponse<BodyType> {
+    const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
+
+    if (!hasExplicitContentType) {
+      responseInit.headers.set('Content-Type', 'application/json')
+    }
+
+    /**
+     * @note TypeScript is incorrect here.
+     * Stringifying undefined will return undefined.
+     */
+    const responseText = JSON.stringify(body) as string | undefined
+
+    if (!responseInit.headers.has('Content-Length')) {
+      responseInit.headers.set(
+        'Content-Length',
+        responseText ? new Blob([responseText]).size.toString() : '0',
+      )
+    }
+
+    const response = new HttpResponse(responseText, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
+  }
+
+  /**
+   * Create a `Response` with a `Content-Type: "application/xml"` body.
+   * @example
+   * HttpResponse.xml(`<user name="John" />`)
+   * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+   */
+  static xml<BodyType extends string>(
+    body?: BodyType | null,
+    init?: HttpResponseInit,
+  ): HttpResponse<BodyType> {
+    const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
+
+    if (!hasExplicitContentType) {
+      responseInit.headers.set('Content-Type', 'text/xml')
+    }
+
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
+  }
+
+  /**
+   * Create a `Response` with a `Content-Type: "text/html"` body.
+   * @example
+   * HttpResponse.html(`<p class="author">Jane Doe</p>`)
+   * HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
+   */
+  static html<BodyType extends string>(
+    body?: BodyType | null,
+    init?: HttpResponseInit,
+  ): HttpResponse<BodyType> {
+    const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
+
+    if (!hasExplicitContentType) {
+      responseInit.headers.set('Content-Type', 'text/html')
+    }
+
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
+  }
+
+  /**
+   * Create a `Response` with an `ArrayBuffer` body.
+   * @example
+   * const buffer = new ArrayBuffer(3)
+   * const view = new Uint8Array(buffer)
+   * view.set([1, 2, 3])
+   *
+   * HttpResponse.arrayBuffer(buffer)
+   */
+  static arrayBuffer<BodyType extends ArrayBuffer | SharedArrayBuffer>(
+    body?: BodyType,
+    init?: HttpResponseInit,
+  ): HttpResponse<BodyType> {
+    const responseInit = normalizeResponseInit(init)
+    const hasExplicitContentType = responseInit.headers.has('Content-Type')
+
+    if (!hasExplicitContentType) {
+      responseInit.headers.set('Content-Type', 'application/octet-stream')
+    }
+
+    if (body && !responseInit.headers.has('Content-Length')) {
+      responseInit.headers.set('Content-Length', body.byteLength.toString())
+    }
+
+    const response = new HttpResponse(body, responseInit)
+
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false,
+      })
+    }
+
+    return response as HttpResponse<BodyType>
+  }
+
+  /**
+   * Create a `Response` with a `FormData` body.
+   * @example
+   * const data = new FormData()
+   * data.set('name', 'Alice')
+   *
+   * HttpResponse.formData(data)
+   */
+  static formData(
+    body?: FormData,
+    init?: HttpResponseInit,
+  ): HttpResponse<FormData> {
+    return new HttpResponse(body, normalizeResponseInit(init))
+  }
+}

package/src/core/SetupApi.ts

@@ -0,0 +1,127 @@
+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/bypass.test.ts

@@ -0,0 +1,80 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { bypass } from './bypass'
+
+it('returns bypassed request given a request url string', async () => {
+  const request = bypass('https://api.example.com/resource')
+
+  // Relative URLs are rebased against the current location.
+  expect(request.method).toBe('GET')
+  expect(request.url).toBe('https://api.example.com/resource')
+  expect(Array.from(request.headers)).toEqual([['accept', 'msw/passthrough']])
+})
+
+it('returns bypassed request given a request url', async () => {
+  const request = bypass(new URL('/resource', 'https://api.example.com'))
+
+  expect(request.url).toBe('https://api.example.com/resource')
+  expect(Array.from(request.headers)).toEqual([['accept', 'msw/passthrough']])
+})
+
+it('returns bypassed request given request instance', async () => {
+  const original = new Request('http://localhost/resource', {
+    method: 'POST',
+    headers: {
+      accept: '*/*',
+      'X-My-Header': 'value',
+    },
+    body: 'hello world',
+  })
+  const request = bypass(original)
+
+  expect(request.method).toBe('POST')
+  expect(request.url).toBe('http://localhost/resource')
+
+  const bypassedRequestBody = await request.text()
+  expect(original.bodyUsed).toBe(false)
+
+  expect(bypassedRequestBody).toEqual(await original.text())
+  expect(Array.from(request.headers)).toEqual([
+    ['accept', '*/*, msw/passthrough'],
+    ['content-type', 'text/plain;charset=UTF-8'],
+    ['x-my-header', 'value'],
+  ])
+})
+
+it('allows modifying the bypassed request instance', async () => {
+  const original = new Request('http://localhost/resource', {
+    method: 'POST',
+    body: 'hello world',
+  })
+  const request = bypass(original, {
+    method: 'PUT',
+    headers: { 'x-modified-header': 'yes' },
+  })
+
+  expect(request.method).toBe('PUT')
+  expect(Array.from(request.headers)).toEqual([
+    ['accept', 'msw/passthrough'],
+    ['x-modified-header', 'yes'],
+  ])
+  expect(original.bodyUsed).toBe(false)
+  expect(request.bodyUsed).toBe(false)
+
+  expect(await request.text()).toBe('hello world')
+  expect(original.bodyUsed).toBe(false)
+})
+
+it('supports bypassing "keepalive: true" requests', async () => {
+  const original = new Request('http://localhost/resource', {
+    method: 'POST',
+    keepalive: true,
+  })
+  const request = bypass(original)
+
+  expect(request.method).toBe('POST')
+  expect(request.url).toBe('http://localhost/resource')
+  expect(request.body).toBeNull()
+  expect(Array.from(request.headers)).toEqual([['accept', 'msw/passthrough']])
+})

package/src/core/bypass.ts

@@ -0,0 +1,46 @@
+import { invariant } from 'outvariant'
+
+export type BypassRequestInput = string | URL | Request
+
+/**
+ * Creates a `Request` instance that will always be ignored by MSW.
+ *
+ * @example
+ * import { bypass } from 'msw'
+ *
+ * fetch(bypass('/resource'))
+ * fetch(bypass(new URL('/resource', 'https://example.com)))
+ * fetch(bypass(new Request('https://example.com/resource')))
+ *
+ * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
+ */
+export function bypass(input: BypassRequestInput, init?: RequestInit): Request {
+  // Always create a new Request instance.
+  // This way, the "init" modifications will propagate
+  // to the bypass request instance automatically.
+  const request = new Request(
+    // If given a Request instance, clone it not to exhaust
+    // the original request's body.
+    input instanceof Request ? input.clone() : input,
+    init,
+  )
+
+  invariant(
+    !request.bodyUsed,
+    'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
+    request.method,
+    request.url,
+  )
+
+  const requestClone = request.clone()
+
+  /**
+   * Send the internal request header that would instruct MSW
+   * to perform this request as-is, ignoring any matching handlers.
+   * @note Use the `accept` header to support scenarios when the
+   * request cannot have headers (e.g. `sendBeacon` requests).
+   */
+  requestClone.headers.append('accept', 'msw/passthrough')
+
+  return requestClone
+}

package/src/core/delay.ts

@@ -0,0 +1,82 @@
+import { isNodeProcess } from 'is-node-process'
+import { hasRefCounted } from './utils/internal/hasRefCounted'
+
+export const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647
+export const MIN_SERVER_RESPONSE_TIME = 100
+export const MAX_SERVER_RESPONSE_TIME = 400
+export const NODE_SERVER_RESPONSE_TIME = 5
+
+function getRealisticResponseTime(): number {
+  if (isNodeProcess()) {
+    return NODE_SERVER_RESPONSE_TIME
+  }
+
+  return Math.floor(
+    Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +
+      MIN_SERVER_RESPONSE_TIME,
+  )
+}
+
+export type DelayMode = 'real' | 'infinite'
+
+/**
+ * Delays the response by the given duration (ms).
+ *
+ * @example
+ * await delay() // emulate realistic server response time
+ * await delay(1200) // delay response by 1200ms
+ * await delay('infinite') // delay response infinitely
+ *
+ * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}
+ */
+export async function delay(
+  durationOrMode?: DelayMode | number,
+): Promise<void> {
+  let delayTime: number
+
+  if (typeof durationOrMode === 'string') {
+    switch (durationOrMode) {
+      case 'infinite': {
+        // Using `Infinity` as a delay value executes the response timeout immediately.
+        // Instead, use the maximum allowed integer for `setTimeout`.
+        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT
+        break
+      }
+      case 'real': {
+        delayTime = getRealisticResponseTime()
+        break
+      }
+      default: {
+        throw new Error(
+          `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`,
+        )
+      }
+    }
+  } else if (typeof durationOrMode === 'undefined') {
+    // Use random realistic server response time when no explicit delay duration was provided.
+    delayTime = getRealisticResponseTime()
+  } else {
+    // Guard against passing values like `Infinity` or `Number.MAX_VALUE`
+    // as the response delay duration. They don't produce the result you may expect.
+    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+      throw new Error(
+        `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`,
+      )
+    }
+
+    delayTime = durationOrMode
+  }
+
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(resolve, delayTime)
+
+    if (
+      delayTime === SET_TIMEOUT_MAX_ALLOWED_INT &&
+      isNodeProcess() &&
+      hasRefCounted(timeoutId)
+    ) {
+      // Prevent the process from hanging if this is the only active ref.
+      timeoutId.unref()
+    }
+  })
+}

package/src/core/getResponse.test.ts

@@ -0,0 +1,74 @@
+// @vitest-environment node
+import { http } from './http'
+import { getResponse } from './getResponse'
+
+it('returns undefined given empty headers array', async () => {
+  await expect(
+    getResponse([], new Request('http://localhost/')),
+  ).resolves.toBeUndefined()
+})
+
+it('returns undefined given no matching handlers', async () => {
+  await expect(
+    getResponse(
+      [http.get('/product', () => void 0)],
+      new Request('http://localhost/user'),
+    ),
+  ).resolves.toBeUndefined()
+})
+
+it('returns undefined given a matching handler that returned no response', async () => {
+  await expect(
+    getResponse(
+      [http.get('*/user', () => void 0)],
+      new Request('http://localhost/user'),
+    ),
+  ).resolves.toBeUndefined()
+})
+
+it('returns undefined given a matching handler that returned explicit undefined', async () => {
+  await expect(
+    getResponse(
+      [http.get('*/user', () => undefined)],
+      new Request('http://localhost/user'),
+    ),
+  ).resolves.toBeUndefined()
+})
+
+it('returns the response returned from a matching handler', async () => {
+  const response = await getResponse(
+    [http.get('*/user', () => Response.json({ name: 'John' }))],
+    new Request('http://localhost/user'),
+  )
+
+  expect(response?.status).toBe(200)
+  expect(response?.headers.get('Content-Type')).toBe('application/json')
+  await expect(response?.json()).resolves.toEqual({ name: 'John' })
+})
+
+it('returns the response from the first matching handler if multiple match', async () => {
+  const response = await getResponse(
+    [
+      http.get('*/user', () => Response.json({ name: 'John' })),
+      http.get('*/user', () => Response.json({ name: 'Kate' })),
+    ],
+    new Request('http://localhost/user'),
+  )
+
+  expect(response?.status).toBe(200)
+  expect(response?.headers.get('Content-Type')).toBe('application/json')
+  await expect(response?.json()).resolves.toEqual({ name: 'John' })
+})
+
+it('supports custom base url', async () => {
+  const response = await getResponse(
+    [http.get('/resource', () => new Response('hello world'))],
+    new Request('https://localhost:3000/resource'),
+    {
+      baseUrl: 'https://localhost:3000/',
+    },
+  )
+
+  expect(response?.status).toBe(200)
+  await expect(response?.text()).resolves.toBe('hello world')
+})

package/src/core/getResponse.ts

@@ -0,0 +1,29 @@
+import { createRequestId } from '@mswjs/interceptors'
+import type { RequestHandler } from './handlers/RequestHandler'
+import {
+  executeHandlers,
+  type ResponseResolutionContext,
+} from './utils/executeHandlers'
+
+/**
+ * Finds a response for the given request instance
+ * in the array of request handlers.
+ * @param handlers The array of request handlers.
+ * @param request The `Request` instance.
+ * @param resolutionContext Request resolution options.
+ * @returns {Response} A mocked response, if any.
+ */
+export const getResponse = async (
+  handlers: Array<RequestHandler>,
+  request: Request,
+  resolutionContext?: ResponseResolutionContext,
+): Promise<Response | undefined> => {
+  const result = await executeHandlers({
+    request,
+    requestId: createRequestId(),
+    handlers,
+    resolutionContext,
+  })
+
+  return result?.response
+}

package/src/core/graphql.test.ts

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