Implement req in beforeResponse #80

Author: fitudao3788

src/rules/requests/request-handler-definitions.ts

@@ -560,7 +560,7 @@ export interface PassThroughHandlerOptions extends PassThroughHandlerConnectionO
      *
      * See {@link CallbackResponseMessageResult} for the possible fields that can be set.
      */
-    beforeResponse?: (res: PassThroughResponse) => MaybePromise<CallbackResponseResult | void> | void;
+    beforeResponse?: (res: PassThroughResponse, req: CompletedRequest) => MaybePromise<CallbackResponseResult | void> | void;
 }
 
 export interface RequestTransform {
@@ -754,7 +754,7 @@ export interface BeforePassthroughRequestRequest {
  * @internal
  */
 export interface BeforePassthroughResponseRequest {
-    args: [Replace<PassThroughResponse, { body: string }>];
+    args: [Replace<PassThroughResponse, { body: string }>, Replace<CompletedRequest, { body: string }>];
 }
 
 /**
@@ -780,7 +780,7 @@ export class PassThroughHandlerDefinition extends Serializable implements Reques
 
     public readonly beforeRequest?: (req: CompletedRequest) =>
         MaybePromise<CallbackRequestResult | void> | void;
-    public readonly beforeResponse?: (res: PassThroughResponse) =>
+    public readonly beforeResponse?: (res: PassThroughResponse, req: CompletedRequest) =>
         MaybePromise<CallbackResponseResult | void> | void;
 
     public readonly proxyConfig?: ProxyConfig;
@@ -925,7 +925,8 @@ export class PassThroughHandlerDefinition extends Serializable implements Reques
                 CallbackResponseResult | undefined
             >('beforeResponse', async (req) => {
                 const callbackResult = await this.beforeResponse!(
-                    withDeserializedBodyReader(req.args[0])
+                    withDeserializedBodyReader(req.args[0]),
+                    withDeserializedBodyReader(req.args[1]),
                 );
 
                 if (typeof callbackResult === 'string') {

src/rules/requests/request-handlers.ts

@@ -924,13 +924,27 @@ export class PassThroughHandler extends PassThroughHandlerDefinition {
                     originalBody = await streamToBuffer(serverRes);
                     let serverHeaders = rawHeadersToObject(serverRawHeaders);
 
+                    let reqHeader = rawHeadersToObjectPreservingCase(rawHeaders);
                     modifiedRes = await this.beforeResponse({
                         id: clientReq.id,
                         statusCode: serverStatusCode,
                         statusMessage: serverRes.statusMessage,
                         headers: serverHeaders,
                         rawHeaders: _.cloneDeep(serverRawHeaders),
                         body: buildBodyReader(originalBody, serverHeaders)
+                    }, {
+                        id: clientReq.id,
+                        protocol: protocol?.replace(':', '') ?? '',
+                        method: method,
+                        url: reqUrl,
+                        path: path ?? '',
+                        headers: reqHeader,
+                        rawHeaders: rawHeaders,
+                        timingEvents: clientReq.timingEvents,
+                        tags: clientReq.tags,
+                        body: buildBodyReader(reqBodyOverride ? Buffer.from(reqBodyOverride.buffer) : await clientReq.body.asDecodedBuffer(), reqHeader),
+                        rawTrailers: clientReq.rawTrailers ?? [],
+                        trailers: rawHeadersToObject(clientReq.rawTrailers ?? []),
                     });
 
                     if (modifiedRes === 'close') {
@@ -1214,17 +1228,17 @@ export class PassThroughHandler extends PassThroughHandlerDefinition {
             };
         }
 
-        let beforeResponse: ((res: PassThroughResponse) => MaybePromise<CallbackResponseResult | void>) | undefined;
+        let beforeResponse: ((res: PassThroughResponse, req: CompletedRequest) => MaybePromise<CallbackResponseResult | void>) | undefined;
         if (data.hasBeforeResponseCallback) {
-            beforeResponse = async (res: PassThroughResponse) => {
+            beforeResponse = async (res: PassThroughResponse, req: CompletedRequest) => {
                 const callbackResult = await channel.request<
                     BeforePassthroughResponseRequest,
                     | WithSerializedCallbackBuffers<CallbackResponseMessageResult>
                     | 'close'
                     | 'reset'
                     | undefined
                 >('beforeResponse', {
-                    args: [withSerializedBodyReader(res)]
+                    args: [withSerializedBodyReader(res), withSerializedBodyReader(req)]
                 })
 
                 if (callbackResult && typeof callbackResult !== 'string') {