galvyn-core 0.5.0

Core concepts for galvyn like trait definitions
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
78
79
80
81
82
83
84
85
86
87
88
89
90

use axum::http::Method;
use axum::http::Response;
use axum::http::StatusCode;
use axum::http::response::Parts;
use axum::routing::MethodRouter;

use self::request_body::RequestBodyMetadata;
use self::request_part::RequestPartMetadata;
use self::response_body::ResponseBodyMetadata;
use self::response_part::ResponsePartMetadata;
use crate::macro_utils::type_metadata::HasMetadata;
use crate::macro_utils::type_metadata::ShouldHaveMetadata;

pub mod context;
mod impls;
pub mod request_body;
pub mod request_part;
pub mod response_body;
pub mod response_part;

/// A function handling a web request
///
/// This trait should not be implemented by hand.
/// Instead, the [`#[handler]`](crate::handler) macro (and its siblings)
/// annotate a function and implements this trait on them[^clarification].
///
/// [^clarification]: Currently, there is no way to implement a trait on a specific function,
///     because a function's type can't be named.
///     The macro creates a zero-sized struct which shadows the function.
pub trait GalvynHandler {
    /// Meta information about a [`GalvynHandler`] gathered by the [`#[handler]`](crate::handler) macro
    fn meta(&self) -> HandlerMeta;

    /// The actual function stored in an axum specific format
    fn method_router(&self) -> MethodRouter;
}

/// Meta information about a [`GalvynHandler`] gathered by the [`#[handler]`](crate::handler) macro
#[derive(Clone, Debug)]
pub struct HandlerMeta {
    /// The http method the handler handles
    pub method: Method,

    /// The handler's path
    pub path: &'static str,

    /// `true` if `#[deprecated]` is present
    pub deprecated: bool,

    /// Set by macro if `#[doc = "..."]` (i.e. a doc comment) is present
    pub doc: &'static [&'static str],

    /// The handler's identifier
    pub ident: &'static str,

    pub request_parts: Vec<RequestPartMetadata>,

    pub request_body: Option<RequestBodyMetadata>,

    pub response_modifier: Option<ResponseModifier>,

    pub response_parts: Vec<ResponsePartMetadata>,

    pub response_body: Option<ResponseBodyMetadata>,
}

#[derive(Clone, Debug)]
pub enum ResponseModifier {
    StatusCode,
    Parts,
    Response,
}

impl<T: HasMetadata<ResponseModifier>> ShouldHaveMetadata<ResponseModifier> for T {}
impl HasMetadata<ResponseModifier> for StatusCode {
    fn metadata() -> ResponseModifier {
        ResponseModifier::StatusCode
    }
}
impl HasMetadata<ResponseModifier> for Parts {
    fn metadata() -> ResponseModifier {
        ResponseModifier::StatusCode
    }
}

impl HasMetadata<ResponseModifier> for Response<()> {
    fn metadata() -> ResponseModifier {
        ResponseModifier::StatusCode
    }
}