Replace st_http::HeaderValue with just bytes

Author: coolreader18

crates/bindings/src/http.rs

@@ -160,13 +160,7 @@ fn convert_request(parts: http::request::Parts) -> st_http::Request {
         },
         headers: headers
             .into_iter()
-            .map(|(k, v)| {
-                let v = st_http::HeaderValue {
-                    is_sensitive: v.is_sensitive(),
-                    bytes: v.as_bytes().into(),
-                };
-                (k.map(|k| k.to_string()), v)
-            })
+            .map(|(k, v)| (k.map(|k| k.as_str().into()), v.as_bytes().into()))
             .collect(),
         timeout: timeout.map(Into::into),
         uri: uri.to_string(),
@@ -195,11 +189,7 @@ fn convert_response(response: st_http::Response) -> http::Result<http::response:
     response.status = http::StatusCode::from_u16(code)?;
     response.headers = headers
         .into_iter()
-        .map(|(k, v)| {
-            let mut value = http::HeaderValue::try_from(v.bytes.into_vec())?;
-            value.set_sensitive(v.is_sensitive);
-            Ok((k.try_into()?, value))
-        })
+        .map(|(k, v)| Ok((k.into_string().try_into()?, v.into_vec().try_into()?)))
         .collect::<http::Result<_>>()?;
     Ok(response)
 }

crates/core/src/host/instance_env.rs

@@ -701,11 +701,7 @@ fn convert_http_request(request: st_http::Request) -> http::Result<(http::reques
     };
     request.headers = headers
         .into_iter()
-        .map(|(k, v)| {
-            let mut value = http::HeaderValue::try_from(v.bytes.into_vec())?;
-            value.set_sensitive(v.is_sensitive);
-            Ok((k.try_into()?, value))
-        })
+        .map(|(k, v)| Ok((k.into_string().try_into()?, v.into_vec().try_into()?)))
         .collect::<http::Result<_>>()?;
 
     let timeout = timeout.map(|d| d.to_duration_saturating());
@@ -729,13 +725,7 @@ fn convert_http_response(response: http::response::Parts) -> st_http::Response {
     st_http::Response {
         headers: headers
             .into_iter()
-            .map(|(k, v)| {
-                let v = st_http::HeaderValue {
-                    is_sensitive: v.is_sensitive(),
-                    bytes: v.as_bytes().into(),
-                };
-                (k.map(|k| k.to_string()), v)
-            })
+            .map(|(k, v)| (k.map(|k| k.as_str().into()), v.as_bytes().into()))
             .collect(),
         version: match version {
             http::Version::HTTP_09 => st_http::Version::Http09,

crates/lib/src/http.rs

@@ -76,15 +76,15 @@ pub struct Headers {
 // `http::header::IntoIter` only returns the `HeaderName` for the first
 // `HeaderValue` with that name, so we have to manually assign the names.
 struct HeaderIter<I, T> {
-    prev: Option<(String, T)>,
+    prev: Option<(Box<str>, T)>,
     inner: I,
 }
 
 impl<I, T> Iterator for HeaderIter<I, T>
 where
-    I: Iterator<Item = (Option<String>, T)>,
+    I: Iterator<Item = (Option<Box<str>>, T)>,
 {
-    type Item = (String, T);
+    type Item = (Box<str>, T);
 
     fn next(&mut self) -> Option<Self::Item> {
         let (prev_k, prev_v) = self
@@ -103,8 +103,8 @@ where
     }
 }
 
-impl FromIterator<(Option<String>, HeaderValue)> for Headers {
-    fn from_iter<T: IntoIterator<Item = (Option<String>, HeaderValue)>>(iter: T) -> Self {
+impl FromIterator<(Option<Box<str>>, Box<[u8]>)> for Headers {
+    fn from_iter<T: IntoIterator<Item = (Option<Box<str>>, Box<[u8]>)>>(iter: T) -> Self {
         let inner = iter.into_iter();
         let entries = HeaderIter { prev: None, inner }
             .map(|(name, value)| HttpHeaderPair { name, value })
@@ -114,7 +114,7 @@ impl FromIterator<(Option<String>, HeaderValue)> for Headers {
 }
 
 impl Headers {
-    pub fn into_iter(self) -> impl Iterator<Item = (String, HeaderValue)> {
+    pub fn into_iter(self) -> impl Iterator<Item = (Box<str>, Box<[u8]>)> {
         IntoIterator::into_iter(self.entries).map(|HttpHeaderPair { name, value }| (name, value))
     }
 }
@@ -123,16 +123,9 @@ impl Headers {
 #[sats(crate = crate, name = "HttpHeaderPair")]
 struct HttpHeaderPair {
     /// A valid HTTP header name, sourced from an already-validated [`http::HeaderName`].
-    name: String,
-    value: HeaderValue,
-}
-
-/// A valid HTTP header value, sourced from an already-validated [`http::HeaderValue`].
-#[derive(Clone, SpacetimeType)]
-#[sats(crate = crate, name = "HttpHeaderValue")]
-pub struct HeaderValue {
-    pub bytes: Box<[u8]>,
-    pub is_sensitive: bool,
+    name: Box<str>,
+    /// A valid HTTP header value, sourced from an already-validated [`http::HeaderValue`].
+    value: Box<[u8]>,
 }
 
 #[derive(Clone, SpacetimeType)]