feat: add "requestId" as response resolver argument

src/core/handlers/RequestHandler.ts

@@ -88,6 +88,7 @@ export interface RequestHandlerExecutionResult<
   handler: RequestHandler
   parsedResult?: ParsedResult
   request: Request
+  requestId: string
   response?: Response
 }
 
@@ -215,6 +216,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) {
@@ -261,12 +263,14 @@ export abstract class RequestHandler<
     const mockedResponse = (await executeResolver({
       ...resolverExtras,
       request: args.request,
+      requestId: args.requestId,
     })) as Response
 
     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 +329,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,
     }

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.

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()
 

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) {