Tidy up logs and general cleanup

package.json

@@ -4,7 +4,7 @@
   "version": "0.0.0",
   "type": "module",
   "scripts": {
-    "tauri-dev": "YAAK_ENV=development tauri dev",
+    "tauri-dev": "RUST_LOG=warn YAAK_ENV=development tauri dev",
     "tauri-build": "tauri build",
     "tauri": "tauri",
     "build": "npm run build:frontend",

src-tauri/src/analytics.rs

@@ -1,3 +1,4 @@
+use log::{debug, warn};
 use sqlx::types::JsonValue;
 use tauri::{async_runtime, AppHandle, Manager};
 
@@ -73,14 +74,14 @@ pub fn track_event(
             .query(&params);
 
         if is_dev() {
-            println!("Ignore dev analytics event: {} {:?}", event, params);
+            debug!("Ignore dev analytics event: {} {:?}", event, params);
         } else if let Err(e) = req.send().await {
-            println!(
+            warn!(
                 "Error sending analytics event: {} {} {:?}",
                 e, event, params
             );
         } else {
-            println!("Sent analytics event: {}: {:?}", event, params);
+            debug!("Sent analytics event: {}: {:?}", event, params);
         }
     });
 }

src-tauri/src/main.rs

@@ -21,9 +21,8 @@ use rand::random;
 use reqwest::redirect::Policy;
 use serde::Serialize;
 use sqlx::migrate::Migrator;
-use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
 use sqlx::types::Json;
-use sqlx::{ConnectOptions, Pool, Sqlite};
+use sqlx::{Pool, Sqlite, SqlitePool};
 #[cfg(target_os = "macos")]
 use tauri::TitleBarStyle;
 use tauri::{AppHandle, Menu, RunEvent, State, Submenu, Window, WindowUrl, Wry};
@@ -65,10 +64,10 @@ async fn migrate_db(
         .path_resolver()
         .resolve_resource("migrations")
         .expect("failed to resolve resource");
-    println!("Running migrations at {}", p.to_string_lossy());
+    info!("Running migrations at {}", p.to_string_lossy());
     let m = Migrator::new(p).await.expect("Failed to load migrations");
     m.run(pool).await.expect("Failed to run migrations");
-    println!("Migrations complete");
+    info!("Migrations complete");
     Ok(())
 }
 
@@ -83,7 +82,7 @@ async fn send_ephemeral_request(
     let response = models::HttpResponse::new();
     let environment_id2 = environment_id.unwrap_or("n/a").to_string();
     request.id = "".to_string();
-    return actually_send_request(request, &response, &environment_id2, &app_handle, pool).await;
+    actually_send_request(request, &response, &environment_id2, &app_handle, pool).await
 }
 
 async fn actually_send_request(
@@ -195,7 +194,7 @@ async fn actually_send_request(
     let sendable_req = match sendable_req_result {
         Ok(r) => r,
         Err(e) => {
-            return response_err(response, e.to_string(), &app_handle, pool).await;
+            return response_err(response, e.to_string(), app_handle, pool).await;
         }
     };
 
@@ -224,7 +223,7 @@ async fn actually_send_request(
                 let dir = app_handle.path_resolver().app_data_dir().unwrap();
                 let base_dir = dir.join("responses");
                 create_dir_all(base_dir.clone()).expect("Failed to create responses dir");
-                let body_path = match response.id == "" {
+                let body_path = match response.id.is_empty() {
                     false => base_dir.join(response.id.clone()),
                     true => base_dir.join(uuid::Uuid::new_v4().to_string()),
                 };
@@ -253,7 +252,7 @@ async fn actually_send_request(
             response = models::update_response_if_id(&response, pool)
                 .await
                 .expect("Failed to update response");
-            if request.id != "" {
+            if request.id.is_empty() {
                 emit_side_effect(app_handle, "updated_model", &response);
             }
             Ok(response)
@@ -793,6 +792,8 @@ fn main() {
         .plugin(
             tauri_plugin_log::Builder::default()
                 .targets([LogTarget::LogDir, LogTarget::Stdout, LogTarget::Webview])
+                .level_for("tao", log::LevelFilter::Info)
+                .level_for("sqlx", log::LevelFilter::Warn)
                 .build(),
         )
         .plugin(tauri_plugin_window_state::Builder::default().build())
@@ -810,14 +811,7 @@ fn main() {
             println!("Connecting to database at {}", url);
 
             tauri::async_runtime::block_on(async move {
-                let pool = SqlitePoolOptions::new()
+                let pool = SqlitePool::connect(p.to_str().unwrap())
-                    .connect_with(
-                        SqliteConnectOptions::new()
-                            .filename(p)
-                            .create_if_missing(true)
-                            .disable_statement_logging()
-                            .clone(),
-                    )
                     .await
                     .expect("Failed to connect to database");
 
@@ -868,8 +862,8 @@ fn main() {
         ])
         .build(tauri::generate_context!())
         .expect("error while running tauri application")
-        .run(|app_handle, event| match event {
+        .run(|app_handle, event| {
-            RunEvent::Ready => {
+            if let RunEvent::Ready = event {
                 let w = create_window(app_handle, None);
                 w.restore_state(StateFlags::all())
                     .expect("Failed to restore window state");
@@ -881,10 +875,6 @@ fn main() {
                     None,
                 );
             }
-
-            // ExitRequested { api, .. } => {
-            // }
-            _ => {}
         });
 }
 
@@ -954,9 +944,9 @@ fn create_window(handle: &AppHandle<Wry>, url: Option<&str>) -> Window<Wry> {
         "focus_url" => win2.emit("focus_url", true).unwrap(),
         "focus_sidebar" => win2.emit("focus_sidebar", true).unwrap(),
         "send_request" => win2.emit("send_request", true).unwrap(),
-        "new_request" => _ = win2.emit("new_request", true).unwrap(),
+        "new_request" => win2.emit("new_request", true).unwrap(),
-        "toggle_settings" => _ = win2.emit("toggle_settings", true).unwrap(),
+        "toggle_settings" => win2.emit("toggle_settings", true).unwrap(),
-        "duplicate_request" => _ = win2.emit("duplicate_request", true).unwrap(),
+        "duplicate_request" => win2.emit("duplicate_request", true).unwrap(),
         "refresh" => win2.eval("location.reload()").unwrap(),
         "new_window" => _ = create_window(&handle2, None),
         "toggle_devtools" => {

src-tauri/src/models.rs

@@ -164,7 +164,7 @@ pub async fn set_key_value(
     let kv = get_key_value(namespace, key, pool)
         .await
         .expect("Failed to get key value");
-    return (kv, existing.is_none());
+    (kv, existing.is_none())
 }
 
 pub async fn get_key_value(namespace: &str, key: &str, pool: &Pool<Sqlite>) -> Option<KeyValue> {
@@ -627,10 +627,11 @@ pub async fn update_response_if_id(
     response: &HttpResponse,
     pool: &Pool<Sqlite>,
 ) -> Result<HttpResponse, sqlx::Error> {
-    if response.id == "" {
+    if response.id.is_empty() {
-        return Ok(response.clone());
+        Ok(response.clone())
+    } else {
+        update_response(response, pool).await
     }
-    return update_response(response, pool).await;
 }
 
 pub async fn upsert_workspace(
@@ -790,10 +791,10 @@ pub async fn delete_all_responses(
 
 pub fn generate_id(prefix: Option<&str>) -> String {
     let id = Alphanumeric.sample_string(&mut rand::thread_rng(), 10);
-    return match prefix {
+    match prefix {
         None => id,
         Some(p) => format!("{p}_{id}"),
-    };
+    }
 }
 
 #[derive(Default, Debug, Deserialize, Serialize)]

src-tauri/src/plugin.rs

@@ -8,6 +8,7 @@ use boa_engine::{
     Context, JsArgs, JsNativeError, JsValue, Module, NativeFunction, Source,
 };
 use boa_runtime::Console;
+use log::debug;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tauri::AppHandle;
@@ -59,7 +60,10 @@ fn run_plugin(
         .join(plugin_name);
     let plugin_index_file = plugin_dir.join("out/index.js");
 
-    println!("Plugin dir={:?} file={:?}", plugin_dir, plugin_index_file);
+    debug!(
+        "Running plugin dir={:?} file={:?}",
+        plugin_dir, plugin_index_file
+    );
 
     // Module loader for the specific plugin
     let loader = &SimpleModuleLoader::new(plugin_dir).expect("failed to create module loader");