fix: order_index unique problem (#1710)

* feat: add sync_sidebar router

* feat: change ID default to NoSet

* chore: address code review feedback

* fix: order_index unique problem

* fix: clippy closure error

* feat: add test

Author: ztygod

jupiter/callisto/src/dynamic_sidebar.rs

@@ -13,7 +13,6 @@ pub struct Model {
     pub label: String,
     pub href: String,
     pub visible: bool,
-    #[sea_orm(unique)]
     pub order_index: i32,
 }
 

jupiter/src/migration/m20251210_113942_remove_unique_constraint_from_order_index.rs

@@ -0,0 +1,37 @@
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_index(
+                Index::drop()
+                    .name("idx_dynamic_sidebar_order_index")
+                    .table(DynamicSidebar::Table)
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_index(
+                Index::create()
+                    .unique()
+                    .name("idx_dynamic_sidebar_order_index")
+                    .table(DynamicSidebar::Table)
+                    .col(DynamicSidebar::OrderIndex)
+                    .to_owned(),
+            )
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum DynamicSidebar {
+    Table,
+    OrderIndex,
+}

jupiter/src/migration/mod.rs

@@ -73,6 +73,7 @@ mod m20251119_145041_add_draft_status;
 mod m20251125_135032_add_draft_conv_type;
 mod m20251128_000001_create_buck_session;
 mod m20251203_013745_add_dynamic_sidebar;
+mod m20251210_113942_remove_unique_constraint_from_order_index;
 
 /// Creates a primary key column definition with big integer type.
 ///
@@ -134,6 +135,7 @@ impl MigratorTrait for Migrator {
             Box::new(m20251125_135032_add_draft_conv_type::Migration),
             Box::new(m20251128_000001_create_buck_session::Migration),
             Box::new(m20251203_013745_add_dynamic_sidebar::Migration),
+            Box::new(m20251210_113942_remove_unique_constraint_from_order_index::Migration),
         ]
     }
 }

jupiter/src/storage/dynamic_sidebar_storage.rs

@@ -1,4 +1,4 @@
-use std::ops::Deref;
+use std::{collections::HashSet, ops::Deref};
 
 use crate::{
     model::sidebar_dto::SidebarSyncDto,
@@ -122,6 +122,21 @@ impl DynamicSidebarStorage {
         Ok(model)
     }
 
+    /// Synchronize sidebar items by applying updates and inserts.
+    ///
+    /// This function does **not** perform full replacement.  
+    /// It assumes:
+    /// - The frontend sends the **complete list of sidebar items**.
+    /// - Existing items include a valid `id` and will be updated.
+    /// - New items have `id = None` and will be inserted.
+    /// - Deletions are handled separately by another API.
+    ///
+    /// Validation rules:
+    /// - `order_index` values in the incoming list must be unique.
+    ///
+    /// Transaction behavior:
+    /// - All updates and inserts happen inside a single transaction.  
+    /// - Any failure will roll back the entire operation.
     pub async fn sync_sidebar(
         &self,
         items: Vec<SidebarSyncDto>,
@@ -130,6 +145,9 @@ impl DynamicSidebarStorage {
             return Ok(Vec::new());
         }
 
+        // Validate that order_index values in items are unique
+        validate_order_index_unique(&items).map_err(MegaError::Other)?;
+
         // Begin a transaction
         let txn = self.get_connection().begin().await?;
 
@@ -175,3 +193,80 @@ impl DynamicSidebarStorage {
         Ok(res_models)
     }
 }
+
+fn validate_order_index_unique(items: &[SidebarSyncDto]) -> Result<(), String> {
+    let mut seen = HashSet::new();
+
+    for item in items {
+        if !seen.insert(item.order_index) {
+            // If insert returns false, it means a duplicate order_index exists
+            return Err(format!("Duplicate order_index found: {}", item.order_index));
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn dto(id: Option<i32>, order: i32) -> SidebarSyncDto {
+        SidebarSyncDto {
+            id,
+            public_id: format!("id_{}", order),
+            label: "label".into(),
+            href: "/".into(),
+            visible: true,
+            order_index: order,
+        }
+    }
+
+    #[test]
+    fn test_validate_unique_order_index_ok() {
+        // All unique order indices
+        let items = vec![dto(Some(1), 0), dto(Some(2), 1), dto(Some(3), 2)];
+
+        let result = validate_order_index_unique(&items);
+
+        assert!(result.is_ok(), "Expected unique order indices to pass.");
+    }
+
+    #[test]
+    fn test_validate_unique_order_index_duplicate() {
+        // Contains duplicate order indices
+        let items = vec![dto(Some(1), 0), dto(Some(2), 1), dto(Some(3), 1)];
+
+        let result = validate_order_index_unique(&items);
+
+        assert!(
+            result.is_err(),
+            "Expected duplicate order indices to produce error."
+        );
+
+        assert!(
+            result.unwrap_err().contains("1"),
+            "Error message should contain the duplicate order index."
+        );
+    }
+
+    #[test]
+    fn test_validate_unique_order_index_empty() {
+        // Empty list should be valid
+        let items: Vec<SidebarSyncDto> = vec![];
+
+        let result = validate_order_index_unique(&items);
+
+        assert!(result.is_ok(), "Empty list should be considered valid.");
+    }
+
+    #[test]
+    fn test_validate_unique_order_index_single_item() {
+        // A single item is always valid
+        let items = vec![dto(Some(1), 10)];
+
+        let result = validate_order_index_unique(&items);
+
+        assert!(result.is_ok(), "Single item should always be valid.");
+    }
+}