nidus-http 1.0.0

Axum and Tower HTTP integration, controllers, middleware, health, metrics, and server defaults for Nidus.
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Axum router composition.

mod metadata;
mod path;

use axum::{Router, handler::Handler, routing};
use http::Method;

use crate::error::RoutePathError;

pub use metadata::{OpenApiSchemaRegistrar, RouteMetadata};
pub(crate) use path::join_paths;
use path::normalize_path;

/// A route declaration that can be mounted by a controller.
pub struct RouteDefinition {
    method: Method,
    path: String,
    route: routing::MethodRouter,
}

impl RouteDefinition {
    /// Creates a GET route.
    pub fn get<H, T>(path: impl Into<String>, handler: H) -> Self
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_get(path, handler).unwrap_or_else(|error| panic!("{error}"))
    }

    /// Tries to create a GET route.
    pub fn try_get<H, T>(path: impl Into<String>, handler: H) -> Result<Self, RoutePathError>
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_new(Method::GET, path, routing::get(handler))
    }

    /// Creates a POST route.
    pub fn post<H, T>(path: impl Into<String>, handler: H) -> Self
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_post(path, handler).unwrap_or_else(|error| panic!("{error}"))
    }

    /// Tries to create a POST route.
    pub fn try_post<H, T>(path: impl Into<String>, handler: H) -> Result<Self, RoutePathError>
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_new(Method::POST, path, routing::post(handler))
    }

    /// Creates a PUT route.
    pub fn put<H, T>(path: impl Into<String>, handler: H) -> Self
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_put(path, handler).unwrap_or_else(|error| panic!("{error}"))
    }

    /// Tries to create a PUT route.
    pub fn try_put<H, T>(path: impl Into<String>, handler: H) -> Result<Self, RoutePathError>
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_new(Method::PUT, path, routing::put(handler))
    }

    /// Creates a PATCH route.
    pub fn patch<H, T>(path: impl Into<String>, handler: H) -> Self
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_patch(path, handler).unwrap_or_else(|error| panic!("{error}"))
    }

    /// Tries to create a PATCH route.
    pub fn try_patch<H, T>(path: impl Into<String>, handler: H) -> Result<Self, RoutePathError>
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_new(Method::PATCH, path, routing::patch(handler))
    }

    /// Creates a DELETE route.
    pub fn delete<H, T>(path: impl Into<String>, handler: H) -> Self
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_delete(path, handler).unwrap_or_else(|error| panic!("{error}"))
    }

    /// Tries to create a DELETE route.
    pub fn try_delete<H, T>(path: impl Into<String>, handler: H) -> Result<Self, RoutePathError>
    where
        H: Handler<T, ()> + Clone + Send + Sync + 'static,
        T: 'static,
    {
        Self::try_new(Method::DELETE, path, routing::delete(handler))
    }

    /// Returns the route path.
    pub fn path(&self) -> &str {
        &self.path
    }

    /// Returns the route method.
    pub fn method(&self) -> &Method {
        &self.method
    }

    pub(crate) fn into_router(self, full_path: String) -> Router {
        Router::new().route(&full_path, self.route)
    }

    fn try_new(
        method: Method,
        path: impl Into<String>,
        route: routing::MethodRouter,
    ) -> Result<Self, RoutePathError> {
        Ok(Self {
            method,
            path: normalize_path(path.into())?,
            route,
        })
    }
}