msw 2.1.3 → 2.1.4

package/lib/mockServiceWorker.js

@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 /**
- * Mock Service Worker (2.1.3).
+ * Mock Service Worker (2.1.4).
  * @see https://github.com/mswjs/msw
  * - Please do NOT modify this file.
  * - Please do NOT serve this file on production.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "./lib/core/index.js",
   "module": "./lib/core/index.mjs",
@@ -93,13 +93,11 @@
   "sideEffects": false,
   "dependencies": {
     "@bundled-es-modules/cookie": "^2.0.0",
-    "@bundled-es-modules/js-levenshtein": "^2.0.1",
     "@bundled-es-modules/statuses": "^1.0.1",
     "@mswjs/cookies": "^1.1.0",
     "@mswjs/interceptors": "^0.25.14",
     "@open-draft/until": "^2.1.0",
     "@types/cookie": "^0.6.0",
-    "@types/js-levenshtein": "^1.1.3",
     "@types/statuses": "^2.0.4",
     "chalk": "^4.1.2",
     "chokidar": "^3.4.2",
@@ -107,7 +105,6 @@
     "headers-polyfill": "^4.0.2",
     "inquirer": "^8.2.0",
     "is-node-process": "^1.2.0",
-    "js-levenshtein": "^1.1.6",
     "outvariant": "^1.4.2",
     "path-to-regexp": "^6.2.0",
     "strict-event-emitter": "^0.5.1",

package/src/core/utils/handleRequest.ts

@@ -82,7 +82,7 @@ export async function handleRequest(
   // If the handler lookup returned nothing, no request handler was found
   // matching this request. Report the request as unhandled.
   if (!lookupResult.data) {
-    await onUnhandledRequest(request, handlers, options.onUnhandledRequest)
+    await onUnhandledRequest(request, options.onUnhandledRequest)
     emitter.emit('request:unhandled', { request, requestId })
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)

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

@@ -5,10 +5,6 @@ import {
   onUnhandledRequest,
   UnhandledRequestCallback,
 } from './onUnhandledRequest'
-import { HttpHandler, HttpMethods } from '../../handlers/HttpHandler'
-import { ResponseResolver } from '../../handlers/RequestHandler'
-
-const resolver: ResponseResolver = () => void 0
 
 const fixtures = {
   warningWithoutSuggestions: `\
@@ -24,18 +20,6 @@ Read more: https://mswjs.io/docs/getting-started/mocks`,
 
   • GET /api
 
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/getting-started/mocks`,
-
-  warningWithSuggestions: (suggestions: string) => `\
-[MSW] Warning: intercepted a request without a matching request handler:
-
-  • GET /api
-
-Did you mean to request one of the following resources instead?
-
-${suggestions}
-
 If you still wish to intercept this unhandled request, please create a request handler for it.
 Read more: https://mswjs.io/docs/getting-started/mocks`,
 }
@@ -52,7 +36,6 @@ afterEach(() => {
 test('supports the "bypass" request strategy', async () => {
   await onUnhandledRequest(
     new Request(new URL('http://localhost/api')),
-    [],
     'bypass',
   )
 
@@ -61,22 +44,14 @@ test('supports the "bypass" request strategy', async () => {
 })
 
 test('supports the "warn" request strategy', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [],
-    'warn',
-  )
+  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
 
   expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
 })
 
 test('supports the "error" request strategy', async () => {
   await expect(
-    onUnhandledRequest(
-      new Request(new URL('http://localhost/api')),
-      [],
-      'error',
-    ),
+    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.',
   )
@@ -89,7 +64,7 @@ test('supports a custom callback function', async () => {
     console.warn(`callback: ${request.method} ${request.url}`)
   })
   const request = new Request(new URL('/user', 'http://localhost:3000'))
-  await onUnhandledRequest(request, [], callback)
+  await onUnhandledRequest(request, callback)
 
   expect(callback).toHaveBeenCalledTimes(1)
   expect(callback).toHaveBeenCalledWith(request, {
@@ -111,7 +86,7 @@ test('supports calling default strategies from the custom callback function', as
     },
   )
   const request = new Request(new URL('http://localhost/api'))
-  await expect(onUnhandledRequest(request, [], callback)).rejects.toThrow(
+  await expect(onUnhandledRequest(request, callback)).rejects.toThrow(
     `[MSW] Cannot bypass a request when using the "error" strategy for the "onUnhandledRequest" option.`,
   )
 
@@ -126,86 +101,15 @@ test('supports calling default strategies from the custom callback function', as
 })
 
 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('does not print any suggestions given no handlers are similar', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [
-      // None of the defined request handlers match the actual request URL
-      // to be used as suggestions.
-      new HttpHandler(HttpMethods.GET, 'https://api.github.com', resolver),
-      new HttpHandler(HttpMethods.GET, 'https://api.stripe.com', resolver),
-    ],
-    'warn',
-  )
+  await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
 
   expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
 })
 
-test('respects RegExp as a request handler method', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [new HttpHandler(/^GE/, 'http://localhost/api', resolver)],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
-})
-
-test('sorts the suggestions by relevance', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [
-      new HttpHandler(HttpMethods.GET, '/', resolver),
-      new HttpHandler(HttpMethods.GET, 'https://api.example.com/api', resolver),
-      new HttpHandler(HttpMethods.POST, '/api', resolver),
-    ],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithSuggestions(`\
-  • POST /api
-  • GET /`),
-  )
-})
-
-test('does not print more than 4 suggestions', async () => {
-  await onUnhandledRequest(
-    new Request(new URL('http://localhost/api')),
-    [
-      new HttpHandler(HttpMethods.GET, '/ap', resolver),
-      new HttpHandler(HttpMethods.GET, '/api', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-1', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-2', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-3', resolver),
-      new HttpHandler(HttpMethods.GET, '/api-4', resolver),
-    ],
-    'warn',
-  )
-
-  expect(console.warn).toHaveBeenCalledWith(
-    fixtures.warningWithSuggestions(`\
-  • GET /api
-  • GET /ap
-  • GET /api-1
-  • GET /api-2`),
-  )
-})
-
 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',
     ),

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

@@ -1,22 +1,6 @@
-import jsLevenshtein from '@bundled-es-modules/js-levenshtein'
-import { RequestHandler } from '../../handlers/RequestHandler'
-import { HttpHandler } from '../../handlers/HttpHandler'
-import { GraphQLHandler } from '../../handlers/GraphQLHandler'
-import {
-  ParsedGraphQLQuery,
-  ParsedGraphQLRequest,
-  parseGraphQLRequest,
-} from '../internal/parseGraphQLRequest'
 import { getPublicUrlFromRequest } from './getPublicUrlFromRequest'
-import { isStringEqual } from '../internal/isStringEqual'
 import { devUtils } from '../internal/devUtils'
 
-const getStringMatchScore = jsLevenshtein
-
-const MAX_MATCH_SCORE = 3
-const MAX_SUGGESTION_COUNT = 4
-const TYPE_MATCH_DELTA = 0.5
-
 export interface UnhandledRequestPrint {
   warning(): void
   error(): void
@@ -33,183 +17,18 @@ export type UnhandledRequestStrategy =
   | 'error'
   | UnhandledRequestCallback
 
-interface RequestHandlerGroups {
-  http: Array<HttpHandler>
-  graphql: Array<GraphQLHandler>
-}
-
-function groupHandlersByType(
-  handlers: Array<RequestHandler>,
-): RequestHandlerGroups {
-  return handlers.reduce<RequestHandlerGroups>(
-    (groups, handler) => {
-      if (handler instanceof HttpHandler) {
-        groups.http.push(handler)
-      }
-
-      if (handler instanceof GraphQLHandler) {
-        groups.graphql.push(handler)
-      }
-
-      return groups
-    },
-    {
-      http: [],
-      graphql: [],
-    },
-  )
-}
-
-type RequestHandlerSuggestion = [number, RequestHandler]
-
-type ScoreGetterFn<RequestHandlerType extends RequestHandler> = (
-  request: Request,
-  handler: RequestHandlerType,
-) => number
-
-function getHttpHandlerScore(): ScoreGetterFn<HttpHandler> {
-  return (request, handler) => {
-    const { path, method } = handler.info
-
-    if (path instanceof RegExp || method instanceof RegExp) {
-      return Infinity
-    }
-
-    const hasSameMethod = isStringEqual(request.method, method)
-
-    // Always treat a handler with the same method as a more similar one.
-    const methodScoreDelta = hasSameMethod ? TYPE_MATCH_DELTA : 0
-    const requestPublicUrl = getPublicUrlFromRequest(request)
-    const score = getStringMatchScore(requestPublicUrl, path)
-
-    return score - methodScoreDelta
-  }
-}
-
-function getGraphQLHandlerScore(
-  parsedQuery: ParsedGraphQLQuery,
-): ScoreGetterFn<GraphQLHandler> {
-  return (_, handler) => {
-    if (typeof parsedQuery.operationName === 'undefined') {
-      return Infinity
-    }
-
-    const { operationType, operationName } = handler.info
-
-    if (typeof operationName !== 'string') {
-      return Infinity
-    }
-
-    const hasSameOperationType = parsedQuery.operationType === operationType
-    // Always treat a handler with the same operation type as a more similar one.
-    const operationTypeScoreDelta = hasSameOperationType ? TYPE_MATCH_DELTA : 0
-    const score = getStringMatchScore(parsedQuery.operationName, operationName)
-
-    return score - operationTypeScoreDelta
-  }
-}
-
-function getSuggestedHandler(
-  request: Request,
-  handlers: Array<HttpHandler> | Array<GraphQLHandler>,
-  getScore: ScoreGetterFn<HttpHandler> | ScoreGetterFn<GraphQLHandler>,
-): Array<RequestHandler> {
-  const suggestedHandlers = (handlers as Array<RequestHandler>)
-    .reduce<Array<RequestHandlerSuggestion>>((suggestions, handler) => {
-      const score = getScore(request, handler as any)
-      return suggestions.concat([[score, handler]])
-    }, [])
-    .sort(([leftScore], [rightScore]) => leftScore - rightScore)
-    .filter(([score]) => score <= MAX_MATCH_SCORE)
-    .slice(0, MAX_SUGGESTION_COUNT)
-    .map(([, handler]) => handler)
-
-  return suggestedHandlers
-}
-
-function getSuggestedHandlersMessage(handlers: RequestHandler[]) {
-  if (handlers.length > 1) {
-    return `\
-Did you mean to request one of the following resources instead?
-
-${handlers.map((handler) => `  • ${handler.info.header}`).join('\n')}`
-  }
-
-  return `Did you mean to request "${handlers[0].info.header}" instead?`
-}
-
 export async function onUnhandledRequest(
   request: Request,
-  handlers: Array<RequestHandler>,
   strategy: UnhandledRequestStrategy = 'warn',
 ): Promise<void> {
-  const parsedGraphQLQuery = await parseGraphQLRequest(request).catch(
-    () => null,
-  )
   const publicUrl = getPublicUrlFromRequest(request)
-
-  function generateHandlerSuggestion(): string {
-    /**
-     * @note Ignore exceptions during GraphQL request parsing because at this point
-     * we cannot assume the unhandled request is a valid GraphQL request.
-     * If the GraphQL parsing fails, just don't treat it as a GraphQL request.
-     */
-    const handlerGroups = groupHandlersByType(handlers)
-    const relevantHandlers = parsedGraphQLQuery
-      ? handlerGroups.graphql
-      : handlerGroups.http
-
-    const suggestedHandlers = getSuggestedHandler(
-      request,
-      relevantHandlers,
-      parsedGraphQLQuery
-        ? getGraphQLHandlerScore(parsedGraphQLQuery)
-        : getHttpHandlerScore(),
-    )
-
-    return suggestedHandlers.length > 0
-      ? getSuggestedHandlersMessage(suggestedHandlers)
-      : ''
-  }
-
-  function getGraphQLRequestHeader(
-    parsedGraphQLRequest: ParsedGraphQLRequest<any>,
-  ): string {
-    if (!parsedGraphQLRequest?.operationName) {
-      return `anonymous ${parsedGraphQLRequest?.operationType} (${request.method} ${publicUrl})`
-    }
-
-    return `${parsedGraphQLRequest.operationType} ${parsedGraphQLRequest.operationName} (${request.method} ${publicUrl})`
-  }
-
-  function generateUnhandledRequestMessage(): string {
-    const requestHeader = parsedGraphQLQuery
-      ? getGraphQLRequestHeader(parsedGraphQLQuery)
-      : `${request.method} ${publicUrl}`
-    const handlerSuggestion = generateHandlerSuggestion()
-
-    const messageTemplate = [
-      `intercepted a request without a matching request handler:`,
-      `  \u2022 ${requestHeader}`,
-      handlerSuggestion,
-      `\
-If you still wish to intercept this unhandled request, please create a request handler for it.
-Read more: https://mswjs.io/docs/getting-started/mocks\
-`,
-    ].filter(Boolean)
-    return messageTemplate.join('\n\n')
-  }
+  const unhandledRequestMessage = `intercepted a request without a matching request handler:\n\n  \u2022 ${request.method} ${publicUrl}\n\nIf you still wish to intercept this unhandled request, please create a request handler for it.\nRead more: https://mswjs.io/docs/getting-started/mocks`
 
   function applyStrategy(strategy: UnhandledRequestStrategy) {
-    // Generate handler suggestions only when applying the strategy.
-    // This saves bandwidth for scenarios when developers opt-out
-    // from the default unhandled request handling strategy.
-    const message = generateUnhandledRequestMessage()
-
     switch (strategy) {
       case 'error': {
         // Print a developer-friendly error.
-        devUtils.error('Error: %s', message)
+        devUtils.error('Error: %s', unhandledRequestMessage)
 
         // Throw an exception to halt request processing and not perform the original request.
         throw new Error(
@@ -220,7 +39,7 @@ Read more: https://mswjs.io/docs/getting-started/mocks\
       }
 
       case 'warn': {
-        devUtils.warn('Warning: %s', message)
+        devUtils.warn('Warning: %s', unhandledRequestMessage)
         break
       }