DOES NOT WORK stateless from request parts

Author: mladedav

axum-core/src/extract/mod.rs

@@ -28,12 +28,21 @@ pub use self::{
 /// type used with axum.
 pub type Request<T = Body> = http::Request<T>;
 
-mod private {
+pub mod private {
     #[derive(Debug, Clone, Copy)]
     pub enum ViaParts {}
 
+    #[derive(Debug, Clone, Copy)]
+    pub enum ViaStatelessParts {}
+
     #[derive(Debug, Clone, Copy)]
     pub enum ViaRequest {}
+
+    #[derive(Debug, Clone, Copy)]
+    pub enum WithState {}
+
+    #[derive(Debug, Clone, Copy)]
+    pub enum Stateless {}
 }
 
 /// Types that can be created from request parts.
@@ -53,7 +62,7 @@ mod private {
         note = "Function argument is not a valid axum extractor. \nSee `https://docs.rs/axum/0.8/axum/extract/index.html` for details",
     )
 )]
-pub trait FromRequestParts<S>: Sized {
+pub trait FromRequestParts<S, Via = private::WithState>: Sized {
     /// If the extractor fails it'll use this "rejection" type. A rejection is
     /// a kind of error that can be converted into a response.
     type Rejection: IntoResponse;
@@ -65,6 +74,32 @@ pub trait FromRequestParts<S>: Sized {
     ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send;
 }
 
+/// Like `FromRequestParts` but without `State`.
+pub trait FromStatelessRequestParts: Sized {
+    /// If the extractor fails it'll use this "rejection" type. A rejection is
+    /// a kind of error that can be converted into a response.
+    type Rejection: IntoResponse;
+
+    /// Perform the extraction.
+    fn from_request_parts(
+        parts: &mut Parts,
+    ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send;
+}
+
+impl<T, S> FromRequestParts<S, private::Stateless> for T
+where
+    T: FromStatelessRequestParts,
+{
+    type Rejection = T::Rejection;
+
+    fn from_request_parts(
+        parts: &mut Parts,
+        _state: &S,
+    ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send {
+        T::from_request_parts(parts)
+    }
+}
+
 /// Types that can be created from requests.
 ///
 /// Extractors that implement `FromRequest` can consume the request body and can thus only be run
@@ -97,7 +132,7 @@ pub trait FromRequest<S, M = private::ViaRequest>: Sized {
 impl<S, T> FromRequest<S, private::ViaParts> for T
 where
     S: Send + Sync,
-    T: FromRequestParts<S>,
+    T: FromRequestParts<S, private::WithState>,
 {
     type Rejection = <Self as FromRequestParts<S>>::Rejection;
 
@@ -110,6 +145,23 @@ where
     }
 }
 
+impl<S, T> FromRequest<S, private::ViaStatelessParts> for T
+where
+    S: Send + Sync,
+    T: FromRequestParts<S, private::Stateless>,
+{
+    type Rejection = <Self as FromRequestParts<S, private::Stateless>>::Rejection;
+
+    fn from_request(
+        req: Request,
+        state: &S,
+    ) -> impl Future<Output = Result<Self, Self::Rejection>> {
+        let (mut parts, _) = req.into_parts();
+        async move { Self::from_request_parts(&mut parts, state).await }
+    }
+}
+
+
 impl<S, T> FromRequestParts<S> for Result<T, T::Rejection>
 where
     T: FromRequestParts<S>,

axum-extra/src/handler/or.rs

@@ -52,12 +52,12 @@ where
     }
 }
 
-impl<S, L, R, Lt, Rt, M> Handler<(M, Lt, Rt), S> for Or<L, R, Lt, Rt, S>
+impl<S, L, R, Lt, Rt, M1, M2> Handler<((M1, M2), Lt, Rt), S> for Or<L, R, Lt, Rt, S>
 where
     L: HandlerCallWithExtractors<Lt, S> + Clone + Send + Sync + 'static,
     R: HandlerCallWithExtractors<Rt, S> + Clone + Send + Sync + 'static,
-    Lt: FromRequestParts<S> + Send + 'static,
-    Rt: FromRequest<S, M> + Send + 'static,
+    Lt: FromRequestParts<S, M1> + Send + 'static,
+    Rt: FromRequest<S, M2> + Send + 'static,
     Lt::Rejection: Send,
     Rt::Rejection: Send,
     S: Send + Sync + 'static,

axum/src/extract/query.rs

@@ -1,4 +1,5 @@
-use super::{rejection::*, FromRequestParts};
+use super::rejection::*;
+use axum_core::extract::FromStatelessRequestParts;
 use http::{request::Parts, Uri};
 use serde::de::DeserializeOwned;
 
@@ -50,14 +51,13 @@ use serde::de::DeserializeOwned;
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Query<T>(pub T);
 
-impl<T, S> FromRequestParts<S> for Query<T>
+impl<T> FromStatelessRequestParts for Query<T>
 where
     T: DeserializeOwned,
-    S: Send + Sync,
 {
     type Rejection = QueryRejection;
 
-    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+    async fn from_request_parts(parts: &mut Parts) -> Result<Self, Self::Rejection> {
         Self::try_from_uri(&parts.uri)
     }
 }

axum/src/handler/mod.rs

@@ -51,6 +51,7 @@ use crate::{
     response::{IntoResponse, Response},
     routing::IntoMakeService,
 };
+use axum_core::extract::FromStatelessRequestParts;
 use std::{convert::Infallible, fmt, future::Future, marker::PhantomData, pin::Pin};
 use tower::ServiceExt;
 use tower_layer::Layer;
@@ -203,6 +204,113 @@ where
     }
 }
 
+struct AutoDerefSpecialization<T>(PhantomData<fn() -> *const T>);
+
+impl<T> AutoDerefSpecialization<T> {
+    fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
+trait ViaRequestParts<S> {
+    type SelfT;
+    type Rejection;
+
+    async fn extract(
+        self,
+        req: &mut http::request::Parts,
+        state: &S,
+    ) -> Result<Self::SelfT, Self::Rejection>;
+}
+
+trait ViaStatelessRequestParts<S> {
+    type SelfT;
+    type Rejection;
+
+    async fn extract(
+        self,
+        req: &mut http::request::Parts,
+        state: &S,
+    ) -> Result<Self::SelfT, Self::Rejection>;
+}
+
+trait ViaPanic<S> {
+    type SelfT;
+    type Rejection;
+
+    async fn extract(
+        self,
+        req: &mut http::request::Parts,
+        state: &S,
+    ) -> Result<Self::SelfT, Self::Rejection>;
+}
+
+impl<T, S> ViaRequestParts<S> for &&AutoDerefSpecialization<T>
+where
+    T: FromRequestParts<S>,
+{
+    type SelfT = T;
+    type Rejection = T::Rejection;
+
+    async fn extract(
+        self,
+        req: &mut http::request::Parts,
+        state: &S,
+    ) -> Result<Self::SelfT, Self::Rejection> {
+        T::from_request_parts(req, state).await
+    }
+}
+
+impl<T, S> ViaStatelessRequestParts<S> for &&&AutoDerefSpecialization<T>
+where
+    T: FromStatelessRequestParts,
+{
+    type SelfT = T;
+    type Rejection = T::Rejection;
+
+    async fn extract(
+        self,
+        req: &mut http::request::Parts,
+        _state: &S,
+    ) -> Result<Self::SelfT, Self::Rejection> {
+        T::from_request_parts(req).await
+    }
+}
+
+impl<T, S> ViaPanic<S> for &AutoDerefSpecialization<T> {
+    type SelfT = T;
+    type Rejection = ();
+
+    async fn extract(
+        self,
+        _req: &mut http::request::Parts,
+        _state: &S,
+    ) -> Result<Self::SelfT, Self::Rejection> {
+        panic!();
+    }
+}
+
+struct Foo;
+
+impl FromStatelessRequestParts for Foo {
+    type Rejection = ();
+
+    fn from_request_parts(
+        _parts: &mut http::request::Parts,
+    ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send {
+        std::future::ready(Ok(Foo))
+    }
+}
+
+#[test]
+fn foo() {
+    let req = todo!();
+    (&&AutoDerefSpecialization::<Foo>::new()).extract(req, &());
+}
+
+trait Something<S, V> {}
+impl<T, S, V> Something<S, V> for T where T: FromRequestParts<S, V> {}
+
 macro_rules! impl_handler {
     (
         [$($ty:ident),*], $last:ident
@@ -214,7 +322,7 @@ macro_rules! impl_handler {
             Fut: Future<Output = Res> + Send,
             S: Send + Sync + 'static,
             Res: IntoResponse,
-            $( $ty: FromRequestParts<S> + Send, )*
+            $( $ty: Send, )*
             $last: FromRequest<S, M> + Send,
         {
             type Future = Pin<Box<dyn Future<Output = Response> + Send>>;
@@ -223,7 +331,7 @@ macro_rules! impl_handler {
                 let (mut parts, body) = req.into_parts();
                 Box::pin(async move {
                     $(
-                        let $ty = match $ty::from_request_parts(&mut parts, &state).await {
+                        let $ty = match (&&&AutoDerefSpecialization::<$ty>::new()).extract(&mut parts, &state).await {
                             Ok(value) => value,
                             Err(rejection) => return rejection.into_response(),
                         };

examples/todos/src/main.rs

@@ -68,7 +68,7 @@ async fn main() {
         )
         .with_state(db);
 
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:2000")
         .await
         .unwrap();
     tracing::debug!("listening on {}", listener.local_addr().unwrap());