feat: add centralized API service layer for frontend

- Create frontend/src/api/mod.rs with centralized HTTP client and error handling
- Implement api::auth module (login, logout, check_auth, get_user)
- Implement api::torrent module (add, action, delete, start, stop, set_label, set_priority)
- Implement api::setup module (get_status, setup)
- Implement api::settings module (set_global_limits)
- Implement api::push module (get_public_key, subscribe)
- Update all components to use api service layer instead of direct gloo_net calls
- Add thiserror dependency for error handling

frontend/src/components/auth/login.rs

@@ -1,12 +1,5 @@
 use leptos::*;
-use serde::Serialize;
-
-#[derive(Serialize)]
-struct LoginRequest {
-    username: String,
-    password: String,
-    remember_me: bool,
-}
+use crate::api;
 
 #[component]
 pub fn Login() -> impl IntoView {
@@ -23,35 +16,31 @@ pub fn Login() -> impl IntoView {
 
         logging::log!("Attempting login for user: {}", username.get());
 
+        let username = username.get();
+        let password = password.get();
+        let remember_me = remember_me.get();
+
         spawn_local(async move {
-            let req = LoginRequest {
-                username: username.get(),
-                password: password.get(),
-                remember_me: remember_me.get(),
-            };
-
-            let client = gloo_net::http::Request::post("/api/auth/login")
-                .json(&req)
-                .expect("Failed to create request");
-
-            match client.send().await {
-                Ok(resp) => {
-                    logging::log!("Login response status: {}", resp.status());
-                    if resp.ok() {
-                        logging::log!("Login successful, redirecting...");
-                        // Force a full reload to re-run auth checks in App.rs
-                        let _ = window().location().set_href("/");
-                    } else if resp.status() == 429 {
-                        set_error.set(Some("Çok fazla başarısız deneme yaptınız. Lütfen bir süre bekleyip tekrar deneyin.".to_string()));
-                    } else {
-                        let text = resp.text().await.unwrap_or_default();
-                        logging::error!("Login failed: {}", text);
-                        set_error.set(Some("Kullanıcı adı veya şifre hatalı".to_string()));
-                    }
+            match api::auth::login(&username, &password, remember_me).await {
+                Ok(_) => {
+                    logging::log!("Login successful, redirecting...");
+                    let _ = window().location().set_href("/");
                 }
                 Err(e) => {
-                    logging::error!("Network error: {}", e);
-                    set_error.set(Some("Bağlantı hatası".to_string()));
+                    logging::error!("Login failed: {:?}", e);
+                    let msg = match e {
+                        crate::api::ApiError::RateLimited => {
+                            "Çok fazla başarısız deneme yaptınız. Lütfen bir süre bekleyip tekrar deneyin.".to_string()
+                        }
+                        crate::api::ApiError::Unauthorized | crate::api::ApiError::LoginFailed => {
+                            "Kullanıcı adı veya şifre hatalı".to_string()
+                        }
+                        crate::api::ApiError::Network => {
+                            "Bağlantı hatası".to_string()
+                        }
+                        _ => "Bir hata oluştu".to_string()
+                    };
+                    set_error.set(Some(msg));
                 }
             }
             set_loading.set(false);

frontend/src/components/auth/setup.rs

@@ -1,11 +1,5 @@
 use leptos::*;
-use serde::Serialize;
-
-#[derive(Serialize)]
-struct SetupRequest {
-    username: String,
-    password: String,
-}
+use crate::api;
 
 #[component]
 pub fn Setup() -> impl IntoView {
@@ -35,29 +29,18 @@ pub fn Setup() -> impl IntoView {
             return;
         }
 
+        let username = username.get();
+        let password = pass;
+
         spawn_local(async move {
-            let req = SetupRequest {
-                username: username.get(),
-                password: pass,
-            };
-
-            let client = gloo_net::http::Request::post("/api/setup")
-                .json(&req)
-                .expect("Failed to create request");
-
-            match client.send().await {
-                Ok(resp) => {
-                    if resp.ok() {
-                        // Redirect to home after setup (auto-login handled by backend)
-                        // Full reload to ensure auth state is refreshed
-                        let _ = window().location().set_href("/");
-                    } else {
-                        let text = resp.text().await.unwrap_or_default();
-                        set_error.set(Some(format!("Hata: {}", text)));
-                    }
+            match api::setup::setup(&username, &password).await {
+                Ok(_) => {
+                    logging::log!("Setup completed successfully, redirecting...");
+                    let _ = window().location().set_href("/");
                 }
-                Err(_) => {
-                    set_error.set(Some("Bağlantı hatası".to_string()));
+                Err(e) => {
+                    logging::error!("Setup failed: {:?}", e);
+                    set_error.set(Some("Kurulum başarısız oldu".to_string()));
                 }
             }
             set_loading.set(false);

frontend/src/components/layout/sidebar.rs

@@ -1,5 +1,6 @@
 use leptos::wasm_bindgen::JsCast;
 use leptos::*;
+use crate::api;
 
 #[component]
 pub fn Sidebar() -> impl IntoView {
@@ -76,12 +77,8 @@ pub fn Sidebar() -> impl IntoView {
 
     let handle_logout = move |_| {
         spawn_local(async move {
-            let client = gloo_net::http::Request::post("/api/auth/logout");
-            if let Ok(resp) = client.send().await {
-                if resp.ok() {
-                    // Force full reload to clear state
-                    let _ = window().location().set_href("/login");
-                }
+            if api::auth::logout().await.is_ok() {
+                let _ = window().location().set_href("/login");
             }
         });
     };

frontend/src/components/layout/statusbar.rs

@@ -2,6 +2,7 @@ use leptos::*;
 use leptos_use::storage::use_local_storage;
 use codee::string::FromToStringCodec;
 use shared::GlobalLimitRequest;
+use crate::api;
 
 fn format_bytes(bytes: i64) -> String {
     const UNITS: [&str; 6] = ["B", "KB", "MB", "GB", "TB", "PB"];
@@ -60,38 +61,23 @@ pub fn StatusBar() -> impl IntoView {
         let limit_type = limit_type.to_string();
         logging::log!("Setting {} limit to {}", limit_type, val);
 
+        let req = if limit_type == "down" {
+            GlobalLimitRequest {
+                max_download_rate: Some(val),
+                max_upload_rate: None,
+            }
+        } else {
+            GlobalLimitRequest {
+                max_download_rate: None,
+                max_upload_rate: Some(val),
+            }
+        };
+
         spawn_local(async move {
-            let req_body = if limit_type == "down" {
-                GlobalLimitRequest {
-                    max_download_rate: Some(val),
-                    max_upload_rate: None,
-                }
+            if let Err(e) = api::settings::set_global_limits(&req).await {
+                logging::error!("Failed to set limit: {:?}", e);
             } else {
-                GlobalLimitRequest {
-                    max_download_rate: None,
-                    max_upload_rate: Some(val),
-                }
-            };
-
-            let client =
-                gloo_net::http::Request::post("/api/settings/global-limits").json(&req_body);
-
-            match client {
-                Ok(req) => match req.send().await {
-                    Ok(resp) => {
-                        if !resp.ok() {
-                            logging::error!(
-                                "Failed to set limit: {} {}",
-                                resp.status(),
-                                resp.status_text()
-                            );
-                        } else {
-                            logging::log!("Limit set successfully");
-                        }
-                    }
-                    Err(e) => logging::error!("Network error setting limit: {}", e),
-                },
-                Err(e) => logging::error!("Failed to create request: {}", e),
+                logging::log!("Limit set successfully");
             }
         });
     };

frontend/src/components/torrent/add_torrent.rs

@@ -1,7 +1,8 @@
 use leptos::*;
 use leptos::html::Dialog;
 use crate::store::{show_toast_with_signal, TorrentStore};
-use shared::{AddTorrentRequest, NotificationLevel};
+use crate::api;
+use shared::NotificationLevel;
 
 
 #[component]
@@ -17,7 +18,6 @@ pub fn AddTorrentModal(
     let (is_loading, set_loading) = create_signal(false);
     let (error_msg, set_error_msg) = create_signal(Option::<String>::None);
 
-    // Effect to open the dialog when the component mounts/renders
     create_effect(move |_| {
         if let Some(dialog) = dialog_ref.get() {
             let _ = dialog.show_modal();
@@ -35,44 +35,22 @@ pub fn AddTorrentModal(
         set_loading.set(true);
         set_error_msg.set(None);
 
+        let uri_val = uri_val;
         spawn_local(async move {
-            let req_body = AddTorrentRequest { uri: uri_val };
-
-            match gloo_net::http::Request::post("/api/torrents/add")
-                .json(&req_body)
-            {
-                Ok(req) => {
-                    match req.send().await {
-                        Ok(resp) => {
-                            if resp.ok() {
-                                logging::log!("Torrent added successfully");
-                                show_toast_with_signal(notifications, NotificationLevel::Success, "Torrent eklendi");
-                                set_loading.set(false);
-                                if let Some(dialog) = dialog_ref.get() {
-                                    dialog.close();
-                                }
-                                on_close.call(());
-                            } else {
-                                let status = resp.status();
-                                let text = resp.text().await.unwrap_or_default();
-                                logging::error!("Failed to add torrent: {} - {}", status, text);
-                                show_toast_with_signal(notifications, NotificationLevel::Error, "Torrent eklenemedi");
-                                set_error_msg.set(Some(format!("Error {}: {}", status, text)));
-                                set_loading.set(false);
-                            }
-                        }
-                        Err(e) => {
-                            logging::error!("Network error: {}", e);
-                            show_toast_with_signal(notifications, NotificationLevel::Error, "Bağlantı hatası");
-                            set_error_msg.set(Some(format!("Network Error: {}", e)));
-                            set_loading.set(false);
-                        }
+            match api::torrent::add(&uri_val).await {
+                Ok(_) => {
+                    logging::log!("Torrent added successfully");
+                    show_toast_with_signal(notifications, NotificationLevel::Success, "Torrent eklendi");
+                    set_loading.set(false);
+                    if let Some(dialog) = dialog_ref.get() {
+                        dialog.close();
                     }
+                    on_close.call(());
                 }
                 Err(e) => {
-                    logging::error!("Serialization error: {}", e);
-                    show_toast_with_signal(notifications, NotificationLevel::Error, "İstek hatası");
-                    set_error_msg.set(Some(format!("Request Error: {}", e)));
+                    logging::error!("Failed to add torrent: {:?}", e);
+                    show_toast_with_signal(notifications, NotificationLevel::Error, "Torrent eklenemedi");
+                    set_error_msg.set(Some(format!("Error: {:?}", e)));
                     set_loading.set(false);
                 }
             }

frontend/src/components/torrent/table.rs

@@ -1,6 +1,7 @@
 use leptos::*;
 use leptos_use::{on_click_outside, use_timeout_fn};
 use crate::store::{get_action_messages, show_toast_with_signal};
+use crate::api;
 use shared::NotificationLevel;
 
 fn format_bytes(bytes: i64) -> String {
@@ -201,54 +202,33 @@ pub fn TorrentTable() -> impl IntoView {
 
     let on_action = move |(action, hash): (String, String)| {
         logging::log!("TorrentTable Action: {} on {}", action, hash);
-        // Note: Don't close menu here - ContextMenu's on_close handles it
-        // Closing here would dispose ContextMenu while still in callback chain
 
-        // Get action messages for toast (Clean Code: DRY)
         let (success_msg, error_msg) = get_action_messages(&action);
         let success_msg = success_msg.to_string();
         let error_msg = error_msg.to_string();
 
-        // Capture notifications signal before async (use_context unavailable in spawn_local)
         let notifications = store.notifications;
 
+        let hash = hash.clone();
+        let action = action.clone();
+
         spawn_local(async move {
-            let action_req = if action == "delete_with_data" {
-                "delete_with_data"
-            } else {
-                &action
+            let result = match action.as_str() {
+                "delete" => api::torrent::delete(&hash).await,
+                "delete_with_data" => api::torrent::delete_with_data(&hash).await,
+                "start" => api::torrent::start(&hash).await,
+                "stop" => api::torrent::stop(&hash).await,
+                _ => api::torrent::action(&hash, &action).await,
             };
 
-            let req_body = shared::TorrentActionRequest {
-                hash: hash.clone(),
-                action: action_req.to_string(),
-            };
-
-            let client = gloo_net::http::Request::post("/api/torrents/action").json(&req_body);
-
-            match client {
-                Ok(req) => match req.send().await {
-                    Ok(resp) => {
-                        if !resp.ok() {
-                            logging::error!(
-                                "Failed to execute action: {} {}",
-                                resp.status(),
-                                resp.status_text()
-                            );
-                            show_toast_with_signal(notifications, NotificationLevel::Error, error_msg);
-                        } else {
-                            logging::log!("Action {} executed successfully", action);
-                            show_toast_with_signal(notifications, NotificationLevel::Success, success_msg);
-                        }
-                    }
-                    Err(e) => {
-                        logging::error!("Network error executing action: {}", e);
-                        show_toast_with_signal(notifications, NotificationLevel::Error, format!("{}: Bağlantı hatası", error_msg));
-                    }
-                },
+            match result {
+                Ok(_) => {
+                    logging::log!("Action {} executed successfully", action);
+                    show_toast_with_signal(notifications, NotificationLevel::Success, success_msg);
+                }
                 Err(e) => {
-                    logging::error!("Failed to serialize request: {}", e);
-                    show_toast_with_signal(notifications, NotificationLevel::Error, error_msg);
+                    logging::error!("Action failed: {:?}", e);
+                    show_toast_with_signal(notifications, NotificationLevel::Error, format!("{}: {:?}", error_msg, e));
                 }
             }
         });