feat: persist connection data

Author: dancixx

src-tauri/Cargo.toml

@@ -13,13 +13,13 @@ edition = "2021"
 tauri-build = { version = "1.5", features = [] }
 
 [dependencies]
-tauri = { version = "1.5.3", features = ["shell-open"] }
-tauri-plugin-store = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
+tauri = { version = "1.5.2", features = ["shell-open"] }
 serde = { version = "1.0.193", features = ["derive"] }
 serde_json = "1.0.108"
 tokio = "1.34.0"
 tokio-postgres = "0.7.10"
 chrono = "0.4.31"
+sled = "0.34.7"
 
 
 

src-tauri/project_db/conf

@@ -0,0 +1,4 @@
+segment_size: 524288
+use_compression: false
+version: 0.34
+vQ�

src-tauri/project_db/db

@@ -2,29 +2,37 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 mod postgres;
+mod project_db;
 mod utils;
 
 use postgres::{get_schema_tables, get_sql_result, pg_connector};
+use project_db::{get_project_details, get_projects, ProjectDB};
 use std::sync::Arc;
 #[cfg(debug_assertions)]
 use tauri::Manager;
-use tauri_plugin_store::StoreBuilder;
 use tokio::sync::Mutex;
 use tokio_postgres::Client;
 
-#[derive(Default)]
 pub struct AppState {
     pub connection_strings: Arc<Mutex<String>>,
     pub client: Arc<Mutex<Option<Client>>>,
+    pub project_db: Arc<Mutex<Option<ProjectDB>>>,
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self {
+            connection_strings: Arc::new(Mutex::new(String::new())),
+            client: Arc::new(Mutex::new(None)),
+            project_db: Arc::new(Mutex::new(Some(ProjectDB::default()))),
+        }
+    }
 }
 
 fn main() {
     tauri::Builder::default()
-        .plugin(tauri_plugin_store::Builder::default().build())
+        .manage(AppState::default())
         .setup(|app| {
-            // create persistent storage
-            StoreBuilder::new(app.app_handle(), "local_storage.bin".parse().unwrap()).build();
-
             // open devtools if we are in debug mode
             #[cfg(debug_assertions)]
             {
@@ -35,8 +43,9 @@ fn main() {
 
             Ok(())
         })
-        .manage(AppState::default())
         .invoke_handler(tauri::generate_handler![
+            get_projects,
+            get_project_details,
             get_schema_tables,
             pg_connector,
             get_sql_result

src-tauri/project_db/snap.00000000000000D3

@@ -4,12 +4,22 @@ use tokio_postgres::{connect, NoTls};
 use crate::{utils::reflective_get, AppState};
 
 #[tauri::command]
-pub async fn pg_connector(key: &str, app_state: State<'_, AppState>) -> Result<Vec<String>> {
+pub async fn pg_connector(
+    project: &str,
+    key: &str,
+    app_state: State<'_, AppState>,
+) -> Result<Vec<String>> {
     if key.is_empty() {
         return Ok(Vec::new());
     }
-    let (client, connection) = connect(key, NoTls).await.expect("connection error");
 
+    // Save connection string to local db
+    let db_path = app_state.project_db.lock().await;
+    let db_path = db_path.as_ref().unwrap().db_path.as_str();
+    let db = sled::open(db_path).unwrap();
+    db.insert(project, key).unwrap();
+
+    let (client, connection) = connect(key, NoTls).await.expect("connection error");
     tokio::spawn(async move {
         if let Err(e) = connection.await {
             eprintln!("connection error: {}", e);

src-tauri/src/main.rs

@@ -0,0 +1,90 @@
+use serde::{Deserialize, Serialize};
+use tauri::{Result, State};
+
+use crate::AppState;
+
+#[tauri::command]
+pub async fn get_projects(app_state: State<'_, AppState>) -> Result<Vec<String>> {
+    let project_db = app_state.project_db.lock().await;
+    let project_db = project_db.as_ref().unwrap();
+
+    let db = sled::open(&project_db.db_path).unwrap();
+    let projects = db
+        .iter()
+        .map(|r| {
+            let (project, _) = r.unwrap();
+            String::from_utf8(project.to_vec()).unwrap()
+        })
+        .collect();
+
+    Ok(projects)
+}
+
+#[tauri::command]
+pub async fn get_project_details(
+    project: String,
+    app_state: State<'_, AppState>,
+) -> Result<ProjectDetails> {
+    let project_db = app_state.project_db.lock().await;
+    let project_db = project_db.as_ref().unwrap();
+
+    let project_details = project_db.get_connection_string(project.as_str())?;
+
+    Ok(project_details)
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+pub struct ProjectDetails {
+    pub user: String,
+    pub password: String,
+    pub host: String,
+    pub port: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ProjectDB {
+    pub db_path: String,
+}
+
+impl Default for ProjectDB {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ProjectDB {
+    pub fn new() -> Self {
+        Self {
+            db_path: String::from("project_db"),
+        }
+    }
+
+    pub fn get_connection_string(&self, project: &str) -> Result<ProjectDetails> {
+        let db = sled::open(&self.db_path).unwrap();
+        let connection_string = db.get(project).unwrap();
+        let mut project_details = ProjectDetails::default();
+
+        if let Some(connection_string) = connection_string {
+            let connection_string = connection_string.to_vec();
+            let connection_string = String::from_utf8(connection_string).unwrap();
+            let connection_string = connection_string.split(" ").collect::<Vec<&str>>();
+
+            for connection_string in connection_string {
+                let connection_string = connection_string.split("=").collect::<Vec<&str>>();
+                let key = connection_string[0];
+                let value = connection_string[1];
+
+                match key {
+                    "user" => project_details.user = value.to_string(),
+                    "password" => project_details.password = value.to_string(),
+                    "host" => project_details.host = value.to_string(),
+                    "port" => project_details.port = value.to_string(),
+                    _ => (),
+                }
+            }
+        }
+
+        Ok(project_details)
+    }
+}
+

src-tauri/src/postgres.rs

@@ -4,9 +4,13 @@ use crate::store::{db::DBStore, query::QueryState};
 
 pub fn db_connector() -> impl IntoView {
     let db = use_context::<DBStore>().unwrap();
+    let refetch_projects = use_context::<Resource<(), Vec<String>>>().unwrap();
     let connect = create_action(move |db: &DBStore| {
         let mut db_clone = *db;
-        async move { db_clone.connect().await }
+        async move {
+            db_clone.connect().await;
+            refetch_projects.refetch();
+        }
     });
     let query_state = use_context::<QueryState>().unwrap();
     let run_query = create_action(move |query_state: &QueryState| {
@@ -22,6 +26,16 @@ pub fn db_connector() -> impl IntoView {
         .child(
             div()
                 .attr("class", "flex flex-row gap-2")
+                .child(
+                    input()
+                        .attr("class", "border-1 border-neutral-200 p-1 rounded-md")
+                        .attr("type", "text")
+                        .attr("value", move || db.project.get())
+                        .attr("placeholder", "project")
+                        .on(ev::input, move |e| {
+                            db.project.set(event_target_value(&e));
+                        }),
+                )
                 .child(
                     input()
                         .attr("class", "border-1 border-neutral-200 p-1 rounded-md")
@@ -79,8 +93,14 @@ pub fn db_connector() -> impl IntoView {
                     button()
                         .attr(
                             "class",
-                            "px-4 py-2 border-1 border-neutral-200 hover:bg-neutral-200 rounded-md",
-                        )
+                            "px-4 py-2 border-1 border-neutral-200 hover:bg-neutral-200 rounded-md disabled:opacity-50",
+                        ).attr("disabled", move || {
+                            db.is_connecting.get()
+                                || db.db_host.get().is_empty()
+                                || db.db_port.get().is_empty()
+                                || db.db_user.get().is_empty()
+                                || db.db_password.get().is_empty()
+                        })
                         .on(ev::click, move |_| {
                             connect.dispatch(db);
                         })

src-tauri/src/project_db.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
 pub struct InvokePostgresConnectionArgs {
+    pub project: String,
     pub key: String,
 }
 
@@ -15,3 +16,11 @@ pub struct InvokeQueryArgs {
     pub sql: String,
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct InvokeProjectsArgs;
+
+#[derive(Serialize, Deserialize)]
+pub struct InvokeProjectDetailsArgs {
+    pub project: String,
+}
+

src/db_connector.rs

@@ -1,14 +1,59 @@
-use crate::{store::db::DBStore, tables::tables};
+use crate::{
+    invoke::InvokeProjectsArgs, store::db::DBStore, tables::tables, wasm_functions::invoke,
+};
 use leptos::{html::*, *};
 
 pub fn sidebar() -> impl IntoView {
     let db = use_context::<DBStore>().unwrap();
+    let get_project_details = create_action(move |(db, project): &(DBStore, String)| {
+        let mut db_clone = *db;
+        let project = project.clone();
+        async move { db_clone.get_project_details(project).await }
+    });
+    let projects = create_resource(
+        || {},
+        move |_| async move {
+            let projects = invoke(
+                "get_projects",
+                serde_wasm_bindgen::to_value(&InvokeProjectsArgs).unwrap(),
+            )
+            .await;
+            let projects = serde_wasm_bindgen::from_value::<Vec<String>>(projects).unwrap();
+            projects
+        },
+    );
+    provide_context(projects);
 
     div()
         .attr(
             "class",
             "flex border-r-1 border-neutral-200 flex-col gap-2 px-4 pt-4 overflow-auto",
         )
+        .child(Suspense(SuspenseProps {
+            children: ChildrenFn::to_children(move || {
+                Fragment::new(vec![div()
+                    .child(p().attr("class", "font-semibold").child("Projects"))
+                    .child(move || {
+                        projects
+                            .get()
+                            .unwrap_or(Vec::new())
+                            .into_iter()
+                            .enumerate()
+                            .map(|(idx, project)| {
+                                button()
+                                    .attr("key", idx)
+                                    .attr("class", "hover:font-semibold")
+                                    .child(&project)
+                                    .on(ev::click, move |_| {
+                                        get_project_details.dispatch((db.clone(), project.clone()))
+                                    })
+                            })
+                            .collect_view()
+                    })
+                    .into_view()])
+            }),
+            fallback: ViewFn::from(|| p().child("Loading...")),
+        }))
         .child(p().attr("class", "font-semibold").child("Schemas"))
         .child(Show(ShowProps {
             when: move || db.is_connecting.get(),