fix: project persist issue

dancixx · dancixx · commit 2e636712f1cc · 2024-01-06T18:17:26.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rust-sql-gui-ui"
-version = "1.0.0-alpha.3"
+version = "1.0.0-alpha.4"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/common/Cargo.toml b/common/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "common"
-version = "1.0.0-alpha.3"
+version = "1.0.0-alpha.4"
 edition = "2021"
 
 [dependencies]
diff --git a/common/src/drivers/postgresql.rs b/common/src/drivers/postgresql.rs
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Postgresql {
   pub user: String,
   pub password: String,
diff --git a/common/src/enums.rs b/common/src/enums.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use super::projects::postgresql::Postgresql;
 
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum Project {
   POSTGRESQL(Postgresql),
 }
@@ -22,7 +22,7 @@ impl Display for Drivers {
   }
 }
 
-#[derive(Clone, Default, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub enum ProjectConnectionStatus {
   Connected,
   #[default]
diff --git a/common/src/projects/postgresql.rs b/common/src/projects/postgresql.rs
@@ -3,11 +3,11 @@ use std::collections::BTreeMap;
 
 use crate::{drivers::postgresql::Postgresql as PostgresqlDriver, enums::ProjectConnectionStatus};
 
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Postgresql {
   pub name: String,
   pub driver: PostgresqlDriver,
-  pub schmemas: Option<Vec<String>>,
+  pub schemas: Option<Vec<String>>,
   pub tables: Option<BTreeMap<String, Vec<(String, String)>>>,
   pub connection_status: ProjectConnectionStatus,
 }
@@ -17,7 +17,7 @@ impl Default for Postgresql {
     Self {
       name: String::default(),
       driver: PostgresqlDriver::default(),
-      schmemas: None,
+      schemas: None,
       tables: None,
       connection_status: ProjectConnectionStatus::Disconnected,
     }
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rust-sql-gui"
-version = "1.0.0-alpha.3"
+version = "1.0.0-alpha.4"
 description = "PostgreSQL GUI written in Rust"
 authors = ["Daniel Boros"]
 license = ""
diff --git a/src-tauri/src/dbs/project.rs b/src-tauri/src/dbs/project.rs
@@ -20,6 +20,7 @@ pub async fn select_projects(app_state: State<'_, AppState>) -> Result<Vec<(Stri
       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();
diff --git a/src-tauri/src/drivers/postgresql.rs b/src-tauri/src/drivers/postgresql.rs
@@ -11,7 +11,6 @@ pub async fn postgresql_connector(
 ) -> Result<Vec<String>> {
   let app_state = app.state::<AppState>();
   let (client, connection) = connect(key, NoTls).await.expect("connection error");
-
   tokio::spawn(async move {
     if let Err(e) = connection.await {
       eprintln!("connection error: {}", e);
@@ -33,18 +32,17 @@ pub async fn postgresql_connector(
   let mut clients = app_state.client.lock().await;
   let clients = clients.as_mut().unwrap();
   clients.insert(project_name.to_string(), client);
-
   Ok(schemas)
 }
 
 #[tauri::command(rename_all = "snake_case")]
 pub async fn select_schema_tables(
-  project: &str,
+  project_name: &str,
   schema: &str,
   app_state: State<'_, AppState>,
 ) -> Result<Vec<(String, String)>> {
   let clients = app_state.client.lock().await;
-  let client = clients.as_ref().unwrap().get(project).unwrap();
+  let client = clients.as_ref().unwrap().get(project_name).unwrap();
   let tables = client
     .query(
       r#"
@@ -66,18 +64,17 @@ pub async fn select_schema_tables(
     .iter()
     .map(|r| (r.get(0), r.get(1)))
     .collect::<Vec<(String, String)>>();
-
   Ok(tables)
 }
 
 #[tauri::command(rename_all = "snake_case")]
 pub async fn select_sql_result(
-  project: &str,
+  project_name: &str,
   sql: String,
   app_state: State<'_, AppState>,
 ) -> Result<(Vec<String>, Vec<Vec<String>>)> {
   let clients = app_state.client.lock().await;
-  let client = clients.as_ref().unwrap().get(project).unwrap();
+  let client = clients.as_ref().unwrap().get(project_name).unwrap();
   let rows = client.query(sql.as_str(), &[]).await.unwrap();
 
   if rows.is_empty() {
diff --git a/src/invoke.rs b/src/invoke.rs
@@ -45,9 +45,9 @@ pub struct InvokeSchemaTablesArgs<'a> {
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct InvokeSqlResultArgs {
-  pub project: String,
-  pub sql: String,
+pub struct InvokeSqlResultArgs<'a> {
+  pub project_name: &'a str,
+  pub sql: &'a str,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -59,20 +59,20 @@ pub struct InvokeInsertProjectArgs {
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct InvokeDeleteProjectArgs {
-  pub project: String,
+pub struct InvokeDeleteProjectArgs<'a> {
+  pub project_name: &'a str,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct InvokeInsertQueryArgs {
-  pub key: String,
-  pub sql: String,
+pub struct InvokeInsertQueryArgs<'a> {
+  pub key: &'a str,
+  pub sql: &'a str,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct InvokeSelectQueriesArgs;
 
 #[derive(Serialize, Deserialize)]
-pub struct InvokeDeleteQueryArgs {
-  pub key: String,
+pub struct InvokeDeleteQueryArgs<'a> {
+  pub key: &'a str,
 }
diff --git a/src/modals/custom_query.rs b/src/modals/custom_query.rs
@@ -1,21 +1,34 @@
 use leptos::{html::*, *};
 use thaw::{Modal, ModalFooter, ModalProps};
 
-use crate::store::{projects::ProjectsStore, query::QueryStore};
+use crate::store::{
+  active_project::ActiveProjectStore, projects::ProjectsStore, query::QueryStore,
+};
 
 pub fn component(show: RwSignal<bool>) -> impl IntoView {
   let projects_store = use_context::<ProjectsStore>().unwrap();
   let query_store = use_context::<QueryStore>().unwrap();
   let (query_title, set_query_title) = create_signal(String::new());
   let projects = create_memo(move |_| projects_store.get_projects().unwrap());
-  let (project, set_project) = create_signal(String::new());
+  let active_project = use_context::<ActiveProjectStore>().unwrap();
+  let (project_name, set_project_name) =
+    create_signal(active_project.0.get_untracked().unwrap_or_default());
+  create_effect(move |_| {
+    if !projects.get().is_empty() {
+      set_project_name(projects.get()[0].clone());
+    }
+  });
+
   let insert_query = create_action(
-    move |(query_db, key, project): &(QueryStore, String, String)| {
+    move |(query_db, key, project_name): &(QueryStore, String, String)| {
       let query_db_clone = *query_db;
       let key = key.clone();
-      let project = project.clone();
+      let project_name = project_name.clone();
       async move {
-        query_db_clone.insert_query(&key, &project).await.unwrap();
+        query_db_clone
+          .insert_query(&key, &project_name)
+          .await
+          .unwrap();
       }
     },
   );
@@ -29,18 +42,21 @@ pub fn component(show: RwSignal<bool>) -> impl IntoView {
         .child(
           select()
             .classes("border-1 border-neutral-200 p-1 rounded-md w-full bg-white appearance-none")
+            .prop("value", project_name)
+            .prop("default_value", "teszt")
+            .prop("placeholder", "Select project..")
             .child(For(ForProps {
               each: move || projects.get(),
               key: |project| project.clone(),
               children: move |p| {
                 option()
                   .prop("value", &p)
-                  .prop("selected", p == project())
+                  .prop("selected", project_name() == p)
                   .child(&p)
               },
             }))
             .on(ev::change, move |e| {
-              set_project(event_target_value(&e));
+              set_project_name(event_target_value(&e));
             }),
         )
         .child(
@@ -63,7 +79,7 @@ pub fn component(show: RwSignal<bool>) -> impl IntoView {
             button()
               .classes("px-4 py-2 border-1 border-neutral-200 hover:bg-neutral-200 rounded-md")
               .on(ev::click, move |_| {
-                insert_query.dispatch((query_store, query_title(), project()));
+                insert_query.dispatch((query_store, query_title(), project_name()));
                 show.set(false);
               })
               .child("Save"),
diff --git a/src/query_editor.rs b/src/query_editor.rs
@@ -16,18 +16,24 @@ use crate::{
 pub type ModelCell = Rc<RefCell<Option<CodeEditor>>>;
 
 pub fn component() -> impl IntoView {
-  let query_state = use_context::<QueryStore>().unwrap();
+  let query_store = use_context::<QueryStore>().unwrap();
   let run_query = create_action(move |query_store: &QueryStore| {
     let query_store = *query_store;
     async move {
       query_store.run_query().await.unwrap();
     }
   });
+  let show = create_rw_signal(false);
+  let _ = use_event_listener(use_document(), ev::keydown, move |event| {
+    if event.key() == "Escape" {
+      show.set(false);
+    }
+  });
   let editor = use_context::<EditorStore>().unwrap().editor;
   let node_ref = create_node_ref();
   let _ = use_event_listener(node_ref, ev::keydown, move |event| {
     if event.key() == "Enter" && event.ctrl_key() {
-      run_query.dispatch(query_state);
+      run_query.dispatch(query_store);
     }
   });
 
@@ -57,18 +63,6 @@ pub fn component() -> impl IntoView {
     });
   });
 
-  let show = create_rw_signal(false);
-  let _ = use_event_listener(use_document(), ev::keydown, move |event| {
-    if event.key() == "Escape" {
-      show.set(false);
-    }
-  });
-  let query_store = use_context::<QueryStore>().unwrap();
-  let run_query = create_action(move |query_store: &QueryStore| {
-    let query_store = *query_store;
-    async move { query_store.run_query().await }
-  });
-
   div()
     .classes("relative border-b-1 border-neutral-200 sticky")
     .node_ref(node_ref)
diff --git a/src/sidebar/index.rs b/src/sidebar/index.rs
@@ -20,11 +20,11 @@ pub fn component() -> impl IntoView {
     }
   });
   let projects = create_resource(
-    move || projects_state.0.get(),
+    move || projects_state.0.get_untracked(),
     move |_| async move {
       let args = serde_wasm_bindgen::to_value(&InvokeSelectProjectsArgs).unwrap_or_default();
       let projects = invoke(&Invoke::select_projects.to_string(), args).await;
-      let projects = serde_wasm_bindgen::from_value::<Vec<Project>>(projects).unwrap();
+      let projects = serde_wasm_bindgen::from_value::<Vec<(String, Project)>>(projects).unwrap();
       projects_state.set_projects(projects).unwrap()
     },
   );
diff --git a/src/store/projects.rs b/src/store/projects.rs
@@ -27,10 +27,13 @@ impl ProjectsStore {
     Self(create_rw_signal(BTreeMap::default()))
   }
 
-  pub fn set_projects(&self, projects: Vec<Project>) -> Result<BTreeMap<String, Project>> {
+  pub fn set_projects(
+    &self,
+    projects: Vec<(String, Project)>,
+  ) -> Result<BTreeMap<String, Project>> {
     let projects = projects
       .into_iter()
-      .map(project_matcher)
+      .map(|(_, project)| project_matcher(project))
       .collect::<BTreeMap<String, Project>>();
     self.0.update(|prev| {
       *prev = projects;
@@ -62,7 +65,7 @@ impl ProjectsStore {
       Project::POSTGRESQL(project) => {
         let driver = project.driver.clone();
         format!(
-          "user={}:password={}:host={}:port={}",
+          "user={} password={} host={} port={}",
           driver.user, driver.password, driver.host, driver.port,
         )
       }
@@ -77,15 +80,14 @@ impl ProjectsStore {
     match project {
       Project::POSTGRESQL(project) => {
         if project.connection_status == ProjectConnectionStatus::Connected {
-          return Ok(project.schmemas.clone().unwrap());
+          return Ok(project.schemas.clone().unwrap());
         }
-
         let schemas = self.postgresql_schema_selector(&project.name).await?;
         projects.update(|prev| {
           let project = prev.get_mut(project_name).unwrap();
           match project {
             Project::POSTGRESQL(project) => {
-              project.schmemas = Some(schemas.clone());
+              project.schemas = Some(schemas.clone());
               project.connection_status = ProjectConnectionStatus::Connected;
             }
           }
@@ -106,7 +108,8 @@ impl ProjectsStore {
 
     match project {
       Project::POSTGRESQL(project) => {
-        if let Some(tables) = project.tables.as_ref().unwrap().get(schema) {
+        if let Some(tables) = &project.tables {
+          let tables = tables.get(schema).unwrap();
           if !tables.is_empty() {
             return Ok(tables.clone());
           }
@@ -121,37 +124,24 @@ impl ProjectsStore {
           let project = prev.get_mut(project_name).unwrap();
           match project {
             Project::POSTGRESQL(project) => {
-              let _tables = project.tables.as_mut().unwrap();
+              let _tables = project.tables.get_or_insert_with(BTreeMap::new);
               _tables.insert(schema.to_string(), tables.clone());
               project.tables = Some(_tables.clone());
             }
           }
         });
 
-        let schemas = self.postgresql_schema_selector(&project.name).await?;
-        projects.update(|prev| {
-          let project = prev.get_mut(project_name).unwrap();
-          match project {
-            Project::POSTGRESQL(project) => {
-              project.schmemas = Some(schemas.clone());
-            }
-          }
-        });
-
         Ok(tables)
       }
     }
   }
 
-  pub async fn delete_project(&self, project: &str) -> Result<()> {
-    let args = serde_wasm_bindgen::to_value(&InvokeDeleteProjectArgs {
-      project: project.to_string(),
-    })
-    .unwrap();
+  pub async fn delete_project(&self, project_name: &str) -> Result<()> {
+    let args = serde_wasm_bindgen::to_value(&InvokeDeleteProjectArgs { project_name }).unwrap();
     invoke(&Invoke::delete_project.to_string(), args).await;
     let projects = self.0;
     projects.update(|prev| {
-      prev.remove(project);
+      prev.remove(project_name);
     });
     Ok(())
   }
diff --git a/src/store/query.rs b/src/store/query.rs

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};`
`4`	`4`
`5`	`5`	`use super::projects::postgresql::Postgresql;`
`6`	`6`
`7`		`-#[derive(Clone, PartialEq, Serialize, Deserialize)]`
	`7`	`+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]`
`8`	`8`	`pub enum Project {`
`9`	`9`	`POSTGRESQL(Postgresql),`
`10`	`10`	`}`
`@@ -22,7 +22,7 @@ impl Display for Drivers {`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`-#[derive(Clone, Default, PartialEq, Serialize, Deserialize)]`
	`25`	`+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]`
`26`	`26`	`pub enum ProjectConnectionStatus {`
`27`	`27`	`Connected,`
`28`	`28`	`#[default]`
Original file line number	Diff line number	Diff line change
`@@ -45,9 +45,9 @@ pub struct InvokeSchemaTablesArgs<'a> {`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`#[derive(Serialize, Deserialize)]`
`48`		`-pub struct InvokeSqlResultArgs {`
`49`		`- pub project: String,`
`50`		`- pub sql: String,`
	`48`	`+pub struct InvokeSqlResultArgs<'a> {`
	`49`	`+ pub project_name: &'a str,`
	`50`	`+ pub sql: &'a str,`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`#[derive(Serialize, Deserialize)]`
`@@ -59,20 +59,20 @@ pub struct InvokeInsertProjectArgs {`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`#[derive(Serialize, Deserialize)]`
`62`		`-pub struct InvokeDeleteProjectArgs {`
`63`		`- pub project: String,`
	`62`	`+pub struct InvokeDeleteProjectArgs<'a> {`
	`63`	`+ pub project_name: &'a str,`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`#[derive(Serialize, Deserialize)]`
`67`		`-pub struct InvokeInsertQueryArgs {`
`68`		`- pub key: String,`
`69`		`- pub sql: String,`
	`67`	`+pub struct InvokeInsertQueryArgs<'a> {`
	`68`	`+ pub key: &'a str,`
	`69`	`+ pub sql: &'a str,`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`#[derive(Serialize, Deserialize)]`
`73`	`73`	`pub struct InvokeSelectQueriesArgs;`
`74`	`74`
`75`	`75`	`#[derive(Serialize, Deserialize)]`
`76`		`-pub struct InvokeDeleteQueryArgs {`
`77`		`- pub key: String,`
	`76`	`+pub struct InvokeDeleteQueryArgs<'a> {`
	`77`	`+ pub key: &'a str,`
`78`	`78`	`}`