rok-core 0.6.0

Core primitives for the rok ecosystem — errors, crypto, i18n, config, DI, and more
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

use std::sync::Arc;

use axum::{
    body::Body,
    http::Request,
    response::{IntoResponse, Response},
};
use tower::{Layer, Service};

use crate::error::RokException;
use crate::Problem;

/// Global error handler middleware.
///
/// Catches `Err` from the inner service and delegates to the wrapped handler.
/// Default handler is [`default_error_handler`].
///
/// The inner service's error type must implement `Into<Box<dyn RokException>>`.
pub struct CatchLayer<F> {
    handler: Arc<F>,
}

impl<F> CatchLayer<F> {
    pub fn new(handler: F) -> Self {
        Self {
            handler: Arc::new(handler),
        }
    }
}

impl<F> Clone for CatchLayer<F> {
    fn clone(&self) -> Self {
        Self {
            handler: self.handler.clone(),
        }
    }
}

impl<S, F> Layer<S> for CatchLayer<F>
where
    F: Fn(Box<dyn RokException>) -> Response + Send + Sync + 'static,
    S: Service<Request<Body>, Response = Response> + Send + 'static,
    S::Future: Send,
{
    type Service = CatchService<S, F>;

    fn layer(&self, inner: S) -> Self::Service {
        CatchService {
            inner,
            handler: self.handler.clone(),
        }
    }
}

/// The per-request service produced by [`CatchLayer`].
pub struct CatchService<S, F> {
    inner: S,
    handler: Arc<F>,
}

impl<S: Clone, F> Clone for CatchService<S, F> {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
            handler: self.handler.clone(),
        }
    }
}

impl<S, F> Service<Request<Body>> for CatchService<S, F>
where
    F: Fn(Box<dyn RokException>) -> Response + Send + Sync + 'static,
    S: Service<Request<Body>, Response = Response> + Send + 'static,
    S::Error: Into<Box<dyn RokException>>,
    S::Future: Send,
{
    type Response = Response;
    type Error = std::convert::Infallible;
    type Future = std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send>,
    >;

    fn poll_ready(
        &mut self,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx).map_err(|_| unreachable!())
    }

    fn call(&mut self, req: Request<Body>) -> Self::Future {
        let handler = self.handler.clone();
        let fut = self.inner.call(req);
        Box::pin(async move {
            match fut.await {
                Ok(resp) => Ok(resp),
                Err(err) => {
                    let rok_err: Box<dyn RokException> = err.into();
                    Ok(handler(rok_err))
                }
            }
        })
    }
}

/// Default error handler: logs the exception and returns Problem JSON.
///
/// * Self-handled exceptions return their own `IntoResponse`.
/// * Non-self-handled exceptions are logged and converted to a 500 `Problem`.
pub fn default_error_handler(err: Box<dyn RokException>) -> Response {
    if err.self_handled() {
        return err.into_response();
    }

    Problem::internal(err.to_string()).into_response()
}