@depup/msw 2.13.2-depup.0 → 2.15.0-depup.7

package/src/core/utils/cookieStore.ts

@@ -4,7 +4,7 @@ import {
   Cookie,
   CookieJar,
   MemoryCookieStore,
-  SerializedCookie,
+  type SerializedCookie,
   type MemoryCookieStoreIndex,
 } from 'tough-cookie'
 import { jsonParse } from './internal/jsonParse'

package/src/core/utils/executeHandlers.ts

@@ -1,7 +1,5 @@
-import {
-  RequestHandler,
-  type RequestHandlerExecutionResult,
-} from '../handlers/RequestHandler'
+import type { RequestHandler } from '../handlers/RequestHandler'
+import { type RequestHandlerExecutionResult } from '../handlers/RequestHandler'
 
 export interface HandlersExecutionResult {
   handler: RequestHandler

package/src/core/utils/handleRequest.test.ts

@@ -1,11 +1,12 @@
 // @vitest-environment jsdom
 import { Emitter } from 'strict-event-emitter'
 import { createRequestId } from '@mswjs/interceptors'
-import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
-import { RequestHandler } from '../handlers/RequestHandler'
+import type { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
+import type { RequestHandler } from '../handlers/RequestHandler'
 import { http } from '../http'
-import { handleRequest, HandleRequestOptions } from './handleRequest'
-import { RequiredDeep } from '../typeUtils'
+import type { HandleRequestOptions } from './handleRequest'
+import { handleRequest } from './handleRequest'
+import type { RequiredDeep } from '../typeUtils'
 import { HttpResponse } from '../HttpResponse'
 import { passthrough } from '../passthrough'
 

package/src/core/utils/handleRequest.ts

@@ -1,7 +1,7 @@
 import { until } from 'until-async'
-import { Emitter } from 'strict-event-emitter'
-import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
-import { RequiredDeep } from '../typeUtils'
+import type { Emitter } from 'strict-event-emitter'
+import type { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
+import type { RequiredDeep } from '../typeUtils'
 import type { RequestHandler } from '../handlers/RequestHandler'
 import {
   type HandlersExecutionResult,

package/src/core/utils/internal/Disposable.ts

@@ -1,3 +1,5 @@
+import { devUtils } from './devUtils'
+
 export type DisposableSubscription = () => void
 
 export class Disposable {
@@ -5,8 +7,27 @@ export class Disposable {
 
   public dispose() {
     let subscription: DisposableSubscription | undefined
+    const errors: Array<Error> = []
+
     while ((subscription = this.subscriptions.shift())) {
-      subscription()
+      try {
+        subscription()
+      } catch (error) {
+        if (error instanceof Error) {
+          errors.push(error)
+        }
+      }
+    }
+
+    if (errors.length > 0) {
+      console.error(
+        new AggregateError(
+          errors,
+          devUtils.formatMessage(
+            'Failed to dispose of some side effects. This is likely an issue with MSW, please report it on GitHub: https://github.com/mswjs/msw/issues',
+          ),
+        ),
+      )
     }
   }
 }

package/src/core/utils/internal/attachSiblingHandlers.ts

@@ -0,0 +1,28 @@
+import { invariant } from 'outvariant'
+import type { AnyHandler } from '../../experimental/handlers-controller'
+
+const kSiblingHandlers = Symbol('kSiblingHandlers')
+
+export function attachSiblingHandlers<T extends AnyHandler>(
+  owner: T,
+  siblings: Array<AnyHandler>,
+): T {
+  invariant(
+    getSiblingHandlers(owner).length === 0,
+    'Failed to merge handlers: the owner "%s" handler is already merged',
+    owner.kind,
+  )
+
+  Object.defineProperty(owner, kSiblingHandlers, {
+    value: siblings,
+    enumerable: false,
+    writable: false,
+    configurable: false,
+  })
+
+  return owner
+}
+
+export function getSiblingHandlers(owner: AnyHandler): Array<AnyHandler> {
+  return Reflect.get(owner, kSiblingHandlers) || []
+}

package/src/core/utils/internal/observe-response-body-stream.test.ts

@@ -0,0 +1,64 @@
+import { observeResponseBodyStream } from './observe-response-body-stream'
+
+it('returns null for a response without a body', () => {
+  expect(observeResponseBodyStream(new Response(null))).toBeNull()
+})
+
+it('returns null for a response whose body is already used', async () => {
+  const response = new Response('hello')
+  await response.text()
+
+  expect(observeResponseBodyStream(response)).toBeNull()
+})
+
+it('returns null for a response whose body is locked', () => {
+  const response = new Response('hello')
+  response.body?.getReader()
+
+  expect(observeResponseBodyStream(response)).toBeNull()
+})
+
+it('resolves "settled" when the response body is read to completion', async () => {
+  const observed = observeResponseBodyStream(new Response('hello'))
+  expect(observed).not.toBeNull()
+
+  await expect(observed?.response.text()).resolves.toBe('hello')
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+it('resolves "settled" when the response body errors', async () => {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.error(new Error('stream error'))
+    },
+  })
+  const observed = observeResponseBodyStream(new Response(stream))
+  expect(observed).not.toBeNull()
+
+  await expect(observed?.response.text()).rejects.toThrow('stream error')
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+it('resolves "settled" when the response body is canceled', async () => {
+  const stream = new ReadableStream({
+    pull(controller) {
+      controller.enqueue(new TextEncoder().encode('ping'))
+    },
+  })
+  const observed = observeResponseBodyStream(new Response(stream))
+  const reader = observed?.response.body?.getReader()
+  expect(reader).toBeDefined()
+
+  await reader?.read()
+  await reader?.cancel(new Error('client disconnected'))
+
+  await expect(observed?.settled).resolves.toBeUndefined()
+})
+
+it('resolves "settled" when the response body is consumed via piping', async () => {
+  const observed = observeResponseBodyStream(new Response('hello'))
+  expect(observed).not.toBeNull()
+
+  await observed?.response.body?.pipeTo(new WritableStream())
+  await expect(observed?.settled).resolves.toBeUndefined()
+})

package/src/core/utils/internal/observe-response-body-stream.ts

@@ -0,0 +1,77 @@
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { FetchResponse } from '@mswjs/interceptors'
+import { copyResponseOwnProperties } from '../HttpResponse/decorators'
+
+export interface ObservedResponse {
+  response: Response
+  /**
+   * A promise that resolves once the response body stream has settled:
+   * it was closed, errored, or canceled, and will not be used anymore.
+   */
+  settled: Promise<void>
+}
+
+/**
+ * Observe the `ReadableStream` body of the given response.
+ * Returns a copy of that response whose body reports when it has
+ * settled (was read to completion, errored, or canceled by the consumer).
+ * Returns `null` for responses whose body cannot be observed
+ * (no body, already used, or locked).
+ */
+export function observeResponseBodyStream(
+  response: Response,
+): ObservedResponse | null {
+  if (response.body == null || response.bodyUsed || response.body.locked) {
+    return null
+  }
+
+  const settled = new DeferredPromise<void>()
+  const reader = response.body.getReader()
+
+  /**
+   * @note Relay the body through a manual underlying source instead of
+   * `.pipeThrough(new TransformStream({ flush, cancel }))`. The `cancel`
+   * transformer callback is not implemented in Chromium, which loses
+   * the stream error/cancelation signals there entirely.
+   */
+  const observedStream = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const readResult = await reader.read()
+
+        if (readResult.done) {
+          settled.resolve()
+          controller.close()
+          return
+        }
+
+        controller.enqueue(readResult.value)
+      } catch (error) {
+        settled.resolve()
+        throw error
+      }
+    },
+    async cancel(reason) {
+      settled.resolve()
+      await reader.cancel(reason)
+    },
+  })
+
+  /**
+   * @note Reconstruct the response because the body of an existing
+   * response cannot be replaced. Use `FetchResponse` to support
+   * non-standard response status codes (e.g. 101).
+   */
+  const observedResponse = new FetchResponse(observedStream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  })
+
+  copyResponseOwnProperties(response, observedResponse)
+
+  return {
+    response: observedResponse,
+    settled,
+  }
+}

package/src/core/utils/internal/parseGraphQLRequest.test.ts

@@ -3,10 +3,8 @@
  */
 import { encodeBuffer } from '@mswjs/interceptors'
 import { OperationTypeNode } from 'graphql'
-import {
-  ParsedGraphQLRequest,
-  parseGraphQLRequest,
-} from './parseGraphQLRequest'
+import type { ParsedGraphQLRequest } from './parseGraphQLRequest'
+import { parseGraphQLRequest } from './parseGraphQLRequest'
 
 test('returns true given a GraphQL-compatible request', async () => {
   const getRequest = new Request(

package/src/core/utils/internal/parseMultipartData.ts

@@ -1,5 +1,5 @@
 import { stringToHeaders } from 'headers-polyfill'
-import { DefaultRequestMultipartBody } from '../../handlers/RequestHandler'
+import { type DefaultRequestMultipartBody } from '../../handlers/RequestHandler'
 
 interface ParsedContentHeaders {
   name: string

package/src/core/utils/internal/pipeEvents.ts

@@ -1,4 +1,5 @@
-import { Emitter, EventMap } from 'strict-event-emitter'
+import type { Emitter } from 'strict-event-emitter'
+import { type EventMap } from 'strict-event-emitter'
 
 /**
  * Pipes all emitted events from one emitter to another.

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

@@ -1,8 +1,6 @@
 // @vitest-environment jsdom
-import {
-  onUnhandledRequest,
-  UnhandledRequestCallback,
-} from './onUnhandledRequest'
+import type { UnhandledRequestCallback } from './onUnhandledRequest'
+import { onUnhandledRequest } from './onUnhandledRequest'
 
 const fixtures = {
   warningWithoutSuggestions: (url = `/api`) => `\

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

@@ -1,5 +1,5 @@
 import { cookieStore } from '../cookieStore'
-import { kSetCookie } from '../HttpResponse/decorators'
+import { getRawSetCookie } from '../HttpResponse/decorators'
 
 export async function storeResponseCookies(
   request: Request,
@@ -7,9 +7,7 @@ export async function storeResponseCookies(
 ): Promise<void> {
   // Grab the raw "Set-Cookie" response header provided
   // in the HeadersInit for this mocked response.
-  const responseCookies = Reflect.get(response, kSetCookie) as
-    | string
-    | undefined
+  const responseCookies = getRawSetCookie(response)
 
   if (responseCookies) {
     await cookieStore.setCookie(responseCookies, request.url)

package/src/core/ws/WebSocketClientManager.test.ts

@@ -1,10 +1,8 @@
 // @vitest-environment node-websocket
 import { setMaxListeners } from 'node:events'
 import { WebSocketClientConnection } from '@mswjs/interceptors/WebSocket'
-import {
-  WebSocketClientManager,
-  WebSocketBroadcastChannelMessage,
-} from './WebSocketClientManager'
+import type { WebSocketBroadcastChannelMessage } from './WebSocketClientManager'
+import { WebSocketClientManager } from './WebSocketClientManager'
 import { TestWebSocketTransport } from '../../../test/support/ws-test-utils'
 
 const channel = new BroadcastChannel('test:channel')

package/src/core/ws/WebSocketClientManager.ts

@@ -3,7 +3,7 @@ import type {
   WebSocketClientConnectionProtocol,
   WebSocketClientEventMap,
 } from '@mswjs/interceptors/WebSocket'
-import { WebSocketClientStore } from './WebSocketClientStore'
+import type { WebSocketClientStore } from './WebSocketClientStore'
 import { WebSocketMemoryClientStore } from './WebSocketMemoryClientStore'
 import { WebSocketIndexedDBClientStore } from './WebSocketIndexedDBClientStore'
 

package/src/core/ws/WebSocketIndexedDBClientStore.ts

@@ -1,9 +1,7 @@
 import { DeferredPromise } from '@open-draft/deferred-promise'
-import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
-import {
-  type SerializedWebSocketClient,
-  WebSocketClientStore,
-} from './WebSocketClientStore'
+import type { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
+import type { WebSocketClientStore } from './WebSocketClientStore'
+import { type SerializedWebSocketClient } from './WebSocketClientStore'
 
 const DB_NAME = 'msw-websocket-clients'
 const DB_STORE_NAME = 'clients'

package/src/core/ws/WebSocketMemoryClientStore.ts

@@ -1,8 +1,6 @@
-import { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
-import {
-  SerializedWebSocketClient,
-  WebSocketClientStore,
-} from './WebSocketClientStore'
+import type { WebSocketClientConnectionProtocol } from '@mswjs/interceptors/WebSocket'
+import type { WebSocketClientStore } from './WebSocketClientStore'
+import { type SerializedWebSocketClient } from './WebSocketClientStore'
 
 export class WebSocketMemoryClientStore implements WebSocketClientStore {
   private store: Map<string, SerializedWebSocketClient>

package/src/core/ws/handleWebSocketEvent.ts

@@ -1,10 +1,10 @@
 import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
-import { RequestHandler } from '../handlers/RequestHandler'
-import { WebSocketHandler } from '../handlers/WebSocketHandler'
+import type { RequestHandler } from '../handlers/RequestHandler'
+import type { WebSocketHandler } from '../handlers/WebSocketHandler'
 import { webSocketInterceptor } from './webSocketInterceptor'
 import {
   onUnhandledRequest,
-  UnhandledRequestStrategy,
+  type UnhandledRequestStrategy,
 } from '../utils/request/onUnhandledRequest'
 import { isHandlerKind } from '../utils/internal/isHandlerKind'
 

package/src/core/ws.ts

@@ -1,4 +1,5 @@
 import { invariant } from 'outvariant'
+import { FetchResponse, resolveWebSocketUrl } from '@mswjs/interceptors'
 import type {
   WebSocketData,
   WebSocketClientConnectionProtocol,
@@ -9,8 +10,15 @@ import {
   type WebSocketHandlerEventMap,
 } from './handlers/WebSocketHandler'
 import { hasRefCounted } from './utils/internal/hasRefCounted'
-import { type Path, isPath } from './utils/matching/matchRequestUrl'
+import {
+  type Path,
+  type PathParams,
+  isPath,
+  matchRequestUrl,
+} from './utils/matching/matchRequestUrl'
 import { WebSocketClientManager } from './ws/WebSocketClientManager'
+import { http } from './http'
+import { attachSiblingHandlers } from './utils/internal/attachSiblingHandlers'
 
 const webSocketChannel = new BroadcastChannel('msw:websocket-client-manager')
 
@@ -100,18 +108,29 @@ function createWebSocketLinkHandler(url: Path): WebSocketLink {
 
   const clientManager = new WebSocketClientManager(webSocketChannel)
 
+  // The same upgrade handler instance is attached as a sibling to every
+  // WebSocketHandler returned by this link. `groupHandlersByKind` dedupes
+  // by reference, so it lands in the `request` bucket exactly once regardless
+  // of which subset of WS handlers the user ends up registering.
+  const upgradeHandler = http.get(({ request }) => {
+    return (
+      request.headers.get('upgrade')?.toLowerCase() === 'websocket' &&
+      matchRequestUrl(new URL(resolveWebSocketUrl(request.url)), url).matches
+    )
+  }, ws.onUpgrade)
+
   return {
     get clients() {
       return clientManager.clients
     },
     addEventListener(event, listener) {
-      const handler = new WebSocketHandler(url)
+      const webSocketHandler = new WebSocketHandler(url)
 
       // Add the connection event listener for when the
       // handler matches and emits a connection event.
       // When that happens, store that connection in the
       // set of all connections for reference.
-      handler[kEmitter].on('connection', async ({ client }) => {
+      webSocketHandler[kEmitter].on('connection', async ({ client }) => {
         await clientManager.addConnection(client)
       })
 
@@ -119,9 +138,9 @@ function createWebSocketLinkHandler(url: Path): WebSocketLink {
       // the "run()" method on the WebSocketHandler.
       // If the handler matches, it will emit the "connection"
       // event. Attach the user-defined listener to that event.
-      handler[kEmitter].on(event, listener)
+      webSocketHandler[kEmitter].on(event, listener)
 
-      return handler
+      return attachSiblingHandlers(webSocketHandler, [upgradeHandler])
     },
 
     broadcast(data) {
@@ -145,6 +164,24 @@ function createWebSocketLinkHandler(url: Path): WebSocketLink {
   }
 }
 
+const WEBSOCKET_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+interface WebSocketNamespace {
+  link: typeof createWebSocketLinkHandler
+  /**
+   * Request handler for the `upgrade` requests to the WebSocket protocol.
+   * This requires a WebSocket handler to be present to fire.
+   * @note This only affects Node.js as the `upgrade` request header is
+   * forbidden and cannot be read in the browser. Consider using the
+   * `WebSocket` API for establishing WebSocket connections in the browser.
+   */
+  onUpgrade: (info: {
+    requestId: string
+    request: Request
+    params: PathParams
+  }) => Promise<Response | undefined> | Response | undefined
+}
+
 /**
  * A namespace to intercept and mock WebSocket connections.
  *
@@ -154,8 +191,30 @@ function createWebSocketLinkHandler(url: Path): WebSocketLink {
  * @see {@link https://mswjs.io/docs/api/ws `ws` API reference}
  * @see {@link https://mswjs.io/docs/basics/handling-websocket-events Handling WebSocket events}
  */
-export const ws = {
+export const ws: WebSocketNamespace = {
   link: createWebSocketLinkHandler,
+  async onUpgrade({ request }) {
+    const key = request.headers.get('sec-websocket-key')
+
+    if (!key) {
+      return
+    }
+
+    const keyBytes = new TextEncoder().encode(key + WEBSOCKET_GUID)
+    const digest = await crypto.subtle.digest('SHA-1', keyBytes)
+    const acceptValue = btoa(String.fromCharCode(...new Uint8Array(digest)))
+
+    new WebSocket(resolveWebSocketUrl(request.url))
+
+    return new FetchResponse(null, {
+      status: 101,
+      headers: {
+        upgrade: 'websocket',
+        connection: 'upgrade',
+        'sec-websocket-accept': acceptValue,
+      },
+    })
+  },
 }
 
-export { WebSocketData }
+export { type WebSocketData }

package/src/mockServiceWorker.js

@@ -137,8 +137,18 @@ async function handleRequest(event, requestId, requestInterceptedAt) {
   if (client && activeClientIds.has(client.id)) {
     const serializedRequest = await serializeRequest(requestCloneForEvents)
 
+    // Omit the body of server-sent event stream responses.
+    // Cloning such responses would prevent client-side stream cancelations
+    // from reaching the original stream (a teed stream only cancels its
+    // source once both of its branches cancel) and would buffer the
+    // entire stream into the unconsumed clone indefinitely.
+    const isEventStreamResponse = response.headers
+      .get('content-type')
+      ?.toLowerCase()
+      .startsWith('text/event-stream')
+
     // Clone the response so both the client and the library could consume it.
-    const responseClone = response.clone()
+    const responseClone = isEventStreamResponse ? null : response.clone()
 
     sendToClient(
       client,
@@ -151,15 +161,17 @@ async function handleRequest(event, requestId, requestInterceptedAt) {
             ...serializedRequest,
           },
           response: {
-            type: responseClone.type,
-            status: responseClone.status,
-            statusText: responseClone.statusText,
-            headers: Object.fromEntries(responseClone.headers.entries()),
-            body: responseClone.body,
+            type: response.type,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: responseClone ? responseClone.body : null,
           },
         },
       },
-      responseClone.body ? [serializedRequest.body, responseClone.body] : [],
+      responseClone && responseClone.body
+        ? [serializedRequest.body, responseClone.body]
+        : [],
     )
   }
 

package/src/native/index.ts

@@ -1,10 +1,10 @@
 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 type { AnyHandler } from '#core/experimental/handlers-controller'
 import {
   defineNetwork,
-  DefineNetworkOptions,
+  type DefineNetworkOptions,
 } from '#core/experimental/define-network'
 import { InterceptorSource } from '#core/experimental/sources/interceptor-source'
 import { type SetupServerCommon } from '../node/glossary'

package/src/node/async-handlers-controller.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
 import {
+  HandlersController,
   type AnyHandler,
   type HandlersMap,
-  HandlersController,
-  HandlersControllerState,
+  type HandlersControllerState,
 } from '#core/experimental/handlers-controller'
 
 export interface AsyncHandlersControllerContext {

package/src/node/index.ts

@@ -5,3 +5,4 @@ export {
   defaultNetworkOptions,
 } from './setup-server'
 export { SetupServerCommonApi } from './setup-server-common'
+export { AsyncHandlersController } from './async-handlers-controller'

package/src/node/setup-server-common.ts

@@ -1,12 +1,12 @@
 import type { PartialDeep } from 'type-fest'
-import { Interceptor } from '@mswjs/interceptors'
+import type { Interceptor } from '@mswjs/interceptors'
 import {
-  type NetworkApi,
   NetworkReadyState,
   defineNetwork,
+  type NetworkApi,
 } from '#core/experimental/define-network'
-import { type AnyHandler } from '#core/experimental/handlers-controller'
-import { type HandlersController } from '#core/experimental/handlers-controller'
+import type { AnyHandler } from '#core/experimental/handlers-controller'
+import type { HandlersController } from '#core/experimental/handlers-controller'
 import { InterceptorSource } from '#core/experimental/sources/interceptor-source'
 import { fromLegacyOnUnhandledRequest } from '#core/experimental/compat'
 import type { ListenOptions, SetupServerCommon } from './glossary'

package/src/node/setup-server.ts

@@ -7,9 +7,9 @@ import {
   defineNetwork,
   type DefineNetworkOptions,
 } from '#core/experimental/define-network'
-import { type AnyHandler } from '#core/experimental/handlers-controller'
+import type { AnyHandler } from '#core/experimental/handlers-controller'
 import { InterceptorSource } from '#core/experimental/sources/interceptor-source'
-import { SetupServer } from './glossary'
+import type { SetupServer } from './glossary'
 import { AsyncHandlersController } from './async-handlers-controller'
 import {
   defineSetupServerApi,

package/lib/core/utils/internal/requestHandlerUtils.d.mts

@@ -1,12 +0,0 @@
-import { R as RequestHandler, r as RequestHandlerDefaultInfo, c as RequestHandlerOptions } from '../../HttpResponse-DlRR1D-f.mjs';
-import '@mswjs/interceptors';
-import './isIterable.mjs';
-import '../../typeUtils.mjs';
-import 'graphql';
-import '../matching/matchRequestUrl.mjs';
-
-declare function use(currentHandlers: Array<RequestHandler>, ...handlers: Array<RequestHandler>): void;
-declare function restoreHandlers(handlers: Array<RequestHandler>): void;
-declare function resetHandlers(initialHandlers: Array<RequestHandler>, ...nextHandlers: Array<RequestHandler>): RequestHandler<RequestHandlerDefaultInfo, any, any, RequestHandlerOptions>[];
-
-export { resetHandlers, restoreHandlers, use };

package/lib/core/utils/internal/requestHandlerUtils.d.ts

@@ -1,12 +0,0 @@
-import { R as RequestHandler, r as RequestHandlerDefaultInfo, c as RequestHandlerOptions } from '../../HttpResponse-CksOMVAa.js';
-import '@mswjs/interceptors';
-import './isIterable.js';
-import '../../typeUtils.js';
-import 'graphql';
-import '../matching/matchRequestUrl.js';
-
-declare function use(currentHandlers: Array<RequestHandler>, ...handlers: Array<RequestHandler>): void;
-declare function restoreHandlers(handlers: Array<RequestHandler>): void;
-declare function resetHandlers(initialHandlers: Array<RequestHandler>, ...nextHandlers: Array<RequestHandler>): RequestHandler<RequestHandlerDefaultInfo, any, any, RequestHandlerOptions>[];
-
-export { resetHandlers, restoreHandlers, use };