msw 2.10.1 → 2.10.3

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '2.10.1'
+const PACKAGE_VERSION = '2.10.3'
 const INTEGRITY_CHECKSUM = 'f5825c521429caf22a4dd13b66e243af'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 const activeClientIds = new Set()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.10.1",
+  "version": "2.10.3",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "type": "commonjs",
   "main": "./lib/core/index.js",
@@ -280,7 +280,7 @@
     "vitest-environment-miniflare": "^2.14.4",
     "webpack": "^5.95.0",
     "webpack-http-server": "^0.5.0",
-    "msw": "2.10.1"
+    "msw": "2.10.3"
   },
   "peerDependencies": {
     "typescript": ">= 4.8.x"

package/src/core/HttpResponse.ts

@@ -10,7 +10,10 @@ export interface HttpResponseInit extends ResponseInit {
   type?: ResponseType
 }
 
-const bodyType: unique symbol = Symbol('bodyType')
+export const bodyType: unique symbol = Symbol('bodyType')
+export type DefaultUnsafeFetchResponse = Response & {
+  [bodyType]?: never
+}
 
 export interface StrictRequest<BodyType extends JsonBodyType> extends Request {
   json(): Promise<BodyType>
@@ -46,6 +49,10 @@ export class HttpResponse<
     decorateResponse(this, responseInit)
   }
 
+  static error(): HttpResponse<any> {
+    return super.error() as HttpResponse<any>
+  }
+
   /**
    * Create a `Response` with a `Content-Type: "text/plain"` body.
    * @example

package/src/core/getResponse.test.ts

@@ -1,40 +1,38 @@
-/**
- * @vitest-environment node
- */
+// @vitest-environment node
 import { http } from './http'
 import { getResponse } from './getResponse'
 
 it('returns undefined given empty headers array', async () => {
-  expect(
-    await getResponse([], new Request('http://localhost/')),
-  ).toBeUndefined()
+  await expect(
+    getResponse([], new Request('http://localhost/')),
+  ).resolves.toBeUndefined()
 })
 
 it('returns undefined given no matching handlers', async () => {
-  expect(
-    await getResponse(
+  await expect(
+    getResponse(
       [http.get('/product', () => void 0)],
       new Request('http://localhost/user'),
     ),
-  ).toBeUndefined()
+  ).resolves.toBeUndefined()
 })
 
 it('returns undefined given a matching handler that returned no response', async () => {
-  expect(
-    await getResponse(
+  await expect(
+    getResponse(
       [http.get('*/user', () => void 0)],
       new Request('http://localhost/user'),
     ),
-  ).toBeUndefined()
+  ).resolves.toBeUndefined()
 })
 
 it('returns undefined given a matching handler that returned explicit undefined', async () => {
-  expect(
-    await getResponse(
+  await expect(
+    getResponse(
       [http.get('*/user', () => undefined)],
       new Request('http://localhost/user'),
     ),
-  ).toBeUndefined()
+  ).resolves.toBeUndefined()
 })
 
 it('returns the response returned from a matching handler', async () => {
@@ -45,7 +43,7 @@ it('returns the response returned from a matching handler', async () => {
 
   expect(response?.status).toBe(200)
   expect(response?.headers.get('Content-Type')).toBe('application/json')
-  expect(await response?.json()).toEqual({ name: 'John' })
+  await expect(response?.json()).resolves.toEqual({ name: 'John' })
 })
 
 it('returns the response from the first matching handler if multiple match', async () => {
@@ -59,5 +57,18 @@ it('returns the response from the first matching handler if multiple match', asy
 
   expect(response?.status).toBe(200)
   expect(response?.headers.get('Content-Type')).toBe('application/json')
-  expect(await response?.json()).toEqual({ name: 'John' })
+  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

@@ -1,22 +1,28 @@
 import { createRequestId } from '@mswjs/interceptors'
 import type { RequestHandler } from './handlers/RequestHandler'
-import { executeHandlers } from './utils/executeHandlers'
+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/handlers/RequestHandler.ts

@@ -6,8 +6,13 @@ import {
 } from '../utils/internal/isIterable'
 import type { ResponseResolutionContext } from '../utils/executeHandlers'
 import type { MaybePromise } from '../typeUtils'
-import type { HttpResponse, StrictRequest } from '..//HttpResponse'
+import {
+  StrictRequest,
+  HttpResponse,
+  DefaultUnsafeFetchResponse,
+} from '../HttpResponse'
 import type { HandlerKind } from './common'
+import type { GraphQLRequestBody } from './GraphQLHandler'
 
 export type DefaultRequestMultipartBody = Record<
   string,
@@ -42,9 +47,19 @@ export interface RequestHandlerInternalInfo {
 export type ResponseResolverReturnType<
   ResponseBodyType extends DefaultBodyType = undefined,
 > =
+  // If ResponseBodyType is a union and one of the types is `undefined`,
+  // allow plain Response as the type.
   | ([ResponseBodyType] extends [undefined]
       ? Response
-      : HttpResponse<ResponseBodyType>)
+      : /**
+         * Treat GraphQL response body type as a special case.
+         * For esome reason, making the default HttpResponse<T> | DefaultUnsafeFetchResponse
+         * union breaks the body type inference for HTTP requests.
+         * @see https://github.com/mswjs/msw/issues/2130
+         */
+        ResponseBodyType extends GraphQLRequestBody<any>
+        ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse
+        : HttpResponse<ResponseBodyType>)
   | undefined
   | void
 

package/src/core/handlers/WebSocketHandler.test.ts

@@ -108,4 +108,20 @@ describe('parse', () => {
       },
     })
   })
+
+  it('supports a custom resolution context (base url)', () => {
+    expect(
+      new WebSocketHandler('/api/ws').parse({
+        url: new URL('ws://localhost:3000/api/ws'),
+        resolutionContext: {
+          baseUrl: 'ws://localhost:3000/',
+        },
+      }),
+    ).toEqual({
+      match: {
+        matches: true,
+        params: {},
+      },
+    })
+  })
 })

package/src/core/handlers/WebSocketHandler.ts

@@ -29,6 +29,10 @@ export interface WebSocketHandlerConnection {
   params: PathParams
 }
 
+export interface WebSocketResolutionContext {
+  baseUrl?: string
+}
+
 export const kEmitter = Symbol('kEmitter')
 export const kSender = Symbol('kSender')
 const kStopPropagationPatched = Symbol('kStopPropagationPatched')
@@ -50,7 +54,10 @@ export class WebSocketHandler {
     this.__kind = 'EventHandler'
   }
 
-  public parse(args: { url: URL }): WebSocketHandlerParsedResult {
+  public parse(args: {
+    url: URL
+    resolutionContext?: WebSocketResolutionContext
+  }): WebSocketHandlerParsedResult {
     const clientUrl = new URL(args.url)
 
     /**
@@ -60,7 +67,11 @@ export class WebSocketHandler {
      */
     clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, '/')
 
-    const match = matchRequestUrl(clientUrl, this.url)
+    const match = matchRequestUrl(
+      clientUrl,
+      this.url,
+      args.resolutionContext?.baseUrl,
+    )
 
     return {
       match,
@@ -76,9 +87,11 @@ export class WebSocketHandler {
 
   public async run(
     connection: Omit<WebSocketHandlerConnection, 'params'>,
+    resolutionContext?: WebSocketResolutionContext,
   ): Promise<boolean> {
     const parsedResult = this.parse({
       url: connection.client.url,
+      resolutionContext,
     })
 
     if (!this.predicate({ url: connection.client.url, parsedResult })) {

package/lib/core/GraphQLHandler-DOXAygvT.d.mts

@@ -1,100 +0,0 @@
-import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
-import { D as DefaultBodyType, R as RequestHandler, g as RequestHandlerDefaultInfo, a as ResponseResolver, c as RequestHandlerOptions } from './HttpResponse-BOGtXZ-B.mjs';
-import { Match, Path } from './utils/matching/matchRequestUrl.mjs';
-
-interface ParsedGraphQLQuery {
-    operationType: OperationTypeNode;
-    operationName?: string;
-}
-type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
-    query: string;
-    variables?: VariablesType;
-}) | undefined;
-declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
-type GraphQLParsedOperationsMap = Record<string, string[]>;
-type GraphQLMultipartRequestBody = {
-    operations: string;
-    map?: string;
-} & {
-    [fileName: string]: File;
-};
-/**
- * Determines if a given request can be considered a GraphQL request.
- * Does not parse the query and does not guarantee its validity.
- */
-declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
-
-type ExpectedOperationTypeNode = OperationTypeNode | 'all';
-type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
-type GraphQLQuery = Record<string, any> | null;
-type GraphQLVariables = Record<string, any>;
-interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
-    operationType: ExpectedOperationTypeNode;
-    operationName: GraphQLHandlerNameSelector;
-}
-type GraphQLRequestParsedResult = {
-    match: Match;
-    cookies: Record<string, string>;
-} & (ParsedGraphQLRequest<GraphQLVariables>
-/**
- * An empty version of the ParsedGraphQLRequest
- * which simplifies the return type of the resolver
- * when the request is to a non-matching endpoint
- */
- | {
-    operationType?: undefined;
-    operationName?: undefined;
-    query?: undefined;
-    variables?: undefined;
-});
-type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
-    query: string;
-    operationName: string;
-    variables: Variables;
-    cookies: Record<string, string>;
-};
-type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
-interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
-    query: string;
-    variables?: Variables;
-}
-type GraphQLResponseBody<BodyType extends DefaultBodyType> = {
-    data?: BodyType | null;
-    errors?: readonly Partial<GraphQLError>[] | null;
-    extensions?: Record<string, any>;
-} | null | undefined;
-declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
-declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, GraphQLRequestParsedResult, GraphQLResolverExtras<any>> {
-    private endpoint;
-    static parsedRequestCache: WeakMap<Request, ParsedGraphQLRequest<GraphQLVariables>>;
-    constructor(operationType: ExpectedOperationTypeNode, operationName: GraphQLHandlerNameSelector, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
-    /**
-     * Parses the request body, once per request, cached across all
-     * GraphQL handlers. This is done to avoid multiple parsing of the
-     * request body, which each requires a clone of the request.
-     */
-    parseGraphQLRequestOrGetFromCache(request: Request): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
-    parse(args: {
-        request: Request;
-    }): Promise<GraphQLRequestParsedResult>;
-    predicate(args: {
-        request: Request;
-        parsedResult: GraphQLRequestParsedResult;
-    }): boolean;
-    protected extendResolverArgs(args: {
-        request: Request;
-        parsedResult: GraphQLRequestParsedResult;
-    }): {
-        query: string;
-        operationName: string;
-        variables: GraphQLVariables;
-        cookies: Record<string, string>;
-    };
-    log(args: {
-        request: Request;
-        response: Response;
-        parsedResult: GraphQLRequestParsedResult;
-    }): Promise<void>;
-}
-
-export { type ExpectedOperationTypeNode as E, GraphQLHandler as G, type ParsedGraphQLRequest as P, type GraphQLQuery as a, type GraphQLVariables as b, type GraphQLRequestBody as c, type GraphQLJsonRequestBody as d, type GraphQLHandlerNameSelector as e, type GraphQLResolverExtras as f, type GraphQLResponseBody as g, type ParsedGraphQLQuery as h, type GraphQLParsedOperationsMap as i, type GraphQLMultipartRequestBody as j, parseGraphQLRequest as k, type GraphQLHandlerInfo as l, type GraphQLRequestParsedResult as m, isDocumentNode as n, parseDocumentNode as p };

package/lib/core/GraphQLHandler-noP9MRWa.d.ts

@@ -1,100 +0,0 @@
-import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
-import { D as DefaultBodyType, R as RequestHandler, g as RequestHandlerDefaultInfo, a as ResponseResolver, c as RequestHandlerOptions } from './HttpResponse-DzeJL_i8.js';
-import { Match, Path } from './utils/matching/matchRequestUrl.js';
-
-interface ParsedGraphQLQuery {
-    operationType: OperationTypeNode;
-    operationName?: string;
-}
-type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
-    query: string;
-    variables?: VariablesType;
-}) | undefined;
-declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
-type GraphQLParsedOperationsMap = Record<string, string[]>;
-type GraphQLMultipartRequestBody = {
-    operations: string;
-    map?: string;
-} & {
-    [fileName: string]: File;
-};
-/**
- * Determines if a given request can be considered a GraphQL request.
- * Does not parse the query and does not guarantee its validity.
- */
-declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
-
-type ExpectedOperationTypeNode = OperationTypeNode | 'all';
-type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
-type GraphQLQuery = Record<string, any> | null;
-type GraphQLVariables = Record<string, any>;
-interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
-    operationType: ExpectedOperationTypeNode;
-    operationName: GraphQLHandlerNameSelector;
-}
-type GraphQLRequestParsedResult = {
-    match: Match;
-    cookies: Record<string, string>;
-} & (ParsedGraphQLRequest<GraphQLVariables>
-/**
- * An empty version of the ParsedGraphQLRequest
- * which simplifies the return type of the resolver
- * when the request is to a non-matching endpoint
- */
- | {
-    operationType?: undefined;
-    operationName?: undefined;
-    query?: undefined;
-    variables?: undefined;
-});
-type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
-    query: string;
-    operationName: string;
-    variables: Variables;
-    cookies: Record<string, string>;
-};
-type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
-interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
-    query: string;
-    variables?: Variables;
-}
-type GraphQLResponseBody<BodyType extends DefaultBodyType> = {
-    data?: BodyType | null;
-    errors?: readonly Partial<GraphQLError>[] | null;
-    extensions?: Record<string, any>;
-} | null | undefined;
-declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
-declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, GraphQLRequestParsedResult, GraphQLResolverExtras<any>> {
-    private endpoint;
-    static parsedRequestCache: WeakMap<Request, ParsedGraphQLRequest<GraphQLVariables>>;
-    constructor(operationType: ExpectedOperationTypeNode, operationName: GraphQLHandlerNameSelector, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
-    /**
-     * Parses the request body, once per request, cached across all
-     * GraphQL handlers. This is done to avoid multiple parsing of the
-     * request body, which each requires a clone of the request.
-     */
-    parseGraphQLRequestOrGetFromCache(request: Request): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
-    parse(args: {
-        request: Request;
-    }): Promise<GraphQLRequestParsedResult>;
-    predicate(args: {
-        request: Request;
-        parsedResult: GraphQLRequestParsedResult;
-    }): boolean;
-    protected extendResolverArgs(args: {
-        request: Request;
-        parsedResult: GraphQLRequestParsedResult;
-    }): {
-        query: string;
-        operationName: string;
-        variables: GraphQLVariables;
-        cookies: Record<string, string>;
-    };
-    log(args: {
-        request: Request;
-        response: Response;
-        parsedResult: GraphQLRequestParsedResult;
-    }): Promise<void>;
-}
-
-export { type ExpectedOperationTypeNode as E, GraphQLHandler as G, type ParsedGraphQLRequest as P, type GraphQLQuery as a, type GraphQLVariables as b, type GraphQLRequestBody as c, type GraphQLJsonRequestBody as d, type GraphQLHandlerNameSelector as e, type GraphQLResolverExtras as f, type GraphQLResponseBody as g, type ParsedGraphQLQuery as h, type GraphQLParsedOperationsMap as i, type GraphQLMultipartRequestBody as j, parseGraphQLRequest as k, type GraphQLHandlerInfo as l, type GraphQLRequestParsedResult as m, isDocumentNode as n, parseDocumentNode as p };