feat: MSRV 1.85, Edition 2024, Remove async-trait

Author: cmackenzie1

Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "axum-jwt-auth"
 version = "0.6.0"
-edition = "2021"
+edition = "2024"
+rust-version = "1.85"
 authors = ["Cole MacKenzie"]
 description = "A simple JWT authentication middleware for Axum"
 license = "MIT"
 repository = "https://github.com/cmackenzie1/axum-jwt-auth"
 
 [dependencies]
-async-trait = "0.1"
 axum = { version = "0.8", features = ["macros"] }
 axum-extra = { version = "0.12", features = ["typed-header", "cookie"] }
 dashmap = "6.1.0"

examples/cloudflare/cloudflare.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use axum::{
+    Json, Router,
     extract::FromRef,
     response::{IntoResponse, Response},
     routing::get,
-    Json, Router,
 };
 use axum_jwt_auth::{
-    define_cookie_extractor, define_header_extractor, Claims, CookieTokenExtractor,
-    HeaderTokenExtractor, JwtDecoderState, RemoteJwksDecoder,
+    Claims, CookieTokenExtractor, HeaderTokenExtractor, JwtDecoderState, RemoteJwksDecoder,
+    define_cookie_extractor, define_header_extractor,
 };
 use jsonwebtoken::{Algorithm, Validation};
 use serde::{Deserialize, Serialize};

examples/local/local.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use axum::{
+    Json, Router,
     extract::{FromRef, State},
     response::{IntoResponse, Response},
     routing::{get, post},
-    Json, Router,
 };
 use axum_jwt_auth::{Claims, JwtDecoderState, LocalDecoder};
 use chrono::{Duration, Utc};
-use jsonwebtoken::{encode, Algorithm, DecodingKey, EncodingKey, Header, Validation};
+use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation, encode};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize, Clone)]

examples/remote/remote.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
-use axum::{extract::FromRef, routing::get, Json, Router};
+use axum::{Json, Router, extract::FromRef, routing::get};
 use axum_jwt_auth::{Claims, JwtDecoderState, RemoteJwksDecoder};
 use jsonwebtoken::{Algorithm, EncodingKey, Header, Validation};
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
+use serde_json::{Value, json};
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 struct CustomClaims {

src/axum.rs

@@ -1,14 +1,13 @@
 use std::marker::PhantomData;
 
-use async_trait::async_trait;
+use axum::RequestPartsExt;
 use axum::extract::FromRef;
-use axum::http::{header::HeaderName, StatusCode};
+use axum::http::{StatusCode, header::HeaderName};
 use axum::response::Response;
-use axum::RequestPartsExt;
 use axum::{http::request::Parts, response::IntoResponse};
+use axum_extra::TypedHeader;
 use axum_extra::headers::authorization::Bearer;
 use axum_extra::headers::{Authorization, Cookie};
-use axum_extra::TypedHeader;
 use jsonwebtoken::errors::ErrorKind;
 use serde::de::DeserializeOwned;
 
@@ -50,20 +49,20 @@ pub struct Claims<T, E = BearerTokenExtractor> {
 ///
 /// Implement this trait to define custom token extraction strategies.
 /// The library provides implementations for common sources via the extractor macros.
-#[async_trait]
-pub trait TokenExtractor {
+pub trait TokenExtractor: Send + Sync {
     /// Extracts a JWT token string from the request parts.
     ///
     /// Returns `AuthError::MissingToken` if the token cannot be found or extracted.
-    async fn extract_token(parts: &mut Parts) -> Result<String, AuthError>;
+    fn extract_token(
+        parts: &mut Parts,
+    ) -> impl std::future::Future<Output = Result<String, AuthError>> + Send;
 }
 
 /// Extracts JWT tokens from the `Authorization: Bearer <token>` header.
 ///
 /// This is the default extractor used by `Claims<T>` when no extractor is specified.
 pub struct BearerTokenExtractor;
 
-#[async_trait]
 impl TokenExtractor for BearerTokenExtractor {
     async fn extract_token(parts: &mut Parts) -> Result<String, AuthError> {
         let auth: TypedHeader<Authorization<Bearer>> =
@@ -77,7 +76,7 @@ impl TokenExtractor for BearerTokenExtractor {
 ///
 /// Implement this trait to specify custom header names or cookie names
 /// Typically used with the `define_*_extractor!` macros rather than implemented manually.
-pub trait ExtractorConfig {
+pub trait ExtractorConfig: Send + Sync {
     /// Returns the header name or cookie name to extract from.
     fn value() -> &'static str;
 }
@@ -147,7 +146,6 @@ macro_rules! define_cookie_extractor {
 /// ```
 pub struct HeaderTokenExtractor<C: ExtractorConfig>(PhantomData<C>);
 
-#[async_trait]
 impl<C: ExtractorConfig> TokenExtractor for HeaderTokenExtractor<C> {
     async fn extract_token(parts: &mut Parts) -> Result<String, AuthError> {
         let header_name = HeaderName::from_static(C::value());
@@ -176,7 +174,6 @@ impl<C: ExtractorConfig> TokenExtractor for HeaderTokenExtractor<C> {
 /// ```
 pub struct CookieTokenExtractor<C: ExtractorConfig>(PhantomData<C>);
 
-#[async_trait]
 impl<C: ExtractorConfig> TokenExtractor for CookieTokenExtractor<C> {
     async fn extract_token(parts: &mut Parts) -> Result<String, AuthError> {
         let cookies: TypedHeader<Cookie> =

src/lib.rs

@@ -60,9 +60,10 @@ mod axum;
 mod local;
 mod remote;
 
+use std::future::Future;
+use std::pin::Pin;
 use std::sync::Arc;
 
-use async_trait::async_trait;
 use jsonwebtoken::TokenData;
 use serde::de::DeserializeOwned;
 use thiserror::Error;
@@ -110,8 +111,7 @@ pub enum Error {
 ///
 /// Implemented by [`LocalDecoder`] and [`RemoteJwksDecoder`] to provide
 /// a unified interface for JWT validation with different key sources.
-#[async_trait]
-pub trait JwtDecoder<T>
+pub trait JwtDecoder<T>: Send + Sync
 where
     T: for<'de> DeserializeOwned,
 {
@@ -121,7 +121,10 @@ where
     ///
     /// Returns an error if the token is invalid, expired, has an invalid signature,
     /// or if the key cannot be found (for remote decoders).
-    async fn decode(&self, token: &str) -> Result<TokenData<T>, Error>;
+    fn decode<'a>(
+        &'a self,
+        token: &'a str,
+    ) -> Pin<Box<dyn Future<Output = Result<TokenData<T>, Error>> + Send + 'a>>;
 }
 
 /// Type alias for a thread-safe, trait-object decoder suitable for Axum state.

src/local.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use jsonwebtoken::{DecodingKey, TokenData, Validation};
 use serde::de::DeserializeOwned;
 
@@ -105,25 +104,30 @@ impl LocalDecoderBuilder {
     }
 }
 
-#[async_trait]
 impl<T> JwtDecoder<T> for LocalDecoder
 where
     T: for<'de> DeserializeOwned,
 {
-    async fn decode(&self, token: &str) -> Result<TokenData<T>, Error> {
-        // Try to decode the token with each key in the cache
-        // If none of them work, return the error from the last one
-        let mut last_error: Option<Error> = None;
-        for key in self.keys.iter() {
-            match jsonwebtoken::decode::<T>(token, key, &self.validation) {
-                Ok(token_data) => return Ok(token_data),
-                Err(e) => {
-                    tracing::error!("Error decoding token: {}", e);
-                    last_error = Some(Error::Jwt(e));
+    fn decode<'a>(
+        &'a self,
+        token: &'a str,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<TokenData<T>, Error>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            // Try to decode the token with each key in the cache
+            // If none of them work, return the error from the last one
+            let mut last_error: Option<Error> = None;
+            for key in self.keys.iter() {
+                match jsonwebtoken::decode::<T>(token, key, &self.validation) {
+                    Ok(token_data) => return Ok(token_data),
+                    Err(e) => {
+                        tracing::error!("Error decoding token: {}", e);
+                        last_error = Some(Error::Jwt(e));
+                    }
                 }
             }
-        }
 
-        Err(last_error.unwrap_or_else(|| Error::Configuration("No keys available".into())))
+            Err(last_error.unwrap_or_else(|| Error::Configuration("No keys available".into())))
+        })
     }
 }

src/remote.rs

@@ -1,8 +1,7 @@
 use std::sync::Arc;
 
-use async_trait::async_trait;
 use dashmap::DashMap;
-use jsonwebtoken::{jwk::JwkSet, DecodingKey, TokenData, Validation};
+use jsonwebtoken::{DecodingKey, TokenData, Validation, jwk::JwkSet};
 use serde::de::DeserializeOwned;
 use tokio::sync::Notify;
 
@@ -340,26 +339,33 @@ impl Default for RemoteJwksDecoderBuilder {
     }
 }
 
-#[async_trait]
 impl<T> JwtDecoder<T> for RemoteJwksDecoder
 where
     T: for<'de> DeserializeOwned,
 {
-    async fn decode(&self, token: &str) -> Result<TokenData<T>, Error> {
-        self.ensure_initialized().await;
-        let header = jsonwebtoken::decode_header(token)?;
-        let target_kid = header.kid;
-
-        if let Some(ref kid) = target_kid {
-            if let Some(key) = self.keys_cache.get(kid) {
-                return Ok(jsonwebtoken::decode::<T>(
-                    token,
-                    key.value(),
-                    &self.validation,
-                )?);
+    fn decode<'a>(
+        &'a self,
+        token: &'a str,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<TokenData<T>, Error>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            self.ensure_initialized().await;
+            let header = jsonwebtoken::decode_header(token)?;
+            let target_kid = header.kid;
+
+            if let Some(ref kid) = target_kid {
+                if let Some(key) = self.keys_cache.get(kid) {
+                    Ok(jsonwebtoken::decode::<T>(
+                        token,
+                        key.value(),
+                        &self.validation,
+                    )?)
+                } else {
+                    Err(Error::KeyNotFound(Some(kid.clone())))
+                }
+            } else {
+                Err(Error::KeyNotFound(None))
             }
-            return Err(Error::KeyNotFound(Some(kid.clone())));
-        }
-        return Err(Error::KeyNotFound(None));
+        })
     }
 }

tests/integration_test.rs

@@ -1,18 +1,18 @@
 use std::sync::Arc;
 
 use axum::{
+    Json, Router,
     extract::FromRef,
     response::IntoResponse,
     routing::{get, post},
-    Json, Router,
 };
 
 use axum_jwt_auth::{
     Claims, Decoder, JwtDecoder, JwtDecoderState, LocalDecoder, RemoteJwksDecoder,
     RemoteJwksDecoderConfig,
 };
 use chrono::{Duration, Utc};
-use jsonwebtoken::{encode, Algorithm, DecodingKey, EncodingKey, Header, TokenData, Validation};
+use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, TokenData, Validation, encode};
 use serde::{Deserialize, Serialize};
 use serde_json::json;