axum-error-sets 0.1.0

Typed, composable HTTP error sets for Axum and Aide
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

use super::*;
use crate::code::{Conflict, InternalServerError, NotAcceptable, NotFound};
use axum::response::IntoResponse as _;
use axum_typed_routing::api_route;
use http::StatusCode;
use rootcause::Report;

struct MyApiError {
    report: Option<Report>,
    msg: Option<String>,
}

impl MyApiError {
    fn new(msg: impl Into<String>) -> Self {
        MyApiError {
            report: None,
            msg: Some(msg.into()),
        }
    }
}

impl<T: Into<Report>> From<T> for MyApiError {
    fn from(err: T) -> Self {
        MyApiError {
            report: Some(err.into()),
            msg: None,
        }
    }
}

impl ErrorSetValue for MyApiError {
    fn into_response_with(self, status: StatusCode) -> Response {
        let msg = self.msg.unwrap_or_else(|| "".to_string());
        (status, msg).into_response()
    }
}

impl AideErrorSetValue for MyApiError {
    type Inner = String;

    fn inferred_response_for(
        _ctx: &mut aide::generate::GenContext,
        _operation: &mut aide::openapi::Operation,
        status: StatusCode,
    ) -> aide::openapi::Response {
        aide::openapi::Response {
            description: format!("An error with status {}", status),
            ..Default::default()
        }
    }
}

type ApiResult<T, E> = Result<T, ErrorSet<MyApiError, E>>;

#[api_route(GET "/test")]
#[axum::debug_handler]
async fn test() -> ApiResult<(), (NotFound, InternalServerError)> {
    another_fn().into_not_found()?;
    another_fn().into_internal()?;
    // another_fn().status_conflict()?;

    subset().into_superset()?;
    // unhandled().into_superset()?;

    Err(NotFound(MyApiError::new("Not found")))?;
    // Err(Conflict(MyApiError::from_msg("Not found")))?;

    Err(ErrorSet::new_with::<NotFound>(MyApiError::new("Not found")))?;
    // Err(ApiError::new::<Conflict>(MyApiError::from_msg("Not found")))?;

    Ok(())
}

fn another_fn() -> Result<(), std::fmt::Error> {
    Ok(())
}

fn subset() -> ApiResult<(), (NotFound,)> {
    Ok(())
}

fn unhandled() -> ApiResult<(), (Conflict, NotAcceptable)> {
    Ok(())
}