msw 2.0.14 → 2.1.1

package/src/core/handlers/RequestHandler.ts

@@ -64,6 +64,7 @@ export type ResponseResolverInfo<
   RequestBodyType extends DefaultBodyType = DefaultBodyType,
 > = {
   request: StrictRequest<RequestBodyType>
+  requestId: string
 } & ResolverExtraInfo
 
 export type ResponseResolver<
@@ -93,6 +94,7 @@ export interface RequestHandlerExecutionResult<
   handler: RequestHandler
   parsedResult?: ParsedResult
   request: Request
+  requestId: string
   response?: Response
 }
 
@@ -220,6 +222,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) {
@@ -263,15 +266,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,
     })
@@ -330,12 +348,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/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) {