use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum RenamedError {
#[error("Authentication error: {message}")]
Authentication {
message: String,
status_code: u16,
},
#[error("Insufficient credits: {message}")]
InsufficientCredits {
message: String,
status_code: u16,
},
#[error("Rate limit exceeded: {message}")]
RateLimit {
message: String,
status_code: u16,
retry_after: Option<u32>,
},
#[error("Validation error: {message}")]
Validation {
message: String,
status_code: u16,
details: Option<HashMap<String, serde_json::Value>>,
},
#[error("Network error: {message}")]
Network {
message: String,
#[source]
source: Option<reqwest::Error>,
},
#[error("Timeout error: {message}")]
Timeout {
message: String,
},
#[error("Job error: {message}")]
Job {
message: String,
job_id: Option<String>,
},
#[error("API error ({status_code}): {message}")]
Api {
message: String,
status_code: u16,
code: String,
details: Option<HashMap<String, serde_json::Value>>,
},
#[error("File error: {message}")]
File {
message: String,
#[source]
source: Option<std::io::Error>,
},
#[error("Serialization error: {message}")]
Serialization {
message: String,
#[source]
source: Option<serde_json::Error>,
},
}
#[derive(Debug, Deserialize, Serialize)]
pub(crate) struct ApiErrorResponse {
pub error: Option<String>,
#[serde(rename = "retryAfter")]
pub retry_after: Option<u32>,
#[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
impl RenamedError {
pub(crate) fn from_http_status(status: u16, body: Option<&str>) -> Self {
let error_response: Option<ApiErrorResponse> =
body.and_then(|b| serde_json::from_str(b).ok());
let message = error_response
.as_ref()
.and_then(|r| r.error.clone())
.unwrap_or_else(|| format!("HTTP {}", status));
let details = error_response
.as_ref()
.map(|r| r.extra.clone())
.filter(|d| !d.is_empty());
match status {
401 => RenamedError::Authentication {
message,
status_code: status,
},
402 => RenamedError::InsufficientCredits {
message,
status_code: status,
},
400 | 422 => RenamedError::Validation {
message,
status_code: status,
details,
},
429 => RenamedError::RateLimit {
message,
status_code: status,
retry_after: error_response.and_then(|r| r.retry_after),
},
_ => RenamedError::Api {
message,
status_code: status,
code: "API_ERROR".to_string(),
details,
},
}
}
pub(crate) fn from_reqwest(err: reqwest::Error) -> Self {
if err.is_timeout() {
RenamedError::Timeout {
message: "Request timed out".to_string(),
}
} else if err.is_connect() {
RenamedError::Network {
message: "Connection failed".to_string(),
source: Some(err),
}
} else {
RenamedError::Network {
message: err.to_string(),
source: Some(err),
}
}
}
pub(crate) fn job_error(message: impl Into<String>, job_id: Option<String>) -> Self {
RenamedError::Job {
message: message.into(),
job_id,
}
}
pub(crate) fn from_io(err: std::io::Error, context: impl Into<String>) -> Self {
RenamedError::File {
message: context.into(),
source: Some(err),
}
}
pub(crate) fn from_serde(err: serde_json::Error) -> Self {
RenamedError::Serialization {
message: err.to_string(),
source: Some(err),
}
}
}
pub type Result<T> = std::result::Result<T, RenamedError>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_error_from_401() {
let err = RenamedError::from_http_status(401, Some(r#"{"error": "Invalid API key"}"#));
assert!(matches!(err, RenamedError::Authentication { .. }));
}
#[test]
fn test_error_from_402() {
let err = RenamedError::from_http_status(402, Some(r#"{"error": "No credits"}"#));
assert!(matches!(err, RenamedError::InsufficientCredits { .. }));
}
#[test]
fn test_error_from_429() {
let err = RenamedError::from_http_status(
429,
Some(r#"{"error": "Slow down", "retryAfter": 30}"#),
);
if let RenamedError::RateLimit { retry_after, .. } = err {
assert_eq!(retry_after, Some(30));
} else {
panic!("Expected RateLimit error");
}
}
}