Struct ApiError 

#[non_exhaustive]
pub struct ApiError {
    pub status: u16,
    pub code: Option<i64>,
    pub message: String,
    pub body: String,
    pub path: String,
}

A non-success HTTP response from Alpaca.

Every field is public to read. Building one goes through from_body, which is also how the transport builds the ones a caller receives.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

status: u16

The HTTP status code.

code: Option<i64>

Alpaca’s numeric error code, when the body was JSON carrying one.

message: String

The human-readable message, falling back to the raw body.

body: String

The unparsed response body.

path: String

The request path that produced this error.

Implementations

impl ApiError

pub fn from_body( status: u16, path: impl Into<String>, body: impl Into<String>, ) -> Self

Builds an ApiError from a status, a path, and the raw response body.

This is the only way to construct one, here and in a caller’s own code: the struct is #[non_exhaustive], so a field-by-field literal is not available outside the crate. That is deliberate rather than an oversight — code and message are read out of body, and a constructor taking all three separately would let a caller build an error whose fields contradict each other, which is a state no response can produce.

It is public so a caller can build one to test their own error handling against, and what they get behaves exactly like a real failure — the same parse, including the degradation below:

use alpaca_sdk::ApiError;

let error = ApiError::from_body(
    403,
    "/v2/orders",
    r#"{"code":40310000,"message":"insufficient buying power"}"#,
);

assert_eq!(error.code, Some(40_310_000));
assert_eq!(error.message, "insufficient buying power");
assert!(!error.is_retried_by_default());

A body that is not the JSON object Alpaca normally sends — a gateway’s HTML, say — leaves code as None and becomes the message verbatim, rather than failing. An error type that errors while reporting an error is the worst place to be strict.

let error = ApiError::from_body(502, "/v2/account", "<html>bad gateway</html>");

assert_eq!(error.code, None);
assert_eq!(error.message, "<html>bad gateway</html>");

pub fn is_retried_by_default(&self) -> bool

Whether this status is in the crate’s default retry set.

The default set, not the policy the client that produced this error was built with — an ApiError does not carry one. A client configured with RetryConfig::status_codes([500, 502]) gets false here for the 500 it actually retried, and true for the 429 it did not. The name says “by default” so that gap is visible at the call site rather than surprising.

Trait Implementations

impl Clone for ApiError

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ApiError

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

Formats the value using the given formatter.

impl Display for ApiError

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

Formats the value using the given formatter.

impl Eq for ApiError

impl Error for ApiError

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 From<ApiError> for Error

fn from(source: ApiError) -> Self

Converts to this type from the input type.

impl PartialEq for ApiError

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ApiError