msw 2.0.13 → 2.1.0

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

@@ -160,6 +160,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -188,6 +189,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -215,6 +217,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -243,6 +246,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -272,6 +276,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -300,6 +305,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -327,6 +333,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -355,6 +362,7 @@ describe('parse', () => {
       })
 
       expect(await handler.parse({ request })).toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {
@@ -393,6 +401,7 @@ describe('parse', () => {
           ),
         }),
       ).resolves.toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {},
@@ -418,6 +427,7 @@ describe('parse', () => {
           ),
         }),
       ).resolves.toEqual({
+        cookies: {},
         match: {
           matches: true,
           params: {},
@@ -452,6 +462,7 @@ describe('parse', () => {
           ),
         }),
       ).resolves.toEqual({
+        cookies: {},
         match: {
           matches: false,
           params: {},
@@ -471,6 +482,7 @@ describe('parse', () => {
           ),
         }),
       ).resolves.toEqual({
+        cookies: {},
         match: {
           matches: false,
           params: {},
@@ -499,6 +511,7 @@ describe('parse', () => {
           ),
         }),
       ).resolves.toEqual({
+        cookies: {},
         match: {
           matches: false,
           params: {},
@@ -518,6 +531,7 @@ describe('parse', () => {
           ),
         }),
       ).resolves.toEqual({
+        cookies: {},
         match: {
           matches: false,
           params: {},
@@ -726,6 +740,7 @@ describe('run', () => {
 
     expect(result!.handler).toEqual(handler)
     expect(result!.parsedResult).toEqual({
+      cookies: {},
       match: {
         matches: true,
         params: {

package/src/core/handlers/GraphQLHandler.ts

@@ -24,6 +24,7 @@ import { getAllRequestCookies } from '../utils/request/getRequestCookies'
 export type ExpectedOperationTypeNode = OperationTypeNode | 'all'
 export type GraphQLHandlerNameSelector = DocumentNode | RegExp | string
 
+export type GraphQLQuery = Record<string, any>
 export type GraphQLVariables = Record<string, any>
 
 export interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
@@ -33,6 +34,7 @@ export interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
 
 export type GraphQLRequestParsedResult = {
   match: Match
+  cookies: Record<string, string>
 } & (
   | ParsedGraphQLRequest<GraphQLVariables>
   /**
@@ -165,8 +167,10 @@ export class GraphQLHandler extends RequestHandler<
      * need to parse it since there's no case where we would handle this
      */
     const match = matchRequestUrl(new URL(args.request.url), this.endpoint)
+    const cookies = getAllRequestCookies(args.request)
+
     if (!match.matches) {
-      return { match }
+      return { match, cookies }
     }
 
     const parsedResult = await this.parseGraphQLRequestOrGetFromCache(
@@ -174,11 +178,12 @@ export class GraphQLHandler extends RequestHandler<
     )
 
     if (typeof parsedResult === 'undefined') {
-      return { match }
+      return { match, cookies }
     }
 
     return {
       match,
+      cookies,
       query: parsedResult.query,
       operationType: parsedResult.operationType,
       operationName: parsedResult.operationName,
@@ -224,13 +229,11 @@ Consider naming this operation or using "graphql.operation()" request handler to
     request: Request
     parsedResult: GraphQLRequestParsedResult
   }) {
-    const cookies = getAllRequestCookies(args.request)
-
     return {
       query: args.parsedResult.query || '',
       operationName: args.parsedResult.operationName || '',
       variables: args.parsedResult.variables || {},
-      cookies,
+      cookies: args.parsedResult.cookies,
     }
   }
 

package/src/core/handlers/RequestHandler.ts

@@ -36,23 +36,28 @@ export interface RequestHandlerInternalInfo {
 }
 
 export type ResponseResolverReturnType<
-  BodyType extends DefaultBodyType = undefined,
+  ResponseBodyType extends DefaultBodyType = undefined,
 > =
-  | ([BodyType] extends [undefined] ? Response : StrictResponse<BodyType>)
+  | ([ResponseBodyType] extends [undefined]
+      ? Response
+      : StrictResponse<ResponseBodyType>)
   | undefined
   | void
 
 export type MaybeAsyncResponseResolverReturnType<
-  BodyType extends DefaultBodyType,
-> = MaybePromise<ResponseResolverReturnType<BodyType>>
+  ResponseBodyType extends DefaultBodyType,
+> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>
 
-export type AsyncResponseResolverReturnType<BodyType extends DefaultBodyType> =
-  | MaybeAsyncResponseResolverReturnType<BodyType>
+export type AsyncResponseResolverReturnType<
+  ResponseBodyType extends DefaultBodyType,
+> = MaybePromise<
+  | ResponseResolverReturnType<ResponseBodyType>
   | Generator<
-      MaybeAsyncResponseResolverReturnType<BodyType>,
-      MaybeAsyncResponseResolverReturnType<BodyType>,
-      MaybeAsyncResponseResolverReturnType<BodyType>
+      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,
+      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,
+      MaybeAsyncResponseResolverReturnType<ResponseBodyType>
     >
+>
 
 export type ResponseResolverInfo<
   ResolverExtraInfo extends Record<string, unknown>,
@@ -88,6 +93,7 @@ export interface RequestHandlerExecutionResult<
   handler: RequestHandler
   parsedResult?: ParsedResult
   request: Request
+  requestId: string
   response?: Response
 }
 
@@ -215,6 +221,7 @@ export abstract class RequestHandler<
    */
   public async run(args: {
     request: StrictRequest<any>
+    requestId: string
     resolutionContext?: ResponseResolutionContext
   }): Promise<RequestHandlerExecutionResult<ParsedResult> | null> {
     if (this.isUsed && this.options?.once) {
@@ -258,15 +265,30 @@ export abstract class RequestHandler<
       request: args.request,
       parsedResult,
     })
-    const mockedResponse = (await executeResolver({
-      ...resolverExtras,
-      request: args.request,
-    })) as Response
+
+    const mockedResponsePromise = (
+      executeResolver({
+        ...resolverExtras,
+        requestId: args.requestId,
+        request: args.request,
+      }) as Promise<Response>
+    ).catch((errorOrResponse) => {
+      // Allow throwing a Response instance in a response resolver.
+      if (errorOrResponse instanceof Response) {
+        return errorOrResponse
+      }
+
+      // Otherwise, throw the error as-is.
+      throw errorOrResponse
+    })
+
+    const mockedResponse = await mockedResponsePromise
 
     const executionResult = this.createExecutionResult({
       // Pass the cloned request to the result so that logging
       // and other consumers could read its body once more.
       request: requestClone,
+      requestId: args.requestId,
       response: mockedResponse,
       parsedResult,
     })
@@ -325,12 +347,14 @@ export abstract class RequestHandler<
 
   private createExecutionResult(args: {
     request: Request
+    requestId: string
     parsedResult: ParsedResult
     response?: Response
   }): RequestHandlerExecutionResult<ParsedResult> {
     return {
       handler: this,
       request: args.request,
+      requestId: args.requestId,
       response: args.response,
       parsedResult: args.parsedResult,
     }

package/src/core/http.ts

@@ -10,22 +10,35 @@ import {
 } from './handlers/HttpHandler'
 import type { Path, PathParams } from './utils/matching/matchRequestUrl'
 
+export type HttpRequestHandler = <
+  Params extends PathParams<keyof Params> = PathParams,
+  RequestBodyType extends DefaultBodyType = DefaultBodyType,
+  // Response body type MUST be undefined by default.
+  // This is how we can distinguish between a handler that
+  // returns plain "Response" and the one returning "HttpResponse"
+  // to enforce a stricter response body type.
+  ResponseBodyType extends DefaultBodyType = undefined,
+  RequestPath extends Path = Path,
+>(
+  path: RequestPath,
+  resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>,
+  options?: RequestHandlerOptions,
+) => HttpHandler
+
+export type HttpResponseResolver<
+  Params extends PathParams<keyof Params> = PathParams,
+  RequestBodyType extends DefaultBodyType = DefaultBodyType,
+  ResponseBodyType extends DefaultBodyType = DefaultBodyType,
+> = ResponseResolver<
+  HttpRequestResolverExtras<Params>,
+  RequestBodyType,
+  ResponseBodyType
+>
+
 function createHttpHandler<Method extends HttpMethods | RegExp>(
   method: Method,
-) {
-  return <
-    Params extends PathParams<keyof Params> = PathParams,
-    RequestBodyType extends DefaultBodyType = DefaultBodyType,
-    ResponseBodyType extends DefaultBodyType = undefined,
-  >(
-    path: Path,
-    resolver: ResponseResolver<
-      HttpRequestResolverExtras<Params>,
-      RequestBodyType,
-      ResponseBodyType
-    >,
-    options: RequestHandlerOptions = {},
-  ) => {
+): HttpRequestHandler {
+  return (path, resolver, options = {}) => {
     return new HttpHandler(method, path, resolver, options)
   }
 }

package/src/core/index.ts

@@ -34,12 +34,15 @@ export type {
   RequestQuery,
   HttpRequestParsedResult,
 } from './handlers/HttpHandler'
+export type { HttpResponseResolver } from './http'
 
 export type {
+  GraphQLQuery,
   GraphQLVariables,
   GraphQLRequestBody,
   GraphQLJsonRequestBody,
 } from './handlers/GraphQLHandler'
+export type { GraphQLResponseResolver } from './graphql'
 
 export type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'
 export type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'

package/src/core/utils/getResponse.ts

@@ -16,16 +16,22 @@ export interface ResponseResolutionContext {
 /**
  * Returns a mocked response for a given request using following request handlers.
  */
-export const getResponse = async <Handler extends Array<RequestHandler>>(
-  request: Request,
-  handlers: Handler,
-  resolutionContext?: ResponseResolutionContext,
-): Promise<ResponseLookupResult | null> => {
+export const getResponse = async <Handler extends Array<RequestHandler>>({
+  request,
+  requestId,
+  handlers,
+  resolutionContext,
+}: {
+  request: Request
+  requestId: string
+  handlers: Handler
+  resolutionContext?: ResponseResolutionContext
+}): Promise<ResponseLookupResult | null> => {
   let matchingHandler: RequestHandler | null = null
   let result: RequestHandlerExecutionResult<any> | null = null
 
   for (const handler of handlers) {
-    result = await handler.run({ request, resolutionContext })
+    result = await handler.run({ request, requestId, resolutionContext })
 
     // If the handler produces some result for this request,
     // it automatically becomes matching.

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

@@ -355,6 +355,26 @@ it('returns undefined without warning on a passthrough request', async () => {
   expect(handleRequestOptions.onMockedResponse).not.toHaveBeenCalled()
 })
 
+it('calls the handler with the requestId', async () => {
+  const { emitter } = setup()
+
+  const requestId = uuidv4()
+  const request = new Request(new URL('http://localhost/user'))
+  const handlerFn = vi.fn()
+  const handlers: Array<RequestHandler> = [http.get('/user', handlerFn)]
+
+  await handleRequest(
+    request,
+    requestId,
+    handlers,
+    options,
+    emitter,
+    handleRequestOptions,
+  )
+
+  expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({ requestId }))
+})
+
 it('marks the first matching one-time handler as used', async () => {
   const { emitter } = setup()
 

package/src/core/utils/handleRequest.ts

@@ -61,11 +61,12 @@ export async function handleRequest(
 
   // Resolve a mocked response from the list of request handlers.
   const lookupResult = await until(() => {
-    return getResponse(
+    return getResponse({
       request,
+      requestId,
       handlers,
-      handleRequestOptions?.resolutionContext,
-    )
+      resolutionContext: handleRequestOptions?.resolutionContext,
+    })
   })
 
   if (lookupResult.error) {