feat: Add game thumbnail fetching from external APIs, migrate

backend/src/auth.rs

@@ -1,8 +1,8 @@
 use crate::items;
 use crate::proto_utils::Proto;
 use rocket::State;
+use rocket::futures::lock::Mutex;
 use std::collections::HashMap;
-use std::sync::Mutex;
 use uuid::Uuid;
 
 pub struct AuthState {
@@ -18,6 +18,12 @@ impl AuthState {
     }
 }
 
+impl Default for AuthState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[derive(Debug)]
 #[allow(dead_code)]
 pub struct Token {
@@ -39,7 +45,7 @@ impl<'r> rocket::request::FromRequest<'r> for Token {
                 // Check if token starts with "Bearer "
                 if let Some(token) = token.strip_prefix("Bearer ") {
                     let state = request.guard::<&State<AuthState>>().await.unwrap();
-                    let tokens = state.tokens.lock().unwrap();
+                    let tokens = state.tokens.lock().await;
 
                     if let Some(username) = tokens.get(token) {
                         return rocket::request::Outcome::Success(Token {
@@ -57,19 +63,19 @@ impl<'r> rocket::request::FromRequest<'r> for Token {
 }
 
 #[post("/login", data = "<request>")]
-pub fn login(
+pub async fn login(
     state: &State<AuthState>,
     user_list: &State<Mutex<Vec<crate::User>>>,
     request: Proto<items::LoginRequest>,
 ) -> items::LoginResponse {
     let req = request.into_inner();
-    let users = user_list.lock().unwrap();
+    let users = user_list.lock().await;
 
     if let Some(user) = users.iter().find(|u| u.person.name == req.username)
         && bcrypt::verify(&req.password, &user.password_hash).unwrap_or(false)
     {
         let token = Uuid::new_v4().to_string();
-        let mut tokens = state.tokens.lock().unwrap();
+        let mut tokens = state.tokens.lock().await;
         tokens.insert(token.clone(), req.username);
 
         return items::LoginResponse {
@@ -87,12 +93,12 @@ pub fn login(
 }
 
 #[post("/logout", data = "<request>")]
-pub fn logout(
+pub async fn logout(
     state: &State<AuthState>,
     request: Proto<items::LogoutRequest>,
 ) -> items::LogoutResponse {
     let req = request.into_inner();
-    let mut tokens = state.tokens.lock().unwrap();
+    let mut tokens = state.tokens.lock().await;
 
     if tokens.remove(&req.token).is_some() {
         items::LogoutResponse {
@@ -108,12 +114,12 @@ pub fn logout(
 }
 
 #[post("/get_auth_status", data = "<request>")]
-pub fn get_auth_status(
+pub async fn get_auth_status(
     state: &State<AuthState>,
     request: Proto<items::AuthStatusRequest>,
 ) -> items::AuthStatusResponse {
     let req = request.into_inner();
-    let tokens = state.tokens.lock().unwrap();
+    let tokens = state.tokens.lock().await;
 
     if let Some(username) = tokens.get(&req.token) {
         items::AuthStatusResponse {