refactor: improve performance for beta

Cargo.toml

@@ -1,17 +1,17 @@
 [package]
-name = "rust-sql-gui-ui"
-version = "1.0.0-alpha.9"
+name = "rsql"
+version = "1.0.0-beta.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
-leptos = { version = "0.6.8", features = ["csr", "nightly"] }
+leptos = { version = "0.6.11", features = ["csr", "nightly"] }
 leptos_devtools = { git = "https://github.com/luoxiaozero/leptos-devtools" }
 serde = { version = "1.0.192", features = ["derive"] }
 serde-wasm-bindgen = "0.6.3"
 wasm-bindgen = { version ="0.2.91", features = ["serde-serialize"] }
 js-sys = "0.3.68"
-leptos-use = { version = "0.10.9", features = ["serde", "serde_json"]}
+leptos-use = { version = "0.10.10", features = ["serde", "serde_json"]}
 leptos_icons = "0.3.0" # https://carlosted.github.io/icondata/
 serde_json = "1.0.113"
 wasm-bindgen-futures = "0.4.39"
@@ -22,6 +22,16 @@ common = { path = "common" }
 futures = "0.3.30"
 async-stream = "0.3.5"
 icondata = "0.3.0"
+ahash = { version = "0.8.11", features = ["serde"] }
+leptos_toaster = { version = "0.1.6", features = ["builtin_toast"] }
+proc-macro2 = "1.0.82"
+quote = "1.0.36"
+syn = { version = "2.0.64", features = ["full"] }
+chrono = "0.4.38"
+
 
 [workspace]
 members = ["src-tauri", "common"]
+
+[lib]
+proc-macro = true

common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "common"
-version = "1.0.0-alpha.9"
+version = "1.0.0-beta.0"
 edition = "2021"
 
 [dependencies]

common/src/enums.rs

@@ -2,29 +2,68 @@ use std::fmt::Display;
 
 use serde::{Deserialize, Serialize};
 
-use super::projects::postgresql::Postgresql;
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum Project {
-  POSTGRESQL(Postgresql),
-}
-
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Copy, Serialize, Deserialize, Default)]
 pub enum Drivers {
-  POSTGRESQL,
+  #[default]
+  PGSQL,
 }
 
 impl Display for Drivers {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     match self {
-      Drivers::POSTGRESQL => write!(f, "POSTGRESQL"),
+      Drivers::PGSQL => write!(f, "PGSQL"),
+    }
+  }
+}
+
+impl AsRef<str> for Drivers {
+  fn as_ref(&self) -> &str {
+    match self {
+      Drivers::PGSQL => "PGSQL",
     }
   }
 }
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub enum ProjectConnectionStatus {
   Connected,
+  Connecting,
   #[default]
   Disconnected,
+  Failed,
 }
+
+impl std::error::Error for ProjectConnectionStatus {}
+impl Display for ProjectConnectionStatus {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      ProjectConnectionStatus::Connected => write!(f, "Connected"),
+      ProjectConnectionStatus::Connecting => write!(f, "Connecting"),
+      ProjectConnectionStatus::Disconnected => write!(f, "Disconnected"),
+      ProjectConnectionStatus::Failed => write!(f, "Failed"),
+    }
+  }
+}
+
+use std::fmt;
+
+#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
+pub enum PostgresqlError {
+  ConnectionTimeout,
+  ConnectionError,
+  QueryTimeout,
+  QueryError,
+}
+
+impl std::error::Error for PostgresqlError {}
+impl fmt::Display for PostgresqlError {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match *self {
+      PostgresqlError::ConnectionTimeout => write!(f, "ConnectionTimeout"),
+      PostgresqlError::ConnectionError => write!(f, "ConnectionError"),
+      PostgresqlError::QueryTimeout => write!(f, "QueryTimeout"),
+      PostgresqlError::QueryError => write!(f, "QueryError"),
+    }
+  }
+}
+

common/src/lib.rs

@@ -1,3 +1,3 @@
-pub mod drivers;
 pub mod enums;
-pub mod projects;
+pub mod types;
+

common/src/types/mod.rs

@@ -0,0 +1,2 @@
+pub mod pgsql;
+

common/src/types/pgsql.rs

@@ -0,0 +1,4 @@
+pub type PgsqlLoadSchemas = Vec<String>;
+pub type PgsqlLoadTables = Vec<(String, String)>;
+pub type PgsqlRunQuery = (Vec<String>, Vec<Vec<String>>, f32);
+

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "rust-sql-gui"
-version = "1.0.0-alpha.9"
+name = "rsql_tauri"
+version = "1.0.0-beta.0"
 description = "PostgreSQL GUI written in Rust"
 authors = ["Daniel Boros"]
 license = ""
@@ -10,17 +10,21 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [build-dependencies]
-tauri-build = { version = "1.5.1", features = [] }
+tauri-build = { version = "1.5.2", features = [] }
 
 [dependencies]
 common = { path = "../common" }
-tauri = { version = "1.6.0", features = [ "shell-open", "fs-all"] }
+tauri = { version = "1.6.5", features = ["shell-open", "fs-all"] }
 serde = { version = "1.0.193", features = ["derive"] }
 serde_json = "1.0.108"
-tokio = "1.36.0"
+tokio = "1.37.0"
 tokio-postgres = "0.7.10"
 chrono = "0.4.31"
 sled = "0.34.7"
+anyhow = "1.0.83"
+tracing = "0.1.40"
+tracing-subscriber = { version = "0.3.18", features = ["fmt"] }
+ahash = { version = "0.8.11", features = ["serde"] }
 
 
 

src-tauri/src/dbs/project.rs

@@ -1,80 +1,49 @@
-use common::{
-  drivers::postgresql::Postgresql as PostgresqlDriver,
-  enums::{Drivers, Project},
-  projects::postgresql::Postgresql,
-};
+use std::collections::BTreeMap;
+
 use tauri::{Result, State};
 
 use crate::AppState;
 
 #[tauri::command(rename_all = "snake_case")]
-pub async fn select_projects(app_state: State<'_, AppState>) -> Result<Vec<(String, Project)>> {
+pub async fn project_db_select(app_state: State<'_, AppState>) -> Result<BTreeMap<String, String>> {
   let project_db = app_state.project_db.lock().await;
-  let mut projects = project_db
-    .clone()
-    .unwrap()
-    .iter()
-    .map(|r| {
-      let (project, connection_string) = r.unwrap();
-      let project = String::from_utf8(project.to_vec()).unwrap();
-      let connection_string = String::from_utf8(connection_string.to_vec()).unwrap();
-      let connection_string = connection_string.split(':').collect::<Vec<&str>>();
-      let _driver = connection_string[0].to_string();
-      let _driver = _driver.split('=').collect::<Vec<&str>>()[1];
-      let project_details = match _driver {
-        d if d == Drivers::POSTGRESQL.to_string() => {
-          let mut driver = PostgresqlDriver::default();
+  let db = project_db.clone().unwrap();
+  let mut projects = BTreeMap::new();
 
-          for c in connection_string[1..].iter() {
-            let c = c.split('=').collect::<Vec<&str>>();
-            let key = c[0];
-            let value = c[1];
+  if db.is_empty() {
+    tracing::info!("No projects found in the database");
+    return Ok(projects);
+  }
 
-            match key {
-              "user" => driver.user = value.to_string(),
-              "password" => driver.password = value.to_string(),
-              "host" => driver.host = value.to_string(),
-              "port" => driver.port = value.to_string(),
-              _ => (),
-            }
-          }
+  for p in db.iter() {
+    let project = p.unwrap();
 
-          Project::POSTGRESQL(Postgresql {
-            name: project.clone(),
-            driver,
-            ..Postgresql::default()
-          })
-        }
-        _ => unreachable!(),
-      };
-      (project, project_details)
-    })
-    .collect::<Vec<(String, Project)>>();
-  projects.sort_by(|a, b| a.0.cmp(&b.0));
+    let project = (
+      String::from_utf8(project.0.to_vec()).unwrap(),
+      String::from_utf8(project.1.to_vec()).unwrap(),
+    );
+    projects.insert(project.0, project.1);
+  }
   Ok(projects)
 }
 
 #[tauri::command(rename_all = "snake_case")]
-pub async fn insert_project(project: Project, app_state: State<'_, AppState>) -> Result<Project> {
+pub async fn project_db_insert(
+  project_id: &str,
+  project_details: &str,
+  app_state: State<'_, AppState>,
+) -> Result<()> {
   let project_db = app_state.project_db.lock().await;
   let db = project_db.clone().unwrap();
-  match project {
-    Project::POSTGRESQL(project) => {
-      let driver = &project.driver;
-      let connection_string = format!(
-        "driver=POSTGRESQL:user={}:password={}:host={}:port={}",
-        driver.user, driver.password, driver.host, driver.port,
-      );
-      db.insert(&project.name, &*connection_string).unwrap();
-      Ok(Project::POSTGRESQL(project))
-    }
-  }
+  db.insert(project_id, project_details).unwrap();
+  Ok(())
 }
 
 #[tauri::command(rename_all = "snake_case")]
-pub async fn delete_project(project_name: &str, app_state: State<'_, AppState>) -> Result<()> {
+pub async fn project_db_delete(project_id: &str, app_state: State<'_, AppState>) -> Result<()> {
   let db = app_state.project_db.lock().await;
   let db = db.clone().unwrap();
-  db.remove(project_name).unwrap();
+  db.remove(project_id).unwrap();
   Ok(())
 }
+

src-tauri/src/dbs/query.rs

@@ -5,17 +5,7 @@ use tauri::{AppHandle, Manager, Result, State};
 use crate::AppState;
 
 #[tauri::command(rename_all = "snake_case")]
-pub async fn insert_query(key: &str, sql: &str, app: AppHandle) -> Result<()> {
-  let app_state = app.state::<AppState>();
-  let db = app_state.query_db.lock().await;
-  if let Some(ref db_instance) = *db {
-    db_instance.insert(key, sql).unwrap();
-  }
-  Ok(())
-}
-
-#[tauri::command(rename_all = "snake_case")]
-pub async fn select_queries(app_state: State<'_, AppState>) -> Result<BTreeMap<String, String>> {
+pub async fn query_db_select(app_state: State<'_, AppState>) -> Result<BTreeMap<String, String>> {
   let query_db = app_state.query_db.lock().await;
   let mut queries = BTreeMap::new();
   if let Some(ref query_db) = *query_db {
@@ -30,10 +20,21 @@ pub async fn select_queries(app_state: State<'_, AppState>) -> Result<BTreeMap<S
 }
 
 #[tauri::command(rename_all = "snake_case")]
-pub async fn delete_query(key: &str, app_state: State<'_, AppState>) -> Result<()> {
+pub async fn query_db_insert(query_id: &str, sql: &str, app: AppHandle) -> Result<()> {
+  let app_state = app.state::<AppState>();
+  let db = app_state.query_db.lock().await;
+  if let Some(ref db_instance) = *db {
+    db_instance.insert(query_id, sql).unwrap();
+  }
+  Ok(())
+}
+
+#[tauri::command(rename_all = "snake_case")]
+pub async fn query_db_delete(query_id: &str, app_state: State<'_, AppState>) -> Result<()> {
   let query_db = app_state.query_db.lock().await;
   if let Some(ref query_db) = *query_db {
-    query_db.remove(key).unwrap();
+    query_db.remove(query_id).unwrap();
   };
   Ok(())
 }
+

src-tauri/src/drivers/mod.rs

@@ -1 +1,2 @@
-pub mod postgresql;
+pub mod pgsql;
+