apollo-errors-derive 0.5.0

Proc macro for deriving apollo-errors::Error trait
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

//! Variant definition

use syn::Ident;

use super::HttpStatusValue;

use super::field::FieldDefinition;
use super::field::TransparentFieldDefinition;
use super::format_string::validate_no_optional_fields_in_message;

/// A single variant of an error enum - either regular or transparent
#[derive(Debug, Clone)]
pub(crate) enum VariantDefinition {
    /// A regular error variant with message, code, and fields
    Regular(RegularVariantDefinition),

    /// A transparent variant that forwards to an inner error type
    Transparent(TransparentVariantDefinition),
}

impl VariantDefinition {
    /// Validate the variant definition
    pub(crate) fn validate(&self) -> syn::Result<()> {
        match self {
            Self::Regular(v) => v.validate(),
            Self::Transparent(v) => v.validate(),
        }
    }
}

/// A regular error variant with its own message, code, and status
#[derive(Debug, Clone)]
pub(crate) struct RegularVariantDefinition {
    /// The variant name
    pub(crate) name: Ident,

    /// Error message from `#[error("...")]`
    pub(crate) error_message: String,

    /// Diagnostic code from `#[diagnostic(code(...))]`
    pub(crate) diagnostic_code: String,

    /// Optional help text from `#[diagnostic(help(...))]`
    pub(crate) help_text: Option<String>,

    /// Optional URL from `#[diagnostic(url(...))]`
    pub(crate) url: Option<String>,

    /// Optional severity from `#[diagnostic(severity(...))]`
    pub(crate) severity: Option<String>,

    /// Optional HTTP status from `#[http_status(...)]`
    pub(crate) http_status: Option<HttpStatusValue>,

    /// Optional JSON-RPC error code from `#[jsonrpc_code(...)]`
    pub(crate) jsonrpc_code: Option<i32>,

    /// Fields of this variant
    pub(crate) fields: Vec<FieldDefinition>,
}

impl RegularVariantDefinition {
    /// Validate the variant definition
    fn validate(&self) -> syn::Result<()> {
        if self.error_message.is_empty() {
            return Err(syn::Error::new_spanned(
                &self.name,
                "variant must have #[error(\"message\")] attribute",
            ));
        }

        validate_no_optional_fields_in_message(&self.error_message, &self.fields)?;

        Ok(())
    }
}

/// A transparent variant that forwards to an inner error type
#[derive(Debug, Clone)]
pub(crate) struct TransparentVariantDefinition {
    /// The variant name
    pub(crate) name: Ident,

    /// The inner error type this variant forwards to
    pub(crate) field: TransparentFieldDefinition,
}

impl TransparentVariantDefinition {
    /// Validate the variant definition
    fn validate(&self) -> syn::Result<()> {
        // Transparent variants just need a valid inner type, which is ensured at parse time
        Ok(())
    }
}