autapi 0.0.1

Automatic OpenAPI specification from function signatures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use http::request::Parts;

use crate::{
    Registry, Undocumented, UndocumentedAxum,
    openapi::Operation,
    request::{FromRequest, FromRequestParts, Request},
};

impl<S, T> FromRequest<S> for Undocumented<T>
where
    T: FromRequest<S>,
    S: Send + Sync,
{
    type Rejection = Undocumented<T::Rejection>;

    fn openapi(_: &mut Operation, _: &mut Registry) {}

    async fn from_request(request: Request, state: &S) -> Result<Self, Self::Rejection> {
        T::from_request(request, state)
            .await
            .map(Self)
            .map_err(Undocumented)
    }
}

impl<S, T> FromRequestParts<S> for Undocumented<T>
where
    T: FromRequestParts<S>,
    S: Send + Sync,
{
    type Rejection = Undocumented<T::Rejection>;

    fn openapi(_: &mut Operation, _: &mut Registry) {}

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        T::from_request_parts(parts, state)
            .await
            .map(Self)
            .map_err(Undocumented)
    }
}

impl<S, T> FromRequest<S> for UndocumentedAxum<T>
where
    T: axum::extract::FromRequest<S>,
    T::Rejection: Send,
    S: Send + Sync,
{
    type Rejection = UndocumentedAxum<T::Rejection>;

    fn openapi(_: &mut Operation, _: &mut Registry) {}

    async fn from_request(request: Request, state: &S) -> Result<Self, Self::Rejection> {
        T::from_request(request, state)
            .await
            .map(Self)
            .map_err(UndocumentedAxum)
    }
}

impl<S, T> FromRequestParts<S> for UndocumentedAxum<T>
where
    T: axum::extract::FromRequestParts<S>,
    T::Rejection: Send,
    S: Send + Sync,
{
    type Rejection = UndocumentedAxum<T::Rejection>;

    fn openapi(_: &mut Operation, _: &mut Registry) {}

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        T::from_request_parts(parts, state)
            .await
            .map(Self)
            .map_err(UndocumentedAxum)
    }
}