Compression Query Paramater Fix (#368)

This PR resolves an issue we found with `unaryGET` requests between iOS
and Android libraries when looking at our CDN logs.

## Background
We noticed that we were appending `compression=identity` to all our iOS
requests and not our equivalent Android requests. That led me on quite a
journey to understand how this all works. The
[connect-kotlin](https://github.com/connectrpc/connect-kotlin/blob/01db4796e47bf5f2a4b677ec1ea6f483a2344bd7/library/src/main/kotlin/com/connectrpc/protocols/ConnectInterceptor.kt#L362-L364)
and
[connect-swift](https://github.com/connectrpc/connect-swift/blob/main/Libraries/Connect/Internal/Interceptors/ConnectInterceptor.swift#L250-L260)
implementations are not currently the same, and the changes proposed in
this PR bring them as close together as possible without a much larger
refactor to the iOS approach.

<img width="1729" height="164" alt="Screenshot 2025-09-19 at 5 46 40 PM"
src="https://github.com/user-attachments/assets/04df5cb5-0944-4611-baf5-6f8da560662b"
/>

## Proposal
Prior to this change, the `unaryGET` logic was incorrectly always
appending the `compression=identity` query parameter even when
compression wasn't being applied. This logic has now been modified (
with ✅ tests ✅ added 😎 ) to only apply the query parameter when the
`Content-Type` header has been set. You cannot use the
`requestCompression` object attached to the `ProtocolClientConfig` since
the data has already been compressed when it reaches this part of the
code. Because of this, I opted to use the `Content-Type` header as the
signal to apply the query parameter.

Please have a deeper look at this to see if you'd rather use the same
approach as the Kotlin library does. I think it would be better to use
the `requestCompression` object to determine whether it should be set or
not, but that will require an order of operations refactor to this
system.

Cheers. 🍻

---------

Signed-off-by: Christian Noon <christian.noon@gmail.com>

Author: cnoon

Libraries/Connect/Internal/Interceptors/ConnectInterceptor.swift

@@ -241,23 +241,28 @@ extension ConnectInterceptor: StreamInterceptor {
     }
 }
 
-private extension ProtocolClientConfig {
+extension ProtocolClientConfig {
     func transformToGETIfNeeded(_ request: HTTPRequest<Data?>) -> HTTPRequest<Data?> {
         guard self.shouldUseUnaryGET(for: request) else {
             return request
         }
 
         var components = URLComponents(url: request.url, resolvingAgainstBaseURL: true)
-        components?.queryItems = [
+
+        var queryItems: [URLQueryItem] = [
             URLQueryItem(name: "base64", value: "1"),
-            URLQueryItem(
-                name: "compression",
-                value: request.headers[HeaderConstants.contentEncoding]?.first ?? "identity"
-            ),
             URLQueryItem(name: "connect", value: "v\(ConnectInterceptor.protocolVersion)"),
             URLQueryItem(name: "encoding", value: self.codec.name()),
             URLQueryItem(name: "message", value: request.message?.base64EncodedString()),
         ]
+
+        if let contentEncoding = request.headers[HeaderConstants.contentEncoding]?.first {
+            let queryItem = URLQueryItem(name: "compression", value: contentEncoding)
+            queryItems.append(queryItem)
+        }
+
+        components?.queryItems = queryItems
+
         guard let url = components?.url else {
             return request
         }

Tests/UnitTests/ConnectLibraryTests/ConnectTests/ProtocolClientConfigTests.swift

@@ -213,4 +213,54 @@ final class ProtocolClientConfigTests: XCTestCase {
             unaryGET: .disabled
         ).shouldUseUnaryGET(for: request))
     }
+
+    func testTransformToGETWithoutRequestCompression() {
+        let request = HTTPRequest<Data?>(
+            url: URL(string: "https://connectrpc.com")!,
+            headers: Headers(),
+            message: Data([0x0, 0x1, 0x2]),
+            method: .post,
+            trailers: nil,
+            idempotencyLevel: .noSideEffects
+        )
+
+        let config = ProtocolClientConfig(
+            host: "https://connectrpc.com",
+            networkProtocol: .connect,
+            unaryGET: .alwaysEnabled
+        )
+
+        let requestWithoutCompression = config.transformToGETIfNeeded(request)
+
+        XCTAssertEqual(requestWithoutCompression.method, .get)
+        XCTAssertEqual(
+            requestWithoutCompression.url.absoluteString,
+            "https://connectrpc.com?base64=1&connect=v1&encoding=json&message=AAEC"
+        )
+    }
+
+    func testTransformToGETWithRequestCompression() {
+        let compressedRequest = HTTPRequest<Data?>(
+            url: URL(string: "https://connectrpc.com")!,
+            headers: [HeaderConstants.contentEncoding: ["gzip"]], // mimics inceptor behavior
+            message: Data([0x0, 0x1, 0x2]),
+            method: .post,
+            trailers: nil,
+            idempotencyLevel: .noSideEffects
+        )
+
+        let config = ProtocolClientConfig(
+            host: "https://connectrpc.com",
+            networkProtocol: .connect,
+            unaryGET: .alwaysEnabled
+        )
+
+        let requestWithCompression = config.transformToGETIfNeeded(compressedRequest)
+
+        XCTAssertEqual(requestWithCompression.method, .get)
+        XCTAssertEqual(
+            requestWithCompression.url.absoluteString,
+            "https://connectrpc.com?base64=1&connect=v1&encoding=json&message=AAEC&compression=gzip"
+        )
+    }
 }