apisdk 0.0.4-beta.4

A highlevel API client framework for Rust.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use reqwest::Url;
use serde_json::Value;
use thiserror::Error;

use crate::{MiddlewareError, MimeType};

/// Route Error
#[derive(Debug, Error)]
pub enum RouteError {
    /// Service discovery error
    #[error("Service discovery error: {0}")]
    ServiceDiscovery(anyhow::Error),
    /// IO error
    #[error("IO error: {0}")]
    IoError(std::io::Error),
    /// Update scheme error
    #[error("Update scheme error: {0} => {1}")]
    UpdateScheme(Url, String),
    /// Update host error
    #[error("Update host error: {0} => {1}")]
    UpdateHost(Url, String, url::ParseError),
    /// Update port error
    #[error("Update port error: {0} => :{1}")]
    UpdatePort(Url, u16),
    /// Custom error
    #[error("Custom error: {0}")]
    Custom(String),
}

/// Api Error
#[derive(Debug, Error)]
pub enum ApiError {
    /// Route error
    #[error("Route error: {0}")]
    Route(#[from] RouteError),
    /// Invalid URL
    #[error("Invalid URL: {0}")]
    InvalidUrl(reqwest::Error),
    /// Build request error
    #[error("Build request error: {0}")]
    BuildRequest(reqwest::Error),
    /// Generic reqwest error
    #[error("Generic reqwest error: {0}")]
    Reqwest(reqwest::Error),
    /// Middleware error
    #[error("Middleware error: {0}")]
    Middleware(anyhow::Error),
    /// Invalid multipart form
    #[error("Invalid multipart form")]
    MultipartForm,
    /// HTTP Client status error
    #[error("HTTP Client status error: [{0}] {1}")]
    HttpClientStatus(u16, String),
    /// HTTP Server status error
    #[error("HTTP Server status error: [{0}] {1}")]
    HttpServerStatus(u16, String),
    /// Unsupported Content-Type
    #[error("Unsupported Content-Type: {0}")]
    UnsupportedContentType(MimeType),
    /// Incompatible Content-Type
    #[error("Incompatible Content-Type: perfer {0}, actual {1}")]
    IncompatibleContentType(MimeType, MimeType),
    /// Decode response error
    /// - 0: value of content-type
    /// - 1: message
    #[error("Decode response error: {0} => {1}")]
    DecodeResponse(MimeType, String),
    /// Decode json error
    #[error("Decode json error: {0}")]
    DecodeJson(#[from] serde_json::Error),
    /// Decode xml error
    #[error("Decode xml error: {0}")]
    DecodeXml(#[from] quick_xml::DeError),
    /// Decode text error
    #[error("Decode text error")]
    DecodeText,
    /// Illegal json
    #[error("Illegal json: {0}")]
    IllegalJson(Value),
    /// Service error
    #[error("Service error: {0} - {1:?}")]
    ServiceError(i32, Option<String>),
    /// Other error
    #[error("Other error: {0}")]
    Other(String),
}

impl ApiError {
    pub fn new(code: i32, message: impl ToString) -> Self {
        Self::ServiceError(code, Some(message.to_string()))
    }
}

impl From<reqwest::Error> for ApiError {
    fn from(e: reqwest::Error) -> Self {
        if e.is_status() {
            let status = e.status().unwrap_or_default();
            if status.is_client_error() {
                ApiError::HttpClientStatus(status.as_u16(), status.to_string())
            } else {
                ApiError::HttpServerStatus(status.as_u16(), status.to_string())
            }
        } else {
            ApiError::Reqwest(e)
        }
    }
}

impl From<MiddlewareError> for ApiError {
    fn from(e: MiddlewareError) -> Self {
        match e {
            MiddlewareError::Reqwest(e) => Self::Reqwest(e),
            MiddlewareError::Middleware(e) => Self::Middleware(e),
        }
    }
}

/// An alias of Result<T, ApiError
pub type ApiResult<T> = Result<T, ApiError>;