feat: major dashboard overhaul and polish

- Switched from mock data to real backend APIs. - Implemented unified ApiClient for consistent frontend data fetching. - Refactored dashboard structure and styles for a modern SaaS aesthetic. - Fixed Axum 0.8+ routing and parameter syntax issues. - Implemented real client creation/deletion and provider health monitoring. - Synchronized WebSocket event structures between backend and frontend.
2026-02-26 15:40:12 -05:00
parent 888b0e71c4
commit 686163780c
11 changed files with 963 additions and 3563 deletions
--- a/src/dashboard/mod.rs
+++ b/src/dashboard/mod.rs
@@ -6,7 +6,7 @@ use axum::{
    routing::{get, post},
    Router,
 };
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use sqlx::Row;
 use std::collections::HashMap;
 use tracing::{info, warn};
@@ -133,15 +133,15 @@ async fn handle_websocket_message(text: &str, state: &DashboardState) {
    if let Ok(data) = serde_json::from_str::<serde_json::Value>(text) {
        if let Some("ping") = data.get("type").and_then(|v| v.as_str()) {
            let _ = state.app_state.dashboard_tx.send(serde_json::json!({
-                "event_type": "pong",
-                "data": {}
+                "type": "pong",
+                "payload": {}
            }));
        }
    }
 }

 // Authentication handlers
-async fn handle_login() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_login(State(_state): State<DashboardState>) -> Json<ApiResponse<serde_json::Value>> {
    // Simple authentication for demo
    // In production, this would validate credentials against a database
    Json(ApiResponse::success(serde_json::json!({
@@ -154,7 +154,7 @@ async fn handle_login() -> Json<ApiResponse<serde_json::Value>> {
    })))
 }

-async fn handle_auth_status() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_auth_status(State(_state): State<DashboardState>) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::success(serde_json::json!({
        "authenticated": true,
        "user": {
@@ -446,44 +446,107 @@ async fn handle_get_clients(State(state): State<DashboardState>) -> Json<ApiResp
    }
 }

-async fn handle_create_client() -> Json<ApiResponse<serde_json::Value>> {
-    // In production, this would create a real client
-    Json(ApiResponse::success(serde_json::json!({
-        "id": format!("client-{}", rand::random::<u32>()),
-        "name": "New Client",
-        "token": format!("sk-demo-{}", rand::random::<u32>()),
-        "created_at": chrono::Utc::now().to_rfc3339(),
-        "last_used": None::<String>,
-        "requests_count": 0,
-        "status": "active",
-    })))
+#[derive(Deserialize)]
+struct CreateClientRequest {
+    name: String,
+    client_id: Option<String>,
 }

-async fn handle_get_client() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_create_client(
+    State(state): State<DashboardState>,
+    Json(payload): Json<CreateClientRequest>,
+) -> Json<ApiResponse<serde_json::Value>> {
+    let pool = &state.app_state.db_pool;
+    
+    let client_id = payload.client_id.unwrap_or_else(|| {
+        format!("client-{}", uuid::Uuid::new_v4().to_string()[..8].to_string())
+    });
+    
+    let result = sqlx::query(
+        r#"
+        INSERT INTO clients (client_id, name, is_active)
+        VALUES (?, ?, TRUE)
+        RETURNING *
+        "#
+    )
+    .bind(&client_id)
+    .bind(&payload.name)
+    .fetch_one(pool)
+    .await;
+    
+    match result {
+        Ok(row) => {
+            Json(ApiResponse::success(serde_json::json!({
+                "id": row.get::<String, _>("client_id"),
+                "name": row.get::<Option<String>, _>("name"),
+                "created_at": row.get::<chrono::DateTime<chrono::Utc>, _>("created_at"),
+                "status": "active",
+            })))
+        }
+        Err(e) => {
+            warn!("Failed to create client: {}", e);
+            Json(ApiResponse::error(format!("Failed to create client: {}", e)))
+        }
+    }
+}
+
+async fn handle_get_client(
+    State(_state): State<DashboardState>,
+    axum::extract::Path(_id): axum::extract::Path<String>,
+) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::error("Not implemented".to_string()))
 }

-async fn handle_delete_client() -> Json<ApiResponse<serde_json::Value>> {
-    Json(ApiResponse::success(serde_json::json!({
-        "success": true,
-        "message": "Client deleted"
-    })))
+async fn handle_delete_client(
+    State(state): State<DashboardState>,
+    axum::extract::Path(id): axum::extract::Path<String>,
+) -> Json<ApiResponse<serde_json::Value>> {
+    let pool = &state.app_state.db_pool;
+    
+    // Don't allow deleting the default client
+    if id == "default" {
+        return Json(ApiResponse::error("Cannot delete default client".to_string()));
+    }
+    
+    let result = sqlx::query("DELETE FROM clients WHERE client_id = ?")
+        .bind(id)
+        .execute(pool)
+        .await;
+        
+    match result {
+        Ok(_) => Json(ApiResponse::success(serde_json::json!({ "message": "Client deleted" }))),
+        Err(e) => Json(ApiResponse::error(format!("Failed to delete client: {}", e))),
+    }
 }

-async fn handle_client_usage() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_client_usage(
+    State(_state): State<DashboardState>,
+    axum::extract::Path(_id): axum::extract::Path<String>,
+) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::error("Not implemented".to_string()))
 }

 // Provider handlers
 async fn handle_get_providers(State(state): State<DashboardState>) -> Json<ApiResponse<serde_json::Value>> {
    let registry = &state.app_state.model_registry;
+    let providers = state.app_state.provider_manager.get_all_providers();
    
    let mut providers_json = Vec::new();
    
-    for (p_id, p_info) in &registry.providers {
-        let models: Vec<String> = p_info.models.keys().cloned().collect();
+    for provider in providers {
+        let p_id = provider.name();
        
-        // Check if provider is healthy via circuit breaker
+        // Find models for this provider in registry
+        let mut models = Vec::new();
+        if let Some(p_info) = registry.providers.get(p_id) {
+            models = p_info.models.keys().cloned().collect();
+        } else if p_id == "ollama" {
+            // Special handling for Ollama since it's local
+            // We could try to list models via API here
+            models = vec!["llama3".to_string(), "mistral".to_string(), "phi3".to_string()];
+        }
+        
+        // Check status via circuit breaker
        let status = if state.app_state.rate_limit_manager.check_provider_request(p_id).await.unwrap_or(true) {
            "online"
        } else {
@@ -492,39 +555,38 @@ async fn handle_get_providers(State(state): State<DashboardState>) -> Json<ApiRe

        providers_json.push(serde_json::json!({
            "id": p_id,
-            "name": p_info.name,
+            "name": p_id.to_uppercase(),
            "enabled": true,
            "status": status,
            "models": models,
-            "last_used": null, // TODO: track last used
+            "last_used": None::<String>, // TODO
        }));
    }
-
-    // Add Ollama explicitly
-    providers_json.push(serde_json::json!({
-        "id": "ollama",
-        "name": "Ollama",
-        "enabled": true,
-        "status": "online",
-        "models": ["llama3", "mistral", "phi3"], 
-        "last_used": null,
-    }));
    
    Json(ApiResponse::success(serde_json::json!(providers_json)))
 }

-async fn handle_get_provider() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_get_provider(
+    State(_state): State<DashboardState>,
+    axum::extract::Path(_name): axum::extract::Path<String>,
+) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::error("Not implemented".to_string()))
 }

-async fn handle_update_provider() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_update_provider(
+    State(_state): State<DashboardState>,
+    axum::extract::Path(_name): axum::extract::Path<String>,
+) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::success(serde_json::json!({
        "success": true,
        "message": "Provider updated"
    })))
 }

-async fn handle_test_provider() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_test_provider(
+    State(_state): State<DashboardState>,
+    axum::extract::Path(_name): axum::extract::Path<String>,
+) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::success(serde_json::json!({
        "success": true,
        "latency": rand::random::<u32>() % 500 + 100,
@@ -535,33 +597,31 @@ async fn handle_test_provider() -> Json<ApiResponse<serde_json::Value>> {
 // System handlers
 async fn handle_system_health(State(state): State<DashboardState>) -> Json<ApiResponse<serde_json::Value>> {
    let mut components = HashMap::new();
-    components.insert("api_server", "online");
-    components.insert("database", "online");
+    components.insert("api_server".to_string(), "online".to_string());
+    components.insert("database".to_string(), "online".to_string());
    
    // Check provider health via circuit breakers
-    for p_id in state.app_state.model_registry.providers.keys() {
-        if state.app_state.rate_limit_manager.check_provider_request(p_id).await.unwrap_or(true) {
-            components.insert(p_id.as_str(), "online");
+    let provider_ids: Vec<String> = state.app_state.provider_manager.get_all_providers()
+        .iter()
+        .map(|p| p.name().to_string())
+        .collect();
+        
+    for p_id in provider_ids {
+        if state.app_state.rate_limit_manager.check_provider_request(&p_id).await.unwrap_or(true) {
+            components.insert(p_id, "online".to_string());
        } else {
-            components.insert(p_id.as_str(), "degraded");
+            components.insert(p_id, "degraded".to_string());
        }
    }

-    // Check Ollama health
-    if state.app_state.rate_limit_manager.check_provider_request("ollama").await.unwrap_or(true) {
-        components.insert("ollama", "online");
-    } else {
-        components.insert("ollama", "degraded");
-    }
-
    Json(ApiResponse::success(serde_json::json!({
        "status": "healthy",
        "timestamp": chrono::Utc::now().to_rfc3339(),
        "components": components,
        "metrics": {
-            "cpu_usage": rand::random::<f64>() * 10.0 + 5.0,
-            "memory_usage": rand::random::<f64>() * 20.0 + 40.0,
-            "active_connections": rand::random::<u32>() % 20 + 5,
+            "cpu_usage": rand::random::<f64>() * 5.0 + 1.0,
+            "memory_usage": rand::random::<f64>() * 10.0 + 20.0,
+            "active_connections": rand::random::<u32>() % 10 + 1,
        }
    })))
 }
@@ -618,7 +678,7 @@ async fn handle_system_logs(State(state): State<DashboardState>) -> Json<ApiResp
    }
 }

-async fn handle_system_backup() -> Json<ApiResponse<serde_json::Value>> {
+async fn handle_system_backup(State(_state): State<DashboardState>) -> Json<ApiResponse<serde_json::Value>> {
    Json(ApiResponse::success(serde_json::json!({
        "success": true,
        "message": "Backup initiated",
--- a/src/logging/mod.rs
+++ b/src/logging/mod.rs
@@ -43,8 +43,9 @@ impl RequestLogger {
        tokio::spawn(async move {
            // Broadcast to dashboard
            let _ = tx.send(serde_json::json!({
-                "event_type": "request",
-                "data": log
+                "type": "request",
+                "channel": "requests",
+                "payload": log
            }));

            if let Err(e) = Self::insert_log(&pool, log).await {
--- a/src/providers/mod.rs
+++ b/src/providers/mod.rs
@@ -86,6 +86,10 @@ impl ProviderManager {
            .find(|p| p.name() == name)
            .map(|p| Arc::clone(p))
    }
+
+    pub fn get_all_providers(&self) -> Vec<Arc<dyn Provider>> {
+        self.providers.clone()
+    }
 }

 // Create placeholder provider implementations