use crate::AxiamError;
use crate::Sensitive;
use crate::token::manager::TokenManager;
pub struct RefreshedTokens {
pub access: Sensitive<String>,
pub refresh: Option<Sensitive<String>>,
pub exp: Option<i64>,
pub tenant_id: Option<uuid::Uuid>,
}
impl TokenManager {
pub async fn refresh_if_needed<F, Fut>(
&self,
observed_access_token: &str,
do_refresh: F,
) -> Result<Sensitive<String>, AxiamError>
where
F: FnOnce(String) -> Fut,
Fut: std::future::Future<Output = Result<RefreshedTokens, AxiamError>>,
{
let state = self.state_handle();
let fast_cache = self.fast_cache_handle();
let mut guard = state.lock().await;
if let Some(current) = &guard.access
&& current.expose() != observed_access_token
{
return Ok(current.clone_inner());
}
let refresh_token = guard
.refresh
.as_ref()
.ok_or_else(|| AxiamError::Auth {
message: "no refresh token available; re-authentication required".into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
})?
.expose()
.clone();
let new_tokens = do_refresh(refresh_token).await?;
guard.access = Some(new_tokens.access.clone_inner());
if new_tokens.refresh.is_some() {
guard.refresh = new_tokens.refresh;
}
if new_tokens.exp.is_some() {
guard.exp = new_tokens.exp;
}
if new_tokens.tenant_id.is_some() {
guard.tenant_id = new_tokens.tenant_id;
}
if let Ok(mut cache) = fast_cache.write() {
*cache = Some(new_tokens.access.clone_inner());
}
Ok(new_tokens.access)
}
}