style: dart formatting

Author: CodingAleCR

lib/http/intercepted_client.dart

@@ -292,12 +292,13 @@ class InterceptedClient extends BaseClient {
       } else {
         // Use a completer to properly handle timeout and cancellation
         final completer = Completer<StreamedResponse>();
-        final Future<StreamedResponse> requestFuture = _inner.send(interceptedRequest);
-        
+        final Future<StreamedResponse> requestFuture =
+            _inner.send(interceptedRequest);
+
         // Set up timeout with proper cleanup
         Timer? timeoutTimer;
         late StreamSubscription streamSubscription;
-        
+
         timeoutTimer = Timer(requestTimeout!, () {
           if (!completer.isCompleted) {
             if (onRequestTimeout != null) {
@@ -318,13 +319,12 @@ class InterceptedClient extends BaseClient {
               // Default timeout behavior
               if (!completer.isCompleted) {
                 completer.completeError(Exception(
-                  'Request timeout after ${requestTimeout!.inMilliseconds}ms'
-                ));
+                    'Request timeout after ${requestTimeout!.inMilliseconds}ms'));
               }
             }
           }
         });
-        
+
         // Handle the actual request completion
         requestFuture.then((streamResponse) {
           timeoutTimer?.cancel();
@@ -337,7 +337,7 @@ class InterceptedClient extends BaseClient {
             completer.completeError(error);
           }
         });
-        
+
         stream = await completer.future;
       }
 

lib/models/retry_policy.dart

@@ -40,7 +40,7 @@ abstract class RetryPolicy {
   ///
   /// [reason] - The exception that occurred during the request
   /// [request] - The original request that failed
-  /// 
+  ///
   /// Returns `true` if the request should be retried, `false` otherwise.
   FutureOr<bool> shouldAttemptRetryOnException(
           Exception reason, BaseRequest request) =>
@@ -50,21 +50,21 @@ abstract class RetryPolicy {
   /// received `response` from the server.
   ///
   /// [response] - The response received from the server
-  /// 
+  ///
   /// Returns `true` if the request should be retried, `false` otherwise.
   /// Common use cases include retrying on 401 (Unauthorized) or 500 (Server Error).
   FutureOr<bool> shouldAttemptRetryOnResponse(BaseResponse response) => false;
 
   /// Number of maximum request attempts that can be retried.
-  /// 
+  ///
   /// Default is 1, meaning the original request plus 1 retry attempt.
   /// Set to 0 to disable retries, or higher values for more retry attempts.
   int get maxRetryAttempts => 1;
 
   /// Delay before retrying when an exception occurs.
   ///
   /// [retryAttempt] - The current retry attempt number (1-based)
-  /// 
+  ///
   /// Returns the delay duration. Default is no delay (Duration.zero).
   /// Consider implementing exponential backoff for production use.
   Duration delayRetryAttemptOnException({required int retryAttempt}) =>
@@ -73,7 +73,7 @@ abstract class RetryPolicy {
   /// Delay before retrying when a response indicates retry is needed.
   ///
   /// [retryAttempt] - The current retry attempt number (1-based)
-  /// 
+  ///
   /// Returns the delay duration. Default is no delay (Duration.zero).
   /// Consider implementing exponential backoff for production use.
   Duration delayRetryAttemptOnResponse({required int retryAttempt}) =>

lib/utils/query_parameters.dart

@@ -11,14 +11,18 @@ String buildUrlString(String url, Map<String, dynamic>? parameters) {
     // Validate URL structure to prevent injection
     // First check if it looks like a valid HTTP/HTTPS URL
     if (!url.startsWith('http://') && !url.startsWith('https://')) {
-      throw ArgumentError('Invalid URL structure: $url - must be a valid HTTP/HTTPS URL');
+      throw ArgumentError(
+        'Invalid URL structure: $url - must be a valid HTTP/HTTPS URL',
+      );
     }
-    
+
     try {
       final uri = Uri.parse(url);
       // Additional validation: ensure it has a host
       if (uri.host.isEmpty) {
-        throw ArgumentError('Invalid URL structure: $url - must have a valid host');
+        throw ArgumentError(
+          'Invalid URL structure: $url - must have a valid host',
+        );
       }
     } catch (e) {
       if (e is ArgumentError) {
@@ -38,15 +42,16 @@ String buildUrlString(String url, Map<String, dynamic>? parameters) {
     parameters.forEach((key, value) {
       // Encode the key to prevent injection
       final encodedKey = Uri.encodeQueryComponent(key);
-      
+
       if (value is List) {
         if (value is List<String>) {
           for (String singleValue in value) {
             url += "$encodedKey=${Uri.encodeQueryComponent(singleValue)}&";
           }
         } else {
           for (dynamic singleValue in value) {
-            url += "$encodedKey=${Uri.encodeQueryComponent(singleValue.toString())}&";
+            url +=
+                "$encodedKey=${Uri.encodeQueryComponent(singleValue.toString())}&";
           }
         }
       } else if (value is String) {

test/utils/utils_test.dart

@@ -12,8 +12,10 @@ main() {
       String parameterUrl = buildUrlString(url, parameters);
 
       // Assert
-      expect(parameterUrl,
-          equals("https://www.google.com/helloworld?foo=bar&num=0"));
+      expect(
+        parameterUrl,
+        equals("https://www.google.com/helloworld?foo=bar&num=0"),
+      );
     });
     test("Adds parameters to a URL string with parameters", () {
       // Arrange
@@ -25,9 +27,11 @@ main() {
 
       // Assert
       expect(
-          parameterUrl,
-          equals(
-              "https://www.google.com/helloworld?foo=bar&num=0&extra=1&extra2=anotherone"));
+        parameterUrl,
+        equals(
+          "https://www.google.com/helloworld?foo=bar&num=0&extra=1&extra2=anotherone",
+        ),
+      );
     });
     test("Adds parameters with array to a URL string without parameters", () {
       // Arrange
@@ -41,10 +45,12 @@ main() {
       String parameterUrl = buildUrlString(url, parameters);
 
       // Assert
-      expect(parameterUrl,
-          equals("https://www.google.com/helloworld?foo=bar&num=0&num=1"));
+      expect(
+        parameterUrl,
+        equals("https://www.google.com/helloworld?foo=bar&num=0&num=1"),
+      );
     });
-    
+
     test("Properly encodes parameter keys to prevent injection", () {
       // Arrange
       String url = "https://www.google.com/helloworld";
@@ -58,30 +64,41 @@ main() {
 
       // Assert
       expect(parameterUrl, contains("normal_key=normal_value"));
-      expect(parameterUrl, contains(Uri.encodeQueryComponent("key&with=special")));
-      expect(parameterUrl, contains(Uri.encodeQueryComponent("value&with=special")));
+      expect(
+        parameterUrl,
+        contains(Uri.encodeQueryComponent("key&with=special")),
+      );
+      expect(
+        parameterUrl,
+        contains(Uri.encodeQueryComponent("value&with=special")),
+      );
       // Should not contain unencoded special characters that could cause injection
       expect(parameterUrl.split('?')[1], isNot(contains("&with=special&")));
     });
-    
+
     test("Validates URL structure and throws error for invalid URLs", () {
       // Arrange
       String invalidUrl = "not a valid url";
       Map<String, dynamic> parameters = {"key": "value"};
 
       // Act & Assert
-      expect(() => buildUrlString(invalidUrl, parameters), 
-             throwsA(isA<ArgumentError>()));
+      expect(
+        () => buildUrlString(invalidUrl, parameters),
+        throwsA(isA<ArgumentError>()),
+      );
     });
-    
-    test("Validates URL structure and throws error for URLs without scheme", () {
+
+    test("Validates URL structure and throws error for URLs without scheme",
+        () {
       // Arrange
       String invalidUrl = "example.com/path"; // No scheme
       Map<String, dynamic> parameters = {"key": "value"};
 
       // Act & Assert
-      expect(() => buildUrlString(invalidUrl, parameters), 
-             throwsA(isA<ArgumentError>()));
+      expect(
+        () => buildUrlString(invalidUrl, parameters),
+        throwsA(isA<ArgumentError>()),
+      );
     });
   });
 }