feat: ConditionOption middleware (#227)

Author: robjtede

actix-web-lab/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Add `ConditionOption` middleware.
+
 ## 0.24.2
 
 - Add `LazyDataShared` extractor.

actix-web-lab/README.md

@@ -36,6 +36,7 @@
 - `RedirectHttps`: middleware to redirect traffic to HTTPS if connection is insecure with optional HSTS [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/struct.RedirectHttps.html)
 - `redirect_to_www`: function middleware to redirect traffic to `www.` if not already there [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/fn.redirect_to_www.html)
 - `redirect_to_non_www`: function middleware to redirect traffic to `www.` if not already there [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/fn.redirect_to_non_www.html)
+- `ConditionOption`: conditional middleware helper [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/struct.ConditionOption.html)
 - `ErrorHandlers`: alternative error handler middleware with simpler interface [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/struct.ErrorHandlers.html)
 - `NormalizePath`: alternative path normalizing middleware with redirect option [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/struct.NormalizePath.html)
 - `CatchPanic`: catch panics in wrapped handlers and middleware, returning empty 500 responses [(docs)](https://docs.rs/actix-web-lab/0.24.2/actix_web_lab/middleware/struct.CatchPanic.html)

actix-web-lab/examples/body_async_write.rs

@@ -18,7 +18,7 @@ use tokio::{
 use tokio_util::compat::TokioAsyncWriteCompatExt as _;
 
 fn zip_to_io_err(err: async_zip::error::ZipError) -> io::Error {
-    io::Error::new(io::ErrorKind::Other, err)
+    io::Error::other(err)
 }
 
 async fn read_dir<W>(zipper: &mut ZipFileWriter<W>) -> io::Result<()>

actix-web-lab/examples/map_response.rs

@@ -6,7 +6,7 @@ use actix_web::{
     App, Error, HttpRequest, HttpResponse, HttpServer, body::MessageBody, dev::ServiceResponse,
     http::header, middleware::Logger, web,
 };
-use actix_web_lab::middleware::{map_response, map_response_body};
+use actix_web_lab::middleware::{ConditionOption, map_response, map_response_body};
 use tracing::info;
 
 async fn add_res_header(
@@ -33,6 +33,10 @@ async fn main() -> io::Result<()> {
     info!("staring server at http://{}:{}", &bind.0, &bind.1);
 
     HttpServer::new(|| {
+        let mutator_enabled = false;
+        let mutate_body_type_mw =
+            ConditionOption::from(mutator_enabled.then(|| map_response_body(mutate_body_type)));
+
         App::new()
             .service(
                 web::resource("/foo")
@@ -43,7 +47,7 @@ async fn main() -> io::Result<()> {
             .service(
                 web::resource("/bar")
                     .default_service(web::to(HttpResponse::Ok))
-                    .wrap(map_response_body(mutate_body_type))
+                    .wrap(mutate_body_type_mw)
                     .wrap(Logger::default()),
             )
             .default_service(web::to(HttpResponse::Ok))

actix-web-lab/src/condition_option.rs

@@ -0,0 +1,128 @@
+//! For middleware documentation, see [`ConditionOption`].
+
+use std::{
+    pin::Pin,
+    task::{self, Poll, ready},
+};
+
+use actix_web::{
+    body::EitherBody,
+    dev::{Service, ServiceResponse, Transform},
+};
+use futures_core::future::LocalBoxFuture;
+use futures_util::future::FutureExt as _;
+use pin_project_lite::pin_project;
+
+/// Middleware for conditionally enabling other middleware in an [`Option`].
+///
+/// Uses [`Condition`](crate::middleware::condition::Condition) under the hood.
+///
+/// # Example
+/// ```
+/// use actix_web::{App, middleware::Logger};
+/// use actix_web_lab::middleware::ConditionOption;
+///
+/// let normalize: ConditionOption<_> = Some(Logger::default()).into();
+/// let app = App::new().wrap(normalize);
+/// ```
+#[derive(Debug)]
+pub struct ConditionOption<T> {
+    inner: Option<T>,
+}
+
+impl<T> From<Option<T>> for ConditionOption<T> {
+    fn from(value: Option<T>) -> Self {
+        Self { inner: value }
+    }
+}
+
+impl<S, T, Req, BE, BD, Err> Transform<S, Req> for ConditionOption<T>
+where
+    S: Service<Req, Response = ServiceResponse<BD>, Error = Err> + 'static,
+    T: Transform<S, Req, Response = ServiceResponse<BE>, Error = Err>,
+    T::Future: 'static,
+    T::InitError: 'static,
+    T::Transform: 'static,
+{
+    type Response = ServiceResponse<EitherBody<BE, BD>>;
+    type Error = Err;
+    type Transform = ConditionMiddleware<T::Transform, S>;
+    type InitError = T::InitError;
+    type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        match &self.inner {
+            Some(transformer) => {
+                let fut = transformer.new_transform(service);
+                async move {
+                    let wrapped_svc = fut.await?;
+                    Ok(ConditionMiddleware::Enable(wrapped_svc))
+                }
+                .boxed_local()
+            }
+            None => async move { Ok(ConditionMiddleware::Disable(service)) }.boxed_local(),
+        }
+    }
+}
+
+/// TODO
+#[derive(Debug)]
+pub enum ConditionMiddleware<E, D> {
+    Enable(E),
+    Disable(D),
+}
+
+impl<E, D, Req, BE, BD, Err> Service<Req> for ConditionMiddleware<E, D>
+where
+    E: Service<Req, Response = ServiceResponse<BE>, Error = Err>,
+    D: Service<Req, Response = ServiceResponse<BD>, Error = Err>,
+{
+    type Response = ServiceResponse<EitherBody<BE, BD>>;
+    type Error = Err;
+    type Future = ConditionMiddlewareFuture<E::Future, D::Future>;
+
+    fn poll_ready(&self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        match self {
+            ConditionMiddleware::Enable(service) => service.poll_ready(cx),
+            ConditionMiddleware::Disable(service) => service.poll_ready(cx),
+        }
+    }
+
+    fn call(&self, req: Req) -> Self::Future {
+        match self {
+            ConditionMiddleware::Enable(service) => ConditionMiddlewareFuture::Enabled {
+                fut: service.call(req),
+            },
+            ConditionMiddleware::Disable(service) => ConditionMiddlewareFuture::Disabled {
+                fut: service.call(req),
+            },
+        }
+    }
+}
+
+pin_project! {
+    #[doc(hidden)]
+    #[project = ConditionProj]
+    pub enum ConditionMiddlewareFuture<E, D> {
+        Enabled { #[pin] fut: E, },
+        Disabled { #[pin] fut: D, },
+    }
+}
+
+impl<E, D, BE, BD, Err> Future for ConditionMiddlewareFuture<E, D>
+where
+    E: Future<Output = Result<ServiceResponse<BE>, Err>>,
+    D: Future<Output = Result<ServiceResponse<BD>, Err>>,
+{
+    type Output = Result<ServiceResponse<EitherBody<BE, BD>>, Err>;
+
+    #[inline]
+    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
+        let res = match self.project() {
+            ConditionProj::Enabled { fut } => ready!(fut.poll(cx))?.map_into_left_body(),
+            ConditionProj::Disabled { fut } => ready!(fut.poll(cx))?.map_into_right_body(),
+        };
+
+        Poll::Ready(Ok(res))
+    }
+}

actix-web-lab/src/lazy_data_shared.rs

@@ -135,15 +135,16 @@ mod tests {
                     actix_web::rt::time::sleep(Duration::from_millis(40)).await;
                     10_usize
                 }))
-                .service(
-                    web::resource("/").to(|lazy_num: LazyDataShared<usize>| async move {
+                .service(web::resource("/").to(
+                    #[expect(clippy::async_yields_async)]
+                    |lazy_num: LazyDataShared<usize>| async move {
                         if *lazy_num.get().await == 10 {
                             HttpResponse::Ok()
                         } else {
                             HttpResponse::InternalServerError()
                         }
-                    }),
-                ),
+                    },
+                )),
         )
         .await;
         let req = TestRequest::default().to_request();

actix-web-lab/src/lib.rs

@@ -31,6 +31,7 @@ mod catch_panic;
 #[cfg(feature = "cbor")]
 mod cbor;
 mod clear_site_data;
+mod condition_option;
 mod content_length;
 mod csv;
 mod display_stream;

actix-web-lab/src/middleware.rs

@@ -4,6 +4,7 @@
 
 pub use crate::{
     catch_panic::CatchPanic,
+    condition_option::ConditionOption,
     err_handler::ErrorHandlers,
     load_shed::LoadShed,
     middleware_map_response::{MapResMiddleware, map_response},

actix-web-lab/src/util.rs

@@ -41,10 +41,9 @@ pub fn fork_request_payload(orig_payload: &mut dev::Payload) -> dev::Payload {
             }
 
             Err(err) => tx
-                .send(Err(PayloadError::Io(io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("error from original stream: {err}"),
-                ))))
+                .send(Err(PayloadError::Io(io::Error::other(format!(
+                    "error from original stream: {err}"
+                )))))
                 .unwrap(),
         }
     }));