refactor(back): reorganize commands

src-tauri/src/connection.rs

@@ -0,0 +1,69 @@
+use crate::utils::{read_from_connections_file, write_into_connections_file, Drivers};
+use sqlx::{AnyConnection, Connection};
+
+#[tauri::command]
+pub async fn test_connection(conn_string: String) -> Result<String, String> {
+    sqlx::any::install_default_drivers();
+    let mut con = AnyConnection::connect(conn_string.as_str())
+        .await
+        .map_err(|_| "Couldn't connect to DB".to_string())?;
+    let _ = con
+        .ping()
+        .await
+        .map_err(|_| "DB not responding to Pings".to_string())?;
+
+    let _ = con.close().await;
+
+    Ok("Connection is healthy".to_string())
+}
+
+#[tauri::command]
+pub fn create_connection_record(
+    app: tauri::AppHandle,
+    conn_string: String,
+    conn_name: String,
+) -> Result<(), String> {
+    write_into_connections_file(
+        app.path_resolver().app_config_dir(),
+        Drivers::SQLITE,
+        conn_string,
+        conn_name,
+    );
+    Ok(())
+}
+
+#[tauri::command]
+pub fn connections_exist(app: tauri::AppHandle) -> Result<bool, String> {
+    let (_, connections) = read_from_connections_file(app.path_resolver().app_config_dir());
+    match connections {
+        Ok(connections) => {
+            if connections.as_object().unwrap().len() > 0 {
+                Ok(true)
+            } else {
+                Ok(false)
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+pub fn get_connections(app: tauri::AppHandle) -> Result<serde_json::Value, String> {
+    let (_, connections) = read_from_connections_file(app.path_resolver().app_config_dir());
+    match connections {
+        Ok(conns) => Ok(conns),
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+pub fn get_connection_details(
+    app: tauri::AppHandle,
+    conn_id: String,
+) -> Result<serde_json::Value, String> {
+    let (_, connections) = read_from_connections_file(app.path_resolver().app_config_dir());
+    match connections {
+        Ok(conns) => Ok(conns.get(conn_id).unwrap().to_owned()),
+        Err(err) => Err(err.to_string()),
+    }
+}

src-tauri/src/main.rs

@@ -1,14 +1,17 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod common;
+mod connection;
 mod sqlite;
 mod utils;
 
-use common::{connections_exist, get_connection_details, get_connections};
+use connection::{
+    connections_exist, create_connection_record, get_connection_details, get_connections,
+    test_connection,
+};
 use sqlite::{
-    connect_sqlite, create_row, create_sqlite_connection, delete_row, get_columns,
-    get_columns_definition, get_rows, get_tables, test_sqlite_conn, update_row,
+    connect_sqlite, create_row, delete_row, get_columns, get_columns_definition, get_rows,
+    get_tables, update_row,
 };
 use sqlx::Pool;
 use tokio::sync::Mutex;
@@ -24,8 +27,8 @@ fn main() {
             pool: Default::default(),
         })
         .invoke_handler(tauri::generate_handler![
-            test_sqlite_conn,
-            create_sqlite_connection,
+            test_connection,
+            create_connection_record,
             connections_exist,
             get_connections,
             get_connection_details,

src-tauri/src/sqlite.rs

@@ -1,45 +1,12 @@
 use crate::{utils, DbInstance};
 use serde_json::Map;
 use serde_json::Value as JsonValue;
-use sqlx::{AnyConnection, Column, Connection, Row};
+use sqlx::{Column, Row};
 use std::collections::HashMap;
 use std::iter::Iterator;
 use std::result::Result::Ok;
 use std::vec;
-use tauri::{Runtime, State};
-
-use crate::utils::{write_into_connections_file, Drivers};
-
-#[tauri::command]
-pub async fn test_sqlite_conn(conn_string: String) -> Result<String, String> {
-    sqlx::any::install_default_drivers();
-    let mut con = AnyConnection::connect(conn_string.as_str())
-        .await
-        .map_err(|_| "Couldn't connect to DB".to_string())?;
-    let _ = con
-        .ping()
-        .await
-        .map_err(|_| "DB not responding to Pings".to_string())?;
-
-    let _ = con.close().await;
-
-    Ok("Connection is healthy".to_string())
-}
-
-#[tauri::command]
-pub fn create_sqlite_connection<R: Runtime>(
-    app: tauri::AppHandle<R>,
-    conn_string: String,
-    conn_name: String,
-) -> Result<(), String> {
-    write_into_connections_file(
-        app.path_resolver().app_config_dir(),
-        Drivers::SQLITE,
-        conn_string,
-        conn_name,
-    );
-    Ok(())
-}
+use tauri::State;
 
 #[tauri::command]
 pub async fn connect_sqlite(

src/app/connect/_components/sqlite-connection.tsx

@@ -14,7 +14,7 @@ import { useRouter } from "next/navigation"
 import { useState, type FC } from "react"
 import { useForm } from "react-hook-form"
 import { z } from "zod"
-import { connectSQLite, testSQLiteConnection } from "../actions"
+import { createConnectionRecord, testConnection } from "../actions"
 
 const SqliteConnection = () => {
   const [selectedPath, setSelectedPath] = useState<string | null>(null)
@@ -59,7 +59,7 @@ const ConnectionForm: FC<ConnectionFormProps> = ({ selectedPath }) => {
     resolver: zodResolver(formSchema)
   })
   const onSubmit = (values: z.infer<typeof formSchema>) => {
-    connectSQLite(values.connName, selectedPath as string)
+    createConnectionRecord(values.connName, `sqlite:${selectedPath}`)
     router.push("/connections")
   }
   return (
@@ -90,7 +90,7 @@ const ConnectionForm: FC<ConnectionFormProps> = ({ selectedPath }) => {
           <Button
             type="button"
             className="bg-green-500 hover:bg-green-700 w-[100px]"
-            onClick={() => testSQLiteConnection(selectedPath as string)}
+            onClick={() => testConnection(`sqlite:${selectedPath}`)}
           >
             Test
           </Button>

src/app/connect/actions.ts

@@ -1,9 +1,9 @@
 import { invoke } from "@tauri-apps/api/tauri"
 import toast from "react-hot-toast"
 
-export const testSQLiteConnection = async (selectedPath: string) => {
-  const command = invoke<string>("test_sqlite_conn", {
-    connString: `sqlite:${selectedPath}`
+export const testConnection = async (connString: string) => {
+  const command = invoke<string>("test_connection", {
+    connString
   })
   toast.promise(command, {
     loading: "Loading",
@@ -12,9 +12,12 @@ export const testSQLiteConnection = async (selectedPath: string) => {
   })
 }
 
-export const connectSQLite = async (connName: string, selectedPath: string) => {
-  await invoke("create_sqlite_connection", {
-    connString: `sqlite:${selectedPath}`,
+export const createConnectionRecord = async (
+  connName: string,
+  connString: string
+) => {
+  await invoke("create_connection_record", {
+    connString,
     connName
   })
 }