Enum ApiError 

#[non_exhaustive]
pub enum ApiError<E: Error = NoDomainError> {
    Http(Error),
    HttpBuild(HttpError),
    Json(Error),
    Api {
        status: u16,
        message: String,
    },
    RateLimited {
        retry_after: Option<u64>,
    },
    ServerError {
        status: u16,
        message: String,
    },
    Url(ParseError),
    Domain(E),
}

Generic API error type with support for domain-specific errors

This error type covers the common error cases across all API clients:

• HTTP transport errors
• JSON parsing errors
• API response errors (4xx)
• Rate limiting (429)
• Server errors (5xx)

Domain-specific errors can be added via the generic parameter E. Use ApiError (without a type parameter) when no domain-specific errors are needed.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Http(Error)

HTTP request error

HttpBuild(HttpError)

HTTP client build error

Json(Error)

JSON parsing error

Api

API returned an error response (4xx, excluding 429)

Fields

status: u16

HTTP status code

message: String

Error message from API

RateLimited

Rate limit exceeded (429)

Fields

retry_after: Option<u64>

Seconds to wait before retrying

ServerError

Server error (5xx)

Fields

status: u16

HTTP status code

message: String

Error message

Url(ParseError)

URL parsing error

Domain(E)

Domain-specific error

Implementations

impl<E: Error> ApiError<E>

pub fn api(status: u16, message: impl Into<String>) -> Self

Create an API error

pub fn rate_limited(retry_after: Option<u64>) -> Self

Create a rate limited error

pub fn server_error(status: u16, message: impl Into<String>) -> Self

Create a server error

pub fn domain(error: E) -> Self

Create a domain-specific error

pub fn from_response(status: u16, body: &str, retry_after: Option<u64>) -> Self

Create from HTTP response status and body

Automatically categorizes the error based on status code:

• 429 -> RateLimited
• 500-599 -> ServerError
• Other -> Api

Note: The body is sanitized to remove potential secrets and truncated if too long (SEC-005 fix).

pub fn is_retryable(&self) -> bool

Check if this error is retryable

Returns true for:

• Rate limited errors
• Server errors (5xx)
• HTTP transport errors

pub fn retry_after(&self) -> Option<Duration>

Get retry-after duration if available

pub fn status_code(&self) -> Option<u16>

Get the HTTP status code if this is an API or server error

Trait Implementations

impl<E: Debug + Error> Debug for ApiError<E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E> Display for ApiError<E>

where E: Display + Error,

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E> Error for ApiError<E>

where E: Error + Error, Self: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<E: Error> From<Error> for ApiError<E>

fn from(source: Error) -> Self

Converts to this type from the input type.

impl<E: Error> From<Error> for ApiError<E>

fn from(source: Error) -> Self

Converts to this type from the input type.

impl<E: Error> From<HttpError> for ApiError<E>

fn from(e: HttpError) -> Self

Converts to this type from the input type.

impl<E: Error> From<ParseError> for ApiError<E>

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl<E: Error> RetryableError for ApiError<E>

fn is_retryable(&self) -> bool

Returns true if the error is transient and the operation should be retried

fn retry_after(&self) -> Option<Duration>

Returns the retry-after duration if specified by the error