fix(auth): simplify auth extractor

Author: Fleeym

src/extractors/auth.rs

@@ -1,5 +1,6 @@
 use std::pin::Pin;
 
+use actix_web::http::header::HeaderMap;
 use actix_web::{web, FromRequest, HttpRequest};
 use futures::Future;
 use uuid::Uuid;
@@ -41,68 +42,44 @@ impl FromRequest for Auth {
         let data = req.app_data::<web::Data<AppData>>().unwrap().clone();
         let headers = req.headers().clone();
         Box::pin(async move {
-            let token = match headers.get("Authorization") {
+            let token = match parse_token(&headers) {
+                Some(t) => t,
                 None => {
                     return Ok(Auth {
                         developer: None,
                         token: None,
-                    })
+                    });
                 }
-                Some(t) => match t.to_str() {
-                    Err(e) => {
-                        log::error!("Failed to parse auth token: {}", e);
-                        return Ok(Auth {
-                            developer: None,
-                            token: None,
-                        });
-                    }
-                    Ok(str) => {
-                        let split = str.split(' ').collect::<Vec<&str>>();
-                        if split.len() != 2 || split[0] != "Bearer" {
-                            return Ok(Auth {
-                                developer: None,
-                                token: None,
-                            });
-                        }
-                        match Uuid::try_parse(split[1]) {
-                            Err(e) => {
-                                log::error!("Failed to parse auth token {}, error: {}", str, e);
-                                return Ok(Auth {
-                                    developer: None,
-                                    token: None,
-                                });
-                            }
-                            Ok(token) => token,
-                        }
-                    }
-                },
             };
 
             let mut pool = data.db.acquire().await.or(Err(ApiError::DbAcquireError))?;
             let hash = sha256::digest(token.to_string());
-            let developer = sqlx::query_as!(
+            let developer = match sqlx::query_as!(
                 FetchedDeveloper,
-                "SELECT d.id, d.username, d.display_name, d.verified, d.admin FROM developers d
+                "SELECT
+                    d.id,
+                    d.username,
+                    d.display_name,
+                    d.verified,
+                    d.admin
+                FROM developers d
                 INNER JOIN auth_tokens a ON d.id = a.developer_id
                 WHERE a.token = $1",
                 hash
             )
             .fetch_optional(&mut *pool)
-            .await;
-            let developer = match developer {
-                Err(e) => {
-                    log::error!("{}", e);
-                    return Err(ApiError::DbError);
+            .await
+            .map_err(|e| {
+                log::error!("Failed to lookup developer for auth: {}", e);
+                ApiError::DbError
+            })? {
+                None => {
+                    return Ok(Auth {
+                        developer: None,
+                        token: None,
+                    })
                 }
-                Ok(d) => match d {
-                    None => {
-                        return Ok(Auth {
-                            developer: None,
-                            token: None,
-                        })
-                    }
-                    Some(data) => data,
-                },
+                Some(d) => d,
             };
 
             Ok(Auth {
@@ -112,3 +89,20 @@ impl FromRequest for Auth {
         })
     }
 }
+
+fn parse_token(map: &HeaderMap) -> Option<Uuid> {
+    map.get("Authorization")
+        .map(|header| header.to_str().ok())
+        .flatten()
+        .map(|str| -> Option<&str> {
+            let split = str.split(' ').collect::<Vec<&str>>();
+            if split.len() != 2 || split[0] != "Bearer" {
+                None
+            } else {
+                Some[1]
+            }
+        })
+        .flatten()
+        .map(|str| Uuid::try_parse(str).ok())
+        .flatten()
+}