apollo-errors 0.6.0

Structured error handling with automatic format conversion
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

//! Metadata structures for error catalog

use serde::Serialize;

/// Metadata for a field within an error variant
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FieldMetadata {
    /// The field name in Rust (snake_case)
    pub rust_name: &'static str,

    /// The output name for serialization
    pub output_name: &'static str,

    /// The Rust type as a string
    pub ty: &'static str,

    /// Whether this field is an extension field
    pub is_extension: bool,

    /// HTTP header name if this field should be returned as a header
    #[serde(skip_serializing_if = "Option::is_none")]
    pub http_header: Option<&'static str>,
}

/// Metadata for a regular error variant with its own message, code, and status
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RegularVariantMetadata {
    /// The variant name
    pub name: &'static str,

    /// Error message template
    pub message: &'static str,

    /// Error code (e.g., "AUTH_FAILED")
    pub code: &'static str,

    /// HTTP status code
    pub http_status: u16,

    /// JSON-RPC error code
    pub jsonrpc_code: i32,

    /// Optional help text
    #[serde(skip_serializing_if = "Option::is_none")]
    pub help: Option<&'static str>,

    /// Optional documentation URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url: Option<&'static str>,

    /// Optional severity
    #[serde(skip_serializing_if = "Option::is_none")]
    pub severity: Option<&'static str>,

    /// Fields in this variant
    pub fields: &'static [FieldMetadata],
}

/// Metadata for a transparent variant that forwards to another error type
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransparentVariantMetadata {
    /// The variant name
    pub name: &'static str,

    /// The type name this variant forwards to
    pub forward_to: &'static str,
}

/// Metadata for a single error variant
#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
pub enum VariantMetadata {
    /// A regular error variant
    Regular(RegularVariantMetadata),

    /// A transparent variant that forwards to another error type
    Transparent(TransparentVariantMetadata),
}

/// Metadata for an error enum type
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorMetadata {
    /// The Rust type name
    pub type_name: &'static str,

    /// All variants of this error type
    pub variants: &'static [VariantMetadata],
}