style: apply formatting and clean up imports in authly-flow and examples

Author: marcjazz

authly-flow/src/device_flow.rs

@@ -33,11 +33,7 @@ pub struct DeviceFlow {
 
 impl DeviceFlow {
     /// Creates a new `DeviceFlow` instance.
-    pub fn new(
-        client_id: String,
-        device_authorization_url: String,
-        token_url: String,
-    ) -> Self {
+    pub fn new(client_id: String, device_authorization_url: String, token_url: String) -> Self {
         Self {
             client_id,
             device_authorization_url,
@@ -59,10 +55,7 @@ impl DeviceFlow {
             .http_client
             .post(&self.device_authorization_url)
             .header("Accept", "application/json")
-            .form(&[
-                ("client_id", &self.client_id),
-                ("scope", &scope_param),
-            ])
+            .form(&[("client_id", &self.client_id), ("scope", &scope_param)])
             .send()
             .await
             .map_err(|_| AuthError::Network)?;
@@ -78,7 +71,12 @@ impl DeviceFlow {
         response
             .json::<DeviceAuthorizationResponse>()
             .await
-            .map_err(|e| AuthError::Provider(format!("Failed to parse device authorization response: {}", e)))
+            .map_err(|e| {
+                AuthError::Provider(format!(
+                    "Failed to parse device authorization response: {}",
+                    e
+                ))
+            })
     }
 
     /// Polls the token endpoint until an access token is granted or an error occurs.
@@ -99,25 +97,27 @@ impl DeviceFlow {
                 .form(&[
                     ("client_id", &self.client_id),
                     ("device_code", &device_code.to_string()),
-                    ("grant_type", &"urn:ietf:params:oauth:grant-type:device_code".to_string()),
+                    (
+                        "grant_type",
+                        &"urn:ietf:params:oauth:grant-type:device_code".to_string(),
+                    ),
                 ])
                 .send()
                 .await
                 .map_err(|_| AuthError::Network)?;
 
             let status = response.status();
-            
+
             if status.is_success() {
-                return response
-                    .json::<OAuthToken>()
-                    .await
-                    .map_err(|e| AuthError::Provider(format!("Failed to parse token response: {}", e)));
+                return response.json::<OAuthToken>().await.map_err(|e| {
+                    AuthError::Provider(format!("Failed to parse token response: {}", e))
+                });
             } else {
                 let error_resp: serde_json::Value = response
                     .json()
                     .await
                     .map_err(|_| AuthError::Provider("Failed to parse error response".into()))?;
-                
+
                 let error = error_resp["error"].as_str().unwrap_or("unknown_error");
 
                 match error {
@@ -134,7 +134,10 @@ impl DeviceFlow {
                         return Err(AuthError::Provider("Device code expired".into()));
                     }
                     _ => {
-                        return Err(AuthError::Provider(format!("Token polling failed: {}", error)));
+                        return Err(AuthError::Provider(format!(
+                            "Token polling failed: {}",
+                            error
+                        )));
                     }
                 }
             }

examples/actix_github.rs

@@ -43,7 +43,10 @@ async fn github_callback(
 }
 
 #[get("/auth/logout")]
-async fn github_logout(req: HttpRequest, data: web::Data<AppState>) -> actix_web::Result<impl Responder> {
+async fn github_logout(
+    req: HttpRequest,
+    data: web::Data<AppState>,
+) -> actix_web::Result<impl Responder> {
     logout(
         req,
         data.session_store.clone(),
@@ -55,11 +58,13 @@ async fn github_logout(req: HttpRequest, data: web::Data<AppState>) -> actix_web
 
 #[get("/protected")]
 async fn protected(session: AuthSession) -> impl Responder {
-    let name = session.0.identity
+    let name = session
+        .0
+        .identity
         .username
         .clone()
         .unwrap_or_else(|| "Unknown".to_string());
-    
+
     HttpResponse::Ok().body(format!(
         "Hello, {}! Your ID is {}. You are authenticated via the new AuthSession extractor.",
         name, session.0.identity.external_id
@@ -70,14 +75,16 @@ async fn protected(session: AuthSession) -> impl Responder {
 async fn main() -> std::io::Result<()> {
     dotenvy::dotenv().ok();
 
-    let client_id = std::env::var("AUTHLY_GITHUB_CLIENT_ID").expect("AUTHLY_GITHUB_CLIENT_ID must be set");
-    let client_secret = std::env::var("AUTHLY_GITHUB_CLIENT_SECRET").expect("AUTHLY_GITHUB_CLIENT_SECRET must be set");
+    let client_id =
+        std::env::var("AUTHLY_GITHUB_CLIENT_ID").expect("AUTHLY_GITHUB_CLIENT_ID must be set");
+    let client_secret = std::env::var("AUTHLY_GITHUB_CLIENT_SECRET")
+        .expect("AUTHLY_GITHUB_CLIENT_SECRET must be set");
     let redirect_uri = std::env::var("AUTHLY_GITHUB_REDIRECT_URI")
         .unwrap_or_else(|_| "http://localhost:8080/auth/github/callback".to_string());
 
     let provider = GithubProvider::new(client_id, client_secret, redirect_uri);
     let github_flow = Arc::new(OAuth2Flow::new(provider));
-    
+
     // For this example, we'll use SQLite for session persistence.
     let db_url = "sqlite::memory:";
     let pool = SqlitePool::connect(db_url)

examples/axum_oauth.rs

@@ -146,7 +146,11 @@ async fn github_login(State(state): State<AppState>, cookies: Cookies) -> Respon
     if let Some(flow) = &state.github_flow {
         initiate_oauth_login(flow, &cookies, &["user:email"]).into_response()
     } else {
-        (axum::http::StatusCode::NOT_IMPLEMENTED, "GitHub not configured").into_response()
+        (
+            axum::http::StatusCode::NOT_IMPLEMENTED,
+            "GitHub not configured",
+        )
+            .into_response()
     }
 }
 
@@ -167,7 +171,11 @@ async fn github_callback(
         .await
         .into_response()
     } else {
-        (axum::http::StatusCode::NOT_IMPLEMENTED, "GitHub not configured").into_response()
+        (
+            axum::http::StatusCode::NOT_IMPLEMENTED,
+            "GitHub not configured",
+        )
+            .into_response()
     }
 }
 
@@ -176,7 +184,11 @@ async fn google_login(State(state): State<AppState>, cookies: Cookies) -> Respon
     if let Some(flow) = &state.google_flow {
         initiate_oauth_login(flow, &cookies, &["openid", "email", "profile"]).into_response()
     } else {
-        (axum::http::StatusCode::NOT_IMPLEMENTED, "Google not configured").into_response()
+        (
+            axum::http::StatusCode::NOT_IMPLEMENTED,
+            "Google not configured",
+        )
+            .into_response()
     }
 }
 
@@ -197,7 +209,11 @@ async fn google_callback(
         .await
         .into_response()
     } else {
-        (axum::http::StatusCode::NOT_IMPLEMENTED, "Google not configured").into_response()
+        (
+            axum::http::StatusCode::NOT_IMPLEMENTED,
+            "Google not configured",
+        )
+            .into_response()
     }
 }
 
@@ -206,7 +222,11 @@ async fn discord_login(State(state): State<AppState>, cookies: Cookies) -> Respo
     if let Some(flow) = &state.discord_flow {
         initiate_oauth_login(flow, &cookies, &["identify", "email"]).into_response()
     } else {
-        (axum::http::StatusCode::NOT_IMPLEMENTED, "Discord not configured").into_response()
+        (
+            axum::http::StatusCode::NOT_IMPLEMENTED,
+            "Discord not configured",
+        )
+            .into_response()
     }
 }
 
@@ -227,7 +247,11 @@ async fn discord_callback(
         .await
         .into_response()
     } else {
-        (axum::http::StatusCode::NOT_IMPLEMENTED, "Discord not configured").into_response()
+        (
+            axum::http::StatusCode::NOT_IMPLEMENTED,
+            "Discord not configured",
+        )
+            .into_response()
     }
 }
 

examples/client_credentials_flow.rs

@@ -5,16 +5,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Example using a hypothetical provider
     // In a real scenario, you would use your OAuth2 provider's client credentials credentials
     let client_id = std::env::var("CLIENT_ID").unwrap_or_else(|_| "your_client_id".to_string());
-    let client_secret = std::env::var("CLIENT_SECRET").unwrap_or_else(|_| "your_client_secret".to_string());
-    let token_url = std::env::var("TOKEN_URL").unwrap_or_else(|_| "https://example.com/oauth/token".to_string());
+    let client_secret =
+        std::env::var("CLIENT_SECRET").unwrap_or_else(|_| "your_client_secret".to_string());
+    let token_url = std::env::var("TOKEN_URL")
+        .unwrap_or_else(|_| "https://example.com/oauth/token".to_string());
 
     println!("Starting Client Credentials Flow...");
 
-    let flow = ClientCredentialsFlow::new(
-        client_id,
-        client_secret,
-        token_url,
-    );
+    let flow = ClientCredentialsFlow::new(client_id, client_secret, token_url);
 
     // Request a token with optional scopes
     let scopes = ["read", "write"];

examples/device_flow.rs

@@ -3,7 +3,8 @@ use authly_flow::DeviceFlow;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // GitHub's Device Authorization Flow endpoints
-    let client_id = std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "Iv1.your_client_id".to_string());
+    let client_id =
+        std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "Iv1.your_client_id".to_string());
     let device_auth_url = "https://github.com/login/device/code";
     let token_url = "https://github.com/login/oauth/access_token";
 
@@ -20,17 +21,23 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .initiate_device_authorization(&["user", "repo"])
         .await?;
 
-    println!("\n1. Open your browser and go to: {}", device_resp.verification_uri);
+    println!(
+        "\n1. Open your browser and go to: {}",
+        device_resp.verification_uri
+    );
     println!("2. Enter the code: {}", device_resp.user_code);
-    
+
     if let Some(complete_uri) = &device_resp.verification_uri_complete {
         println!("\nOR just open this URL directly: {}", complete_uri);
     }
 
     println!("\nWaiting for authorization...");
 
     // 2. Poll for the token
-    match flow.poll_for_token(&device_resp.device_code, device_resp.interval).await {
+    match flow
+        .poll_for_token(&device_resp.device_code, device_resp.interval)
+        .await
+    {
         Ok(token) => {
             println!("\nAuthorization successful!");
             println!("Access Token: {}", token.access_token);

examples/offline_validation.rs

@@ -1,24 +1,27 @@
-use authly_token::offline_validation::{JwksCache, validate_jwt};
-use jsonwebtoken::{Validation, Algorithm};
+use authly_token::offline_validation::{validate_jwt, JwksCache};
+use jsonwebtoken::{Algorithm, Validation};
 use std::time::Duration;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // 1. Initialize the JWKS Cache
     // In a real scenario, this would be your OIDC provider's JWKS URI
-    // For this example, we'll use a placeholder or a mock if we were testing, 
+    // For this example, we'll use a placeholder or a mock if we were testing,
     // but here we show the structure.
     let jwks_uri = "https://www.googleapis.com/oauth2/v3/certs".to_string();
     let refresh_interval = Duration::from_secs(3600); // 1 hour
 
     println!("Initializing JWKS cache for: {}", jwks_uri);
-    
+
     // Note: This will actually attempt to fetch the JWKS from the URI.
     // If you are offline or the URI is invalid, this will fail.
     let cache = match JwksCache::new(jwks_uri, refresh_interval).await {
         Ok(c) => c,
         Err(e) => {
-            eprintln!("Failed to initialize JWKS cache: {}. (Expected if no network or invalid URI)", e);
+            eprintln!(
+                "Failed to initialize JWKS cache: {}. (Expected if no network or invalid URI)",
+                e
+            );
             return Ok(());
         }
     };
@@ -32,7 +35,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // 3. Validate a Token
     // In a real app, you'd get this from an Authorization header
-    let token = "your.jwt.token"; 
+    let token = "your.jwt.token";
 
     println!("Validating token...");
     match validate_jwt(token, &cache, &validation).await {