krabdex 0.1.0

A type-safe, async Rust SDK for the PokeAPI
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

use thiserror::Error;
use std::{error::Error as StdError, fmt};

/// Convenience result type used throughout the SDK.
pub type Result<T> = std::result::Result<T, Error>;

/// Top-level error type for the SDK.
#[derive(Debug, Error)]
pub enum Error {
    /// Internal SDK error (bug).
    #[error("internal error: {0}")]
    Internal(&'static str),
    
    /// Networking error (TLS, DNS, IO, etc).
    #[error("transport error")]
    Transport {
        #[source]
        source: Box<dyn StdError + Send + Sync>,
    },

    /// API returned a non-success HTTP status.
    #[error("api error: {0}")]
    Api(ApiError),

    /// Response body could not be deserialized.
    #[error("failed to deserialize response from {url}")]
    Deserialize {
        url: String,
        #[source]
        source: serde_json::Error,
    },

    /// User provided invalid input (local validation failure).
    #[error("invalid argument `{field}`: {reason}")]
    InvalidArgument {
        field: &'static str,
        reason: String,
    },
}

/// Details of an API error response.
#[derive(Debug)]
pub struct ApiError {
    pub status: u16,
    pub url: String,
    pub kind: ApiErrorKind,
}

/// Classification of API error responses.
#[derive(Debug)]
pub enum ApiErrorKind {
    NotFound {
        resource: &'static str,
        identifier: String,
    },
    RateLimited {
        retry_after: Option<u64>,
    },
    HttpStatus {
        body_snippet: Option<String>,
    },
}

impl fmt::Display for ApiError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.kind {
            ApiErrorKind::NotFound { resource, identifier } => {
                write!(
                    f,
                    "{} `{}` not found (status {})",
                    resource, identifier, self.status
                )
            }
            ApiErrorKind::RateLimited { retry_after } => {
                if let Some(secs) = retry_after {
                    write!(
                        f,
                        "rate limited (retry after {}s) (status {})",
                        secs, self.status
                    )
                } else {
                    write!(f, "rate limited (status {})", self.status)
                }
            }
            ApiErrorKind::HttpStatus { .. } => {
                write!(f, "http error (status {})", self.status)
            }
        }
    }
}