fix: wrong custom section id return type and imgage migration error

Author: chloecinders

src/routes/api/v1/search_sections.rs

@@ -9,11 +9,12 @@ use crate::{
         api_response::V1ApiResponseTrait,
         v1::guards::{AuthenticatedUser, UserRole},
     },
+    utils::id::Id,
 };
 
 #[derive(Serialize, sqlx::FromRow)]
 pub struct V1SearchSectionResponse {
-    pub id: i64,
+    pub id: Id,
     pub title: String,
     pub section_type: String,
     pub smart_filter: Option<String>,
@@ -28,7 +29,7 @@ impl V1ApiResponseTrait for V1SearchSectionResponse {}
 pub async fn get_search_sections(
     _user: AuthenticatedUser,
 ) -> V1ApiResponseType<Vec<V1SearchSectionResponse>> {
-        let sections = sqlx::query!(
+    let sections = sqlx::query!(
             "SELECT id, title, section_type, smart_filter, filter_value, order_index FROM search_sections ORDER BY order_index ASC"
         )
         .fetch_all(&*SQL)
@@ -38,12 +39,12 @@ pub async fn get_search_sections(
             V1ApiError::InternalError
         })?;
 
-        let mut out = Vec::new();
+    let mut out = Vec::new();
 
-        for s in sections {
-            let mut custom_roms = None;
-            if s.section_type == "custom" {
-                let rom_ids = sqlx::query!(
+    for s in sections {
+        let mut custom_roms = None;
+        if s.section_type == "custom" {
+            let rom_ids = sqlx::query!(
                     "SELECT rom_id FROM search_section_roms WHERE section_id = $1 ORDER BY order_index ASC",
                     s.id
                 )
@@ -53,21 +54,21 @@ pub async fn get_search_sections(
                     error!("Failed to fetch custom section roms: {:?}", e);
                     V1ApiError::InternalError
                 })?;
-                custom_roms = Some(rom_ids.into_iter().map(|r| r.rom_id).collect());
-            }
-
-            out.push(V1SearchSectionResponse {
-                id: s.id,
-                title: s.title,
-                section_type: s.section_type,
-                smart_filter: s.smart_filter,
-                filter_value: s.filter_value,
-                order_index: s.order_index,
-                roms: custom_roms,
-            });
+            custom_roms = Some(rom_ids.into_iter().map(|r| r.rom_id).collect());
         }
 
-        Ok(V1ApiResponse(out))
+        out.push(V1SearchSectionResponse {
+            id: Id::new(s.id),
+            title: s.title,
+            section_type: s.section_type,
+            smart_filter: s.smart_filter,
+            filter_value: s.filter_value,
+            order_index: s.order_index,
+            roms: custom_roms,
+        });
+    }
+
+    Ok(V1ApiResponse(out))
 }
 
 #[derive(Deserialize)]
@@ -210,7 +211,10 @@ pub async fn update_search_section(
             .execute(&mut *tx)
             .await
             .map_err(|e| {
-                error!("Failed to clear section roms (type changed from custom): {:?}", e);
+                error!(
+                    "Failed to clear section roms (type changed from custom): {:?}",
+                    e
+                );
                 V1ApiError::InternalError
             })?;
     }
@@ -225,8 +229,7 @@ pub async fn update_search_section(
 
 #[derive(Deserialize)]
 pub struct V1SearchSectionOrderUpdateRequest {
-    // Array of (id, order_index)
-    pub updates: Vec<(i64, i32)>,
+    pub updates: Vec<(Id, i32)>,
 }
 
 #[put("/api/v1/search_sections/order", format = "json", data = "<data>")]
@@ -237,20 +240,24 @@ pub async fn update_search_sections_order(
     if user.role != UserRole::Admin && user.role != UserRole::Moderator {
         return Err(V1ApiError::NotAuthorized);
     }
-    
+
     let mut tx = SQL.begin().await.map_err(|e| {
         error!("Failed to begin transaction: {:?}", e);
         V1ApiError::InternalError
     })?;
 
     for (id, order) in &data.updates {
-        sqlx::query!("UPDATE search_sections SET order_index = $1 WHERE id = $2", order, id)
-            .execute(&mut *tx)
-            .await
-            .map_err(|e| {
-                error!("Failed to update order for {}: {:?}", id, e);
-                V1ApiError::InternalError
-            })?;
+        sqlx::query!(
+            "UPDATE search_sections SET order_index = $1 WHERE id = $2",
+            order,
+            id.value()
+        )
+        .execute(&mut *tx)
+        .await
+        .map_err(|e| {
+            error!("Failed to update order for {}: {:?}", id, e);
+            V1ApiError::InternalError
+        })?;
     }
 
     tx.commit().await.map_err(|e| {
@@ -262,10 +269,7 @@ pub async fn update_search_sections_order(
 }
 
 #[delete("/api/v1/search_sections/<id>")]
-pub async fn delete_search_section(
-    id: i64,
-    user: AuthenticatedUser,
-) -> V1ApiResponseType<()> {
+pub async fn delete_search_section(id: i64, user: AuthenticatedUser) -> V1ApiResponseType<()> {
     if user.role != UserRole::Admin && user.role != UserRole::Moderator {
         return Err(V1ApiError::NotAuthorized);
     }

src/utils/migration.rs

@@ -6,6 +6,46 @@ use std::io::Cursor;
 pub async fn migrate_covers() {
     println!("Checking if any covers need migration...");
 
+    let mut root_covers = std::collections::HashMap::new();
+    let mut root_smalls = std::collections::HashMap::new();
+    let mut root_icons = std::collections::HashMap::new();
+
+    let bucket = &*crate::S3;
+
+    for base in ["covers", "covers_small", "icons"] {
+        for prefix in [format!("{}/", base), format!("/{}/", base)] {
+            if let Ok(results) = bucket.list(prefix.clone(), Some("/".to_string())).await {
+                let mut count = 0;
+
+                for res in results {
+                    for obj in res.contents {
+                        if obj.key.ends_with('/') {
+                            continue;
+                        }
+
+                        let path = std::path::Path::new(&obj.key);
+                        if let Some(stem) = path.file_stem().and_then(|s| s.to_str()) {
+                            let stem = stem.to_string();
+                            if base == "covers" {
+                                root_covers.insert(stem, obj.key);
+                            } else if base == "covers_small" {
+                                root_smalls.insert(stem, obj.key);
+                            } else if base == "icons" {
+                                root_icons.insert(stem, obj.key);
+                            }
+                            count += 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    println!(
+        "Total images sitting in root folders: {}",
+        root_covers.len() + root_smalls.len() + root_icons.len()
+    );
+
     let roms = match sqlx::query!("SELECT id, console, image_hash FROM roms")
         .fetch_all(&*SQL)
         .await
@@ -23,20 +63,26 @@ pub async fn migrate_covers() {
         let hash = &rom.image_hash;
 
         let new_cover = format!("covers/{}/{}/{}.webp", rom.console, rom.id, hash);
-        let old_cover = format!("covers/{}.webp", hash);
-
         let new_small = format!("covers_small/{}/{}/{}.webp", rom.console, rom.id, hash);
-        let old_small = format!("covers_small/{}.webp", hash);
-
         let new_icon = format!("icons/{}/{}/{}.webp", rom.console, rom.id, hash);
-        let old_icon = format!("icons/{}.webp", hash);
+
+        let old_cover_key = root_covers.get(hash);
+        if old_cover_key.is_none() {
+            if crate::utils::s3::download_object(&new_cover).await.is_ok() {
+                continue;
+            }
+        }
 
         let mut moved_any = false;
         let mut source_bytes = None;
 
-        if let Ok(bytes) = crate::utils::s3::download_object(&old_cover).await {
-            source_bytes = Some(bytes);
-        } else {
+        if let Some(key) = old_cover_key {
+            if let Ok(bytes) = crate::utils::s3::download_object(key).await {
+                source_bytes = Some(bytes);
+            }
+        }
+
+        if source_bytes.is_none() {
             let shared_roms = sqlx::query!(
                 "SELECT id, console FROM roms WHERE image_hash = $1 AND id != $2",
                 rom.image_hash,
@@ -52,45 +98,67 @@ pub async fn migrate_covers() {
                 if let Ok(bytes) = crate::utils::s3::download_object(&other_new_path).await {
                     source_bytes = Some(bytes);
 
-                    // Also try to recover small and icon from the same source ROM if needed
-                    if crate::utils::s3::download_object(&old_small).await.is_err() {
+                    if crate::utils::s3::download_object(&new_small).await.is_err() {
                         let other_new_small = format!(
                             "covers_small/{}/{}/{}.webp",
                             s.console, s.id, rom.image_hash
                         );
-                        if let Ok(s_bytes) =
-                            crate::utils::s3::download_object(&other_new_small).await
-                        {
-                            let _ = crate::utils::s3::upload_object(&new_small, &s_bytes).await;
+                        if let Some(key) = root_smalls.get(hash) {
+                            if let Ok(s_bytes) = crate::utils::s3::download_object(key).await {
+                                let _ = crate::utils::s3::upload_object(&new_small, &s_bytes).await;
+                            }
                         }
                     }
-                    if crate::utils::s3::download_object(&old_icon).await.is_err() {
+                    if crate::utils::s3::download_object(&new_icon).await.is_err() {
                         let other_new_icon =
                             format!("icons/{}/{}/{}.webp", s.console, s.id, rom.image_hash);
-                        if let Ok(i_bytes) =
-                            crate::utils::s3::download_object(&other_new_icon).await
-                        {
-                            let _ = crate::utils::s3::upload_object(&new_icon, &i_bytes).await;
+                        if let Some(key) = root_icons.get(hash) {
+                            if let Ok(i_bytes) = crate::utils::s3::download_object(key).await {
+                                let _ = crate::utils::s3::upload_object(&new_icon, &i_bytes).await;
+                            }
                         }
                     }
                     break;
                 }
             }
         }
 
-        if let Some(bytes) = source_bytes {
+        if let Some(mut bytes) = source_bytes {
+            if let Ok(img) = image::load_from_memory(&bytes) {
+                let mut buf = std::io::Cursor::new(Vec::new());
+                if img.write_to(&mut buf, image::ImageFormat::WebP).is_ok() {
+                    bytes = buf.into_inner();
+                }
+            }
+
             if crate::utils::s3::upload_object(&new_cover, &bytes)
                 .await
                 .is_ok()
             {
                 moved_any = true;
             }
 
-            if let Ok(s_bytes) = crate::utils::s3::download_object(&old_small).await {
-                let _ = crate::utils::s3::upload_object(&new_small, &s_bytes).await;
+            if let Some(key) = root_smalls.get(hash) {
+                if let Ok(mut s_bytes) = crate::utils::s3::download_object(key).await {
+                    if let Ok(img) = image::load_from_memory(&s_bytes) {
+                        let mut buf = std::io::Cursor::new(Vec::new());
+                        if img.write_to(&mut buf, image::ImageFormat::WebP).is_ok() {
+                            s_bytes = buf.into_inner();
+                        }
+                    }
+                    let _ = crate::utils::s3::upload_object(&new_small, &s_bytes).await;
+                }
             }
-            if let Ok(i_bytes) = crate::utils::s3::download_object(&old_icon).await {
-                let _ = crate::utils::s3::upload_object(&new_icon, &i_bytes).await;
+            if let Some(key) = root_icons.get(hash) {
+                if let Ok(mut i_bytes) = crate::utils::s3::download_object(key).await {
+                    if let Ok(img) = image::load_from_memory(&i_bytes) {
+                        let mut buf = std::io::Cursor::new(Vec::new());
+                        if img.write_to(&mut buf, image::ImageFormat::WebP).is_ok() {
+                            i_bytes = buf.into_inner();
+                        }
+                    }
+                    let _ = crate::utils::s3::upload_object(&new_icon, &i_bytes).await;
+                }
             }
         }
 
@@ -107,12 +175,19 @@ pub async fn migrate_covers() {
     }
 
     println!("Cleaning up unused covers in root directories...");
-    for prefix in ["covers/", "covers_small/", "icons/"] {
-        if let Ok(results) = crate::utils::s3::list_objects_shallow(prefix).await {
-            for key in results {
-                if key.ends_with(".webp") {
-                    println!("Deleting unused file: {}", key);
-                    let _ = crate::utils::s3::delete_object(&key).await;
+
+    for base in ["covers", "covers_small", "icons"] {
+        for prefix in [format!("{}/", base), format!("/{}/", base)] {
+            let bucket = &*crate::S3;
+
+            if let Ok(results) = bucket.list(prefix, Some("/".to_string())).await {
+                for res in results {
+                    for obj in res.contents {
+                        if !obj.key.ends_with('/') {
+                            println!("Deleting unused file: {}", obj.key);
+                            let _ = bucket.delete_object(&obj.key).await;
+                        }
+                    }
                 }
             }
         }