actix_failwrap 1.0.3

A micro-package that enables ergonomic error propagation (using thiserror) inside actix-web route handlers.
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

//! [`ErrorResponse`] Output Module
//!
//! Declares the macro generation functions,
//! abstracting the macro generation instead
//! of declaring it into the main module.

use proc_macro2::TokenStream as TokenStream2;
use quote::{TokenStreamExt, format_ident, quote};
use syn::Fields as VariantFields;

use crate::macro_input::error_response::{ErrorResponse, ErrorResponseVariant};

/// **`variant_match_head()`**
///
/// Generates an 'ignore all' head depending on the
/// provided enum variant. Returns a [`TokenStream2`]
/// with the generated head.
fn variant_match_head(variant: &ErrorResponseVariant) -> TokenStream2 {
    let variant_name = &variant
        .variant()
        .ident;
    let variant_head_type = match variant
        .variant()
        .fields
    {
        VariantFields::Named(_) => quote! { {..} },
        VariantFields::Unnamed(_) => quote! { (..) },
        VariantFields::Unit => quote! {},
    };

    quote! { Self::#variant_name #variant_head_type => }
}

/// **`error_response_output()`**
///
/// Generates the [`ErrorResponse`] macro output.
pub fn error_response_output(input: &ErrorResponse) -> TokenStream2 {
    let enum_name = input.enum_name();

    let (http_response_variants, error_variants) = input
        .variants()
        .iter()
        .map(|variant| {
            let status_code = variant
                .status_code()
                .unwrap_or(input.default_status_code());

            let variant_head = variant_match_head(variant);

            let mut http_response_variant = variant_head.clone();
            let http_response_tokens = quote! {
                ::actix_web::HttpResponse::#status_code()
            };

            http_response_variant.append_all(
                if let Some(transformer_fn) = input.transform_response() {
                    quote! {{
                        let transformed: ::actix_web::HttpResponse // type checking.
                            = #transformer_fn(#http_response_tokens, self.to_string());

                        transformed
                    }}
                } else {
                    quote! {
                        #http_response_tokens
                            .body(self.to_string())
                    }
                },
            );

            let mut error_variant = variant_head.clone();
            let error_variant_ident = format_ident!("Error{status_code}");
            error_variant
                .append_all(quote! { ::actix_web::error::#error_variant_ident(self.to_string()) });

            (http_response_variant, error_variant)
        })
        .collect::<(Vec<_>, Vec<_>)>();

    quote! {
        impl ::std::convert::Into<::actix_web::HttpResponse> for #enum_name {
            fn into(self) -> ::actix_web::HttpResponse {
                match self {
                    #(#http_response_variants),*
                }
            }
        }

        impl ::std::convert::Into<::actix_web::Error> for #enum_name {
            fn into(self) -> ::actix_web::Error {
                match self {
                    #(#error_variants),*
                }
            }
        }
    }
}