avoid unwrap in typed-header-encode

GlenDC · GlenDC · commit 2456b81f3570 · 2025-11-23T08:18:25.000+01:00
also make it easier to use typed headers
in SetRequest/Response layers, while still
preserving unique encodes per call
diff --git a/examples/http_mitm_proxy_boring.rs b/examples/http_mitm_proxy_boring.rs
@@ -62,7 +62,7 @@ use rama::{
         client::EasyHttpWebClient,
         conn::TargetHttpVersion,
         headers::{
-            HeaderEncode, HeaderMapExt as _, SecWebSocketExtensions, TypedHeader,
+            HeaderMapExt as _, SecWebSocketExtensions, TypedHeader as _,
             sec_websocket_extensions::Extension,
         },
         io::upgrade,
@@ -432,10 +432,8 @@ where
         }) {
             tracing::debug!("use deflate ext for ingress ws cfg: {accept_pmd_cfg:?}");
             ingress_socket_cfg.per_message_deflate = Some((&accept_pmd_cfg).into());
-            let _ = response_parts.headers.insert(
-                SecWebSocketExtensions::name(),
-                SecWebSocketExtensions::per_message_deflate_with_config(accept_pmd_cfg)
-                    .encode_to_value(),
+            response_parts.headers.typed_insert(
+                SecWebSocketExtensions::per_message_deflate_with_config(accept_pmd_cfg),
             );
         } else {
             tracing::debug!(
diff --git a/examples/http_web_router.rs b/examples/http_web_router.rs
@@ -31,7 +31,7 @@ use rama::{
     extensions::ExtensionsRef,
     http::{
         Request,
-        headers::{HeaderEncode, TypedHeader, exotic::XClacksOverhead},
+        headers::exotic::XClacksOverhead,
         layer::set_header::SetResponseHeaderLayer,
         layer::{match_redirect::UriMatchRedirectLayer, trace::TraceLayer},
         matcher::UriParams,
@@ -113,9 +113,7 @@ async fn main() {
 
     let middlewares = (
         TraceLayer::new_for_http(),
-        SetResponseHeaderLayer::if_not_present_fn(XClacksOverhead::name().clone(), || {
-            std::future::ready(XClacksOverhead::new().encode_to_value())
-        }),
+        SetResponseHeaderLayer::if_not_present_typed(XClacksOverhead::new()),
         UriMatchRedirectLayer::permanent([
             UriMatchReplaceRule::try_new("*/v1/*", "$1/v2/$2").unwrap(), // upgrade users as-is to v2 (backwards compatible)
             // this is now a new endpoint,
diff --git a/rama-cli/src/cmd/serve/fp/mod.rs b/rama-cli/src/cmd/serve/fp/mod.rs
@@ -11,8 +11,7 @@ use rama::{
         HeaderName, HeaderValue, Request,
         header::COOKIE,
         headers::{
-            Cookie, HeaderEncode, HeaderMapExt, SecWebSocketProtocol, TypedHeader,
-            all_client_hint_header_name_strings,
+            Cookie, HeaderMapExt, SecWebSocketProtocol, all_client_hint_header_name_strings,
             exotic::XClacksOverhead,
             forwarded::{CFConnectingIp, ClientIp, TrueClientIp, XClientIp, XRealIp},
             sec_websocket_extensions,
@@ -172,9 +171,7 @@ pub async fn run(graceful: ShutdownGuard, cfg: CliCommandFingerprint) -> Result<
         TraceLayer::new_for_http(),
         CompressionLayer::new(),
         CatchPanicLayer::new(),
-        SetResponseHeaderLayer::if_not_present_fn(XClacksOverhead::name().clone(), || {
-            std::future::ready(XClacksOverhead::new().encode_to_value())
-        }),
+        SetResponseHeaderLayer::if_not_present_typed(XClacksOverhead::new()),
         AddRequiredResponseHeadersLayer::default(),
         SetResponseHeaderLayer::overriding(
             HeaderName::from_static("x-sponsored-by"),
diff --git a/rama-http-headers/src/header.rs b/rama-http-headers/src/header.rs
@@ -1,4 +1,3 @@
-use rama_core::telemetry::tracing;
 use rama_http_types::{HeaderName, HeaderValue};
 
 use std::error;
@@ -48,13 +47,12 @@ pub trait HeaderEncode: TypedHeader {
     fn encode<E: Extend<HeaderValue>>(&self, values: &mut E);
 
     /// Encode this header to [`HeaderValue`].
-    fn encode_to_value(&self) -> HeaderValue {
+    ///
+    /// [`None`] is returned in case no header was encoded.
+    fn encode_to_value(&self) -> Option<HeaderValue> {
         let mut container = ExtendOnce(None);
         self.encode(&mut container);
-        container.0.unwrap_or_else(|| {
-            tracing::warn!("failed to get an encoded HeaderValue; default to empty");
-            HeaderValue::from_static("")
-        })
+        container.0
     }
 }
 
@@ -65,7 +63,7 @@ impl<H: HeaderEncode> HeaderEncode for &H {
     }
 
     #[inline]
-    fn encode_to_value(&self) -> HeaderValue {
+    fn encode_to_value(&self) -> Option<HeaderValue> {
         (*self).encode_to_value()
     }
 }
@@ -77,7 +75,7 @@ impl<H: HeaderEncode> HeaderEncode for Arc<H> {
     }
 
     #[inline]
-    fn encode_to_value(&self) -> HeaderValue {
+    fn encode_to_value(&self) -> Option<HeaderValue> {
         self.as_ref().encode_to_value()
     }
 }
diff --git a/rama-http-headers/src/req_builder_ext.rs b/rama-http-headers/src/req_builder_ext.rs
@@ -16,7 +16,11 @@ impl HttpRequestBuilderExt for request::Builder {
     where
         H: HeaderEncode,
     {
-        self.header(H::name(), header.encode_to_value())
+        if let Some(value) = header.encode_to_value() {
+            self.header(H::name(), value)
+        } else {
+            self
+        }
     }
 }
 
diff --git a/rama-http-headers/src/resp_builder_ext.rs b/rama-http-headers/src/resp_builder_ext.rs
@@ -16,7 +16,11 @@ impl HttpResponseBuilderExt for response::Builder {
     where
         H: HeaderEncode,
     {
-        self.header(H::name(), header.encode_to_value())
+        if let Some(value) = header.encode_to_value() {
+            self.header(H::name(), value)
+        } else {
+            self
+        }
     }
 }
 
diff --git a/rama-http-headers/src/x_robots_tag/header.rs b/rama-http-headers/src/x_robots_tag/header.rs
@@ -137,7 +137,7 @@ mod tests {
                 "BadBot: noindex, nofollow, googlebot: nofollow",
             ),
         ] {
-            let value = header_value.encode_to_value();
+            let value = header_value.encode_to_value().unwrap();
             let s = value.to_str().unwrap();
             assert_eq!(expected, s);
         }
diff --git a/rama-http/src/convert/curl.rs b/rama-http/src/convert/curl.rs
@@ -194,8 +194,9 @@ fn write_curl_command_for_request_parts(
         .or_else(|| parts.extensions().get())
     {
         writer.write_tuple("-x", proxy_addr, true);
-        if let Some(ProxyCredential::Bearer(bearer)) = &proxy_addr.credential {
-            let value = ProxyAuthorization(bearer.clone()).encode_to_value();
+        if let Some(ProxyCredential::Bearer(bearer)) = &proxy_addr.credential
+            && let Some(value) = ProxyAuthorization(bearer.clone()).encode_to_value()
+        {
             let s_value = String::from_utf8_lossy(value.as_bytes());
             writer.write_header(
                 Http1HeaderName::from(crate::header::PROXY_AUTHORIZATION),
diff --git a/rama-http/src/layer/har/spec.rs b/rama-http/src/layer/har/spec.rs
@@ -536,7 +536,8 @@ impl Response {
         let redirect_url = parts
             .headers
             .typed_get::<Location>()
-            .and_then(|h| h.encode_to_value().to_str().ok().map(ToOwned::to_owned));
+            .and_then(|h| h.encode_to_value())
+            .and_then(|v| v.to_str().ok().map(ToOwned::to_owned));
 
         let cookies = parts
             .headers
diff --git a/rama-http/src/layer/set_header/mod.rs b/rama-http/src/layer/set_header/mod.rs
@@ -10,3 +10,5 @@ pub use self::{
     request::{SetRequestHeader, SetRequestHeaderLayer},
     response::{SetResponseHeader, SetResponseHeaderLayer},
 };
+
+pub mod utils;
diff --git a/rama-http/src/layer/set_header/request/header.rs b/rama-http/src/layer/set_header/request/header.rs
@@ -1,4 +1,6 @@
+use crate::layer::set_header::utils::TypedHeaderAsMaker;
 use crate::{HeaderName, HeaderValue, Request};
+use rama_http_headers::HeaderEncode;
 use std::{
     future::{Future, ready},
     marker::PhantomData,
@@ -107,6 +109,19 @@ where
     }
 }
 
+impl<B, M> MakeHeaderValue<B> for Option<M>
+where
+    M: MakeHeaderValue<B> + Clone,
+    B: Send + 'static,
+{
+    async fn make_header_value(&self, req: Request<B>) -> (Request<B>, Option<HeaderValue>) {
+        match self {
+            Some(m) => m.make_header_value(req).await,
+            None => (req, None),
+        }
+    }
+}
+
 impl<B> MakeHeaderValue<B> for HeaderValue
 where
     B: Send + 'static,
@@ -119,15 +134,17 @@ where
     }
 }
 
-impl<B> MakeHeaderValue<B> for Option<HeaderValue>
+impl<B, H> MakeHeaderValue<B> for TypedHeaderAsMaker<H>
 where
     B: Send + 'static,
+    H: HeaderEncode + Send + Sync + 'static,
 {
     fn make_header_value(
         &self,
         req: Request<B>,
-    ) -> impl Future<Output = (Request<B>, Self)> + Send + '_ {
-        ready((req, self.clone()))
+    ) -> impl Future<Output = (Request<B>, Option<HeaderValue>)> + Send {
+        let maybe_value = self.0.encode_to_value();
+        ready((req, maybe_value))
     }
 }
 
diff --git a/rama-http/src/layer/set_header/request/mod.rs b/rama-http/src/layer/set_header/request/mod.rs
@@ -80,6 +80,7 @@
 //! # }
 //! ```
 
+use super::utils::TypedHeaderAsMaker;
 use crate::{HeaderValue, Request, Response, header::HeaderName, headers::HeaderEncode};
 use rama_core::{Layer, Service};
 use rama_utils::macros::define_inner_service_accessors;
@@ -142,7 +143,7 @@ impl<M> SetRequestHeaderLayer<M> {
     }
 }
 
-impl SetRequestHeaderLayer<HeaderValue> {
+impl SetRequestHeaderLayer<Option<HeaderValue>> {
     /// Create a new [`SetRequestHeaderLayer`] from a typed [`HeaderEncode`].
     ///
     /// See [`SetRequestHeaderLayer::overriding`] for more details.
@@ -247,28 +248,28 @@ pub struct SetRequestHeader<S, M> {
     mode: InsertHeaderMode,
 }
 
-impl<S> SetRequestHeader<S, HeaderValue> {
+impl<S, H: HeaderEncode> SetRequestHeader<S, TypedHeaderAsMaker<H>> {
     /// Create a new [`SetRequestHeader`] using a typed header.
     ///
     /// If a previous value exists for the same header, it is removed and replaced with the new
     /// header value.
-    pub fn overriding_typed<H: HeaderEncode>(inner: S, header: H) -> Self {
-        Self::overriding(inner, H::name().clone(), header.encode_to_value())
+    pub fn overriding_typed(inner: S, header: H) -> Self {
+        Self::overriding(inner, H::name().clone(), TypedHeaderAsMaker(header))
     }
 
     /// Create a new [`SetRequestHeader`] using a typed header.
     ///
     /// The new header is always added, preserving any existing values. If previous values exist,
     /// the header will have multiple values.
-    pub fn appending_typed<H: HeaderEncode>(inner: S, header: H) -> Self {
-        Self::appending(inner, H::name().clone(), header.encode_to_value())
+    pub fn appending_typed(inner: S, header: H) -> Self {
+        Self::appending(inner, H::name().clone(), TypedHeaderAsMaker(header))
     }
 
     /// Create a new [`SetRequestHeader`] using a typed header.
     ///
     /// If a previous value exists for the header, the new value is not inserted.
-    pub fn if_not_present_typed<H: HeaderEncode>(inner: S, header: H) -> Self {
-        Self::if_not_present(inner, H::name().clone(), header.encode_to_value())
+    pub fn if_not_present_typed(inner: S, header: H) -> Self {
+        Self::if_not_present(inner, H::name().clone(), TypedHeaderAsMaker(header))
     }
 }
 
diff --git a/rama-http/src/layer/set_header/response/header.rs b/rama-http/src/layer/set_header/response/header.rs
@@ -1,4 +1,6 @@
+use crate::layer::set_header::utils::TypedHeaderAsMaker;
 use crate::{HeaderName, HeaderValue, Request, Response};
+use rama_http_headers::HeaderEncode;
 use std::{
     future::{Future, ready},
     marker::PhantomData,
@@ -26,7 +28,6 @@ pub trait MakeHeaderValueFactory<ReqBody, ResBody>: Send + Sync + 'static {
     /// Try to create a header value from the request or response.
     fn make_header_value_maker(
         &self,
-
         request: Request<ReqBody>,
     ) -> impl Future<Output = (Request<ReqBody>, Self::Maker)> + Send + '_;
 }
@@ -73,6 +74,20 @@ where
     }
 }
 
+impl<B, H> MakeHeaderValue<B> for TypedHeaderAsMaker<H>
+where
+    B: Send + 'static,
+    H: HeaderEncode + Send + Sync + 'static,
+{
+    fn make_header_value(
+        self,
+        response: Response<B>,
+    ) -> impl Future<Output = (Response<B>, Option<HeaderValue>)> + Send {
+        let maybe_value = self.0.encode_to_value();
+        ready((response, maybe_value))
+    }
+}
+
 impl<ReqBody, ResBody> MakeHeaderValueFactory<ReqBody, ResBody> for HeaderValue
 where
     ReqBody: Send + 'static,
@@ -97,7 +112,6 @@ where
 
     fn make_header_value_maker(
         &self,
-
         req: Request<ReqBody>,
     ) -> impl Future<Output = (Request<ReqBody>, Self::Maker)> + Send + '_ {
         ready((req, self.clone()))
@@ -111,7 +125,6 @@ pub trait MakeHeaderValueFactoryFn<ReqBody, ResBody, A>: Send + Sync + 'static {
     /// Try to create a header value from the request or response.
     fn call(
         &self,
-
         request: Request<ReqBody>,
     ) -> impl Future<Output = (Request<ReqBody>, Self::Maker)> + Send + '_;
 }
@@ -200,7 +213,6 @@ where
 
     fn make_header_value_maker(
         &self,
-
         request: Request<ReqBody>,
     ) -> impl Future<Output = (Request<ReqBody>, Self::Maker)> + Send + '_ {
         self.f.call(request)
diff --git a/rama-http/src/layer/set_header/response/mod.rs b/rama-http/src/layer/set_header/response/mod.rs
@@ -155,6 +155,8 @@ use rama_core::{Layer, Service};
 use rama_utils::macros::define_inner_service_accessors;
 use std::fmt;
 
+use super::utils::TypedHeaderAsMaker;
+
 mod header;
 use header::InsertHeaderMode;
 
@@ -181,7 +183,7 @@ impl<M> fmt::Debug for SetResponseHeaderLayer<M> {
     }
 }
 
-impl SetResponseHeaderLayer<HeaderValue> {
+impl SetResponseHeaderLayer<Option<HeaderValue>> {
     /// Create a new [`SetResponseHeaderLayer`] from a typed [`HeaderEncode`].
     ///
     /// See [`SetResponseHeaderLayer::overriding`] for more details.
@@ -319,26 +321,26 @@ pub struct SetResponseHeader<S, M> {
     mode: InsertHeaderMode,
 }
 
-impl<S> SetResponseHeader<S, HeaderValue> {
+impl<S, H: HeaderEncode> SetResponseHeader<S, TypedHeaderAsMaker<H>> {
     /// Create a new [`SetResponseHeader`] from a typed [`HeaderEncode`].
     ///
     /// See [`SetResponseHeader::overriding`] for more details.
-    pub fn overriding_typed<H: HeaderEncode>(inner: S, header: H) -> Self {
-        Self::overriding(inner, H::name().clone(), header.encode_to_value())
+    pub fn overriding_typed(inner: S, header: H) -> Self {
+        Self::overriding(inner, H::name().clone(), TypedHeaderAsMaker(header))
     }
 
     /// Create a new [`SetResponseHeader`] from a typed [`HeaderEncode`].
     ///
     /// See [`SetResponseHeader::appending`] for more details.
-    pub fn appending_typed<H: HeaderEncode>(inner: S, header: H) -> Self {
-        Self::appending(inner, H::name().clone(), header.encode_to_value())
+    pub fn appending_typed(inner: S, header: H) -> Self {
+        Self::appending(inner, H::name().clone(), TypedHeaderAsMaker(header))
     }
 
     /// Create a new [`SetResponseHeader`] from a typed [`HeaderEncode`].
     ///
     /// See [`SetResponseHeader::if_not_present`] for more details.
-    pub fn if_not_present_typed<H: HeaderEncode>(inner: S, header: H) -> Self {
-        Self::if_not_present(inner, H::name().clone(), header.encode_to_value())
+    pub fn if_not_present_typed(inner: S, header: H) -> Self {
+        Self::if_not_present(inner, H::name().clone(), TypedHeaderAsMaker(header))
     }
 }
 
diff --git a/rama-http/src/layer/set_header/utils.rs b/rama-http/src/layer/set_header/utils.rs
@@ -0,0 +1,17 @@
+use std::fmt;
+
+/// Wrapper used internally as part of making typed headers
+/// encode header values on the spot, when needed.
+pub struct TypedHeaderAsMaker<H>(pub(super) H);
+
+impl<H: fmt::Debug> fmt::Debug for TypedHeaderAsMaker<H> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("TypedHeaderAsMaker").field(&self.0).finish()
+    }
+}
+
+impl<H: Clone> Clone for TypedHeaderAsMaker<H> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
diff --git a/rama-http/src/service/client/ext.rs b/rama-http/src/service/client/ext.rs
diff --git a/src/cli/service/echo.rs b/src/cli/service/echo.rs
diff --git a/src/cli/service/fs.rs b/src/cli/service/fs.rs
diff --git a/src/cli/service/ip.rs b/src/cli/service/ip.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-use rama_core::telemetry::tracing;`
`2`	`1`	`use rama_http_types::{HeaderName, HeaderValue};`
`3`	`2`
`4`	`3`	`use std::error;`
`@@ -48,13 +47,12 @@ pub trait HeaderEncode: TypedHeader {`
`48`	`47`	`fn encode<E: Extend<HeaderValue>>(&self, values: &mut E);`
`49`	`48`
`50`	`49`	/// Encode this header to [`HeaderValue`].
`51`		`- fn encode_to_value(&self) -> HeaderValue {`
	`50`	`+ ///`
	`51`	+ /// [`None`] is returned in case no header was encoded.
	`52`	`+ fn encode_to_value(&self) -> Option<HeaderValue> {`
`52`	`53`	`let mut container = ExtendOnce(None);`
`53`	`54`	`self.encode(&mut container);`
`54`		`- container.0.unwrap_or_else(\|\| {`
`55`		`- tracing::warn!("failed to get an encoded HeaderValue; default to empty");`
`56`		`- HeaderValue::from_static("")`
`57`		`- })`
	`55`	`+ container.0`
`58`	`56`	`}`
`59`	`57`	`}`
`60`	`58`
`@@ -65,7 +63,7 @@ impl<H: HeaderEncode> HeaderEncode for &H {`
`65`	`63`	`}`
`66`	`64`
`67`	`65`	`#[inline]`
`68`		`- fn encode_to_value(&self) -> HeaderValue {`
	`66`	`+ fn encode_to_value(&self) -> Option<HeaderValue> {`
`69`	`67`	`(*self).encode_to_value()`
`70`	`68`	`}`
`71`	`69`	`}`
`@@ -77,7 +75,7 @@ impl<H: HeaderEncode> HeaderEncode for Arc<H> {`
`77`	`75`	`}`
`78`	`76`
`79`	`77`	`#[inline]`
`80`		`- fn encode_to_value(&self) -> HeaderValue {`
	`78`	`+ fn encode_to_value(&self) -> Option<HeaderValue> {`
`81`	`79`	`self.as_ref().encode_to_value()`
`82`	`80`	`}`
`83`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,11 @@ impl HttpRequestBuilderExt for request::Builder {`
`16`	`16`	`where`
`17`	`17`	`H: HeaderEncode,`
`18`	`18`	`{`
`19`		`- self.header(H::name(), header.encode_to_value())`
	`19`	`+ if let Some(value) = header.encode_to_value() {`
	`20`	`+ self.header(H::name(), value)`
	`21`	`+ } else {`
	`22`	`+ self`
	`23`	`+ }`
`20`	`24`	`}`
`21`	`25`	`}`
`22`	`26`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,11 @@ impl HttpResponseBuilderExt for response::Builder {`
`16`	`16`	`where`
`17`	`17`	`H: HeaderEncode,`
`18`	`18`	`{`
`19`		`- self.header(H::name(), header.encode_to_value())`
	`19`	`+ if let Some(value) = header.encode_to_value() {`
	`20`	`+ self.header(H::name(), value)`
	`21`	`+ } else {`
	`22`	`+ self`
	`23`	`+ }`
`20`	`24`	`}`
`21`	`25`	`}`
`22`	`26`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ mod tests {`
`137`	`137`	`"BadBot: noindex, nofollow, googlebot: nofollow",`
`138`	`138`	`),`
`139`	`139`	`] {`
`140`		`- let value = header_value.encode_to_value();`
	`140`	`+ let value = header_value.encode_to_value().unwrap();`
`141`	`141`	`let s = value.to_str().unwrap();`
`142`	`142`	`assert_eq!(expected, s);`
`143`	`143`	`}`