parse-rs 0.2.0

A modern and asynchronous Rust SDK for interacting with Parse Server backends
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use reqwest::header::InvalidHeaderValue;
// src/error.rs
use serde_json::Value;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ParseError {
    #[error("HTTP request failed: {0}")]
    ReqwestError(#[from] reqwest::Error),

    #[error("URL parsing failed: {0}")]
    UrlParseError(#[from] url::ParseError),

    #[error("JSON processing error: {0}")]
    JsonError(#[from] serde_json::Error),

    #[error("JSON deserialization failed: {0}")]
    JsonDeserializationFailed(String),

    #[error("Parse API error (code {code}): {error}")]
    ApiError { code: i32, error: String },

    #[error("Object not found: {0}")]
    ObjectNotFound(String),

    #[error("Invalid input: {0}")]
    InvalidInput(String),

    #[error("Invalid class name: {0}")]
    InvalidClassName(String),

    #[error("Invalid session token: {0}")]
    InvalidSessionToken(String),

    #[error("Session token is missing")]
    SessionTokenMissing,

    #[error("Master key required: {0}")]
    MasterKeyRequired(String),

    #[error("Serialization error: {0}")]
    SerializationError(String),

    #[error("Unexpected response: {0}")]
    UnexpectedResponse(String),

    #[error("Resource not found: {0}")]
    NotFound(String),

    #[error("Unknown error: {0}")]
    Unknown(String),

    #[error("Operation forbidden: {0}")]
    OperationForbidden(String),

    #[error("Other Parse error (Code: {code}): {message}")]
    OtherParseError { code: u16, message: String },

    #[error("SDK error: {0}")]
    SdkError(String),

    #[error("Authentication error: {0}")]
    AuthenticationError(String),

    #[error("Connection failed: {0}")]
    ConnectionFailed(String),

    #[error("Invalid query: {0}")]
    InvalidQuery(String),

    #[error("Duplicate value: {0}")]
    DuplicateValue(String),

    #[error("Username taken: {0}")]
    UsernameTaken(String),

    #[error("Email taken: {0}")]
    EmailTaken(String),

    #[error("Internal server error: {0}")]
    InternalServerError(String),

    #[error("Invalid header value: {0}")]
    InvalidHeaderValue(InvalidHeaderValue),

    #[error("Invalid URL: {0}")]
    InvalidUrl(String),
}

impl ParseError {
    /// Creates a `ParseError` from an HTTP status code and a JSON response body.
    pub(crate) fn from_response(status_code: u16, response_body: Value) -> Self {
        let error_code = response_body
            .get("code")
            .and_then(|v| v.as_u64())
            .unwrap_or(0) as u16;
        let error_message = response_body
            .get("error")
            .and_then(|v| v.as_str())
            .unwrap_or("Unknown error")
            .to_string();

        match error_code {
            100 => ParseError::ConnectionFailed(format!("({}) {}", error_code, error_message)),
            101 => ParseError::ObjectNotFound(format!("({}) {}", error_code, error_message)), // Invalid username/password or object not found
            102 => ParseError::InvalidQuery(format!("({}) {}", error_code, error_message)),
            111 => ParseError::InvalidInput(format!(
                "Invalid field type: ({}) {}",
                error_code, error_message
            )),
            119 => ParseError::OperationForbidden(format!(
                "Missing master key for operation: ({}) {}",
                error_code, error_message
            )),
            137 => ParseError::DuplicateValue(format!("({}) {}", error_code, error_message)),
            202 => ParseError::UsernameTaken(format!("({}) {}", error_code, error_message)),
            203 => ParseError::EmailTaken(format!("({}) {}", error_code, error_message)),
            209 => ParseError::InvalidSessionToken(format!("({}) {}", error_code, error_message)),
            _ => {
                if status_code >= 500 {
                    ParseError::InternalServerError(format!(
                        "Server error (HTTP {}): ({}) {}",
                        status_code, error_code, error_message
                    ))
                } else if status_code == 401 || status_code == 403 {
                    ParseError::AuthenticationError(format!(
                        "Auth error (HTTP {}): ({}) {}",
                        status_code, error_code, error_message
                    ))
                } else if status_code == 404 {
                    ParseError::ObjectNotFound(format!(
                        "Not found (HTTP {}): ({}) {}",
                        status_code, error_code, error_message
                    ))
                } else {
                    ParseError::OtherParseError {
                        code: error_code,
                        message: error_message,
                    }
                }
            }
        }
    }
}