Cookie Support (#19)

src-tauri/src/main.rs

@@ -3,27 +3,28 @@
     windows_subsystem = "windows"
 )]
 
+extern crate core;
 #[cfg(target_os = "macos")]
 #[macro_use]
 extern crate objc;
 
 use std::collections::HashMap;
 use std::env::current_dir;
-use std::fs::{create_dir_all, read_to_string, File};
+use std::fs::{create_dir_all, File, read_to_string};
 use std::process::exit;
 
 use fern::colors::ColoredLevelConfig;
 use log::{debug, error, info, warn};
 use rand::random;
 use serde::Serialize;
-use serde_json::Value;
+use serde_json::{json, Value};
+use sqlx::{Pool, Sqlite, SqlitePool};
 use sqlx::migrate::Migrator;
 use sqlx::types::Json;
-use sqlx::{Pool, Sqlite, SqlitePool};
-#[cfg(target_os = "macos")]
-use tauri::TitleBarStyle;
 use tauri::{AppHandle, RunEvent, State, Window, WindowUrl, Wry};
 use tauri::{Manager, WindowEvent};
+#[cfg(target_os = "macos")]
+use tauri::TitleBarStyle;
 use tauri_plugin_log::{fern, LogTarget};
 use tauri_plugin_window_state::{StateFlags, WindowExt};
 use tokio::sync::Mutex;
@@ -78,17 +79,36 @@ async fn migrate_db(
 async fn send_ephemeral_request(
     mut request: models::HttpRequest,
     environment_id: Option<&str>,
+    cookie_jar_id: Option<&str>,
     app_handle: AppHandle<Wry>,
     db_instance: State<'_, Mutex<Pool<Sqlite>>>,
 ) -> Result<models::HttpResponse, String> {
     let pool = &*db_instance.lock().await;
     let response = models::HttpResponse::new();
-    let environment_id2 = environment_id.unwrap_or("n/a").to_string();
     request.id = "".to_string();
+    let environment = match environment_id {
+        Some(id) => Some(
+            models::get_environment(id, pool)
+                .await
+                .expect("Failed to get environment"),
+        ),
+        None => None,
+    };
+    let cookie_jar = match cookie_jar_id {
+        Some(id) => Some(
+            models::get_cookie_jar(id, pool)
+                .await
+                .expect("Failed to get cookie jar"),
+        ),
+        None => None,
+    };
+
+    // let cookie_jar_id2 = cookie_jar_id.unwrap_or("").to_string();
     send_http_request(
         request,
         &response,
-        &environment_id2,
+        environment,
+        cookie_jar,
         &app_handle,
         pool,
         None,
@@ -151,6 +171,13 @@ async fn import_data(
         )
         .await
         {
+            analytics::track_event(
+                &window.app_handle(),
+                AnalyticsResource::App,
+                AnalyticsAction::Import,
+                Some(json!({ "plugin": plugin_name })),
+            )
+            .await;
             result = Some(r);
             break;
         }
@@ -217,8 +244,17 @@ async fn export_data(
     serde_json::to_writer_pretty(&f, &export_data)
         .map_err(|e| e.to_string())
         .expect("Failed to write");
+
     f.sync_all().expect("Failed to sync");
-    info!("Exported Yaak workspace to {:?}", export_path);
+
+    analytics::track_event(
+        &app_handle,
+        AnalyticsResource::App,
+        AnalyticsAction::Export,
+        None,
+    )
+    .await;
+
     Ok(())
 }
 
@@ -228,47 +264,56 @@ async fn send_request(
     db_instance: State<'_, Mutex<Pool<Sqlite>>>,
     request_id: &str,
     environment_id: Option<&str>,
+    cookie_jar_id: Option<&str>,
     download_dir: Option<&str>,
 ) -> Result<models::HttpResponse, String> {
     let pool = &*db_instance.lock().await;
+    let app_handle = window.app_handle();
 
-    let req = models::get_request(request_id, pool)
+    let request = models::get_request(request_id, pool)
         .await
         .expect("Failed to get request");
 
-    let response = models::create_response(&req.id, 0, "", 0, None, None, None, vec![], pool)
+    let environment = match environment_id {
+        Some(id) => Some(
+            models::get_environment(id, pool)
+                .await
+                .expect("Failed to get environment"),
+        ),
+        None => None,
+    };
+
+    let cookie_jar = match cookie_jar_id {
+        Some(id) => Some(
+            models::get_cookie_jar(id, pool)
+                .await
+                .expect("Failed to get cookie jar"),
+        ),
+        None => None,
+    };
+
+    let response = models::create_response(&request.id, 0, "", 0, None, None, None, vec![], pool)
         .await
         .expect("Failed to create response");
 
-    let response2 = response.clone();
-    let environment_id2 = environment_id.unwrap_or("n/a").to_string();
-    let app_handle2 = window.app_handle().clone();
-    let pool2 = pool.clone();
-
     let download_path = if let Some(p) = download_dir {
         Some(std::path::Path::new(p).to_path_buf())
     } else {
         None
     };
 
-    tokio::spawn(async move {
-        if let Err(e) = send_http_request(
-            req,
-            &response2,
-            &environment_id2,
-            &app_handle2,
-            &pool2,
-            download_path,
-        )
-        .await
-        {
-            response_err(&response2, e, &app_handle2, &pool2)
-                .await
-                .expect("Failed to update response");
-        }
-    });
+    emit_side_effect(&app_handle, "created_model", response.clone());
 
-    emit_and_return(&window, "created_model", response)
+    send_http_request(
+        request.clone(),
+        &response,
+        environment,
+        cookie_jar,
+        &app_handle,
+        &pool,
+        download_path,
+    )
+    .await
 }
 
 async fn response_err(
@@ -362,6 +407,57 @@ async fn create_workspace(
     emit_and_return(&window, "created_model", created_workspace)
 }
 
+#[tauri::command]
+async fn update_cookie_jar(
+    cookie_jar: models::CookieJar,
+    window: Window<Wry>,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<models::CookieJar, String> {
+    let pool = &*db_instance.lock().await;
+    println!("Updating cookie jar {}", cookie_jar.cookies.len());
+
+    let updated = models::upsert_cookie_jar(pool, &cookie_jar)
+        .await
+        .expect("Failed to update cookie jar");
+
+    emit_and_return(&window, "updated_model", updated)
+}
+
+#[tauri::command]
+async fn delete_cookie_jar(
+    window: Window<Wry>,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+    cookie_jar_id: &str,
+) -> Result<models::CookieJar, String> {
+    let pool = &*db_instance.lock().await;
+    let req = models::delete_cookie_jar(cookie_jar_id, pool)
+        .await
+        .expect("Failed to delete cookie jar");
+    emit_and_return(&window, "deleted_model", req)
+}
+
+#[tauri::command]
+async fn create_cookie_jar(
+    workspace_id: &str,
+    name: &str,
+    window: Window<Wry>,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<models::CookieJar, String> {
+    let pool = &*db_instance.lock().await;
+    let created_cookie_jar = models::upsert_cookie_jar(
+        pool,
+        &models::CookieJar {
+            name: name.to_string(),
+            workspace_id: workspace_id.to_string(),
+            ..Default::default()
+        },
+    )
+    .await
+    .expect("Failed to create cookie jar");
+
+    emit_and_return(&window, "created_model", created_cookie_jar)
+}
+
 #[tauri::command]
 async fn create_environment(
     workspace_id: &str,
@@ -627,6 +723,44 @@ async fn get_request(
         .map_err(|e| e.to_string())
 }
 
+#[tauri::command]
+async fn get_cookie_jar(
+    id: &str,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<models::CookieJar, String> {
+    let pool = &*db_instance.lock().await;
+    models::get_cookie_jar(id, pool)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+async fn list_cookie_jars(
+    workspace_id: &str,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<Vec<models::CookieJar>, String> {
+    let pool = &*db_instance.lock().await;
+    let cookie_jars = models::find_cookie_jars(workspace_id, pool)
+        .await
+        .expect("Failed to find cookie jars");
+
+    if cookie_jars.is_empty() {
+        let cookie_jar = models::upsert_cookie_jar(
+            pool,
+            &models::CookieJar {
+                name: "Default".to_string(),
+                workspace_id: workspace_id.to_string(),
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("Failed to create CookieJar");
+        Ok(vec![cookie_jar])
+    } else {
+        Ok(cookie_jars)
+    }
+}
+
 #[tauri::command]
 async fn get_environment(
     id: &str,
@@ -755,6 +889,7 @@ fn main() {
                 .level_for("tracing", log::LevelFilter::Info)
                 .level_for("reqwest", log::LevelFilter::Info)
                 .level_for("tokio_util", log::LevelFilter::Info)
+                .level_for("cookie_store", log::LevelFilter::Info)
                 .with_colors(ColoredLevelConfig::default())
                 .level(log::LevelFilter::Trace)
                 .build(),
@@ -807,11 +942,13 @@ fn main() {
         })
         .invoke_handler(tauri::generate_handler![
             check_for_updates,
+            create_cookie_jar,
             create_environment,
             create_folder,
             create_request,
             create_workspace,
             delete_all_responses,
+            delete_cookie_jar,
             delete_environment,
             delete_folder,
             delete_request,
@@ -820,13 +957,15 @@ fn main() {
             duplicate_request,
             export_data,
             filter_response,
-            get_key_value,
+            get_cookie_jar,
             get_environment,
             get_folder,
+            get_key_value,
             get_request,
             get_settings,
             get_workspace,
             import_data,
+            list_cookie_jars,
             list_environments,
             list_folders,
             list_requests,
@@ -838,6 +977,7 @@ fn main() {
             set_key_value,
             set_update_mode,
             track_event,
+            update_cookie_jar,
             update_environment,
             update_folder,
             update_request,