refactor: better error handling

Author: realprogrammersusevim

src/app.rs

@@ -51,7 +51,12 @@ impl AppState {
     pub fn render(&self, template: &str, context: &Context) -> Result<Response> {
         let mut context = context.clone();
         context.insert("build_id", &self.build_id);
-        let rendered = self.tera.render(template, &context)?;
-        Ok(axum::response::Html(rendered).into_response())
+        match self.tera.render(template, &context) {
+            Ok(rendered) => Ok(axum::response::Html(rendered).into_response()),
+            Err(e) => {
+                tracing::error!("Template rendering failed: {}", e);
+                Err(anyhow::anyhow!("Template error: {}", e))
+            }
+        }
     }
 }

src/routes.rs

@@ -46,17 +46,27 @@ pub async fn posts_index(pagination: Query<Pagination>, state: State<AppState>)
     }
 }
 
-pub async fn about(state: State<AppState>) -> Response {
-    match state.post_service.get_special_page("about").await {
+async fn handle_special_page(state: State<AppState>, page_id: &str) -> Response {
+    match state.post_service.get_special_page(page_id).await {
         Ok(post) => {
             let mut context = Context::new();
             context.insert("post", &post);
-            state.render("post.html", &context).unwrap()
+            state.render("post.html", &context).unwrap_or_else(|e| {
+                tracing::error!("Rendering error: {}", e);
+                StatusCode::INTERNAL_SERVER_ERROR.into_response()
+            })
+        }
+        Err(e) => {
+            tracing::error!("Database error: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR.into_response()
         }
-        Err(_) => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
     }
 }
 
+pub async fn about(state: State<AppState>) -> Response {
+    handle_special_page(state, "about").await
+}
+
 pub async fn contact(state: State<AppState>) -> Response {
     match state.post_service.get_special_page("contact").await {
         Ok(post) => {
@@ -69,13 +79,27 @@ pub async fn contact(state: State<AppState>) -> Response {
 }
 
 pub async fn post(Path(id): Path<String>, state: State<AppState>) -> Response {
+    if id.is_empty() || id.len() > 100 {
+        return StatusCode::BAD_REQUEST.into_response();
+    }
+
     match state.post_service.get_post(&id).await {
         Ok(post) => {
             let mut context = Context::new();
             context.insert("post", &post);
-            state.render("post.html", &context).unwrap()
+            state.render("post.html", &context).unwrap_or_else(|e| {
+                tracing::error!("Rendering error: {}", e);
+                StatusCode::INTERNAL_SERVER_ERROR.into_response()
+            })
+        }
+        Err(e) => {
+            if e.to_string().contains("not found") {
+                StatusCode::NOT_FOUND.into_response()
+            } else {
+                tracing::error!("Database error: {}", e);
+                StatusCode::INTERNAL_SERVER_ERROR.into_response()
+            }
         }
-        Err(_) => (StatusCode::NOT_FOUND, "Post not found").into_response(),
     }
 }
 

src/services/post.rs

@@ -109,39 +109,63 @@ impl PostService {
     }
 
     pub async fn get_post(&self, id: &str) -> Result<Post> {
-        let id_clone = id.to_owned();
+        let id_for_blocking = id.to_owned();
+        let id_for_error = id.to_owned();
         let pool = self.pool.clone();
         let query = task::spawn_blocking(move || {
             let conn = pool.get()?;
             let result = conn.query_row(
                 "SELECT * FROM posts WHERE id = ? AND content_type != 'special'",
-                [&id_clone],
+                [&id_for_blocking],
                 Self::row_to_post,
             )?;
             anyhow::Result::<_>::Ok(result)
         })
         .await
         .context("Failed to join blocking task")?
-        .context(format!("Failed to fetch post {}", id))?;
+        .map_err(|e| {
+            if let Some(sqlite_err) = e.downcast_ref::<rusqlite::Error>() {
+                match sqlite_err {
+                    rusqlite::Error::QueryReturnedNoRows => {
+                        anyhow::anyhow!("Post not found: {}", id_for_error)
+                    }
+                    _ => e.into()
+                }
+            } else {
+                e
+            }
+        })?;
 
         self.convert_to_post(query).await
     }
 
     pub async fn get_special_page(&self, id: &str) -> Result<Post> {
-        let id_clone = id.to_owned();
+        let id_for_blocking = id.to_owned();
+        let id_for_error = id.to_owned();
         let pool = self.pool.clone();
         let query = task::spawn_blocking(move || {
             let conn = pool.get()?;
             let result = conn.query_row(
                 "SELECT * FROM posts WHERE id = ? AND content_type = 'special'",
-                [&id_clone],
+                [&id_for_blocking],
                 Self::row_to_post,
             )?;
             anyhow::Result::<_>::Ok(result)
         })
         .await
         .context("Failed to join blocking task")?
-        .context(format!("Failed to fetch special page {}", id))?;
+        .map_err(|e| {
+            if let Some(sqlite_err) = e.downcast_ref::<rusqlite::Error>() {
+                match sqlite_err {
+                    rusqlite::Error::QueryReturnedNoRows => {
+                        anyhow::anyhow!("Special page not found: {}", id_for_error)
+                    }
+                    _ => e.into()
+                }
+            } else {
+                e
+            }
+        })?;
 
         self.convert_to_post(query).await
     }