accept encoding

Author: ardatan

lib/executor/src/executors/compression.rs

@@ -15,8 +15,10 @@ pub enum CompressionType {
     Identity,
 }
 
-
 impl CompressionType {
+    pub fn accept_encoding() -> &'static str {
+        "gzip, deflate, br, zstd"
+    }
     pub fn header_value(&self) -> String {
         match self {
             CompressionType::Gzip => "gzip".to_string(),
@@ -32,9 +34,7 @@ impl CompressionType {
                 .to_string(),
         }
     }
-    pub fn from_encoding_header(
-        encoding: &str,
-    ) -> Result<CompressionType, SubgraphExecutorError> {
+    pub fn from_encoding_header(encoding: &str) -> Result<CompressionType, SubgraphExecutorError> {
         let encodings: Vec<&str> = encoding.split(',').map(|s| s.trim()).collect();
         if encodings.len() > 1 {
             let types = encodings
@@ -54,43 +54,54 @@ impl CompressionType {
             }
         }
     }
-    pub fn decompress<'a>(&'a self, body: Bytes) -> BoxFuture<'a, Result<Bytes, SubgraphExecutorError>> {
+    pub fn decompress<'a>(
+        &'a self,
+        body: Bytes,
+    ) -> BoxFuture<'a, Result<Bytes, SubgraphExecutorError>> {
         Box::pin(async move {
             match self {
                 CompressionType::Gzip => {
                     let mut decoder = GzipDecoder::new(body.as_ref());
                     let mut buf = Vec::new();
-                    let _ = decoder
-                        .read_to_end(&mut buf)
-                        .await
-                        .map_err(|e| SubgraphExecutorError::DecompressionFailed(self.header_value(), e.to_string()));
+                    let _ = decoder.read_to_end(&mut buf).await.map_err(|e| {
+                        SubgraphExecutorError::DecompressionFailed(
+                            self.header_value(),
+                            e.to_string(),
+                        )
+                    });
                     Ok(Bytes::from(buf))
                 }
                 CompressionType::Deflate => {
                     let mut decoder = DeflateDecoder::new(body.as_ref());
                     let mut buf = Vec::new();
-                    let _ = decoder
-                        .read_to_end(&mut buf)
-                        .await
-                        .map_err(|e| SubgraphExecutorError::DecompressionFailed(self.header_value(), e.to_string()));
+                    let _ = decoder.read_to_end(&mut buf).await.map_err(|e| {
+                        SubgraphExecutorError::DecompressionFailed(
+                            self.header_value(),
+                            e.to_string(),
+                        )
+                    });
                     Ok(Bytes::from(buf))
                 }
                 CompressionType::Brotli => {
                     let mut decoder = BrotliDecoder::new(body.as_ref());
                     let mut buf = Vec::new();
-                    let _ = decoder
-                        .read_to_end(&mut buf)
-                        .await
-                        .map_err(|e| SubgraphExecutorError::DecompressionFailed(self.header_value(), e.to_string()));
+                    let _ = decoder.read_to_end(&mut buf).await.map_err(|e| {
+                        SubgraphExecutorError::DecompressionFailed(
+                            self.header_value(),
+                            e.to_string(),
+                        )
+                    });
                     Ok(Bytes::from(buf))
                 }
                 CompressionType::Zstd => {
                     let mut decoder = ZstdDecoder::new(body.as_ref());
                     let mut buf = Vec::new();
-                    let _ = decoder
-                        .read_to_end(&mut buf)
-                        .await
-                        .map_err(|e| SubgraphExecutorError::DecompressionFailed(self.header_value(), e.to_string()));
+                    let _ = decoder.read_to_end(&mut buf).await.map_err(|e| {
+                        SubgraphExecutorError::DecompressionFailed(
+                            self.header_value(),
+                            e.to_string(),
+                        )
+                    });
                     Ok(Bytes::from(buf))
                 }
                 CompressionType::Multiple(types) => {

lib/executor/src/executors/error.rs

@@ -79,7 +79,7 @@ impl SubgraphExecutorError {
             SubgraphExecutorError::RequestFailure(_, _) => "SUBGRAPH_REQUEST_FAILURE",
             SubgraphExecutorError::VariablesSerializationFailure(_, _) => {
                 "SUBGRAPH_VARIABLES_SERIALIZATION_FAILURE"
-            },
+            }
             SubgraphExecutorError::UnknownEncoding(_) => "SUBGRAPH_UNKNOWN_ENCODING",
             SubgraphExecutorError::DecompressionFailed(_, _) => "SUBGRAPH_DECOMPRESSION_FAILED",
         }

lib/executor/src/executors/http.rs

@@ -12,8 +12,8 @@ use async_trait::async_trait;
 use bytes::{BufMut, Bytes, BytesMut};
 use http::HeaderMap;
 use http::HeaderValue;
+use http_body_util::BodyExt;
 use http_body_util::Full;
-use http_body_util::{BodyExt};
 use hyper::Version;
 use hyper_tls::HttpsConnector;
 use hyper_util::client::legacy::{connect::HttpConnector, Client};
@@ -65,7 +65,7 @@ impl HTTPSubgraphExecutor {
         );
         header_map.insert(
             http::header::ACCEPT_ENCODING,
-            HeaderValue::from_static("gzip, deflate, br, zstd"),
+            HeaderValue::from_static(CompressionType::accept_encoding()),
         );
 
         Self {

lib/executor/src/executors/mod.rs

@@ -1,6 +1,6 @@
 pub mod common;
+pub mod compression;
 pub mod dedupe;
 pub mod error;
 pub mod http;
 pub mod map;
-pub mod compression;