feat: update popover, select, sheet, and tooltip components to use new state attributes for animations

test: add unit tests for useIsMobile hook and db-functions utilities

feat: implement clipboard export functionality and enhance tauri API with createDatabase method

fix: update useAppStore to support multiple databases and improve connection handling

chore: set up testing environment with mocks for localStorage, sessionStorage, and other global objects

style: adjust theme handling in useAppStore and ensure proper application of dark/light classes

refactor: improve test utility functions for rendering components with providers

Author: imrj05

package-lock.json

@@ -1,11 +1,13 @@
 {
     "name": "db-connect",
     "private": true,
-    "version": "0.0.14",
+    "version": "0.0.15",
     "type": "module",
     "scripts": {
         "dev": "vite",
         "build": "tsc && vite build",
+        "test": "vitest run",
+        "test:watch": "vitest",
         "preview": "vite preview",
         "tauri": "tauri",
         "prepare": "git config core.hooksPath .githooks && chmod +x .githooks/*"
@@ -82,13 +84,18 @@
     "devDependencies": {
         "@tailwindcss/vite": "^4.2.1",
         "@tauri-apps/cli": "^2",
+        "@testing-library/jest-dom": "^6.9.1",
+        "@testing-library/react": "^16.3.2",
+        "@testing-library/user-event": "^14.6.1",
         "@types/node": "^25.5.0",
         "@types/react": "^19.1.8",
         "@types/react-dom": "^19.1.6",
         "@vitejs/plugin-react": "^4.6.0",
         "autoprefixer": "^10.4.27",
+        "jsdom": "^29.0.2",
         "tailwindcss": "^4.2.1",
         "typescript": "~5.8.3",
-        "vite": "^7.0.4"
+        "vite": "^7.0.4",
+        "vitest": "^4.1.5"
     }
 }

package.json

@@ -859,6 +859,16 @@ pub async fn get_databases(id: String) -> Result<Vec<String>, String> {
     driver.get_databases().await.map_err(|e| e.to_string())
 }
 
+#[tauri::command]
+pub async fn create_database(id: String, name: String) -> Result<(), String> {
+    let driver = REGISTRY
+        .connections
+        .get(&id)
+        .ok_or_else(|| "Not connected".to_string())?;
+
+    driver.create_database(&name).await.map_err(|e| e.to_string())
+}
+
 #[tauri::command]
 pub async fn get_tables(
     id: String,

src-tauri/src/commands.rs

@@ -45,6 +45,10 @@ pub trait DatabaseDriver: Send + Sync {
         page_size: u32,
     ) -> Result<QueryResult>;
 
+    async fn create_database(&self, _name: &str) -> Result<()> {
+        Err(anyhow::anyhow!("Create database not supported for this database type"))
+    }
+
     async fn dump_database(
         &self,
         _database: &str,

src-tauri/src/db/mod.rs

@@ -188,6 +188,20 @@ impl DatabaseDriver for MongoDriver {
         Ok(client.list_database_names(None, None).await?)
     }
 
+    async fn create_database(&self, name: &str) -> Result<()> {
+        // MongoDB creates a database implicitly when a collection is inserted into.
+        // We create a sentinel collection then drop it so the DB persists as empty.
+        let client_lock = self.client.read().await;
+        let client = client_lock
+            .as_ref()
+            .ok_or_else(|| anyhow!("Not connected"))?;
+
+        let db = client.database(name);
+        // Creating a collection forces the database to materialise on disk.
+        db.create_collection("_init", None).await?;
+        Ok(())
+    }
+
     async fn get_schemas(&self, _database: &str) -> Result<Vec<String>> {
         Ok(vec!["collection".to_string()])
     }

src-tauri/src/db/mongodb.rs

@@ -73,6 +73,14 @@ impl DatabaseDriver for MySqlDriver {
         Ok(rows.iter().map(|r| r.get::<String, _>(0)).collect())
     }
 
+    async fn create_database(&self, name: &str) -> Result<()> {
+        let pool_lock = self.pool.read().await;
+        let pool = pool_lock.as_ref().ok_or_else(|| anyhow!("Not connected"))?;
+        let sql = format!("CREATE DATABASE `{}`", name.replace('`', ""));
+        sqlx::query(&sql).execute(pool).await?;
+        Ok(())
+    }
+
     async fn get_schemas(&self, _database: &str) -> Result<Vec<String>> {
         Ok(vec!["default".to_string()])
     }

src-tauri/src/db/mysql.rs

@@ -69,6 +69,15 @@ impl DatabaseDriver for PostgresDriver {
         Ok(rows.iter().map(|r| r.get::<String, _>(0)).collect())
     }
 
+    async fn create_database(&self, name: &str) -> Result<()> {
+        let pool_lock = self.pool.read().await;
+        let pool = pool_lock.as_ref().ok_or_else(|| anyhow!("Not connected"))?;
+        // CREATE DATABASE cannot run inside a transaction; use a simple execute.
+        let sql = format!("CREATE DATABASE \"{}\"", name.replace('"', ""));
+        sqlx::query(&sql).execute(pool).await?;
+        Ok(())
+    }
+
     async fn get_schemas(&self, _database: &str) -> Result<Vec<String>> {
         let pool_lock = self.pool.read().await;
         let pool = pool_lock.as_ref().ok_or_else(|| anyhow!("Not connected"))?;
@@ -323,6 +332,24 @@ impl DatabaseDriver for PostgresDriver {
         let pool = pool_lock.as_ref().ok_or_else(|| anyhow!("Not connected"))?;
 
         let start = Instant::now();
+
+        // Multi-statement SQL (e.g. CREATE TABLE + COMMENT ON COLUMN) must use the
+        // simple query protocol — prepared statements reject multiple commands.
+        let stmt_count = query
+            .split(';')
+            .map(|s| s.trim())
+            .filter(|s| !s.is_empty())
+            .count();
+        if stmt_count > 1 {
+            sqlx::raw_sql(query).execute(pool).await?;
+            let duration = start.elapsed().as_millis() as u64;
+            return Ok(QueryResult {
+                columns: vec![],
+                rows: vec![],
+                execution_time_ms: duration,
+            });
+        }
+
         let rows = sqlx::query(query).fetch_all(pool).await?;
         let duration = start.elapsed().as_millis() as u64;
 

src-tauri/src/db/postgres.rs

@@ -48,6 +48,39 @@ impl DatabaseDriver for SqliteDriver {
         Ok(vec!["main".to_string()])
     }
 
+    async fn create_database(&self, name: &str) -> Result<()> {
+        // SQLite "databases" are files. Create a new .db file next to the current one.
+        let pool_lock = self.pool.read().await;
+        let pool = pool_lock.as_ref().ok_or_else(|| anyhow!("Not connected"))?;
+
+        // Get the current file path from PRAGMA database_list
+        let row = sqlx::query("PRAGMA database_list")
+            .fetch_one(pool)
+            .await?;
+        let current_path: String = row.get(2);
+
+        let parent = std::path::Path::new(&current_path)
+            .parent()
+            .ok_or_else(|| anyhow!("Cannot determine parent directory of current SQLite file"))?;
+
+        let safe_name = name.replace(['/', '\\', ':', '*', '?', '"', '<', '>', '|'], "_");
+        let new_path = parent.join(format!("{}.db", safe_name));
+
+        if new_path.exists() {
+            return Err(anyhow!("A database file '{}' already exists", new_path.display()));
+        }
+
+        // Opening (connecting) to a new path creates the file in SQLite
+        let url = format!("sqlite:{}", new_path.to_string_lossy());
+        let new_pool = sqlx::sqlite::SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect(&url)
+            .await?;
+        new_pool.close().await;
+
+        Ok(())
+    }
+
     async fn get_schemas(&self, _database: &str) -> Result<Vec<String>> {
         Ok(vec!["main".to_string()])
     }

src-tauri/src/db/sqlite.rs

@@ -34,6 +34,7 @@ pub fn run() {
             commands::connect_database,
             commands::disconnect_database,
             commands::get_databases,
+            commands::create_database,
             commands::get_tables,
             commands::execute_query,
             commands::ping_connection,

src-tauri/src/lib.rs

@@ -1,7 +1,7 @@
 {
     "$schema": "https://schema.tauri.app/config/2",
     "productName": "DB Connect",
-    "version": "0.0.14",
+    "version": "0.0.15",
     "identifier": "com.rajeshwar.db-connect",
     "build": {
         "beforeDevCommand": "npm run dev",