Refactor model emit, and recent conn dropdown

src-tauri/src/analytics.rs

@@ -14,6 +14,8 @@ pub enum AnalyticsResource {
     Dialog,
     Environment,
     Folder,
+    GrpcConnection,
+    GrpcMessage,
     GrpcRequest,
     HttpRequest,
     HttpResponse,
@@ -30,6 +32,8 @@ impl AnalyticsResource {
             "CookieJar" => Some(AnalyticsResource::CookieJar),
             "Environment" => Some(AnalyticsResource::Environment),
             "Folder" => Some(AnalyticsResource::Folder),
+            "GrpcConnection" => Some(AnalyticsResource::GrpcConnection),
+            "GrpcMessage" => Some(AnalyticsResource::GrpcMessage),
             "GrpcRequest" => Some(AnalyticsResource::GrpcRequest),
             "HttpRequest" => Some(AnalyticsResource::HttpRequest),
             "HttpResponse" => Some(AnalyticsResource::HttpResponse),
@@ -91,6 +95,8 @@ fn resource_name(resource: AnalyticsResource) -> &'static str {
         AnalyticsResource::Environment => "environment",
         AnalyticsResource::Folder => "folder",
         AnalyticsResource::GrpcRequest => "grpc_request",
+        AnalyticsResource::GrpcConnection => "grpc_connection",
+        AnalyticsResource::GrpcMessage => "grpc_message",
         AnalyticsResource::HttpRequest => "http_request",
         AnalyticsResource::HttpResponse => "http_response",
         AnalyticsResource::KeyValue => "key_value",

src-tauri/src/http.rs

@@ -15,7 +15,7 @@ use reqwest::{multipart, Url};
 use sqlx::types::{Json, JsonValue};
 use tauri::AppHandle;
 
-use crate::{emit_side_effect, models, render, response_err};
+use crate::{models, render, response_err};
 
 pub async fn send_http_request(
     app_handle: &AppHandle,
@@ -363,9 +363,6 @@ pub async fn send_http_request(
             response = models::update_response_if_id(app_handle, &response)
                 .await
                 .expect("Failed to update response");
-            if !request.id.is_empty() {
-                emit_side_effect(app_handle, "upserted_model", &response);
-            }
 
             // Copy response to download path, if specified
             match (download_path, response.body_path.clone()) {
@@ -395,13 +392,8 @@ pub async fn send_http_request(
                         .collect::<Vec<_>>(),
                 );
                 cookie_jar.cookies = json_cookies;
-                match models::upsert_cookie_jar(&app_handle, &cookie_jar).await {
-                    Ok(updated_jar) => {
-                        emit_side_effect(app_handle, "upserted_model", &updated_jar);
-                    }
-                    Err(e) => {
-                        error!("Failed to update cookie jar: {}", e);
-                    }
+                if let Err(e) = models::upsert_cookie_jar(&app_handle, &cookie_jar).await {
+                    error!("Failed to update cookie jar: {}", e);
                 };
             }
 

src-tauri/src/main.rs

@@ -20,7 +20,6 @@ use fern::colors::ColoredLevelConfig;
 use futures::StreamExt;
 use log::{debug, error, info, warn};
 use rand::random;
-use serde::Serialize;
 use serde_json::{json, Value};
 use sqlx::migrate::Migrator;
 use sqlx::types::Json;
@@ -42,11 +41,12 @@ use window_ext::TrafficLightWindowExt;
 use crate::analytics::{AnalyticsAction, AnalyticsResource};
 use crate::http::send_http_request;
 use crate::models::{
-    cancel_pending_responses, create_response, delete_all_responses, delete_cookie_jar,
-    delete_environment, delete_folder, delete_request, delete_response, delete_workspace,
-    duplicate_grpc_request, duplicate_http_request, generate_id, get_cookie_jar, get_environment,
-    get_folder, get_grpc_request, get_http_request, get_key_value_raw, get_or_create_settings,
-    get_response, get_workspace, get_workspace_export_resources, list_cookie_jars,
+    cancel_pending_responses, create_response, delete_all_grpc_connections,
+    delete_all_http_responses, delete_cookie_jar, delete_environment, delete_folder,
+    delete_grpc_connection, delete_http_request, delete_http_response, delete_workspace,
+    duplicate_grpc_request, duplicate_http_request, get_cookie_jar, get_environment, get_folder,
+    get_grpc_request, get_http_request, get_http_response, get_key_value_raw,
+    get_or_create_settings, get_workspace, get_workspace_export_resources, list_cookie_jars,
     list_environments, list_folders, list_grpc_connections, list_grpc_messages, list_grpc_requests,
     list_requests, list_responses, list_workspaces, set_key_value_raw, update_response_if_id,
     update_settings, upsert_cookie_jar, upsert_environment, upsert_folder, upsert_grpc_connection,
@@ -119,7 +119,6 @@ async fn cmd_grpc_call_unary(
         .await
         .map_err(|e| e.to_string())?
     };
-    emit_side_effect(&app_handle, "upserted_model", conn.clone());
 
     {
         let req = req.clone();
@@ -140,11 +139,11 @@ async fn cmd_grpc_call_unary(
     };
 
     let uri = safe_uri(&req.url).map_err(|e| e.to_string())?;
-    let conn_id = generate_id(Some("grpc"));
+    let start = std::time::Instant::now();
     let msg = match grpc_handle
         .lock()
         .await
-        .connect(&conn_id, uri)
+        .connect(&conn.clone().id, uri)
         .await
         .unary(
             &req.service.unwrap_or_default(),
@@ -160,7 +159,7 @@ async fn cmd_grpc_call_unary(
                     message: msg,
                     workspace_id: req.workspace_id,
                     request_id: req.id,
-                    connection_id: conn.id,
+                    connection_id: conn.clone().id,
                     is_server: true,
                     ..Default::default()
                 },
@@ -170,6 +169,16 @@ async fn cmd_grpc_call_unary(
         Err(e) => return Err(e.to_string()),
     };
 
+    upsert_grpc_connection(
+        &app_handle,
+        &GrpcConnection {
+            elapsed: start.elapsed().as_millis() as i64,
+            ..conn
+        },
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
     msg.map_err(|e| e.to_string())
 }
 
@@ -194,7 +203,6 @@ async fn cmd_grpc_client_streaming(
         .await
         .map_err(|e| e.to_string())?
     };
-    emit_side_effect(&app_handle, "upserted_model", conn.clone());
 
     {
         let conn = conn.clone();
@@ -296,6 +304,7 @@ async fn cmd_grpc_client_streaming(
     let event_handler =
         app_handle.listen_global(format!("grpc_client_msg_{}", conn.id).as_str(), cb);
 
+    let start = std::time::Instant::now();
     let grpc_listen = {
         let app_handle = app_handle.clone();
         let conn = conn.clone();
@@ -308,10 +317,11 @@ async fn cmd_grpc_client_streaming(
                 .client_streaming(&conn.id, uri, &service, &method, in_msg_stream)
                 .await
                 .unwrap();
+            let message = serde_json::to_string(&msg).unwrap();
             upsert_grpc_message(
                 &app_handle,
                 &GrpcMessage {
-                    message: msg.to_string(),
+                    message,
                     workspace_id: req.workspace_id,
                     request_id: req.id,
                     connection_id: conn.id,
@@ -336,12 +346,21 @@ async fn cmd_grpc_client_streaming(
                             message: "Connection completed".to_string(),
                             workspace_id: req.workspace_id,
                             request_id: req.id,
-                            connection_id: conn.id,
+                            connection_id: conn.clone().id,
                             is_info: true,
                             ..Default::default()
                         },
                     )
-                    .await.map_err(|e| e.to_string()).unwrap();
+                    .await.unwrap();
+                    upsert_grpc_connection(
+                        &app_handle,
+                        &GrpcConnection {
+                            elapsed: start.elapsed().as_millis() as i64,
+                            ..conn
+                        },
+                    )
+                    .await
+                    .unwrap();
                 },
                 _ = cancelled_rx.changed() => {
                     upsert_grpc_message(
@@ -350,13 +369,22 @@ async fn cmd_grpc_client_streaming(
                             message: "Connection cancelled".to_string(),
                             workspace_id: req.workspace_id,
                             request_id: req.id,
-                            connection_id: conn.id,
+                            connection_id: conn.clone().id,
                             is_info: true,
                             ..Default::default()
                         },
                     )
+                    .await.unwrap();
+
+                    upsert_grpc_connection(
+                        &app_handle,
+                        &GrpcConnection {
+                            elapsed: start.elapsed().as_millis() as i64,
+                            ..conn
+                        },
+                    )
                     .await
-                    .map_err(|e| e.to_string()).unwrap();
+                    .unwrap();
                 },
             }
             app_handle.unlisten(event_handler);
@@ -388,7 +416,6 @@ async fn cmd_grpc_streaming(
         .await
         .map_err(|e| e.to_string())?
     };
-    emit_side_effect(&app_handle, "upserted_model", conn.clone());
 
     {
         let conn = conn.clone();
@@ -423,6 +450,7 @@ async fn cmd_grpc_streaming(
         }
     };
 
+    let start = std::time::Instant::now();
     let mut stream = grpc_handle
         .lock()
         .await
@@ -533,26 +561,40 @@ async fn cmd_grpc_streaming(
                             message: "Connection completed".to_string(),
                             workspace_id: req.workspace_id,
                             request_id: req.id,
-                            connection_id: conn.id,
+                            connection_id: conn.clone().id,
                             is_info: true,
                             ..Default::default()
                         },
                     )
-                    .await.map_err(|e| e.to_string()).unwrap();
+                    .await.unwrap();
+                    upsert_grpc_connection(
+                        &app_handle,
+                        &GrpcConnection{
+                            elapsed: start.elapsed().as_millis() as i64,
+                            ..conn
+                        },
+                    ).await.unwrap();
                 },
                 _ = cancelled_rx.changed() => {
-                        upsert_grpc_message(
-                            &app_handle,
-                            &GrpcMessage {
-                                message: "Connection cancelled".to_string(),
-                                workspace_id: req.workspace_id,
-                                request_id: req.id,
-                                connection_id: conn.id,
-                                is_info: true,
-                                ..Default::default()
-                            },
-                        )
-                        .await.map_err(|e| e.to_string()).unwrap();
+                    upsert_grpc_message(
+                        &app_handle,
+                        &GrpcMessage {
+                            message: "Connection cancelled".to_string(),
+                            workspace_id: req.workspace_id,
+                            request_id: req.id,
+                            connection_id: conn.clone().id,
+                            is_info: true,
+                            ..Default::default()
+                        },
+                    )
+                    .await.unwrap();
+                    upsert_grpc_connection(
+                        &app_handle,
+                        &GrpcConnection{
+                            elapsed: start.elapsed().as_millis() as i64,
+                            ..conn
+                        },
+                    ).await.unwrap();
                 },
             }
             app_handle.unlisten(event_handler);
@@ -585,7 +627,6 @@ async fn cmd_grpc_server_streaming(
         .await
         .map_err(|e| e.to_string())?
     };
-    emit_side_effect(&app_handle, "upserted_model", conn.clone());
 
     {
         let req = req.clone();
@@ -647,6 +688,7 @@ async fn cmd_grpc_server_streaming(
     let event_handler =
         app_handle.listen_global(format!("grpc_client_msg_{}", conn.id).as_str(), cb);
 
+    let start = std::time::Instant::now();
     let grpc_listen = {
         let conn_id = conn.clone().id;
         let app_handle = app_handle.clone();
@@ -694,32 +736,46 @@ async fn cmd_grpc_server_streaming(
         tauri::async_runtime::spawn(async move {
             tokio::select! {
                 _ = grpc_listen => {
-                        upsert_grpc_message(
-                            &app_handle,
-                            &GrpcMessage {
-                                message: "Connection completed".to_string(),
-                                workspace_id: req.workspace_id,
-                                request_id: req.id,
-                                connection_id: conn.id,
-                                is_info: true,
-                                ..Default::default()
-                            },
-                        )
-                        .await.unwrap();
+                    upsert_grpc_message(
+                        &app_handle,
+                        &GrpcMessage {
+                            message: "Connection completed".to_string(),
+                            workspace_id: req.workspace_id,
+                            request_id: req.id,
+                            connection_id: conn.clone().id,
+                            is_info: true,
+                            ..Default::default()
+                        },
+                    )
+                    .await.unwrap();
+                    upsert_grpc_connection(
+                        &app_handle,
+                        &GrpcConnection{
+                            elapsed: start.elapsed().as_millis() as i64,
+                            ..conn
+                        },
+                    ).await.unwrap();
                 },
                 _ = cancelled_rx.changed() => {
-                        upsert_grpc_message(
-                            &app_handle,
-                            &GrpcMessage {
-                                message: "Connection cancelled".to_string(),
-                                workspace_id: req.workspace_id,
-                                request_id: req.id,
-                                connection_id: conn.id,
-                                is_info: true,
-                                ..Default::default()
-                            },
-                        )
-                        .await.unwrap();
+                    upsert_grpc_message(
+                        &app_handle,
+                        &GrpcMessage {
+                            message: "Connection cancelled".to_string(),
+                            workspace_id: req.workspace_id,
+                            request_id: req.id,
+                            connection_id: conn.clone().id,
+                            is_info: true,
+                            ..Default::default()
+                        },
+                    )
+                    .await.unwrap();
+                    upsert_grpc_connection(
+                        &app_handle,
+                        &GrpcConnection{
+                            elapsed: start.elapsed().as_millis() as i64,
+                            ..conn
+                        },
+                    ).await.unwrap();
                 },
             }
             app_handle.unlisten(event_handler);
@@ -774,7 +830,7 @@ async fn cmd_filter_response(
     response_id: &str,
     filter: &str,
 ) -> Result<String, String> {
-    let response = get_response(&app_handle, response_id)
+    let response = get_http_response(&app_handle, response_id)
         .await
         .expect("Failed to get response");
 
@@ -958,8 +1014,6 @@ async fn cmd_send_request(
         None
     };
 
-    emit_side_effect(&app_handle, "upserted_model", response.clone());
-
     send_http_request(
         &app_handle,
         request.clone(),
@@ -982,7 +1036,6 @@ async fn response_err(
     response = update_response_if_id(&app_handle, &response)
         .await
         .expect("Failed to update response");
-    emit_side_effect(&app_handle, "upserted_model", &response);
     Ok(response)
 }
 
@@ -1009,12 +1062,10 @@ async fn cmd_track_event(
 }
 
 #[tauri::command]
-async fn cmd_set_update_mode(
-    update_mode: &str,
-    window: Window<Wry>,
-    app_handle: AppHandle,
-) -> Result<KeyValue, String> {
-    cmd_set_key_value("app", "update_mode", update_mode, window, app_handle).await
+async fn cmd_set_update_mode(update_mode: &str, app_handle: AppHandle) -> Result<KeyValue, String> {
+    cmd_set_key_value("app", "update_mode", update_mode, app_handle)
+        .await
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1032,64 +1083,46 @@ async fn cmd_set_key_value(
     namespace: &str,
     key: &str,
     value: &str,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<KeyValue, String> {
-    let (key_value, created) = set_key_value_raw(&app_handle, namespace, key, value).await;
-
-    if created {
-        emit_and_return(&window, "upserted_model", key_value)
-    } else {
-        emit_and_return(&window, "upserted_model", key_value)
-    }
+    let (key_value, _created) = set_key_value_raw(&app_handle, namespace, key, value).await;
+    Ok(key_value)
 }
 
 #[tauri::command]
-async fn cmd_create_workspace(
-    name: &str,
-    window: Window<Wry>,
-    app_handle: AppHandle,
-) -> Result<Workspace, String> {
-    let created_workspace = upsert_workspace(&app_handle, Workspace::new(name.to_string()))
+async fn cmd_create_workspace(name: &str, app_handle: AppHandle) -> Result<Workspace, String> {
+    upsert_workspace(&app_handle, Workspace::new(name.to_string()))
         .await
-        .expect("Failed to create Workspace");
-
-    emit_and_return(&window, "upserted_model", created_workspace)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_update_cookie_jar(
     cookie_jar: CookieJar,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<CookieJar, String> {
-    let updated = upsert_cookie_jar(&app_handle, &cookie_jar)
+    upsert_cookie_jar(&app_handle, &cookie_jar)
         .await
-        .expect("Failed to update cookie jar");
-
-    emit_and_return(&window, "upserted_model", updated)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_delete_cookie_jar(
-    window: Window<Wry>,
     app_handle: AppHandle,
     cookie_jar_id: &str,
 ) -> Result<CookieJar, String> {
-    let req = delete_cookie_jar(&app_handle, cookie_jar_id)
+    delete_cookie_jar(&app_handle, cookie_jar_id)
         .await
-        .expect("Failed to delete cookie jar");
-    emit_and_return(&window, "deleted_model", req)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_create_cookie_jar(
     workspace_id: &str,
     name: &str,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<CookieJar, String> {
-    let created_cookie_jar = upsert_cookie_jar(
+    upsert_cookie_jar(
         &app_handle,
         &CookieJar {
             name: name.to_string(),
@@ -1098,9 +1131,7 @@ async fn cmd_create_cookie_jar(
         },
     )
     .await
-    .expect("Failed to create cookie jar");
-
-    emit_and_return(&window, "upserted_model", created_cookie_jar)
+    .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1108,10 +1139,9 @@ async fn cmd_create_environment(
     workspace_id: &str,
     name: &str,
     variables: Vec<EnvironmentVariable>,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<Environment, String> {
-    let created_environment = upsert_environment(
+    upsert_environment(
         &app_handle,
         Environment {
             workspace_id: workspace_id.to_string(),
@@ -1121,9 +1151,7 @@ async fn cmd_create_environment(
         },
     )
     .await
-    .expect("Failed to create environment");
-
-    emit_and_return(&window, "upserted_model", created_environment)
+    .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1132,10 +1160,9 @@ async fn cmd_create_grpc_request(
     name: &str,
     sort_priority: f64,
     folder_id: Option<&str>,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<GrpcRequest, String> {
-    let created = upsert_grpc_request(
+    upsert_grpc_request(
         &app_handle,
         &GrpcRequest {
             workspace_id: workspace_id.to_string(),
@@ -1146,21 +1173,17 @@ async fn cmd_create_grpc_request(
         },
     )
     .await
-    .expect("Failed to create grpc request");
-
-    emit_and_return(&window, "upserted_model", created)
+    .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_duplicate_grpc_request(
     id: &str,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<GrpcRequest, String> {
-    let request = duplicate_grpc_request(&app_handle, id)
+    duplicate_grpc_request(&app_handle, id)
         .await
-        .expect("Failed to duplicate grpc request");
-    emit_and_return(&window, "upserted_model", request)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1169,10 +1192,9 @@ async fn cmd_create_http_request(
     name: &str,
     sort_priority: f64,
     folder_id: Option<&str>,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<HttpRequest, String> {
-    let created_request = upsert_http_request(
+    upsert_http_request(
         &app_handle,
         HttpRequest {
             workspace_id: workspace_id.to_string(),
@@ -1184,95 +1206,77 @@ async fn cmd_create_http_request(
         },
     )
     .await
-    .expect("Failed to create http request");
-
-    emit_and_return(&window, "upserted_model", created_request)
+    .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_duplicate_http_request(
     id: &str,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<HttpRequest, String> {
-    let request = duplicate_http_request(&app_handle, id)
+    duplicate_http_request(&app_handle, id)
         .await
-        .expect("Failed to duplicate http request");
-    emit_and_return(&window, "upserted_model", request)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_update_workspace(
     workspace: Workspace,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<Workspace, String> {
-    let updated_workspace = upsert_workspace(&app_handle, workspace)
+    upsert_workspace(&app_handle, workspace)
         .await
-        .expect("Failed to update request");
-
-    emit_and_return(&window, "upserted_model", updated_workspace)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_update_environment(
     environment: Environment,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<Environment, String> {
-    let updated_environment = upsert_environment(&app_handle, environment)
+    upsert_environment(&app_handle, environment)
         .await
-        .expect("Failed to update environment");
-
-    emit_and_return(&window, "upserted_model", updated_environment)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_update_grpc_request(
     request: GrpcRequest,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<GrpcRequest, String> {
-    let updated_request = upsert_grpc_request(&app_handle, &request)
+    upsert_grpc_request(&app_handle, &request)
         .await
-        .expect("Failed to update grpc request");
-    emit_and_return(&window, "upserted_model", updated_request)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_update_http_request(
     request: HttpRequest,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<HttpRequest, String> {
-    let updated_request = upsert_http_request(&app_handle, request)
+    upsert_http_request(&app_handle, request)
         .await
-        .expect("Failed to update request");
-    emit_and_return(&window, "upserted_model", updated_request)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_delete_grpc_request(
-    window: Window<Wry>,
     app_handle: AppHandle,
     request_id: &str,
 ) -> Result<HttpRequest, String> {
-    let req = delete_request(&app_handle, request_id)
+    delete_http_request(&app_handle, request_id)
         .await
-        .expect("Failed to delete request");
-    emit_and_return(&window, "deleted_model", req)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_delete_http_request(
-    window: Window<Wry>,
     app_handle: AppHandle,
     request_id: &str,
 ) -> Result<HttpRequest, String> {
-    let req = delete_request(&app_handle, request_id)
+    delete_http_request(&app_handle, request_id)
         .await
-        .expect("Failed to delete request");
-    emit_and_return(&window, "deleted_model", req)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1291,10 +1295,9 @@ async fn cmd_create_folder(
     name: &str,
     sort_priority: f64,
     folder_id: Option<&str>,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<Folder, String> {
-    let created_request = upsert_folder(
+    upsert_folder(
         &app_handle,
         Folder {
             workspace_id: workspace_id.to_string(),
@@ -1305,45 +1308,31 @@ async fn cmd_create_folder(
         },
     )
     .await
-    .expect("Failed to create folder");
-
-    emit_and_return(&window, "upserted_model", created_request)
+    .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
-async fn cmd_update_folder(
-    folder: Folder,
-    window: Window<Wry>,
-    app_handle: AppHandle,
-) -> Result<Folder, String> {
-    let updated_folder = upsert_folder(&app_handle, folder)
+async fn cmd_update_folder(folder: Folder, app_handle: AppHandle) -> Result<Folder, String> {
+    upsert_folder(&app_handle, folder)
         .await
-        .expect("Failed to update request");
-    emit_and_return(&window, "upserted_model", updated_folder)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
-async fn cmd_delete_folder(
-    window: Window<Wry>,
-    app_handle: AppHandle,
-    folder_id: &str,
-) -> Result<Folder, String> {
-    let req = delete_folder(&app_handle, folder_id)
+async fn cmd_delete_folder(app_handle: AppHandle, folder_id: &str) -> Result<Folder, String> {
+    delete_folder(&app_handle, folder_id)
         .await
-        .expect("Failed to delete folder");
-    emit_and_return(&window, "deleted_model", req)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 async fn cmd_delete_environment(
-    window: Window<Wry>,
     app_handle: AppHandle,
     environment_id: &str,
 ) -> Result<Environment, String> {
-    let req = delete_environment(&app_handle, environment_id)
+    delete_environment(&app_handle, environment_id)
         .await
-        .expect("Failed to delete environment");
-    emit_and_return(&window, "deleted_model", req)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1409,14 +1398,11 @@ async fn cmd_get_settings(app_handle: AppHandle) -> Result<Settings, ()> {
 #[tauri::command]
 async fn cmd_update_settings(
     settings: Settings,
-    window: Window<Wry>,
     app_handle: AppHandle,
 ) -> Result<Settings, String> {
-    let updated_settings = update_settings(&app_handle, settings)
+    update_settings(&app_handle, settings)
         .await
-        .expect("Failed to update settings");
-
-    emit_and_return(&window, "upserted_model", updated_settings)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1497,20 +1483,38 @@ async fn cmd_list_http_responses(
 }
 
 #[tauri::command]
-async fn cmd_delete_response(
-    id: &str,
-    window: Window<Wry>,
-    app_handle: AppHandle,
-) -> Result<HttpResponse, String> {
-    let response = delete_response(&app_handle, id)
+async fn cmd_delete_http_response(id: &str, app_handle: AppHandle) -> Result<HttpResponse, String> {
+    delete_http_response(&app_handle, id)
         .await
-        .expect("Failed to delete response");
-    emit_and_return(&window, "deleted_model", response)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
-async fn cmd_delete_all_responses(request_id: &str, app_handle: AppHandle) -> Result<(), String> {
-    delete_all_responses(&app_handle, request_id)
+async fn cmd_delete_grpc_connection(
+    id: &str,
+    app_handle: AppHandle,
+) -> Result<GrpcConnection, String> {
+    delete_grpc_connection(&app_handle, id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn cmd_delete_all_grpc_connections(
+    request_id: &str,
+    app_handle: AppHandle,
+) -> Result<(), String> {
+    delete_all_grpc_connections(&app_handle, request_id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn cmd_delete_all_http_responses(
+    request_id: &str,
+    app_handle: AppHandle,
+) -> Result<(), String> {
+    delete_all_http_responses(&app_handle, request_id)
         .await
         .map_err(|e| e.to_string())
 }
@@ -1544,14 +1548,12 @@ async fn cmd_new_window(window: Window<Wry>, url: &str) -> Result<(), String> {
 
 #[tauri::command]
 async fn cmd_delete_workspace(
-    window: Window<Wry>,
     app_handle: AppHandle,
     workspace_id: &str,
 ) -> Result<Workspace, String> {
-    let workspace = delete_workspace(&app_handle, workspace_id)
+    delete_workspace(&app_handle, workspace_id)
         .await
-        .expect("Failed to delete Workspace");
-    emit_and_return(&window, "deleted_model", workspace)
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -1646,13 +1648,15 @@ fn main() {
             cmd_create_grpc_request,
             cmd_create_http_request,
             cmd_create_workspace,
-            cmd_delete_all_responses,
+            cmd_delete_all_http_responses,
+            cmd_delete_all_grpc_connections,
             cmd_delete_cookie_jar,
             cmd_delete_environment,
             cmd_delete_folder,
             cmd_delete_grpc_request,
+            cmd_delete_grpc_connection,
             cmd_delete_http_request,
-            cmd_delete_response,
+            cmd_delete_http_response,
             cmd_delete_workspace,
             cmd_duplicate_http_request,
             cmd_duplicate_grpc_request,
@@ -1858,21 +1862,6 @@ fn create_window(handle: &AppHandle, url: Option<&str>) -> Window<Wry> {
     win
 }
 
-/// Emit an event to all windows, with a source window
-fn emit_and_return<S: Serialize + Clone, E>(
-    current_window: &Window<Wry>,
-    event: &str,
-    payload: S,
-) -> Result<S, E> {
-    current_window.emit_all(event, &payload).unwrap();
-    Ok(payload)
-}
-
-/// Emit an event to all windows, used for side-effects where there is no source window to attribute. This
-fn emit_side_effect<S: Serialize + Clone>(app_handle: &AppHandle, event: &str, payload: S) {
-    app_handle.emit_all(event, &payload).unwrap();
-}
-
 async fn get_update_mode(app_handle: &AppHandle) -> UpdateMode {
     let settings = get_or_create_settings(app_handle).await;
     update_mode_from_str(settings.update_channel.as_str())

src-tauri/src/models.rs

@@ -217,6 +217,7 @@ pub struct GrpcConnection {
     pub updated_at: NaiveDateTime,
     pub service: String,
     pub method: String,
+    pub elapsed: i64,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
@@ -416,10 +417,10 @@ pub async fn delete_workspace(app_handle: &AppHandle, id: &str) -> Result<Worksp
     .await;
 
     for r in list_responses_by_workspace_id(app_handle, id).await? {
-        delete_response(app_handle, &r.id).await?;
+        delete_http_response(app_handle, &r.id).await?;
     }
 
-    Ok(workspace)
+    emit_deleted_model(app_handle, workspace)
 }
 
 pub async fn get_cookie_jar(app_handle: &AppHandle, id: &str) -> Result<CookieJar, sqlx::Error> {
@@ -471,7 +472,7 @@ pub async fn delete_cookie_jar(app_handle: &AppHandle, id: &str) -> Result<Cooki
     .execute(&db)
     .await;
 
-    Ok(cookie_jar)
+    emit_deleted_model(app_handle, cookie_jar)
 }
 
 pub async fn duplicate_grpc_request(
@@ -522,7 +523,10 @@ pub async fn upsert_grpc_request(
     .execute(&db)
     .await?;
 
-    get_grpc_request(app_handle, &id).await
+    match get_grpc_request(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn get_grpc_request(
@@ -577,24 +581,29 @@ pub async fn upsert_grpc_connection(
     sqlx::query!(
         r#"
             INSERT INTO grpc_connections (
-                id, workspace_id, request_id, service, method
+                id, workspace_id, request_id, service, method, elapsed
             )
-            VALUES (?, ?, ?, ?, ?)
+            VALUES (?, ?, ?, ?, ?, ?)
             ON CONFLICT (id) DO UPDATE SET
                 updated_at = CURRENT_TIMESTAMP,
                 service = excluded.service,
-                method = excluded.method
+                method = excluded.method,
+                elapsed = excluded.elapsed
         "#,
         id,
         connection.workspace_id,
         connection.request_id,
         connection.service,
         connection.method,
+        connection.elapsed,
     )
     .execute(&db)
     .await?;
 
-    get_grpc_connection(app_handle, &id).await
+    match get_grpc_connection(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn get_grpc_connection(
@@ -605,7 +614,9 @@ pub async fn get_grpc_connection(
     sqlx::query_as!(
         GrpcConnection,
         r#"
-            SELECT id, model, workspace_id, request_id, created_at, updated_at, service, method
+            SELECT
+                id, model, workspace_id, request_id, created_at, updated_at, service,
+                method, elapsed
             FROM grpc_connections
             WHERE id = ?
         "#,
@@ -623,7 +634,9 @@ pub async fn list_grpc_connections(
     sqlx::query_as!(
         GrpcConnection,
         r#"
-            SELECT id, model, workspace_id, request_id, created_at, updated_at, service, method
+            SELECT
+                id, model, workspace_id, request_id, created_at, updated_at, service,
+                method, elapsed
             FROM grpc_connections
             WHERE request_id = ?
             ORDER BY created_at DESC
@@ -666,9 +679,8 @@ pub async fn upsert_grpc_message(
     .execute(&db)
     .await?;
 
-    let msg = get_grpc_message(app_handle, &id).await;
-    match msg {
-        Ok(msg) => Ok(emit_upserted_model(app_handle, msg.clone()).await),
+    match get_grpc_message(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
         Err(e) => Err(e),
     }
 }
@@ -743,7 +755,10 @@ pub async fn upsert_cookie_jar(
     .execute(&db)
     .await?;
 
-    get_cookie_jar(&app_handle, &id).await
+    match get_cookie_jar(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn list_environments(
@@ -781,7 +796,7 @@ pub async fn delete_environment(
     .execute(&db)
     .await;
 
-    Ok(env)
+    emit_deleted_model(app_handle, env)
 }
 
 async fn get_settings(app_handle: &AppHandle) -> Result<Settings, sqlx::Error> {
@@ -837,7 +852,11 @@ pub async fn update_settings(
     )
     .execute(&db)
     .await?;
-    get_settings(app_handle).await
+
+    match get_settings(app_handle).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn upsert_environment(
@@ -868,7 +887,11 @@ pub async fn upsert_environment(
     )
     .execute(&db)
     .await?;
-    get_environment(app_handle, &id).await
+
+    match get_environment(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn get_environment(app_handle: &AppHandle, id: &str) -> Result<Environment, sqlx::Error> {
@@ -924,7 +947,7 @@ pub async fn list_folders(
 }
 
 pub async fn delete_folder(app_handle: &AppHandle, id: &str) -> Result<Folder, sqlx::Error> {
-    let env = get_folder(app_handle, id).await?;
+    let folder = get_folder(app_handle, id).await?;
     let db = get_db(app_handle).await;
     let _ = sqlx::query!(
         r#"
@@ -936,7 +959,7 @@ pub async fn delete_folder(app_handle: &AppHandle, id: &str) -> Result<Folder, s
     .execute(&db)
     .await;
 
-    Ok(env)
+    emit_deleted_model(app_handle, folder)
 }
 
 pub async fn upsert_folder(app_handle: &AppHandle, r: Folder) -> Result<Folder, sqlx::Error> {
@@ -968,7 +991,10 @@ pub async fn upsert_folder(app_handle: &AppHandle, r: Folder) -> Result<Folder,
     .execute(&db)
     .await?;
 
-    get_folder(&app_handle, &id).await
+    match get_folder(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn duplicate_http_request(
@@ -1032,7 +1058,10 @@ pub async fn upsert_http_request(
     .execute(&db)
     .await?;
 
-    get_http_request(app_handle, &id).await
+    match get_http_request(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn list_requests(
@@ -1084,11 +1113,14 @@ pub async fn get_http_request(
     .await
 }
 
-pub async fn delete_request(app_handle: &AppHandle, id: &str) -> Result<HttpRequest, sqlx::Error> {
+pub async fn delete_http_request(
+    app_handle: &AppHandle,
+    id: &str,
+) -> Result<HttpRequest, sqlx::Error> {
     let req = get_http_request(app_handle, id).await?;
 
     // DB deletes will cascade but this will delete the files
-    delete_all_responses(app_handle, id).await?;
+    delete_all_http_responses(app_handle, id).await?;
 
     let db = get_db(app_handle).await;
     let _ = sqlx::query!(
@@ -1101,7 +1133,7 @@ pub async fn delete_request(app_handle: &AppHandle, id: &str) -> Result<HttpRequ
     .execute(&db)
     .await;
 
-    Ok(req)
+    emit_deleted_model(app_handle, req)
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -1148,7 +1180,7 @@ pub async fn create_response(
     .execute(&db)
     .await?;
 
-    get_response(app_handle, &id).await
+    get_http_response(app_handle, &id).await
 }
 
 pub async fn cancel_pending_responses(app_handle: &AppHandle) -> Result<(), sqlx::Error> {
@@ -1214,7 +1246,10 @@ pub async fn upsert_workspace(
     .execute(&db)
     .await?;
 
-    get_workspace(app_handle, &id).await
+    match get_workspace(app_handle, &id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
 pub async fn update_response(
@@ -1245,10 +1280,17 @@ pub async fn update_response(
     )
     .execute(&db)
     .await?;
-    get_response(app_handle, &response.id).await
+
+    match get_http_response(app_handle, &response.id).await {
+        Ok(m) => Ok(emit_upserted_model(app_handle, m)),
+        Err(e) => Err(e),
+    }
 }
 
-pub async fn get_response(app_handle: &AppHandle, id: &str) -> Result<HttpResponse, sqlx::Error> {
+pub async fn get_http_response(
+    app_handle: &AppHandle,
+    id: &str,
+) -> Result<HttpResponse, sqlx::Error> {
     let db = get_db(app_handle).await;
     sqlx::query_as!(
         HttpResponse,
@@ -1317,11 +1359,31 @@ pub async fn list_responses_by_workspace_id(
     .await
 }
 
-pub async fn delete_response(
+pub async fn delete_grpc_connection(
+    app_handle: &AppHandle,
+    id: &str,
+) -> Result<GrpcConnection, sqlx::Error> {
+    let resp = get_grpc_connection(app_handle, id).await?;
+
+    let db = get_db(app_handle).await;
+    let _ = sqlx::query!(
+        r#"
+            DELETE FROM grpc_connections
+            WHERE id = ?
+        "#,
+        id,
+    )
+    .execute(&db)
+    .await;
+
+    emit_deleted_model(app_handle, resp)
+}
+
+pub async fn delete_http_response(
     app_handle: &AppHandle,
     id: &str,
 ) -> Result<HttpResponse, sqlx::Error> {
-    let resp = get_response(app_handle, id).await?;
+    let resp = get_http_response(app_handle, id).await?;
 
     // Delete the body file if it exists
     if let Some(p) = resp.body_path.clone() {
@@ -1341,15 +1403,25 @@ pub async fn delete_response(
     .execute(&db)
     .await;
 
-    Ok(resp)
+    emit_deleted_model(app_handle, resp)
 }
 
-pub async fn delete_all_responses(
+pub async fn delete_all_grpc_connections(
+    app_handle: &AppHandle,
+    request_id: &str,
+) -> Result<(), sqlx::Error> {
+    for r in list_grpc_connections(app_handle, request_id).await? {
+        delete_grpc_connection(app_handle, &r.id).await?;
+    }
+    Ok(())
+}
+
+pub async fn delete_all_http_responses(
     app_handle: &AppHandle,
     request_id: &str,
 ) -> Result<(), sqlx::Error> {
     for r in list_responses(app_handle, request_id, None).await? {
-        delete_response(app_handle, &r.id).await?;
+        delete_http_response(app_handle, &r.id).await?;
     }
     Ok(())
 }
@@ -1406,13 +1478,18 @@ pub async fn get_workspace_export_resources(
     };
 }
 
-async fn emit_upserted_model<S: Serialize + Clone>(app_handle: &AppHandle, model: S) -> S {
+fn emit_upserted_model<S: Serialize + Clone>(app_handle: &AppHandle, model: S) -> S {
     app_handle
         .emit_all("upserted_model", model.clone())
         .unwrap();
     model
 }
 
+fn emit_deleted_model<S: Serialize + Clone, E>(app_handle: &AppHandle, model: S) -> Result<S, E> {
+    app_handle.emit_all("deleted_model", model.clone()).unwrap();
+    Ok(model)
+}
+
 async fn get_db(app_handle: &AppHandle) -> Pool<Sqlite> {
     let db_state = app_handle.state::<Mutex<Pool<Sqlite>>>();
     let db = &*db_state.lock().await;