Vendor dependencies

notes-service/vendor/axum/src/middleware/from_extractor.rs

@@ -0,0 +1,386 @@
+use crate::{
+    extract::FromRequestParts,
+    response::{IntoResponse, Response},
+};
+use futures_util::future::BoxFuture;
+use http::Request;
+use pin_project_lite::pin_project;
+use std::{
+    fmt,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{ready, Context, Poll},
+};
+use tower_layer::Layer;
+use tower_service::Service;
+
+/// Create a middleware from an extractor.
+///
+/// If the extractor succeeds the value will be discarded and the inner service
+/// will be called. If the extractor fails the rejection will be returned and
+/// the inner service will _not_ be called.
+///
+/// This can be used to perform validation of requests if the validation doesn't
+/// produce any useful output, and run the extractor for several handlers
+/// without repeating it in the function signature.
+///
+/// Note that if the extractor consumes the request body, as `String` or
+/// [`Bytes`] does, an empty body will be left in its place. Thus won't be
+/// accessible to subsequent extractors or handlers.
+///
+/// # Example
+///
+/// ```rust
+/// use axum::{
+///     extract::FromRequestParts,
+///     middleware::from_extractor,
+///     routing::{get, post},
+///     Router,
+///     http::{header, StatusCode, request::Parts},
+/// };
+///
+/// // An extractor that performs authorization.
+/// struct RequireAuth;
+///
+/// impl<S> FromRequestParts<S> for RequireAuth
+/// where
+///     S: Send + Sync,
+/// {
+///     type Rejection = StatusCode;
+///
+///     async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
+///         let auth_header = parts
+///             .headers
+///             .get(header::AUTHORIZATION)
+///             .and_then(|value| value.to_str().ok());
+///
+///         match auth_header {
+///             Some(auth_header) if token_is_valid(auth_header) => {
+///                 Ok(Self)
+///             }
+///             _ => Err(StatusCode::UNAUTHORIZED),
+///         }
+///     }
+/// }
+///
+/// fn token_is_valid(token: &str) -> bool {
+///     // ...
+///     # false
+/// }
+///
+/// async fn handler() {
+///     // If we get here the request has been authorized
+/// }
+///
+/// async fn other_handler() {
+///     // If we get here the request has been authorized
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(handler))
+///     .route("/foo", post(other_handler))
+///     // The extractor will run before all routes
+///     .route_layer(from_extractor::<RequireAuth>());
+/// # let _: Router = app;
+/// ```
+///
+/// [`Bytes`]: bytes::Bytes
+pub fn from_extractor<E>() -> FromExtractorLayer<E, ()> {
+    from_extractor_with_state(())
+}
+
+/// Create a middleware from an extractor with the given state.
+///
+/// See [`State`](crate::extract::State) for more details about accessing state.
+pub fn from_extractor_with_state<E, S>(state: S) -> FromExtractorLayer<E, S> {
+    FromExtractorLayer {
+        state,
+        _marker: PhantomData,
+    }
+}
+
+/// [`Layer`] that applies [`FromExtractor`] that runs an extractor and
+/// discards the value.
+///
+/// See [`from_extractor`] for more details.
+///
+/// [`Layer`]: tower::Layer
+#[must_use]
+pub struct FromExtractorLayer<E, S> {
+    state: S,
+    _marker: PhantomData<fn() -> E>,
+}
+
+impl<E, S> Clone for FromExtractorLayer<E, S>
+where
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            state: self.state.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<E, S> fmt::Debug for FromExtractorLayer<E, S>
+where
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FromExtractorLayer")
+            .field("state", &self.state)
+            .field("extractor", &format_args!("{}", std::any::type_name::<E>()))
+            .finish()
+    }
+}
+
+impl<E, T, S> Layer<T> for FromExtractorLayer<E, S>
+where
+    S: Clone,
+{
+    type Service = FromExtractor<T, E, S>;
+
+    fn layer(&self, inner: T) -> Self::Service {
+        FromExtractor {
+            inner,
+            state: self.state.clone(),
+            _extractor: PhantomData,
+        }
+    }
+}
+
+/// Middleware that runs an extractor and discards the value.
+///
+/// See [`from_extractor`] for more details.
+pub struct FromExtractor<T, E, S> {
+    inner: T,
+    state: S,
+    _extractor: PhantomData<fn() -> E>,
+}
+
+#[test]
+fn traits() {
+    use crate::test_helpers::*;
+    assert_send::<FromExtractor<(), NotSendSync, ()>>();
+    assert_sync::<FromExtractor<(), NotSendSync, ()>>();
+}
+
+impl<T, E, S> Clone for FromExtractor<T, E, S>
+where
+    T: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+            state: self.state.clone(),
+            _extractor: PhantomData,
+        }
+    }
+}
+
+impl<T, E, S> fmt::Debug for FromExtractor<T, E, S>
+where
+    T: fmt::Debug,
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FromExtractor")
+            .field("inner", &self.inner)
+            .field("state", &self.state)
+            .field("extractor", &format_args!("{}", std::any::type_name::<E>()))
+            .finish()
+    }
+}
+
+impl<T, E, B, S> Service<Request<B>> for FromExtractor<T, E, S>
+where
+    E: FromRequestParts<S> + 'static,
+    B: Send + 'static,
+    T: Service<Request<B>> + Clone,
+    T::Response: IntoResponse,
+    S: Clone + Send + Sync + 'static,
+{
+    type Response = Response;
+    type Error = T::Error;
+    type Future = ResponseFuture<B, T, E, S>;
+
+    #[inline]
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Request<B>) -> Self::Future {
+        let state = self.state.clone();
+        let (mut parts, body) = req.into_parts();
+
+        let extract_future = Box::pin(async move {
+            let extracted = E::from_request_parts(&mut parts, &state).await;
+            let req = Request::from_parts(parts, body);
+            (req, extracted)
+        });
+
+        ResponseFuture {
+            state: State::Extracting {
+                future: extract_future,
+            },
+            svc: Some(self.inner.clone()),
+        }
+    }
+}
+
+pin_project! {
+    /// Response future for [`FromExtractor`].
+    #[allow(missing_debug_implementations)]
+    pub struct ResponseFuture<B, T, E, S>
+    where
+        E: FromRequestParts<S>,
+        T: Service<Request<B>>,
+    {
+        #[pin]
+        state: State<B, T, E, S>,
+        svc: Option<T>,
+    }
+}
+
+pin_project! {
+    #[project = StateProj]
+    enum State<B, T, E, S>
+    where
+        E: FromRequestParts<S>,
+        T: Service<Request<B>>,
+    {
+        Extracting {
+            future: BoxFuture<'static, (Request<B>, Result<E, E::Rejection>)>,
+        },
+        Call { #[pin] future: T::Future },
+    }
+}
+
+impl<B, T, E, S> Future for ResponseFuture<B, T, E, S>
+where
+    E: FromRequestParts<S>,
+    T: Service<Request<B>>,
+    T::Response: IntoResponse,
+{
+    type Output = Result<Response, T::Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        loop {
+            let mut this = self.as_mut().project();
+
+            let new_state = match this.state.as_mut().project() {
+                StateProj::Extracting { future } => {
+                    let (req, extracted) = ready!(future.as_mut().poll(cx));
+
+                    match extracted {
+                        Ok(_) => {
+                            let mut svc = this.svc.take().expect("future polled after completion");
+                            let future = svc.call(req);
+                            State::Call { future }
+                        }
+                        Err(err) => {
+                            let res = err.into_response();
+                            return Poll::Ready(Ok(res));
+                        }
+                    }
+                }
+                StateProj::Call { future } => {
+                    return future
+                        .poll(cx)
+                        .map(|result| result.map(IntoResponse::into_response));
+                }
+            };
+
+            this.state.set(new_state);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{handler::Handler, routing::get, test_helpers::*, Router};
+    use axum_core::extract::FromRef;
+    use http::{header, request::Parts, StatusCode};
+    use tower_http::limit::RequestBodyLimitLayer;
+
+    #[crate::test]
+    async fn test_from_extractor() {
+        #[derive(Clone)]
+        struct Secret(&'static str);
+
+        struct RequireAuth;
+
+        impl<S> FromRequestParts<S> for RequireAuth
+        where
+            S: Send + Sync,
+            Secret: FromRef<S>,
+        {
+            type Rejection = StatusCode;
+
+            async fn from_request_parts(
+                parts: &mut Parts,
+                state: &S,
+            ) -> Result<Self, Self::Rejection> {
+                let Secret(secret) = Secret::from_ref(state);
+                if let Some(auth) = parts
+                    .headers
+                    .get(header::AUTHORIZATION)
+                    .and_then(|v| v.to_str().ok())
+                {
+                    if auth == secret {
+                        return Ok(Self);
+                    }
+                }
+
+                Err(StatusCode::UNAUTHORIZED)
+            }
+        }
+
+        async fn handler() {}
+
+        let state = Secret("secret");
+        let app = Router::new().route(
+            "/",
+            get(handler.layer(from_extractor_with_state::<RequireAuth, _>(state))),
+        );
+
+        let client = TestClient::new(app);
+
+        let res = client.get("/").await;
+        assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
+
+        let res = client
+            .get("/")
+            .header(http::header::AUTHORIZATION, "secret")
+            .await;
+        assert_eq!(res.status(), StatusCode::OK);
+    }
+
+    // just needs to compile
+    #[allow(dead_code)]
+    fn works_with_request_body_limit() {
+        struct MyExtractor;
+
+        impl<S> FromRequestParts<S> for MyExtractor
+        where
+            S: Send + Sync,
+        {
+            type Rejection = std::convert::Infallible;
+
+            async fn from_request_parts(
+                _parts: &mut Parts,
+                _state: &S,
+            ) -> Result<Self, Self::Rejection> {
+                unimplemented!()
+            }
+        }
+
+        let _: Router = Router::new()
+            .layer(from_extractor::<MyExtractor>())
+            .layer(RequestBodyLimitLayer::new(1));
+    }
+}

notes-service/vendor/axum/src/middleware/from_fn.rs

@@ -0,0 +1,418 @@
+use axum_core::extract::{FromRequest, FromRequestParts, Request};
+use futures_util::future::BoxFuture;
+use std::{
+    any::type_name,
+    convert::Infallible,
+    fmt,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+use tower::util::BoxCloneSyncService;
+use tower_layer::Layer;
+use tower_service::Service;
+
+use crate::{
+    response::{IntoResponse, Response},
+    util::MapIntoResponse,
+};
+
+/// Create a middleware from an async function.
+///
+/// `from_fn` requires the function given to
+///
+/// 1. Be an `async fn`.
+/// 2. Take zero or more [`FromRequestParts`] extractors.
+/// 3. Take exactly one [`FromRequest`] extractor as the second to last argument.
+/// 4. Take [`Next`](Next) as the last argument.
+/// 5. Return something that implements [`IntoResponse`].
+///
+/// Note that this function doesn't support extracting [`State`]. For that, use [`from_fn_with_state`].
+///
+/// # Example
+///
+/// ```rust
+/// use axum::{
+///     Router,
+///     http,
+///     routing::get,
+///     response::Response,
+///     middleware::{self, Next},
+///     extract::Request,
+/// };
+///
+/// async fn my_middleware(
+///     request: Request,
+///     next: Next,
+/// ) -> Response {
+///     // do something with `request`...
+///
+///     let response = next.run(request).await;
+///
+///     // do something with `response`...
+///
+///     response
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .layer(middleware::from_fn(my_middleware));
+/// # let app: Router = app;
+/// ```
+///
+/// # Running extractors
+///
+/// ```rust
+/// use axum::{
+///     Router,
+///     extract::Request,
+///     http::{StatusCode, HeaderMap},
+///     middleware::{self, Next},
+///     response::Response,
+///     routing::get,
+/// };
+///
+/// async fn auth(
+///     // run the `HeaderMap` extractor
+///     headers: HeaderMap,
+///     // you can also add more extractors here but the last
+///     // extractor must implement `FromRequest` which
+///     // `Request` does
+///     request: Request,
+///     next: Next,
+/// ) -> Result<Response, StatusCode> {
+///     match get_token(&headers) {
+///         Some(token) if token_is_valid(token) => {
+///             let response = next.run(request).await;
+///             Ok(response)
+///         }
+///         _ => {
+///             Err(StatusCode::UNAUTHORIZED)
+///         }
+///     }
+/// }
+///
+/// fn get_token(headers: &HeaderMap) -> Option<&str> {
+///     // ...
+///     # None
+/// }
+///
+/// fn token_is_valid(token: &str) -> bool {
+///     // ...
+///     # false
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .route_layer(middleware::from_fn(auth));
+/// # let app: Router = app;
+/// ```
+///
+/// [extractors]: crate::extract::FromRequest
+/// [`State`]: crate::extract::State
+pub fn from_fn<F, T>(f: F) -> FromFnLayer<F, (), T> {
+    from_fn_with_state((), f)
+}
+
+/// Create a middleware from an async function with the given state.
+///
+/// For the requirements for the function supplied see [`from_fn`].
+///
+/// See [`State`](crate::extract::State) for more details about accessing state.
+///
+/// # Example
+///
+/// ```rust
+/// use axum::{
+///     Router,
+///     http::StatusCode,
+///     routing::get,
+///     response::{IntoResponse, Response},
+///     middleware::{self, Next},
+///     extract::{Request, State},
+/// };
+///
+/// #[derive(Clone)]
+/// struct AppState { /* ... */ }
+///
+/// async fn my_middleware(
+///     State(state): State<AppState>,
+///     // you can add more extractors here but the last
+///     // extractor must implement `FromRequest` which
+///     // `Request` does
+///     request: Request,
+///     next: Next,
+/// ) -> Response {
+///     // do something with `request`...
+///
+///     let response = next.run(request).await;
+///
+///     // do something with `response`...
+///
+///     response
+/// }
+///
+/// let state = AppState { /* ... */ };
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .route_layer(middleware::from_fn_with_state(state.clone(), my_middleware))
+///     .with_state(state);
+/// # let _: axum::Router = app;
+/// ```
+pub fn from_fn_with_state<F, S, T>(state: S, f: F) -> FromFnLayer<F, S, T> {
+    FromFnLayer {
+        f,
+        state,
+        _extractor: PhantomData,
+    }
+}
+
+/// A [`tower::Layer`] from an async function.
+///
+/// [`tower::Layer`] is used to apply middleware to [`Router`](crate::Router)'s.
+///
+/// Created with [`from_fn`] or [`from_fn_with_state`]. See those functions for more details.
+#[must_use]
+pub struct FromFnLayer<F, S, T> {
+    f: F,
+    state: S,
+    _extractor: PhantomData<fn() -> T>,
+}
+
+impl<F, S, T> Clone for FromFnLayer<F, S, T>
+where
+    F: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            f: self.f.clone(),
+            state: self.state.clone(),
+            _extractor: self._extractor,
+        }
+    }
+}
+
+impl<S, I, F, T> Layer<I> for FromFnLayer<F, S, T>
+where
+    F: Clone,
+    S: Clone,
+{
+    type Service = FromFn<F, S, I, T>;
+
+    fn layer(&self, inner: I) -> Self::Service {
+        FromFn {
+            f: self.f.clone(),
+            state: self.state.clone(),
+            inner,
+            _extractor: PhantomData,
+        }
+    }
+}
+
+impl<F, S, T> fmt::Debug for FromFnLayer<F, S, T>
+where
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FromFnLayer")
+            // Write out the type name, without quoting it as `&type_name::<F>()` would
+            .field("f", &format_args!("{}", type_name::<F>()))
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+/// A middleware created from an async function.
+///
+/// Created with [`from_fn`] or [`from_fn_with_state`]. See those functions for more details.
+pub struct FromFn<F, S, I, T> {
+    f: F,
+    inner: I,
+    state: S,
+    _extractor: PhantomData<fn() -> T>,
+}
+
+impl<F, S, I, T> Clone for FromFn<F, S, I, T>
+where
+    F: Clone,
+    I: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            f: self.f.clone(),
+            inner: self.inner.clone(),
+            state: self.state.clone(),
+            _extractor: self._extractor,
+        }
+    }
+}
+
+macro_rules! impl_service {
+    (
+        [$($ty:ident),*], $last:ident
+    ) => {
+        #[allow(non_snake_case, unused_mut)]
+        impl<F, Fut, Out, S, I, $($ty,)* $last> Service<Request> for FromFn<F, S, I, ($($ty,)* $last,)>
+        where
+            F: FnMut($($ty,)* $last, Next) -> Fut + Clone + Send + 'static,
+            $( $ty: FromRequestParts<S> + Send, )*
+            $last: FromRequest<S> + Send,
+            Fut: Future<Output = Out> + Send + 'static,
+            Out: IntoResponse + 'static,
+            I: Service<Request, Error = Infallible>
+                + Clone
+                + Send
+                + Sync
+                + 'static,
+            I::Response: IntoResponse,
+            I::Future: Send + 'static,
+            S: Clone + Send + Sync + 'static,
+        {
+            type Response = Response;
+            type Error = Infallible;
+            type Future = ResponseFuture;
+
+            fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+                self.inner.poll_ready(cx)
+            }
+
+            fn call(&mut self, req: Request) -> Self::Future {
+                let not_ready_inner = self.inner.clone();
+                let ready_inner = std::mem::replace(&mut self.inner, not_ready_inner);
+
+                let mut f = self.f.clone();
+                let state = self.state.clone();
+                let (mut parts, body) = req.into_parts();
+
+                let future = Box::pin(async move {
+                    $(
+                        let $ty = match $ty::from_request_parts(&mut parts, &state).await {
+                            Ok(value) => value,
+                            Err(rejection) => return rejection.into_response(),
+                        };
+                    )*
+
+                    let req = Request::from_parts(parts, body);
+
+                    let $last = match $last::from_request(req, &state).await {
+                        Ok(value) => value,
+                        Err(rejection) => return rejection.into_response(),
+                    };
+
+                    let inner = BoxCloneSyncService::new(MapIntoResponse::new(ready_inner));
+                    let next = Next { inner };
+
+                    f($($ty,)* $last, next).await.into_response()
+                });
+
+                ResponseFuture {
+                    inner: future
+                }
+            }
+        }
+    };
+}
+
+all_the_tuples!(impl_service);
+
+impl<F, S, I, T> fmt::Debug for FromFn<F, S, I, T>
+where
+    S: fmt::Debug,
+    I: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FromFnLayer")
+            .field("f", &format_args!("{}", type_name::<F>()))
+            .field("inner", &self.inner)
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+/// The remainder of a middleware stack, including the handler.
+#[derive(Debug, Clone)]
+pub struct Next {
+    inner: BoxCloneSyncService<Request, Response, Infallible>,
+}
+
+impl Next {
+    /// Execute the remaining middleware stack.
+    pub async fn run(mut self, req: Request) -> Response {
+        match self.inner.call(req).await {
+            Ok(res) => res,
+            Err(err) => match err {},
+        }
+    }
+}
+
+impl Service<Request> for Next {
+    type Response = Response;
+    type Error = Infallible;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        self.inner.call(req)
+    }
+}
+
+/// Response future for [`FromFn`].
+pub struct ResponseFuture {
+    inner: BoxFuture<'static, Response>,
+}
+
+impl Future for ResponseFuture {
+    type Output = Result<Response, Infallible>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.inner.as_mut().poll(cx).map(Ok)
+    }
+}
+
+impl fmt::Debug for ResponseFuture {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ResponseFuture").finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{body::Body, routing::get, Router};
+    use http::{HeaderMap, StatusCode};
+    use http_body_util::BodyExt;
+    use tower::ServiceExt;
+
+    #[crate::test]
+    async fn basic() {
+        async fn insert_header(mut req: Request, next: Next) -> impl IntoResponse {
+            req.headers_mut()
+                .insert("x-axum-test", "ok".parse().unwrap());
+
+            next.run(req).await
+        }
+
+        async fn handle(headers: HeaderMap) -> String {
+            headers["x-axum-test"].to_str().unwrap().to_owned()
+        }
+
+        let app = Router::new()
+            .route("/", get(handle))
+            .layer(from_fn(insert_header));
+
+        let res = app
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.collect().await.unwrap().to_bytes();
+        assert_eq!(&body[..], b"ok");
+    }
+}

notes-service/vendor/axum/src/middleware/map_request.rs

@@ -0,0 +1,439 @@
+use crate::body::{Body, Bytes, HttpBody};
+use crate::response::{IntoResponse, Response};
+use crate::BoxError;
+use axum_core::extract::{FromRequest, FromRequestParts};
+use futures_util::future::BoxFuture;
+use http::Request;
+use std::{
+    any::type_name,
+    convert::Infallible,
+    fmt,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+use tower_layer::Layer;
+use tower_service::Service;
+
+/// Create a middleware from an async function that transforms a request.
+///
+/// This differs from [`tower::util::MapRequest`] in that it allows you to easily run axum-specific
+/// extractors.
+///
+/// # Example
+///
+/// ```
+/// use axum::{
+///     Router,
+///     routing::get,
+///     middleware::map_request,
+///     http::Request,
+/// };
+///
+/// async fn set_header<B>(mut request: Request<B>) -> Request<B> {
+///     request.headers_mut().insert("x-foo", "foo".parse().unwrap());
+///     request
+/// }
+///
+/// async fn handler<B>(request: Request<B>) {
+///     // `request` will have an `x-foo` header
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(handler))
+///     .layer(map_request(set_header));
+/// # let _: Router = app;
+/// ```
+///
+/// # Rejecting the request
+///
+/// The function given to `map_request` is allowed to also return a `Result` which can be used to
+/// reject the request and return a response immediately, without calling the remaining
+/// middleware.
+///
+/// Specifically the valid return types are:
+///
+/// - `Request<B>`
+/// - `Result<Request<B>, E> where E:  IntoResponse`
+///
+/// ```
+/// use axum::{
+///     Router,
+///     http::{Request, StatusCode},
+///     routing::get,
+///     middleware::map_request,
+/// };
+///
+/// async fn auth<B>(request: Request<B>) -> Result<Request<B>, StatusCode> {
+///     let auth_header = request.headers()
+///         .get(http::header::AUTHORIZATION)
+///         .and_then(|header| header.to_str().ok());
+///
+///     match auth_header {
+///         Some(auth_header) if token_is_valid(auth_header) => Ok(request),
+///         _ => Err(StatusCode::UNAUTHORIZED),
+///     }
+/// }
+///
+/// fn token_is_valid(token: &str) -> bool {
+///     // ...
+///     # false
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .route_layer(map_request(auth));
+/// # let app: Router = app;
+/// ```
+///
+/// # Running extractors
+///
+/// ```
+/// use axum::{
+///     Router,
+///     routing::get,
+///     middleware::map_request,
+///     extract::Path,
+///     http::Request,
+/// };
+/// use std::collections::HashMap;
+///
+/// async fn log_path_params<B>(
+///     Path(path_params): Path<HashMap<String, String>>,
+///     request: Request<B>,
+/// ) -> Request<B> {
+///     tracing::debug!(?path_params);
+///     request
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .layer(map_request(log_path_params));
+/// # let _: Router = app;
+/// ```
+///
+/// Note that to access state you must use either [`map_request_with_state`].
+pub fn map_request<F, T>(f: F) -> MapRequestLayer<F, (), T> {
+    map_request_with_state((), f)
+}
+
+/// Create a middleware from an async function that transforms a request, with the given state.
+///
+/// See [`State`](crate::extract::State) for more details about accessing state.
+///
+/// # Example
+///
+/// ```rust
+/// use axum::{
+///     Router,
+///     http::{Request, StatusCode},
+///     routing::get,
+///     response::IntoResponse,
+///     middleware::map_request_with_state,
+///     extract::State,
+/// };
+///
+/// #[derive(Clone)]
+/// struct AppState { /* ... */ }
+///
+/// async fn my_middleware<B>(
+///     State(state): State<AppState>,
+///     // you can add more extractors here but the last
+///     // extractor must implement `FromRequest` which
+///     // `Request` does
+///     request: Request<B>,
+/// ) -> Request<B> {
+///     // do something with `state` and `request`...
+///     request
+/// }
+///
+/// let state = AppState { /* ... */ };
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .route_layer(map_request_with_state(state.clone(), my_middleware))
+///     .with_state(state);
+/// # let _: axum::Router = app;
+/// ```
+pub fn map_request_with_state<F, S, T>(state: S, f: F) -> MapRequestLayer<F, S, T> {
+    MapRequestLayer {
+        f,
+        state,
+        _extractor: PhantomData,
+    }
+}
+
+/// A [`tower::Layer`] from an async function that transforms a request.
+///
+/// Created with [`map_request`]. See that function for more details.
+#[must_use]
+pub struct MapRequestLayer<F, S, T> {
+    f: F,
+    state: S,
+    _extractor: PhantomData<fn() -> T>,
+}
+
+impl<F, S, T> Clone for MapRequestLayer<F, S, T>
+where
+    F: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            f: self.f.clone(),
+            state: self.state.clone(),
+            _extractor: self._extractor,
+        }
+    }
+}
+
+impl<S, I, F, T> Layer<I> for MapRequestLayer<F, S, T>
+where
+    F: Clone,
+    S: Clone,
+{
+    type Service = MapRequest<F, S, I, T>;
+
+    fn layer(&self, inner: I) -> Self::Service {
+        MapRequest {
+            f: self.f.clone(),
+            state: self.state.clone(),
+            inner,
+            _extractor: PhantomData,
+        }
+    }
+}
+
+impl<F, S, T> fmt::Debug for MapRequestLayer<F, S, T>
+where
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapRequestLayer")
+            // Write out the type name, without quoting it as `&type_name::<F>()` would
+            .field("f", &format_args!("{}", type_name::<F>()))
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+/// A middleware created from an async function that transforms a request.
+///
+/// Created with [`map_request`]. See that function for more details.
+pub struct MapRequest<F, S, I, T> {
+    f: F,
+    inner: I,
+    state: S,
+    _extractor: PhantomData<fn() -> T>,
+}
+
+impl<F, S, I, T> Clone for MapRequest<F, S, I, T>
+where
+    F: Clone,
+    I: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            f: self.f.clone(),
+            inner: self.inner.clone(),
+            state: self.state.clone(),
+            _extractor: self._extractor,
+        }
+    }
+}
+
+macro_rules! impl_service {
+    (
+        [$($ty:ident),*], $last:ident
+    ) => {
+        #[allow(non_snake_case, unused_mut)]
+        impl<F, Fut, S, I, B, $($ty,)* $last> Service<Request<B>> for MapRequest<F, S, I, ($($ty,)* $last,)>
+        where
+            F: FnMut($($ty,)* $last) -> Fut + Clone + Send + 'static,
+            $( $ty: FromRequestParts<S> + Send, )*
+            $last: FromRequest<S> + Send,
+            Fut: Future + Send + 'static,
+            Fut::Output: IntoMapRequestResult<B> + Send + 'static,
+            I: Service<Request<B>, Error = Infallible>
+                + Clone
+                + Send
+                + 'static,
+            I::Response: IntoResponse,
+            I::Future: Send + 'static,
+            B: HttpBody<Data = Bytes> + Send + 'static,
+            B::Error: Into<BoxError>,
+            S: Clone + Send + Sync + 'static,
+        {
+            type Response = Response;
+            type Error = Infallible;
+            type Future = ResponseFuture;
+
+            fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+                self.inner.poll_ready(cx)
+            }
+
+            fn call(&mut self, req: Request<B>) -> Self::Future {
+                let req = req.map(Body::new);
+
+                let not_ready_inner = self.inner.clone();
+                let mut ready_inner = std::mem::replace(&mut self.inner, not_ready_inner);
+
+                let mut f = self.f.clone();
+                let state = self.state.clone();
+                let (mut parts, body) = req.into_parts();
+
+                let future = Box::pin(async move {
+                    $(
+                        let $ty = match $ty::from_request_parts(&mut parts, &state).await {
+                            Ok(value) => value,
+                            Err(rejection) => return rejection.into_response(),
+                        };
+                    )*
+
+                    let req = Request::from_parts(parts, body);
+
+                    let $last = match $last::from_request(req, &state).await {
+                        Ok(value) => value,
+                        Err(rejection) => return rejection.into_response(),
+                    };
+
+                    match f($($ty,)* $last).await.into_map_request_result() {
+                        Ok(req) => {
+                            ready_inner.call(req).await.into_response()
+                        }
+                        Err(res) => {
+                            res
+                        }
+                    }
+                });
+
+                ResponseFuture {
+                    inner: future
+                }
+            }
+        }
+    };
+}
+
+all_the_tuples!(impl_service);
+
+impl<F, S, I, T> fmt::Debug for MapRequest<F, S, I, T>
+where
+    S: fmt::Debug,
+    I: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapRequest")
+            .field("f", &format_args!("{}", type_name::<F>()))
+            .field("inner", &self.inner)
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+/// Response future for [`MapRequest`].
+pub struct ResponseFuture {
+    inner: BoxFuture<'static, Response>,
+}
+
+impl Future for ResponseFuture {
+    type Output = Result<Response, Infallible>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.inner.as_mut().poll(cx).map(Ok)
+    }
+}
+
+impl fmt::Debug for ResponseFuture {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ResponseFuture").finish()
+    }
+}
+
+mod private {
+    use crate::{http::Request, response::IntoResponse};
+
+    pub trait Sealed<B> {}
+    impl<B, E> Sealed<B> for Result<Request<B>, E> where E: IntoResponse {}
+    impl<B> Sealed<B> for Request<B> {}
+}
+
+/// Trait implemented by types that can be returned from [`map_request`],
+/// [`map_request_with_state`].
+///
+/// This trait is sealed such that it cannot be implemented outside this crate.
+pub trait IntoMapRequestResult<B>: private::Sealed<B> {
+    /// Perform the conversion.
+    #[allow(clippy::result_large_err)]
+    fn into_map_request_result(self) -> Result<Request<B>, Response>;
+}
+
+impl<B, E> IntoMapRequestResult<B> for Result<Request<B>, E>
+where
+    E: IntoResponse,
+{
+    fn into_map_request_result(self) -> Result<Request<B>, Response> {
+        self.map_err(IntoResponse::into_response)
+    }
+}
+
+impl<B> IntoMapRequestResult<B> for Request<B> {
+    fn into_map_request_result(self) -> Result<Request<B>, Response> {
+        Ok(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{routing::get, test_helpers::TestClient, Router};
+    use http::{HeaderMap, StatusCode};
+
+    #[crate::test]
+    async fn works() {
+        async fn add_header<B>(mut req: Request<B>) -> Request<B> {
+            req.headers_mut().insert("x-foo", "foo".parse().unwrap());
+            req
+        }
+
+        async fn handler(headers: HeaderMap) -> Response {
+            headers["x-foo"]
+                .to_str()
+                .unwrap()
+                .to_owned()
+                .into_response()
+        }
+
+        let app = Router::new()
+            .route("/", get(handler))
+            .layer(map_request(add_header));
+        let client = TestClient::new(app);
+
+        let res = client.get("/").await;
+
+        assert_eq!(res.text().await, "foo");
+    }
+
+    #[crate::test]
+    async fn works_for_short_circutting() {
+        async fn add_header<B>(_req: Request<B>) -> Result<Request<B>, (StatusCode, &'static str)> {
+            Err((StatusCode::INTERNAL_SERVER_ERROR, "something went wrong"))
+        }
+
+        async fn handler(_headers: HeaderMap) -> Response {
+            unreachable!()
+        }
+
+        let app = Router::new()
+            .route("/", get(handler))
+            .layer(map_request(add_header));
+        let client = TestClient::new(app);
+
+        let res = client.get("/").await;
+
+        assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
+        assert_eq!(res.text().await, "something went wrong");
+    }
+}

notes-service/vendor/axum/src/middleware/map_response.rs

@@ -0,0 +1,363 @@
+use crate::response::{IntoResponse, Response};
+use axum_core::extract::FromRequestParts;
+use futures_util::future::BoxFuture;
+use http::Request;
+use std::{
+    any::type_name,
+    convert::Infallible,
+    fmt,
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+use tower_layer::Layer;
+use tower_service::Service;
+
+/// Create a middleware from an async function that transforms a response.
+///
+/// This differs from [`tower::util::MapResponse`] in that it allows you to easily run axum-specific
+/// extractors.
+///
+/// # Example
+///
+/// ```
+/// use axum::{
+///     Router,
+///     routing::get,
+///     middleware::map_response,
+///     response::Response,
+/// };
+///
+/// async fn set_header<B>(mut response: Response<B>) -> Response<B> {
+///     response.headers_mut().insert("x-foo", "foo".parse().unwrap());
+///     response
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .layer(map_response(set_header));
+/// # let _: Router = app;
+/// ```
+///
+/// # Running extractors
+///
+/// It is also possible to run extractors that implement [`FromRequestParts`]. These will be run
+/// before calling the handler.
+///
+/// ```
+/// use axum::{
+///     Router,
+///     routing::get,
+///     middleware::map_response,
+///     extract::Path,
+///     response::Response,
+/// };
+/// use std::collections::HashMap;
+///
+/// async fn log_path_params<B>(
+///     Path(path_params): Path<HashMap<String, String>>,
+///     response: Response<B>,
+/// ) -> Response<B> {
+///     tracing::debug!(?path_params);
+///     response
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .layer(map_response(log_path_params));
+/// # let _: Router = app;
+/// ```
+///
+/// Note that to access state you must use either [`map_response_with_state`].
+///
+/// # Returning any `impl IntoResponse`
+///
+/// It is also possible to return anything that implements [`IntoResponse`]
+///
+/// ```
+/// use axum::{
+///     Router,
+///     routing::get,
+///     middleware::map_response,
+///     response::{Response, IntoResponse},
+/// };
+/// use std::collections::HashMap;
+///
+/// async fn set_header(response: Response) -> impl IntoResponse {
+///     (
+///         [("x-foo", "foo")],
+///         response,
+///     )
+/// }
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .layer(map_response(set_header));
+/// # let _: Router = app;
+/// ```
+pub fn map_response<F, T>(f: F) -> MapResponseLayer<F, (), T> {
+    map_response_with_state((), f)
+}
+
+/// Create a middleware from an async function that transforms a response, with the given state.
+///
+/// See [`State`](crate::extract::State) for more details about accessing state.
+///
+/// # Example
+///
+/// ```rust
+/// use axum::{
+///     Router,
+///     http::StatusCode,
+///     routing::get,
+///     response::Response,
+///     middleware::map_response_with_state,
+///     extract::State,
+/// };
+///
+/// #[derive(Clone)]
+/// struct AppState { /* ... */ }
+///
+/// async fn my_middleware<B>(
+///     State(state): State<AppState>,
+///     // you can add more extractors here but they must
+///     // all implement `FromRequestParts`
+///     // `FromRequest` is not allowed
+///     response: Response<B>,
+/// ) -> Response<B> {
+///     // do something with `state` and `response`...
+///     response
+/// }
+///
+/// let state = AppState { /* ... */ };
+///
+/// let app = Router::new()
+///     .route("/", get(|| async { /* ... */ }))
+///     .route_layer(map_response_with_state(state.clone(), my_middleware))
+///     .with_state(state);
+/// # let _: axum::Router = app;
+/// ```
+pub fn map_response_with_state<F, S, T>(state: S, f: F) -> MapResponseLayer<F, S, T> {
+    MapResponseLayer {
+        f,
+        state,
+        _extractor: PhantomData,
+    }
+}
+
+/// A [`tower::Layer`] from an async function that transforms a response.
+///
+/// Created with [`map_response`]. See that function for more details.
+#[must_use]
+pub struct MapResponseLayer<F, S, T> {
+    f: F,
+    state: S,
+    _extractor: PhantomData<fn() -> T>,
+}
+
+impl<F, S, T> Clone for MapResponseLayer<F, S, T>
+where
+    F: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            f: self.f.clone(),
+            state: self.state.clone(),
+            _extractor: self._extractor,
+        }
+    }
+}
+
+impl<S, I, F, T> Layer<I> for MapResponseLayer<F, S, T>
+where
+    F: Clone,
+    S: Clone,
+{
+    type Service = MapResponse<F, S, I, T>;
+
+    fn layer(&self, inner: I) -> Self::Service {
+        MapResponse {
+            f: self.f.clone(),
+            state: self.state.clone(),
+            inner,
+            _extractor: PhantomData,
+        }
+    }
+}
+
+impl<F, S, T> fmt::Debug for MapResponseLayer<F, S, T>
+where
+    S: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapResponseLayer")
+            // Write out the type name, without quoting it as `&type_name::<F>()` would
+            .field("f", &format_args!("{}", type_name::<F>()))
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+/// A middleware created from an async function that transforms a response.
+///
+/// Created with [`map_response`]. See that function for more details.
+pub struct MapResponse<F, S, I, T> {
+    f: F,
+    inner: I,
+    state: S,
+    _extractor: PhantomData<fn() -> T>,
+}
+
+impl<F, S, I, T> Clone for MapResponse<F, S, I, T>
+where
+    F: Clone,
+    I: Clone,
+    S: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            f: self.f.clone(),
+            inner: self.inner.clone(),
+            state: self.state.clone(),
+            _extractor: self._extractor,
+        }
+    }
+}
+
+macro_rules! impl_service {
+    (
+        $($ty:ident),*
+    ) => {
+        #[allow(non_snake_case, unused_mut)]
+        impl<F, Fut, S, I, B, ResBody, $($ty,)*> Service<Request<B>> for MapResponse<F, S, I, ($($ty,)*)>
+        where
+            F: FnMut($($ty,)* Response<ResBody>) -> Fut + Clone + Send + 'static,
+            $( $ty: FromRequestParts<S> + Send, )*
+            Fut: Future + Send + 'static,
+            Fut::Output: IntoResponse + Send + 'static,
+            I: Service<Request<B>, Response = Response<ResBody>, Error = Infallible>
+                + Clone
+                + Send
+                + 'static,
+            I::Future: Send + 'static,
+            B: Send + 'static,
+            ResBody: Send + 'static,
+            S: Clone + Send + Sync + 'static,
+        {
+            type Response = Response;
+            type Error = Infallible;
+            type Future = ResponseFuture;
+
+            fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+                self.inner.poll_ready(cx)
+            }
+
+
+            fn call(&mut self, req: Request<B>) -> Self::Future {
+                let not_ready_inner = self.inner.clone();
+                let mut ready_inner = std::mem::replace(&mut self.inner, not_ready_inner);
+
+                let mut f = self.f.clone();
+                let _state = self.state.clone();
+                let (mut parts, body) = req.into_parts();
+
+                let future = Box::pin(async move {
+                    $(
+                        let $ty = match $ty::from_request_parts(&mut parts, &_state).await {
+                            Ok(value) => value,
+                            Err(rejection) => return rejection.into_response(),
+                        };
+                    )*
+
+                    let req = Request::from_parts(parts, body);
+
+                    match ready_inner.call(req).await {
+                        Ok(res) => {
+                            f($($ty,)* res).await.into_response()
+                        }
+                        Err(err) => match err {}
+                    }
+                });
+
+                ResponseFuture {
+                    inner: future
+                }
+            }
+        }
+    };
+}
+
+impl_service!();
+impl_service!(T1);
+impl_service!(T1, T2);
+impl_service!(T1, T2, T3);
+impl_service!(T1, T2, T3, T4);
+impl_service!(T1, T2, T3, T4, T5);
+impl_service!(T1, T2, T3, T4, T5, T6);
+impl_service!(T1, T2, T3, T4, T5, T6, T7);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
+impl_service!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);
+
+impl<F, S, I, T> fmt::Debug for MapResponse<F, S, I, T>
+where
+    S: fmt::Debug,
+    I: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MapResponse")
+            .field("f", &format_args!("{}", type_name::<F>()))
+            .field("inner", &self.inner)
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+/// Response future for [`MapResponse`].
+pub struct ResponseFuture {
+    inner: BoxFuture<'static, Response>,
+}
+
+impl Future for ResponseFuture {
+    type Output = Result<Response, Infallible>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.inner.as_mut().poll(cx).map(Ok)
+    }
+}
+
+impl fmt::Debug for ResponseFuture {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ResponseFuture").finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+    use crate::{test_helpers::TestClient, Router};
+
+    #[crate::test]
+    async fn works() {
+        async fn add_header<B>(mut res: Response<B>) -> Response<B> {
+            res.headers_mut().insert("x-foo", "foo".parse().unwrap());
+            res
+        }
+
+        let app = Router::new().layer(map_response(add_header));
+        let client = TestClient::new(app);
+
+        let res = client.get("/").await;
+
+        assert_eq!(res.headers()["x-foo"], "foo");
+    }
+}

notes-service/vendor/axum/src/middleware/mod.rs

@@ -0,0 +1,33 @@
+//! Utilities for writing middleware
+//!
+#![doc = include_str!("../docs/middleware.md")]
+
+mod from_extractor;
+mod from_fn;
+mod map_request;
+mod map_response;
+mod response_axum_body;
+
+pub use self::from_extractor::{
+    from_extractor, from_extractor_with_state, FromExtractor, FromExtractorLayer,
+};
+pub use self::from_fn::{from_fn, from_fn_with_state, FromFn, FromFnLayer, Next};
+pub use self::map_request::{
+    map_request, map_request_with_state, IntoMapRequestResult, MapRequest, MapRequestLayer,
+};
+pub use self::map_response::{
+    map_response, map_response_with_state, MapResponse, MapResponseLayer,
+};
+pub use self::response_axum_body::{
+    ResponseAxumBody, ResponseAxumBodyFuture, ResponseAxumBodyLayer,
+};
+pub use crate::extension::AddExtension;
+
+pub mod future {
+    //! Future types.
+
+    pub use super::from_extractor::ResponseFuture as FromExtractorResponseFuture;
+    pub use super::from_fn::ResponseFuture as FromFnResponseFuture;
+    pub use super::map_request::ResponseFuture as MapRequestResponseFuture;
+    pub use super::map_response::ResponseFuture as MapResponseResponseFuture;
+}

notes-service/vendor/axum/src/middleware/response_axum_body.rs

@@ -0,0 +1,76 @@
+use std::{
+    error::Error,
+    future::Future,
+    pin::Pin,
+    task::{ready, Context, Poll},
+};
+
+use axum_core::{body::Body, response::Response};
+use bytes::Bytes;
+use http_body::Body as HttpBody;
+use pin_project_lite::pin_project;
+use tower::{Layer, Service};
+
+/// Layer that transforms the Response body to [`crate::body::Body`].
+///
+/// This is useful when another layer maps the body to some other type to convert it back.
+#[derive(Debug, Clone)]
+pub struct ResponseAxumBodyLayer;
+
+impl<S> Layer<S> for ResponseAxumBodyLayer {
+    type Service = ResponseAxumBody<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        ResponseAxumBody::<S>(inner)
+    }
+}
+
+/// Service generated by [`ResponseAxumBodyLayer`].
+#[derive(Debug, Clone)]
+pub struct ResponseAxumBody<S>(S);
+
+impl<S, Request, ResBody> Service<Request> for ResponseAxumBody<S>
+where
+    S: Service<Request, Response = Response<ResBody>>,
+    ResBody: HttpBody<Data = Bytes> + Send + 'static,
+    <ResBody as HttpBody>::Error: Error + Send + Sync,
+{
+    type Response = Response;
+
+    type Error = S::Error;
+
+    type Future = ResponseAxumBodyFuture<S::Future>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.0.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        ResponseAxumBodyFuture {
+            inner: self.0.call(req),
+        }
+    }
+}
+
+pin_project! {
+    /// Response future for [`ResponseAxumBody`].
+    pub struct ResponseAxumBodyFuture<Fut> {
+        #[pin]
+        inner: Fut,
+    }
+}
+
+impl<Fut, ResBody, E> Future for ResponseAxumBodyFuture<Fut>
+where
+    Fut: Future<Output = Result<Response<ResBody>, E>>,
+    ResBody: HttpBody<Data = Bytes> + Send + 'static,
+    <ResBody as HttpBody>::Error: Error + Send + Sync,
+{
+    type Output = Result<Response<Body>, E>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        let res = ready!(this.inner.poll(cx)?);
+        Poll::Ready(Ok(res.map(Body::new)))
+    }
+}