apidoc 0.3.3

Apidoc integration
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

use apidoc_core::error::{ApiErrorItem, ApiErrors};
use syn::{parse_quote, DeriveInput};

#[test]
fn test_expand() {
    pub enum Error {
        UserNotExist,

        NoPermission,

        BadRequest,

        Error2(Error2),
    }

    let _e = Error::UserNotExist;
    let _e = Error::NoPermission;
    let _e = Error::BadRequest;
    let _e = Error::Error2(Error2);

    pub struct Error2;

    pub enum ErrorKind {
        BadRequest,
    }

    impl From<ErrorKind> for ApiErrorItem {
        fn from(_value: ErrorKind) -> Self {
            todo!()
        }
    }

    impl ApiErrors for Error2 {
        fn api_errors() -> Vec<ApiErrorItem> {
            let result = vec![
                ApiErrorItem {
                    status: 200,
                    code: "001".into(),
                    cause: "用户不存在".into(),
                },
                ApiErrorItem {
                    status: 200,
                    code: "002".into(),
                    cause: "没有权限".into(),
                },
                ErrorKind::BadRequest.into(),
                {
                    let item: ApiErrorItem = ErrorKind::BadRequest.into();
                    ApiErrorItem {
                        status: item.status,
                        code: item.code,
                        cause: "错误请求".into(),
                    }
                },
            ];
            result
        }
    }

    impl ApiErrors for Error {
        fn api_errors() -> Vec<ApiErrorItem> {
            let mut result = vec![
                ApiErrorItem {
                    status: 200,
                    code: "001".into(),
                    cause: "用户不存在".into(),
                },
                ApiErrorItem {
                    status: 200,
                    code: "002".into(),
                    cause: "没有权限".into(),
                },
                ErrorKind::BadRequest.into(),
                {
                    let item: ApiErrorItem = ErrorKind::BadRequest.into();
                    ApiErrorItem {
                        status: item.status,
                        code: item.code,
                        cause: "错误请求".into(),
                    }
                },
            ];
            result.extend(<Error2 as ApiErrors>::api_errors());
            result
        }
    }

    let input: DeriveInput = parse_quote! {
        #[derive(ApiError)]
        pub enum Error {
            #[api_error(status = 200, code = "001", cause = "用户不存在")]
            UserNotExist,

            #[api_error("002", "没有权限")]
            NoPermission,

            #[api_error(from(ErrorKind::BadRequest))]
            BadRequest,

            #[api_error(from(ErrorKind::BadRequest, "错误请求"))]
            BadRequest2,

            Error2(Error2),
        }
    };
    let result = apidoc_expand::api_error::expand(&input)
        .unwrap()
        .to_string();
    println!("{result}")
}