Merge pull request #1438 from KevinZhang19870314/master

fix: #1428

@@ -192,38 +192,39 @@ class GetHttpClient {
       });
       });
 
 
       if (authenticate) await _modifier.authenticator!(request);
       if (authenticate) await _modifier.authenticator!(request);
-      await _modifier.modifyRequest(request);
+      final newRequest = await _modifier.modifyRequest<T>(request);
 
 
-      var response = await _httpClient.send<T>(request);
+      var response = await _httpClient.send<T>(newRequest);
 
 
-      await _modifier.modifyResponse(request, response);
+      final newResponse =
+          await _modifier.modifyResponse<T>(newRequest, response);
 
 
-      if (HttpStatus.unauthorized == response.statusCode &&
+      if (HttpStatus.unauthorized == newResponse.statusCode &&
           _modifier.authenticator != null &&
           _modifier.authenticator != null &&
           requestNumber <= maxAuthRetries) {
           requestNumber <= maxAuthRetries) {
         return _performRequest<T>(
         return _performRequest<T>(
           handler,
           handler,
           authenticate: true,
           authenticate: true,
           requestNumber: requestNumber + 1,
           requestNumber: requestNumber + 1,
-          headers: request.headers,
+          headers: newRequest.headers,
         );
         );
-      } else if (HttpStatus.unauthorized == response.statusCode) {
+      } else if (HttpStatus.unauthorized == newResponse.statusCode) {
         if (!errorSafety) {
         if (!errorSafety) {
           throw UnauthorizedException();
           throw UnauthorizedException();
         } else {
         } else {
           return Response<T>(
           return Response<T>(
-            request: request,
-            headers: response.headers,
-            statusCode: response.statusCode,
-            body: response.body,
-            bodyBytes: response.bodyBytes,
-            bodyString: response.bodyString,
-            statusText: response.statusText,
+            request: newRequest,
+            headers: newResponse.headers,
+            statusCode: newResponse.statusCode,
+            body: newResponse.body,
+            bodyBytes: newResponse.bodyBytes,
+            bodyString: newResponse.bodyString,
+            statusText: newResponse.statusText,
           );
           );
         }
         }
       }
       }
 
 
-      return response;
+      return newResponse;
     } on Exception catch (err) {
     } on Exception catch (err) {
       if (!errorSafety) {
       if (!errorSafety) {
         throw GetHttpException(err.toString());
         throw GetHttpException(err.toString());

@@ -31,19 +31,26 @@ class GetModifier<T> {
     _requestModifiers.remove(interceptor);
     _requestModifiers.remove(interceptor);
   }
   }
 
 
-  Future<void> modifyRequest(Request request) async {
+  Future<Request<T>> modifyRequest<T>(Request<T> request) async {
+    var newRequest = request;
     if (_requestModifiers.isNotEmpty) {
     if (_requestModifiers.isNotEmpty) {
       for (var interceptor in _requestModifiers) {
       for (var interceptor in _requestModifiers) {
-        await interceptor(request);
+        newRequest = await interceptor(newRequest) as Request<T>;
       }
       }
     }
     }
+
+    return newRequest;
   }
   }
 
 
-  Future<void> modifyResponse(Request request, Response response) async {
+  Future<Response<T>> modifyResponse<T>(
+      Request<T> request, Response<T> response) async {
+    var newResponse = response;
     if (_responseModifiers.isNotEmpty) {
     if (_responseModifiers.isNotEmpty) {
       for (var interceptor in _responseModifiers) {
       for (var interceptor in _responseModifiers) {
-        await interceptor(request, response);
+        newResponse = await interceptor(request, response) as Response<T>;
       }
       }
     }
     }
+
+    return newResponse;
   }
   }
 }
 }

@@ -74,6 +74,42 @@ class Request<T> {
       decoder: decoder,
       decoder: decoder,
     );
     );
   }
   }
+
+  Request copyWith({
+    Uri? url,
+    String? method,
+    Map<String, String>? headers,
+    Stream<List<int>>? bodyBytes,
+    bool followRedirects = true,
+    int maxRedirects = 4,
+    int? contentLength,
+    FormData? files,
+    bool persistentConnection = true,
+    Decoder<T>? decoder,
+    bool appendHeader = true,
+  }) {
+    if (followRedirects) {
+      assert(maxRedirects > 0);
+    }
+
+    // If appendHeader is set to true, we will merge origin headers with that
+    if (appendHeader && headers != null) {
+      headers.addAll(this.headers);
+    }
+
+    return Request._(
+      url: url ?? this.url,
+      method: method ?? this.method,
+      bodyBytes: bodyBytes ??= BodyBytesStream.fromBytes(const []),
+      headers: headers == null ? this.headers : Map.from(headers),
+      followRedirects: followRedirects,
+      maxRedirects: maxRedirects,
+      contentLength: contentLength,
+      files: files,
+      persistentConnection: persistentConnection,
+      decoder: decoder,
+    );
+  }
 }
 }
 
 
 extension BodyBytesStream on Stream<List<int>> {
 extension BodyBytesStream on Stream<List<int>> {