clippy warnings and unwrap cleanups

src/main.rs

···
 use tower_governor::governor::GovernorConfigBuilder;
 use tower_http::compression::CompressionLayer;
 use tower_http::cors::{Any, CorsLayer};
-use tracing::{error, log};
+use tracing::{error};
 use tracing_subscriber::{EnvFilter, fmt, prelude::*};
 
 mod middleware;
···
 
     let intro = "\n\nThis is a PDS gatekeeper\n\nCode: https://tangled.sh/@baileytownsend.dev/pds-gatekeeper\n";
 
-    let banner = format!("         {}\n{}", body, intro);
+    let banner = format!("         {body}\n{intro}");
 
     (
         [(header::CONTENT_TYPE, "text/plain; charset=utf-8")],
···
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     setup_tracing();
-    //TODO prod
+    //TODO may need to change where this reads from? Like an env variable for it's location?
     dotenvy::from_path(Path::new("./pds.env"))?;
     let pds_root = env::var("PDS_DATA_DIRECTORY")?;
-    let account_db_url = format!("{}/account.sqlite", pds_root);
-    log::info!("accounts_db_url: {}", account_db_url);
+    let account_db_url = format!("{pds_root}/account.sqlite");
 
     let account_options = SqliteConnectOptions::new()
         .journal_mode(SqliteJournalMode::Wal)
···
         .connect_with(account_options)
         .await?;
 
-    let bells_db_url = format!("{}/pds_gatekeeper.sqlite", pds_root);
+    let bells_db_url = format!("{pds_root}/pds_gatekeeper.sqlite");
     let options = SqliteConnectOptions::new()
         .journal_mode(SqliteJournalMode::Wal)
         .filename(bells_db_url)
···
         .per_second(60)
         .burst_size(5)
         .finish()
-        .unwrap();
+        .expect("failed to create governor config. this hsould not happen and is a bug");
+
     let governor_limiter = governor_conf.limiter().clone();
     let interval = Duration::from_secs(60);
     // a separate background task to clean up

src/middleware.rs

···
     match token {
         Ok(token) => {
             match token {
-                None => json_error_response(StatusCode::BAD_REQUEST, "TokenRequired", "").unwrap(),
+                None => json_error_response(StatusCode::BAD_REQUEST, "TokenRequired", "").expect("Error creating an error response"),
                 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();
+                            .expect("Error creating an error response");
                     }
-                    let parsed_token = token.unwrap();
+                    let parsed_token = token.expect("Already checked for error");
                     let claims: Result<Claims<TokenClaims>, ValidationError> =
                         parsed_token.deserialize_claims_unchecked();
                     if claims.is_err() {
                         return json_error_response(StatusCode::BAD_REQUEST, "TokenRequired", "")
-                            .unwrap();
+                            .expect("Error creating an error response");
                     }
 
-                    let key = Hs256Key::new(env::var("PDS_JWT_SECRET").unwrap());
+                    let key = Hs256Key::new(env::var("PDS_JWT_SECRET").expect("PDS_JWT_SECRET not set in the pds.env"));
                     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();
+                            .expect("Error creating an error response");
                     }
-                    let token = token.unwrap();
+                    let token = token.expect("Already checked for error,");
                     //Not going to worry about expiration since it still goes to the PDS
-
                     req.extensions_mut()
                         .insert(Did(Some(token.claims().custom.sub.clone())));
                     next.run(req).await
···
             }
         }
         Err(err) => {
-            log::error!("Error extracting token: {}", err);
-            json_error_response(StatusCode::BAD_REQUEST, "InvalidToken", "").unwrap()
+            log::error!("Error extracting token: {err}");
+            json_error_response(StatusCode::BAD_REQUEST, "InvalidToken", "").expect("Error creating an error response")
         }
     }
 }

src/xrpc/com_atproto_server.rs

···
         },
         Err(err) => {
             log::error!(
-                "Error during pre-auth check. This happens on the create_session endpoint when trying to decide if the user has access\n {}",
-                err
+                "Error during pre-auth check. This happens on the create_session endpoint when trying to decide if the user has access\n {err}"
+
             );
             json_error_response(
                 StatusCode::INTERNAL_SERVER_ERROR,

src/xrpc/helpers.rs

···
+use anyhow::anyhow;
 use crate::AppState;
 use crate::xrpc::helpers::TokenCheckError::InvalidToken;
 use axum::body::{Body, to_bytes};
···
     //Just going a head and doing uppercase here.
     let slice_one = &full_code[0..5].to_ascii_uppercase();
     let slice_two = &full_code[5..10].to_ascii_uppercase();
-    format!("{}-{}", slice_one, slice_two)
+    format!("{slice_one}-{slice_two}")
 }
 
 pub enum TokenCheckError {
···
     let sha = hasher.finalize();
     let salt = hex::encode(&sha[..16]);
     let hash_hex = scrypt_hex(password, &salt)?;
-    Ok(format!("{}:{}", salt, hash_hex))
+    Ok(format!("{salt}:{hash_hex}"))
 }
 
-async fn verify_password(password: &str, password_scrypt: &str) -> Result<bool, StatusCode> {
+async fn verify_password(password: &str, password_scrypt: &str) -> anyhow::Result<bool> {
     // Expected format: "salt:hash" where hash is hex of scrypt(password, salt, 64 bytes)
     let mut parts = password_scrypt.splitn(2, ':');
     let salt = match parts.next() {
···
         )
         .bind(identifier)
         .fetch_optional(&state.account_pool)
-        .await
-        .map_err(|_| StatusCode::BAD_REQUEST)?,
+        .await?,
         IdentifierType::Handle => sqlx::query_as::<_, (String, String, String, String)>(
             "SELECT account.did, account.passwordScrypt, account.email, actor.handle
                  FROM actor
···
         )
         .bind(identifier)
         .fetch_optional(&state.account_pool)
-        .await
-        .map_err(|_| StatusCode::BAD_REQUEST)?,
+        .await?,
         IdentifierType::Did => sqlx::query_as::<_, (String, String, String, String)>(
             "SELECT account.did, account.passwordScrypt, account.email, actor.handle
                  FROM actor
···
         )
         .bind(identifier)
         .fetch_optional(&state.account_pool)
-        .await
-        .map_err(|_| StatusCode::BAD_REQUEST)?,
+        .await?,
     };
 
     if let Some((did, password_scrypt, email, handle)) = account_row {
···
         )
         .bind(did.clone())
         .fetch_optional(&state.pds_gatekeeper_pool)
-        .await
-        .map_err(|_| StatusCode::BAD_REQUEST)?;
+        .await?;
 
         let two_factor_required = match required_opt {
             Some(row) => row.0 != 0,
···
                         }
                     }
                     Err(err) => {
-                        log::error!("Error checking the app password: {}", err);
-                        Err(StatusCode::BAD_REQUEST)
+                        log::error!("Error checking the app password: {err}");
+                        Err(err)
                     }
                 };
             }
···
                     .await
                     {
                         Ok(_) => {
-                            let _ = delete_all_email_tokens(&state.account_pool, did.clone()).await;
+                            let result_of_cleanup = delete_all_email_tokens(&state.account_pool, did.clone()).await;
+                            if result_of_cleanup.is_err(){
+                                log::error!("There was an error deleting the email tokens after login: {:?}", result_of_cleanup.err())
+                            }
                             Ok(AuthResult::ProxyThrough)
                         }
                         Err(err) => Ok(AuthResult::TokenCheckFailed(err)),
···
             }
 
             return match create_two_factor_token(&state.account_pool, did).await {
-                //TODO replace unwraps with the mythical ?
                 Ok(code) => {
                     let mut email_data = Map::new();
                     email_data.insert("token".to_string(), Value::from(code.clone()));
                     email_data.insert("handle".to_string(), Value::from(handle.clone()));
-                    //TODO bad unwrap
                     let email_body = state
                         .template_engine
-                        .render("two_factor_code.hbs", email_data)
-                        .unwrap();
+                        .render("two_factor_code.hbs", email_data)?;
 
                     let email = Message::builder()
                         //TODO prob get the proper type in the state
-                        .from(state.mailer_from.parse().unwrap())
-                        .to(email.parse().unwrap())
+                        .from(state.mailer_from.parse()?)
+                        .to(email.parse()?)
                         .subject("Sign in to Bluesky")
                         .multipart(
                             MultiPart::alternative() // This is composed of two parts.
                                 .singlepart(
                                     SinglePart::builder()
                                         .header(header::ContentType::TEXT_PLAIN)
-                                        .body(format!("We received a sign-in request for the account @{}. Use the code: {} to sign in. If this wasn't you, we recommend taking steps to protect your account by changing your password at https://bsky.app/settings.", handle, code)), // Every message should have a plain text fallback.
+                                        .body(format!("We received a sign-in request for the account @{handle}. Use the code: {code} to sign in. If this wasn't you, we recommend taking steps to protect your account by changing your password at https://bsky.app/settings.")), // Every message should have a plain text fallback.
                                 )
                                 .singlepart(
                                     SinglePart::builder()
                                         .header(header::ContentType::TEXT_HTML)
                                         .body(email_body),
                                 ),
-                        )
-                        //TODO bad
-                        .unwrap();
+                        )?;
                     match state.mailer.send(email).await {
                         Ok(_) => Ok(AuthResult::TwoFactorRequired),
                         Err(err) => {
-                            log::error!("Error sending the 2FA email: {}", err);
-                            Err(StatusCode::BAD_REQUEST)
+                            log::error!("Error sending the 2FA email: {err}");
+                            Err(anyhow!(err))
                         }
                     }
                 }
                 Err(err) => {
-                    log::error!("error on creating a 2fa token: {}", err);
-                    Err(StatusCode::BAD_REQUEST)
+                    log::error!("error on creating a 2fa token: {err}");
+                    Err(anyhow!(err))
                 }
             };
         }
···
 
     match res {
         Ok(_) => Ok(token),
-        Err(e) => {
-            log::error!("Error creating a two factor token: {}", e);
-            Err(anyhow::anyhow!(e))
+        Err(err) => {
+            log::error!("Error creating a two factor token: {err}");
+            Err(anyhow::anyhow!(err))
         }
     }
 }
···
     .fetch_optional(account_db)
     .await
     .map_err(|err| {
-        log::error!("Error getting the 2fa token: {}", err);
+        log::error!("Error getting the 2fa token: {err}");
         InvalidToken
     })?;