Some clippy warning clean ups

src/main.rs

···
+#![warn(clippy::unwrap_used)]
 use crate::xrpc::com_atproto_server::{create_session, get_session, update_email};
-use axum::middleware as ax_middleware;
-mod middleware;
 use axum::body::Body;
 use axum::handler::Handler;
 use axum::http::{Method, header};
+use axum::middleware as ax_middleware;
 use axum::routing::post;
 use axum::{Router, routing::get};
 use axum_template::engine::Engine;
···
 use tracing::{error, log};
 use tracing_subscriber::{EnvFilter, fmt, prelude::*};
 
+mod middleware;
 mod xrpc;
 
 type HyperUtilClient = hyper_util::client::legacy::Client<HttpConnector, Body>;
···
     //TODO prod
     dotenvy::from_path(Path::new("./pds.env"))?;
     let pds_root = env::var("PDS_DATA_DIRECTORY")?;
-    // let pds_root = "/home/baileytownsend/Documents/code/docker_compose/pds/pds_data";
     let account_db_url = format!("{}/account.sqlite", pds_root);
     log::info!("accounts_db_url: {}", account_db_url);
 
···
         .connect_with(options)
         .await?;
 
-    // Run migrations for the bells_and_whistles database
+    // Run migrations for the extra database
     // Note: the migrations are embedded at compile time from the given directory
     // sqlx
     sqlx::migrate!("./migrations")

src/middleware.rs

···
 use jwt_compact::{AlgorithmExt, Claims, Token, UntrustedToken, ValidationError};
 use serde::{Deserialize, Serialize};
 use std::env;
+use tracing::log;
 
 #[derive(Clone, Debug)]
 pub struct Did(pub Option<String>);
···
     match token {
         Ok(token) => {
             match token {
-                None => {
-                    return json_error_response(
-                        StatusCode::BAD_REQUEST,
-                        "TokenRequired",
-                        "",
-                    ).unwrap();
-                }
+                None => json_error_response(StatusCode::BAD_REQUEST, "TokenRequired", "").unwrap(),
                 Some(token) => {
                     let token = UntrustedToken::new(&token);
                     //Doing weird unwraps cause I can't do Result for middleware?
                     if token.is_err() {
-                        return json_error_response(
-                            StatusCode::BAD_REQUEST,
-                            "TokenRequired",
-                            "",
-                        ).unwrap();
+                        return json_error_response(StatusCode::BAD_REQUEST, "TokenRequired", "")
+                            .unwrap();
                     }
                     let parsed_token = token.unwrap();
                     let claims: Result<Claims<TokenClaims>, ValidationError> =
                         parsed_token.deserialize_claims_unchecked();
                     if claims.is_err() {
-                        return json_error_response(
-                            StatusCode::BAD_REQUEST,
-                            "TokenRequired",
-                            "",
-                        ).unwrap();
+                        return json_error_response(StatusCode::BAD_REQUEST, "TokenRequired", "")
+                            .unwrap();
                     }
 
                     let key = Hs256Key::new(env::var("PDS_JWT_SECRET").unwrap());
                     let token: Result<Token<TokenClaims>, ValidationError> =
                         Hs256.validator(&key).validate(&parsed_token);
                     if token.is_err() {
-                        return json_error_response(
-                            StatusCode::BAD_REQUEST,
-                            "InvalidToken",
-                            "",
-                        ).unwrap();
+                        return json_error_response(StatusCode::BAD_REQUEST, "InvalidToken", "")
+                            .unwrap();
                     }
                     let token = token.unwrap();
                     //Not going to worry about expiration since it still goes to the PDS
···
                 }
             }
         }
-        Err(_) => {
-            return json_error_response(
-                StatusCode::BAD_REQUEST,
-                "InvalidToken",
-                "",
-            ).unwrap();
+        Err(err) => {
+            log::error!("Error extracting token: {}", err);
+            json_error_response(StatusCode::BAD_REQUEST, "InvalidToken", "").unwrap()
         }
     }
 }

src/xrpc/helpers.rs

···
 
 pub enum IdentifierType {
     Email,
-    DID,
+    Did,
     Handle,
 }
 
···
         if identifier.contains("@") {
             IdentifierType::Email
         } else if identifier.contains("did:") {
-            IdentifierType::DID
+            IdentifierType::Did
         } else {
             IdentifierType::Handle
         }
···
         .fetch_optional(&state.account_pool)
         .await
         .map_err(|_| StatusCode::BAD_REQUEST)?,
-        IdentifierType::DID => sqlx::query_as::<_, (String, String, String, String)>(
+        IdentifierType::Did => sqlx::query_as::<_, (String, String, String, String)>(
             "SELECT account.did, account.passwordScrypt, account.email, actor.handle
                  FROM actor
                  LEFT JOIN account ON actor.did = account.did
···
         let required_opt = sqlx::query_as::<_, (u8,)>(
             "SELECT required FROM two_factor_accounts WHERE did = ? LIMIT 1",
         )
-        .bind(&did.clone())
+        .bind(did.clone())
         .fetch_optional(&state.pds_gatekeeper_pool)
         .await
         .map_err(|_| StatusCode::BAD_REQUEST)?;
···
             let verified = verify_password(password, &password_scrypt).await?;
             if !verified {
                 //Theres a chance it could be an app password so check that as well
-                return match verify_app_password(&state.account_pool, &did, &password).await {
+                return match verify_app_password(&state.account_pool, &did, password).await {
                     Ok(valid) => {
                         if valid {
                             //Was a valid app password up to the PDS now
···
             //Two factor is required and a taken was provided
             if let Some(two_factor_code) = two_factor_code {
                 //It seems it sends over a empty on login without it set? As in no input is shown on the ui for the first login try
-                if two_factor_code != "" {
+                if !two_factor_code.is_empty() {
                     return match assert_valid_token(
                         &state.account_pool,
                         did.clone(),
···
 ) -> anyhow::Result<String> {
     let purpose = "2fa_code";
 
-    loop {
-        let token = get_random_token();
-        let right_now = Utc::now();
+    let token = get_random_token();
+    let right_now = Utc::now();
 
-        let res = sqlx::query(
-            "INSERT INTO email_token (purpose, did, token, requestedAt)
+    let res = sqlx::query(
+        "INSERT INTO email_token (purpose, did, token, requestedAt)
                      VALUES (?, ?, ?, ?)
                      ON CONFLICT(purpose, did) DO UPDATE SET
                        token=excluded.token,
                        requestedAt=excluded.requestedAt",
-        )
-        .bind(purpose)
-        .bind(&did)
-        .bind(&token)
-        .bind(right_now)
-        .execute(account_db)
-        .await;
+    )
+    .bind(purpose)
+    .bind(&did)
+    .bind(&token)
+    .bind(right_now)
+    .execute(account_db)
+    .await;
 
-        return match res {
-            Ok(_) => Ok(token),
-            Err(e) => {
-                log::error!("Error creating a two factor token: {}", e);
-                Err(anyhow::anyhow!(e))
-            }
-        };
+    match res {
+        Ok(_) => Ok(token),
+        Err(e) => {
+            log::error!("Error creating a two factor token: {}", e);
+            Err(anyhow::anyhow!(e))
+        }
     }
 }