Merge pull request #2 from dancixx/feat/migrate-to-sqlite

feat: migrate to sqlite

Author: dancixx

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
@@ -20,5 +20,6 @@ thaw = "0.1.3"
 common = { path = "common" }
 
 
+
 [workspace]
 members = ["src-tauri", "common"]

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]

common/src/drivers/mod.rs

@@ -0,0 +1 @@
+pub mod postgresql;

common/src/drivers/postgresql.rs

@@ -0,0 +1,20 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Postgresql {
+  pub user: String,
+  pub password: String,
+  pub host: String,
+  pub port: String,
+}
+
+impl Postgresql {
+  pub fn new(user: String, password: String, host: String, port: String) -> Self {
+    Self {
+      user,
+      password,
+      host,
+      port,
+    }
+  }
+}

common/src/enums.rs

@@ -0,0 +1,30 @@
+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)]
+pub enum Drivers {
+  POSTGRESQL,
+}
+
+impl Display for Drivers {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    match self {
+      Drivers::POSTGRESQL => write!(f, "POSTGRESQL"),
+    }
+  }
+}
+
+#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ProjectConnectionStatus {
+  Connected,
+  #[default]
+  Disconnected,
+}

common/src/lib.rs

@@ -1 +1,4 @@
-pub mod project;
+pub mod drivers;
+pub mod enums;
+pub mod projects;
+pub mod utils;

common/src/project.rs

@@ -0,0 +1 @@
+pub mod postgresql;

common/src/projects/mod.rs

@@ -0,0 +1,25 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+use crate::{drivers::postgresql::Postgresql as PostgresqlDriver, enums::ProjectConnectionStatus};
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Postgresql {
+  pub name: String,
+  pub driver: PostgresqlDriver,
+  pub schemas: Option<Vec<String>>,
+  pub tables: Option<BTreeMap<String, Vec<(String, String)>>>,
+  pub connection_status: ProjectConnectionStatus,
+}
+
+impl Default for Postgresql {
+  fn default() -> Self {
+    Self {
+      name: String::default(),
+      driver: PostgresqlDriver::default(),
+      schemas: None,
+      tables: None,
+      connection_status: ProjectConnectionStatus::Disconnected,
+    }
+  }
+}

common/src/projects/postgresql.rs

@@ -0,0 +1,7 @@
+use crate::enums::Project;
+
+pub fn project_matcher(project: Project) -> (String, Project) {
+  match project {
+    Project::POSTGRESQL(project) => (project.name.clone(), Project::POSTGRESQL(project)),
+  }
+}

common/src/utils.rs

@@ -1,8 +1,8 @@
 [package]
 name = "rust-sql-gui"
-version = "1.0.0-alpha.3"
+version = "1.0.0-alpha.4"
 description = "PostgreSQL GUI written in Rust"
-authors = ["you"]
+authors = ["Daniel Boros"]
 license = ""
 repository = ""
 edition = "2021"
@@ -13,14 +13,16 @@ edition = "2021"
 tauri-build = { version = "1.5", features = [] }
 
 [dependencies]
+common = { path = "../common" }
 tauri = { version = "1.5.2", features = [ "shell-open", "fs-all"] }
 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"
-common = { path = "../common" }
+strum = "0.25.0"
+strum_macros = "0.25.3"
 
 
 

src-tauri/Cargo.toml

@@ -0,0 +1,2 @@
+pub mod project;
+pub mod query;

src-tauri/src/constant.rs

@@ -0,0 +1,80 @@
+use common::{
+  drivers::postgresql::Postgresql as PostgresqlDriver,
+  enums::{Drivers, Project},
+  projects::postgresql::Postgresql,
+};
+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)>> {
+  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();
+
+          for c in connection_string[1..].iter() {
+            let c = c.split('=').collect::<Vec<&str>>();
+            let key = c[0];
+            let value = c[1];
+
+            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(),
+              _ => (),
+            }
+          }
+
+          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));
+  Ok(projects)
+}
+
+#[tauri::command(rename_all = "snake_case")]
+pub async fn insert_project(project: Project, app_state: State<'_, AppState>) -> Result<Project> {
+  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))
+    }
+  }
+}
+
+#[tauri::command(rename_all = "snake_case")]
+pub async fn delete_project(project_name: &str, app_state: State<'_, AppState>) -> Result<String> {
+  let db = app_state.project_db.lock().await;
+  let db = db.clone().unwrap();
+  db.remove(project_name).unwrap();
+  Ok(project_name.to_string())
+}

src-tauri/src/dbs/mod.rs

@@ -4,7 +4,7 @@ use tauri::{AppHandle, Manager, Result, State};
 
 use crate::AppState;
 
-#[tauri::command]
+#[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;
@@ -14,7 +14,7 @@ pub async fn insert_query(key: &str, sql: &str, app: AppHandle) -> Result<()> {
   Ok(())
 }
 
-#[tauri::command]
+#[tauri::command(rename_all = "snake_case")]
 pub async fn select_queries(app_state: State<'_, AppState>) -> Result<BTreeMap<String, String>> {
   let query_db = app_state.query_db.lock().await;
   let mut queries = BTreeMap::new();
@@ -29,7 +29,7 @@ pub async fn select_queries(app_state: State<'_, AppState>) -> Result<BTreeMap<S
   Ok(queries)
 }
 
-#[tauri::command]
+#[tauri::command(rename_all = "snake_case")]
 pub async fn delete_query(key: &str, app_state: State<'_, AppState>) -> Result<()> {
   let query_db = app_state.query_db.lock().await;
   if let Some(ref query_db) = *query_db {

src-tauri/src/dbs/project.rs

@@ -0,0 +1 @@
+pub mod postgresql;

src-tauri/src/query_db.rs renamed to src-tauri/src/dbs/query.rs

@@ -3,14 +3,13 @@ use tokio_postgres::{connect, NoTls};
 
 use crate::{utils::reflective_get, AppState};
 
-#[tauri::command]
-pub async fn pg_connector(project: &str, key: &str, app: AppHandle) -> Result<Vec<String>> {
+#[tauri::command(rename_all = "snake_case")]
+pub async fn postgresql_connector(
+  project_name: &str,
+  key: &str,
+  app: AppHandle,
+) -> Result<Vec<String>> {
   let app_state = app.state::<AppState>();
-  let mut db = app_state.project_db.lock().await;
-  if let Some(ref mut db_instance) = *db {
-    db_instance.insert(project, key).unwrap();
-  }
-
   let (client, connection) = connect(key, NoTls).await.expect("connection error");
   tokio::spawn(async move {
     if let Err(e) = connection.await {
@@ -32,19 +31,18 @@ pub async fn pg_connector(project: &str, key: &str, app: AppHandle) -> Result<Ve
   let schemas = schemas.iter().map(|r| r.get(0)).collect();
   let mut clients = app_state.client.lock().await;
   let clients = clients.as_mut().unwrap();
-  clients.insert(project.to_string(), client);
-
+  clients.insert(project_name.to_string(), client);
   Ok(schemas)
 }
 
-#[tauri::command]
+#[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#"
@@ -69,14 +67,14 @@ pub async fn select_schema_tables(
   Ok(tables)
 }
 
-#[tauri::command]
+#[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() {

src-tauri/src/drivers/mod.rs

@@ -1,16 +1,13 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod constant;
-mod postgres;
-mod project_db;
-mod query_db;
+mod dbs;
+mod drivers;
 mod utils;
 
-use constant::{PROJECT_DB_PATH, QUERY_DB_PATH};
-use postgres::{pg_connector, select_schema_tables, select_sql_result};
-use project_db::{delete_project, insert_project, select_projects};
-use query_db::{delete_query, insert_query, select_queries};
+const PROJECT_DB_PATH: &str = "project_db";
+const QUERY_DB_PATH: &str = "query_db";
+
 use sled::Db;
 use std::{collections::BTreeMap, sync::Arc};
 use tauri::Manager;
@@ -60,15 +57,15 @@ fn main() {
       Ok(())
     })
     .invoke_handler(tauri::generate_handler![
-      delete_project,
-      delete_query,
-      insert_project,
-      insert_query,
-      pg_connector,
-      select_projects,
-      select_queries,
-      select_schema_tables,
-      select_sql_result,
+      dbs::project::delete_project,
+      dbs::project::insert_project,
+      dbs::project::select_projects,
+      dbs::query::delete_query,
+      dbs::query::insert_query,
+      dbs::query::select_queries,
+      drivers::postgresql::postgresql_connector,
+      drivers::postgresql::select_schema_tables,
+      drivers::postgresql::select_sql_result,
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");