use crate::action::{ActionContext, ApiResponse, User};
use crate::error::BaseError;
use crate::router::middleware::{Middleware, MiddlewareRole, MiddlewareScope, Next};
use crate::token::TokenClaims;
use async_trait::async_trait;
pub struct TokenAuthMiddleware<F, V = NoopTokenClaimsValidator> {
build_user: F,
claims_validator: V,
authenticate_public_actions: bool,
}
#[async_trait]
pub trait TokenClaimsValidator: Send + Sync + 'static {
async fn validate(
&self,
context: &ActionContext,
claims: &TokenClaims,
) -> Result<(), BaseError>;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct NoopTokenClaimsValidator;
#[async_trait]
impl TokenClaimsValidator for NoopTokenClaimsValidator {
async fn validate(
&self,
_context: &ActionContext,
_claims: &TokenClaims,
) -> Result<(), BaseError> {
Ok(())
}
}
#[doc(hidden)]
pub trait IntoUserProjection {
fn into_user_projection(self) -> Result<User, BaseError>;
}
impl IntoUserProjection for User {
fn into_user_projection(self) -> Result<User, BaseError> {
Ok(self)
}
}
impl IntoUserProjection for Result<User, BaseError> {
fn into_user_projection(self) -> Result<User, BaseError> {
self
}
}
impl<F, R> TokenAuthMiddleware<F, NoopTokenClaimsValidator>
where
F: Fn(&TokenClaims) -> R + Send + Sync + 'static,
R: IntoUserProjection,
{
pub fn new(build_user: F) -> Self {
Self {
build_user,
claims_validator: NoopTokenClaimsValidator,
authenticate_public_actions: false,
}
}
}
impl<F, V> TokenAuthMiddleware<F, V> {
pub fn with_claims_validator<N>(self, claims_validator: N) -> TokenAuthMiddleware<F, N>
where
N: TokenClaimsValidator,
{
TokenAuthMiddleware {
build_user: self.build_user,
claims_validator,
authenticate_public_actions: self.authenticate_public_actions,
}
}
pub fn authenticate_public_actions(mut self) -> Self {
self.authenticate_public_actions = true;
self
}
}
#[async_trait]
impl<F, R, V> Middleware for TokenAuthMiddleware<F, V>
where
F: Fn(&TokenClaims) -> R + Send + Sync + 'static,
R: IntoUserProjection + Send + Sync + 'static,
V: TokenClaimsValidator,
{
fn role(&self) -> MiddlewareRole {
MiddlewareRole::Authentication
}
fn scope(&self) -> MiddlewareScope {
if self.authenticate_public_actions {
MiddlewareScope::AllActions
} else {
MiddlewareScope::ProtectedActions
}
}
async fn handle(
&self,
mut ctx: ActionContext,
next: Next<'_>,
) -> Result<ApiResponse, BaseError> {
let token = match ctx.request.token() {
Some(t) => t.to_string(),
None if self.authenticate_public_actions
&& next.policy.is_public
&& ctx.request.get_header("authorization").is_none() =>
{
return next.run(ctx).await;
}
None => {
return Err(BaseError::Unauthorized(
"缺少 Authorization Bearer Token".to_string(),
))
}
};
let claims = ctx
.tools()
.token()?
.verify_token_checked(&token, crate::token::TokenType::Access)
.await?;
self.claims_validator.validate(&ctx, &claims).await?;
ctx.user = Some((self.build_user)(&claims).into_user_projection()?);
if let Some(user) = &ctx.user {
tracing::Span::current().record("actor_id", user.id);
}
next.run(ctx).await
}
}