fix: #21 3

Author: washanhanzi

connectrpc-axum/src/context/compression.rs

@@ -201,12 +201,47 @@ impl CompressionConfig {
 }
 
 /// Negotiate response encoding from Accept-Encoding header.
+///
+/// Follows connect-go's approach: first supported encoding wins (client preference order).
+/// Respects `q=0` which means "not acceptable" per RFC 7231.
 pub fn negotiate_response_encoding(accept: Option<&str>) -> CompressionEncoding {
-    // Simple: if gzip is in Accept-Encoding, use it
-    match accept {
-        Some(s) if s.contains("gzip") => CompressionEncoding::Gzip,
-        _ => CompressionEncoding::Identity,
+    let Some(accept) = accept else {
+        return CompressionEncoding::Identity;
+    };
+
+    for token in accept.split(',') {
+        let token = token.trim();
+        if token.is_empty() {
+            continue;
+        }
+
+        // Parse "gzip;q=0.5" into encoding="gzip", q_value=Some("0.5")
+        let (encoding, q_value) = match token.split_once(';') {
+            Some((enc, params)) => {
+                let q = params
+                    .split(';')
+                    .find_map(|p| p.trim().strip_prefix("q="));
+                (enc.trim(), q)
+            }
+            None => (token, None),
+        };
+
+        // Skip if q=0 (explicitly disabled)
+        if let Some(q) = q_value {
+            if q.trim() == "0" || q.trim() == "0.0" || q.trim() == "0.00" || q.trim() == "0.000" {
+                continue;
+            }
+        }
+
+        // Return first supported encoding
+        match encoding {
+            "gzip" => return CompressionEncoding::Gzip,
+            "identity" => return CompressionEncoding::Identity,
+            _ => continue,
+        }
     }
+
+    CompressionEncoding::Identity
 }
 
 /// Header name for Connect streaming request compression.
@@ -363,6 +398,89 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_negotiate_response_encoding_order() {
+        // First supported encoding wins (client preference order)
+        assert_eq!(
+            negotiate_response_encoding(Some("br, gzip")),
+            CompressionEncoding::Gzip
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip, identity")),
+            CompressionEncoding::Gzip
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("identity, gzip")),
+            CompressionEncoding::Identity
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("br, zstd, gzip")),
+            CompressionEncoding::Gzip
+        );
+    }
+
+    #[test]
+    fn test_negotiate_response_encoding_q_values() {
+        // q=0 means "not acceptable" - should be skipped
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=0")),
+            CompressionEncoding::Identity
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=0, identity")),
+            CompressionEncoding::Identity
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=0.0")),
+            CompressionEncoding::Identity
+        );
+
+        // Non-zero q values should be accepted (we ignore the actual weight)
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=1")),
+            CompressionEncoding::Gzip
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=0.5")),
+            CompressionEncoding::Gzip
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=0.001")),
+            CompressionEncoding::Gzip
+        );
+
+        // Mixed: skip disabled, use first enabled
+        assert_eq!(
+            negotiate_response_encoding(Some("br;q=1, gzip;q=0, identity")),
+            CompressionEncoding::Identity
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;q=0, identity;q=0")),
+            CompressionEncoding::Identity
+        );
+    }
+
+    #[test]
+    fn test_negotiate_response_encoding_whitespace() {
+        // Handle various whitespace scenarios
+        assert_eq!(
+            negotiate_response_encoding(Some("  gzip  ")),
+            CompressionEncoding::Gzip
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip ; q=0")),
+            CompressionEncoding::Identity
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("gzip;  q=0")),
+            CompressionEncoding::Identity
+        );
+        assert_eq!(
+            negotiate_response_encoding(Some("br ,  gzip")),
+            CompressionEncoding::Gzip
+        );
+    }
+
     #[test]
     fn test_compress_decompress_gzip() {
         let original = Bytes::from_static(b"Hello, World! This is a test message.");

docs/.vitepress/config.mts

@@ -44,7 +44,8 @@ export default defineConfig({
               text: 'MakeServiceBuilder',
               link: '/guide/configuration',
               items: [
-                { text: 'Timeout', link: '/guide/timeout' }
+                { text: 'Timeout', link: '/guide/timeout' },
+                { text: 'Compression', link: '/guide/compression' }
               ]
             },
             { text: 'HTTP Endpoints', link: '/guide/http-endpoints' },

docs/guide/compression.md

@@ -0,0 +1,149 @@
+# Compression
+
+## Basic Usage
+
+Configure response compression using `MakeServiceBuilder`:
+
+```rust
+use connectrpc_axum::{MakeServiceBuilder, CompressionConfig};
+
+MakeServiceBuilder::new()
+    .add_router(router)
+    .compression(CompressionConfig::new(512))  // Compress responses >= 512 bytes
+    .build()
+```
+
+## Supported Encodings
+
+| Encoding | Description |
+|----------|-------------|
+| `gzip` | Gzip compression via flate2 |
+| `identity` | No compression (passthrough) |
+
+## Accept-Encoding Negotiation
+
+The server negotiates response compression using standard HTTP headers:
+
+- **Unary RPCs**: `Accept-Encoding` header
+- **Streaming RPCs**: `Connect-Accept-Encoding` header
+
+### How Negotiation Works
+
+Following connect-go's approach:
+
+1. **First supported encoding wins** - client preference order is respected
+2. **`q=0` means disabled** - encodings with `q=0` are skipped per RFC 7231
+3. **Other q-values are ignored** - no preference weighting beyond order
+
+| Accept-Encoding | Result |
+|-----------------|--------|
+| `gzip` | gzip |
+| `gzip, deflate, br` | gzip (first supported) |
+| `br, zstd, gzip` | gzip (first supported) |
+| `identity, gzip` | identity (first supported) |
+| `gzip;q=0` | identity (gzip disabled) |
+| `gzip;q=0, identity` | identity (gzip disabled) |
+| `gzip;q=0.5` | gzip (non-zero q accepted) |
+| `deflate, br` | identity (none supported) |
+
+::: tip
+Unlike full HTTP content negotiation, Connect protocol doesn't weight by q-value—it uses client order. This matches connect-go's behavior.
+:::
+
+## Configuration Options
+
+### Minimum Bytes Threshold
+
+Only compress responses larger than a threshold (default: 1024 bytes):
+
+```rust
+use connectrpc_axum::CompressionConfig;
+
+// Compress responses >= 512 bytes
+let config = CompressionConfig::new(512);
+
+// Default: 1024 bytes
+let config = CompressionConfig::default();
+```
+
+Small messages often don't benefit from compression due to overhead.
+
+### Disabling Compression
+
+Disable response compression entirely:
+
+```rust
+use connectrpc_axum::CompressionConfig;
+
+MakeServiceBuilder::new()
+    .add_router(router)
+    .compression(CompressionConfig::disabled())
+    .build()
+```
+
+## Request Decompression
+
+The server automatically decompresses incoming requests based on:
+
+- **Unary RPCs**: `Content-Encoding` header
+- **Streaming RPCs**: `Connect-Content-Encoding` header
+
+Unsupported encodings return `Unimplemented` error:
+
+```
+unsupported compression "br": supported encodings are gzip, identity
+```
+
+## Streaming Compression
+
+For streaming RPCs, compression is applied per-message using the envelope format:
+
+- Each message frame has a compression flag (byte 0, bit 0x01)
+- Compressed frames are automatically decompressed on read
+- Response frames are compressed based on negotiated encoding and size threshold
+
+## Protocol Headers
+
+| RPC Type | Request Compression | Response Negotiation |
+|----------|---------------------|----------------------|
+| Unary | `Content-Encoding` | `Accept-Encoding` |
+| Streaming | `Connect-Content-Encoding` | `Connect-Accept-Encoding` |
+
+## Implementation Notes
+
+### Conformance with connect-go
+
+This implementation matches connect-go's compression behavior:
+
+- First-match-wins negotiation (no q-value weighting)
+- Respects `q=0` as "not acceptable"
+- Same header names for unary vs streaming
+- Same error messages for unsupported encodings
+
+### Custom Codecs
+
+For custom compression algorithms (zstd, brotli), implement the `Codec` trait:
+
+```rust
+use connectrpc_axum::compression::Codec;
+use bytes::Bytes;
+use std::io;
+
+struct ZstdCodec { level: i32 }
+
+impl Codec for ZstdCodec {
+    fn name(&self) -> &'static str { "zstd" }
+
+    fn compress(&self, data: Bytes) -> io::Result<Bytes> {
+        // ... zstd compression
+    }
+
+    fn decompress(&self, data: Bytes) -> io::Result<Bytes> {
+        // ... zstd decompression
+    }
+}
+```
+
+::: warning
+Custom codecs require additional wiring to integrate with the negotiation logic. This API is subject to change.
+:::

docs/guide/configuration.md

@@ -70,6 +70,10 @@ MakeServiceBuilder::new()
 
 See [Timeout](./timeout.md) for detailed timeout configuration.
 
+### Compression
+
+See [Compression](./compression.md) for detailed compression configuration.
+
 ### Protocol Header Validation
 
 Require the `Connect-Protocol-Version` header for Connect protocol requests: