use std::error::Error as StdError;
use std::fmt;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum AuthzKind {
#[default]
Denied,
NotFound,
Conflict,
}
#[derive(thiserror::Error, Debug)]
pub enum AxiamError {
#[error("authentication failed: {message}")]
#[non_exhaustive]
Auth {
message: String,
oauth: Option<OAuthProtocolError>,
reason: Option<IdTokenFailureReason>,
set_reason: Option<SetFailureReason>,
retry_after: Option<std::time::Duration>,
},
#[error("authorization denied: {message}")]
#[non_exhaustive]
Authz {
kind: AuthzKind,
message: String,
action: Option<String>,
resource_id: Option<String>,
reason_code: Option<Box<str>>,
},
#[error("network error: {message}")]
#[non_exhaustive]
Network {
message: String,
#[source]
source: Option<Box<dyn StdError + Send + Sync>>,
},
}
impl AxiamError {
pub fn auth(message: impl Into<String>) -> AxiamError {
AxiamError::Auth {
message: message.into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
}
}
pub fn authz(
message: impl Into<String>,
action: Option<String>,
resource_id: Option<String>,
) -> AxiamError {
AxiamError::authz_kind(AuthzKind::Denied, message, action, resource_id)
}
pub fn authz_kind(
kind: AuthzKind,
message: impl Into<String>,
action: Option<String>,
resource_id: Option<String>,
) -> AxiamError {
AxiamError::Authz {
kind,
message: message.into(),
action,
resource_id,
reason_code: None,
}
}
pub fn network(message: impl Into<String>) -> AxiamError {
AxiamError::Network {
message: message.into(),
source: None,
}
}
pub fn network_with_source(
message: impl Into<String>,
source: Box<dyn StdError + Send + Sync>,
) -> AxiamError {
AxiamError::Network {
message: message.into(),
source: Some(source),
}
}
pub fn from_http_status(status: u16, message: impl Into<String>) -> AxiamError {
let message = message.into();
match status {
401 => AxiamError::Auth {
message,
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
},
403 | 409 => {
let (action, resource_id, reason_code) = parse_authz_body_fields(&message);
AxiamError::Authz {
kind: if status == 409 {
AuthzKind::Conflict
} else {
AuthzKind::Denied
},
message,
action,
resource_id,
reason_code: if status == 409 {
reason_code.map(String::into_boxed_str)
} else {
None
},
}
}
_ => AxiamError::Network {
message,
source: None,
},
}
}
pub fn from_grpc_code(code: i32, message: impl Into<String>) -> AxiamError {
let message = message.into();
match code {
16 => AxiamError::Auth {
message,
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
},
7 => AxiamError::Authz {
kind: AuthzKind::Denied,
message,
action: None,
resource_id: None,
reason_code: None,
},
_ => AxiamError::Network {
message,
source: None,
},
}
}
}
impl AxiamError {
pub fn oauth_error_code(&self) -> Option<&str> {
match self {
AxiamError::Auth { oauth, .. } => oauth.as_ref().map(|o| o.error.as_str()),
_ => None,
}
}
pub fn retry_after(&self) -> Option<std::time::Duration> {
match self {
AxiamError::Auth { retry_after, .. } => *retry_after,
_ => None,
}
}
pub fn is_retryable_transport(&self) -> bool {
matches!(self, AxiamError::Network { .. })
}
pub fn oauth_protocol_error(
error: impl Into<String>,
error_description: impl Into<String>,
) -> AxiamError {
let error = error.into();
let error_description = error_description.into();
let message = format!("{error}: {error_description}");
AxiamError::Auth {
message,
oauth: Some(OAuthProtocolError {
error,
error_description,
}),
reason: None,
set_reason: None,
retry_after: None,
}
}
pub fn id_token_invalid(reason: IdTokenFailureReason, detail: impl fmt::Display) -> AxiamError {
AxiamError::Auth {
message: format!("id_token validation failed ({reason}): {detail}"),
oauth: None,
reason: Some(reason),
set_reason: None,
retry_after: None,
}
}
pub fn as_oauth_protocol_error(&self) -> Option<&OAuthProtocolError> {
match self {
AxiamError::Auth {
oauth: Some(oauth), ..
} => Some(oauth),
_ => None,
}
}
pub fn id_token_failure_reason(&self) -> Option<IdTokenFailureReason> {
match self {
AxiamError::Auth { reason, .. } => *reason,
_ => None,
}
}
#[cfg_attr(not(feature = "rest"), allow(dead_code))]
pub(crate) fn clone_for_waiter(&self) -> AxiamError {
match self {
AxiamError::Auth {
message,
oauth,
reason,
set_reason,
retry_after,
} => AxiamError::Auth {
message: message.clone(),
oauth: oauth.clone(),
reason: *reason,
set_reason: *set_reason,
retry_after: *retry_after,
},
AxiamError::Authz {
kind,
message,
action,
resource_id,
reason_code,
} => AxiamError::Authz {
kind: *kind,
message: message.clone(),
action: action.clone(),
resource_id: resource_id.clone(),
reason_code: reason_code.clone(),
},
AxiamError::Network { message, .. } => AxiamError::Network {
message: message.clone(),
source: None,
},
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OAuthProtocolError {
pub error: String,
pub error_description: String,
}
impl fmt::Display for OAuthProtocolError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}: {}", self.error, self.error_description)
}
}
impl StdError for OAuthProtocolError {}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum IdTokenFailureReason {
InvalidAlg,
UnknownKid,
InvalidSignature,
InvalidIssuer,
InvalidAudience,
TokenExpired,
NonceMismatch,
}
impl IdTokenFailureReason {
pub fn as_str(self) -> &'static str {
match self {
IdTokenFailureReason::InvalidAlg => "invalid_alg",
IdTokenFailureReason::UnknownKid => "unknown_kid",
IdTokenFailureReason::InvalidSignature => "invalid_signature",
IdTokenFailureReason::InvalidIssuer => "invalid_issuer",
IdTokenFailureReason::InvalidAudience => "invalid_audience",
IdTokenFailureReason::TokenExpired => "token_expired",
IdTokenFailureReason::NonceMismatch => "nonce_mismatch",
}
}
}
impl fmt::Display for IdTokenFailureReason {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
fn parse_authz_body_fields(body: &str) -> (Option<String>, Option<String>, Option<String>) {
#[derive(serde::Deserialize)]
struct AuthzErrorBody {
#[serde(default)]
action: Option<String>,
#[serde(default)]
resource_id: Option<String>,
#[serde(default)]
reason_code: Option<serde_json::Value>,
}
match serde_json::from_str::<AuthzErrorBody>(body) {
Ok(parsed) => (
parsed.action,
parsed.resource_id,
parsed
.reason_code
.and_then(|v| v.as_str().map(str::to_string)),
),
Err(_) => (None, None, None),
}
}
#[allow(dead_code)]
fn _assert_no_token_in_display<T: fmt::Display>(_: &T) {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn assert_no_token_in_display_accepts_any_display_error_variant() {
let auth = AxiamError::auth("msg");
_assert_no_token_in_display(&auth);
}
#[test]
fn public_constructors_build_the_documented_variants() {
assert!(matches!(AxiamError::auth("a"), AxiamError::Auth { .. }));
assert!(matches!(
AxiamError::authz("b", Some("users:get".into()), None),
AxiamError::Authz {
action: Some(_),
resource_id: None,
..
}
));
assert!(matches!(
AxiamError::network("c"),
AxiamError::Network { source: None, .. }
));
let chained = AxiamError::network_with_source("d", Box::new(std::fmt::Error));
assert!(StdError::source(&chained).is_some());
}
#[test]
fn clone_for_waiter_preserves_variant_oauth_payload_and_reason() {
let oauth = AxiamError::oauth_protocol_error("invalid_grant", "refresh token revoked");
let cloned = oauth.clone_for_waiter();
assert!(matches!(cloned, AxiamError::Auth { .. }));
assert_eq!(
cloned.as_oauth_protocol_error().map(|o| o.error.as_str()),
Some("invalid_grant")
);
assert_eq!(
cloned
.as_oauth_protocol_error()
.map(|o| o.error_description.as_str()),
Some("refresh token revoked")
);
assert_eq!(cloned.to_string(), oauth.to_string());
let id_token = AxiamError::id_token_invalid(IdTokenFailureReason::NonceMismatch, "nope");
let cloned = id_token.clone_for_waiter();
assert_eq!(
cloned.id_token_failure_reason(),
Some(IdTokenFailureReason::NonceMismatch)
);
assert_eq!(cloned.to_string(), id_token.to_string());
}
#[test]
fn clone_for_waiter_keeps_authz_fields_and_drops_only_the_network_source() {
let authz = AxiamError::from_http_status(
403,
r#"{"action":"users:get","resource_id":"r-1"}"#.to_string(),
);
let cloned = authz.clone_for_waiter();
match cloned {
AxiamError::Authz {
ref action,
ref resource_id,
..
} => {
assert_eq!(action.as_deref(), Some("users:get"));
assert_eq!(resource_id.as_deref(), Some("r-1"));
}
other => panic!("expected Authz, got {other:?}"),
}
let network = AxiamError::network_with_source("boom", Box::new(std::fmt::Error));
let cloned = network.clone_for_waiter();
assert!(matches!(cloned, AxiamError::Network { source: None, .. }));
assert_eq!(cloned.to_string(), network.to_string());
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum SetFailureReason {
Malformed,
InvalidType,
InvalidKey,
InvalidIssuer,
InvalidAudience,
InvalidRequest,
Replayed,
}
impl SetFailureReason {
pub fn as_str(self) -> &'static str {
match self {
SetFailureReason::Malformed => "malformed",
SetFailureReason::InvalidType => "invalid_type",
SetFailureReason::InvalidKey => "invalid_key",
SetFailureReason::InvalidIssuer => "invalid_issuer",
SetFailureReason::InvalidAudience => "invalid_audience",
SetFailureReason::InvalidRequest => "invalid_request",
SetFailureReason::Replayed => "replayed",
}
}
pub fn push_error_code(self) -> &'static str {
match self {
SetFailureReason::Replayed
| SetFailureReason::Malformed
| SetFailureReason::InvalidType => "invalid_request",
other => other.as_str(),
}
}
}
impl fmt::Display for SetFailureReason {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl AxiamError {
pub fn set_refused(reason: SetFailureReason, detail: impl fmt::Display) -> AxiamError {
AxiamError::Auth {
message: format!("security event token refused ({reason}): {detail}"),
oauth: None,
reason: None,
set_reason: Some(reason),
retry_after: None,
}
}
pub fn set_failure_reason(&self) -> Option<SetFailureReason> {
match self {
AxiamError::Auth { set_reason, .. } => *set_reason,
_ => None,
}
}
}