fix: fix code blame error about refs (#1577)

Signed-off-by: allure <[email protected]>

Author: AllureCurtain

ceres/src/model/blame.rs

@@ -79,12 +79,16 @@ impl From<jupiter::model::blame_dto::BlameQuery> for BlameQuery {
     }
 }
 
+fn default_path() -> String {
+    "/".to_string()
+}
+
 /// Request parameters for blame API endpoints
 #[derive(Debug, Deserialize, IntoParams, ToSchema)]
 pub struct BlameRequest {
     #[serde(default)]
     pub refs: String,
-    #[serde(default)]
+    #[serde(default = "default_path")]
     pub path: String,
     #[serde(default)]
     pub start_line: Option<usize>,

jupiter/src/service/blame_service.rs

@@ -251,43 +251,7 @@ impl BlameService {
                         format!("refs/heads/{}", ref_str)
                     };
                     tracing::debug!("Trying to resolve ref: {}", full_ref_name);
-                    match self.mono_storage.get_ref_by_name(&full_ref_name).await {
-                        Ok(Some(commit_id)) => self
-                            .get_commit_by_hash(&commit_id.ref_commit_hash)
-                            .await?
-                            .ok_or_else(|| GitError::ObjectNotFound(ref_str.to_string())),
-                        Ok(None) => {
-                            // Fallback to default branch
-                            tracing::debug!(
-                                "Ref not found by name, falling back to get_ref with root path"
-                            );
-                            match self.mono_storage.get_ref("/").await {
-                                Ok(Some(commit_id)) => {
-                                    tracing::debug!(
-                                        "Found commit via fallback: {}",
-                                        commit_id.ref_commit_hash
-                                    );
-                                    self.get_commit_by_hash(&commit_id.ref_commit_hash)
-                                        .await?
-                                        .ok_or_else(|| {
-                                            GitError::ObjectNotFound(ref_str.to_string())
-                                        })
-                                }
-                                Ok(None) => {
-                                    tracing::debug!("No commit found via fallback");
-                                    Err(GitError::ObjectNotFound(ref_str.to_string()))
-                                }
-                                Err(e) => Err(GitError::CustomError(format!(
-                                    "Failed to resolve reference: {}",
-                                    e
-                                ))),
-                            }
-                        }
-                        Err(e) => Err(GitError::CustomError(format!(
-                            "Failed to resolve reference: {}",
-                            e
-                        ))),
-                    }
+                    self.commit_by_ref_or_default(&full_ref_name, ref_str).await
                 }
             }
             None => {
@@ -319,6 +283,64 @@ impl BlameService {
         Ok(resolved_commit)
     }
 
+    // Extracted helper: resolve commit by ref name with safe fallback
+    async fn commit_by_ref_or_default(
+        &self,
+        full_ref_name: &str,
+        ref_display_name: &str,
+    ) -> Result<Commit, GitError> {
+        match self.mono_storage.get_ref_by_name(full_ref_name).await {
+            Ok(Some(ref_row)) => match self.get_commit_by_hash(&ref_row.ref_commit_hash).await? {
+                Some(commit) => Ok(commit),
+                None => {
+                    tracing::warn!(
+                        "Ref {} -> {} missing in mono commits, falling back to root default",
+                        full_ref_name,
+                        ref_row.ref_commit_hash
+                    );
+                    match self.mono_storage.get_ref("/").await {
+                        Ok(Some(default_ref)) => self
+                            .get_commit_by_hash(&default_ref.ref_commit_hash)
+                            .await?
+                            .ok_or_else(|| GitError::ObjectNotFound(ref_display_name.to_string())),
+                        Ok(None) => {
+                            tracing::debug!("No default ref found at root path");
+                            Err(GitError::ObjectNotFound(ref_display_name.to_string()))
+                        }
+                        Err(e) => Err(GitError::CustomError(format!(
+                            "Failed to resolve default reference: {}",
+                            e
+                        ))),
+                    }
+                }
+            },
+            Ok(None) => {
+                tracing::debug!(
+                    "Ref not found by name: {}, falling back to root default",
+                    full_ref_name
+                );
+                match self.mono_storage.get_ref("/").await {
+                    Ok(Some(default_ref)) => self
+                        .get_commit_by_hash(&default_ref.ref_commit_hash)
+                        .await?
+                        .ok_or_else(|| GitError::ObjectNotFound(ref_display_name.to_string())),
+                    Ok(None) => {
+                        tracing::debug!("No default ref found at root path");
+                        Err(GitError::ObjectNotFound(ref_display_name.to_string()))
+                    }
+                    Err(e) => Err(GitError::CustomError(format!(
+                        "Failed to resolve reference: {}",
+                        e
+                    ))),
+                }
+            }
+            Err(e) => Err(GitError::CustomError(format!(
+                "Failed to resolve reference: {}",
+                e
+            ))),
+        }
+    }
+
     /// Get file version at specific commit (with caching)
     async fn get_file_version(
         &self,

mono/src/api/router/preview_router.rs

@@ -315,11 +315,6 @@ async fn get_file_blame(
         params.refs
     );
 
-    // Validate input parameters
-    if params.path.is_empty() {
-        return Err(ApiError::from(anyhow::anyhow!("File path cannot be empty")));
-    }
-
     // Use refs parameter if provided, otherwise use None to let the service handle defaults
     let ref_name = if params.refs.is_empty() {
         None
@@ -330,18 +325,12 @@ async fn get_file_blame(
     // Convert BlameRequest to BlameQuery
     let query = BlameQuery::from(&params);
     // Call the business logic in ceres module
-    match state
+    let result = state
         .api_handler(params.path.as_ref())
         .await?
         .get_file_blame(&params.path, ref_name, query)
-        .await
-    {
-        Ok(result) => Ok(Json(CommonResult::success(Some(result)))),
-        Err(e) => {
-            tracing::error!("Blame operation failed for {}: {}", params.path, e);
-            Err(ApiError::from(anyhow::anyhow!("Blame failed: {}", e)))
-        }
-    }
+        .await?;
+    Ok(Json(CommonResult::success(Some(result))))
 }
 
 /// Preview unified diff for a single file before saving