axum-reject-macro 0.1.1

A macro that allows creating axum rejections easily
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

use darling::ast::{self, Fields};
use darling::{util, FromDeriveInput, FromVariant};
use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use syn::{Ident, Type};

#[derive(Debug, FromVariant)]
#[darling(attributes(http_error))]
struct HttpErrorVariant {
    ident: Ident,
    fields: Fields<Type>,
    status: Ident,
    message: String,
}

#[derive(Debug, FromDeriveInput)]
#[darling(attributes(http_error))]
struct HttpError {
    ident: Ident,
    generics: syn::Generics,
    data: ast::Data<HttpErrorVariant, util::Ignored>,
}

impl ToTokens for HttpError {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let ident = &self.ident;
        let generics = &self.generics;
        let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

        let match_arms = self.data.as_ref()
            .take_enum()
            .expect("Should be an enum")
            .into_iter()
            .map(|variant| {
                let ident = &variant.ident;
                let status = &variant.status;
                let message = &variant.message;
                let field = variant.fields.iter().map(|_| quote! { _ }).collect::<Vec<_>>();

                if field.is_empty() {
                    quote! {
                        Self::#ident => (axum::http::StatusCode::#status, format!(r#"{{"error": "{}"}}"#, #message).to_string()).into_response()
                    }
                } else {
                    quote! {
                        Self::#ident(#(#field),*) => (axum::http::StatusCode::#status, format!(r#"{{"error": "{}"}}"#, #message).to_string()).into_response()
                    }
                }
            });

        tokens.extend(quote! {
            impl #impl_generics axum::response::IntoResponse for #ident #ty_generics #where_clause {
                fn into_response(self) -> axum::response::Response {
                    match self {
                        #(#match_arms),*
                    }
                }
            }
        });
    }
}

#[proc_macro_derive(HttpError, attributes(http_error))]
pub fn derive_http_error(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = syn::parse_macro_input!(input as syn::DeriveInput);
    let http_error = HttpError::from_derive_input(&input).unwrap();
    http_error.into_token_stream().into()
}