use super::audit::{AuthAuditEvent, AuthAuditHook, TracingAuditHook};
use super::dto::{RefreshInput, TokenPairClaims, TokenPairResponse};
use crate::action::{ActionContext, TypedHandler};
use crate::error::BaseError;
use crate::token::TokenClaims;
use async_trait::async_trait;
use yang_base_derive::Action;
#[async_trait]
pub trait RefreshClaimsResolver: Send + Sync + 'static {
async fn resolve(&self, ctx: &ActionContext, sub: &str)
-> Result<serde_json::Value, BaseError>;
async fn resolve_pair(
&self,
ctx: &ActionContext,
sub: &str,
) -> Result<TokenPairClaims, BaseError> {
Ok(TokenPairClaims::new(self.resolve(ctx, sub).await?))
}
async fn resolve_pair_from_claims(
&self,
ctx: &ActionContext,
claims: &TokenClaims,
) -> Result<TokenPairClaims, BaseError> {
self.resolve_pair(ctx, &claims.sub).await
}
}
#[derive(Debug, Clone, Default)]
pub struct DefaultRefreshClaims;
#[async_trait]
impl RefreshClaimsResolver for DefaultRefreshClaims {
async fn resolve(
&self,
_ctx: &ActionContext,
_sub: &str,
) -> Result<serde_json::Value, BaseError> {
Ok(serde_json::Value::Null)
}
}
#[derive(Action, Default)]
#[action(
name = "refresh",
display_name = "刷新 Token",
description = "用 Refresh Token 换取新的 Access Token",
public
)]
pub struct RefreshAction<
R: RefreshClaimsResolver = DefaultRefreshClaims,
A: AuthAuditHook = TracingAuditHook,
> {
resolver: R,
audit: A,
}
impl<R: RefreshClaimsResolver> RefreshAction<R, TracingAuditHook> {
pub fn new(resolver: R) -> Self {
Self {
resolver,
audit: TracingAuditHook,
}
}
}
impl<R: RefreshClaimsResolver, A: AuthAuditHook> RefreshAction<R, A> {
pub fn with_audit(resolver: R, audit: A) -> Self {
Self { resolver, audit }
}
}
#[async_trait]
impl<R: RefreshClaimsResolver, A: AuthAuditHook> TypedHandler for RefreshAction<R, A> {
type Input = RefreshInput;
type Output = TokenPairResponse;
async fn handle(
&self,
ctx: ActionContext,
input: RefreshInput,
) -> Result<TokenPairResponse, BaseError> {
let request_id = ctx.request_id.to_string();
let manager = ctx.tools().token()?;
let run = async {
let claims = manager
.verify_token_checked(&input.refresh_token, crate::token::TokenType::Refresh)
.await?;
let custom_claims = self
.resolver
.resolve_pair_from_claims(&ctx, &claims)
.await?;
let (access_token, refresh_token) = manager
.rotate_refresh_token_from_claims_with_refresh_claims(
&claims,
custom_claims.access,
custom_claims.refresh,
)
.await?;
Ok::<_, BaseError>((access_token, refresh_token, claims.sub))
};
match run.await {
Ok((access_token, refresh_token, sub)) => {
self.audit
.on_success(AuthAuditEvent {
request_id,
action: "refresh",
subject: Some(sub),
error_code: None,
})
.await;
Ok(TokenPairResponse {
access_token,
refresh_token,
})
}
Err(e) => {
self.audit
.on_failure(AuthAuditEvent {
request_id,
action: "refresh",
subject: None,
error_code: Some(e.code_str()),
})
.await;
Err(e)
}
}
}
}