refactor(frontend,backend): enforce type over interface, async ConnectionManager, clippy fixes

Frontend:
- Update ESLint config to enforce `type` over `interface` declarations
- Auto-convert 40 `interface` usages to `type` across stores, components, types
- Fix DataTableView.vue invoke call to use nested `query` object matching TableDataQuery struct
Backend:
- Migrate ConnectionManager from std::sync::RwLock to tokio::sync::RwLock for async compatibility
- Make get_stats(), get_all_metadata(), get_connection_metadata() async
- Rename update_stats_locked → update_stats_from_metadata
- Refactor get_table_data command: 8 flat params → TableDataQuery struct (fixes clippy too_many_arguments)
- Derive Default for SslMode with #[default] attribute
- Remove unnecessary `as usize` casts in postgres.rs
- Replace format!() with string literals for static SQL in mysql.rs
- Auto-fix clippy: needless_borrows_for_generic_args, manual_map, new_without_default, redundant_closure
Tests:
- Update connection_manager_tests.rs to async API
- Restore concurrent connection tests (test_concurrent_connections, test_concurrent_isolation_no_interference)
- Fix integration tests: unused imports, missing ConnectionPool import, field name corrections

Author: Blankll

eslint.config.js

@@ -25,10 +25,12 @@ export default antfu({
     '**/.tauri/**',
     'AGENTS.md',
     'docs/**',
+    'src-tauri/gen/**',
   ],
   rules: {
     'no-console': 'warn',
     'unused-imports/no-unused-vars': 'warn',
     'style/eol-last': ['error', 'always'],
+    'ts/consistent-type-definitions': ['error', 'type'],
   },
 })

src-tauri/examples/mysql_usage.rs

@@ -13,7 +13,8 @@
 //! ```
 
 use sqlkit_lib::database::{
-    ConnectionConfig, DatabaseAdapter, DatabaseType, MySQLAdapter, PoolConfig, SslMode,
+    ConnectionConfig, ConnectionPool, DatabaseAdapter, DatabaseType, MySQLAdapter, PoolConfig,
+    SslMode,
 };
 use std::env;
 use std::time::Duration;
@@ -40,7 +41,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         max_connections: 10,
         connection_timeout: Duration::from_secs(30),
         max_lifetime: Duration::from_secs(1800), // 30 minutes
-        idle_timeout: Duration::from_secs(600),   // 10 minutes
+        idle_timeout: Duration::from_secs(600),  // 10 minutes
     };
 
     // Create connection configuration
@@ -66,7 +67,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Server Version: {}", status.server_version.unwrap());
     println!(
         "Current Database: {}",
-        status.current_database.unwrap_or_else(|| "None".to_string())
+        status
+            .current_database
+            .unwrap_or_else(|| "None".to_string())
     );
     println!("Current User: {}\n", status.current_user.unwrap());
 

src-tauri/examples/postgres_usage.rs

@@ -16,7 +16,8 @@
 //! - POSTGRES_DB (default: postgres)
 
 use sqlkit_lib::database::{
-    ConnectionConfig, DatabaseAdapter, DatabaseType, PoolConfig, PostgresAdapter, SslMode,
+    ConnectionConfig, ConnectionPool, DatabaseAdapter, DatabaseType, PoolConfig, PostgresAdapter,
+    SslMode,
 };
 use std::env;
 use std::time::Duration;
@@ -42,7 +43,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         max_connections: 10,
         connection_timeout: Duration::from_secs(30),
         max_lifetime: Duration::from_secs(1800), // 30 minutes
-        idle_timeout: Duration::from_secs(600),   // 10 minutes
+        idle_timeout: Duration::from_secs(600),  // 10 minutes
     };
 
     // Build connection configuration
@@ -67,9 +68,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("Testing connection...");
     let status = adapter.test_connection().await?;
     println!("✓ Connection Status:");
-    println!("  - Server Version: {}", status.server_version.unwrap_or_default());
-    println!("  - Current Database: {}", status.current_database.unwrap_or_default());
-    println!("  - Current User: {}\n", status.current_user.unwrap_or_default());
+    println!(
+        "  - Server Version: {}",
+        status.server_version.unwrap_or_default()
+    );
+    println!(
+        "  - Current Database: {}",
+        status.current_database.unwrap_or_default()
+    );
+    println!(
+        "  - Current User: {}\n",
+        status.current_user.unwrap_or_default()
+    );
 
     // List databases
     println!("Listing databases...");
@@ -112,7 +122,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Execute a simple query
     println!("Executing query: SELECT version()");
     let result = adapter.execute_query("SELECT version() as version").await?;
-    println!("✓ Query executed in {}ms", result.execution_time_ms.unwrap_or(0));
+    println!(
+        "✓ Query executed in {}ms",
+        result.execution_time_ms.unwrap_or(0)
+    );
     if let Some(row) = result.rows.first() {
         if let Some(version) = row.get("version") {
             println!("  PostgreSQL Version: {:?}\n", version);
@@ -124,7 +137,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let result = adapter
         .execute_query("SELECT current_timestamp, current_user")
         .await?;
-    println!("✓ Query executed in {}ms", result.execution_time_ms.unwrap_or(0));
+    println!(
+        "✓ Query executed in {}ms",
+        result.execution_time_ms.unwrap_or(0)
+    );
     println!("  Columns: {:?}", result.columns);
     println!("  Rows: {}\n", result.rows.len());
 
@@ -138,7 +154,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             '{"role": "admin", "active": true}'::jsonb as metadata
     "#;
     let result = adapter.execute_query(query).await?;
-    println!("✓ Complex types query executed in {}ms", result.execution_time_ms.unwrap_or(0));
+    println!(
+        "✓ Complex types query executed in {}ms",
+        result.execution_time_ms.unwrap_or(0)
+    );
     if let Some(row) = result.rows.first() {
         println!("  Result contains: {:?}", row.keys().collect::<Vec<_>>());
     }

src-tauri/examples/sqlite_usage.rs

@@ -35,7 +35,7 @@ async fn file_based_example() -> Result<(), Box<dyn std::error::Error>> {
     let temp_dir = std::env::temp_dir();
     let db_path = temp_dir.join("example.db");
     let db_path_str = db_path.to_string_lossy().to_string();
-    
+
     // Clean up any existing database
     let _ = fs::remove_file(&db_path);
     let _ = fs::remove_file(db_path.with_extension("db-wal"));
@@ -178,7 +178,7 @@ async fn metadata_example() -> Result<(), Box<dyn std::error::Error>> {
     let temp_dir = std::env::temp_dir();
     let db_path = temp_dir.join("metadata_example.db");
     let db_path_str = db_path.to_string_lossy().to_string();
-    
+
     // Clean up
     let _ = fs::remove_file(&db_path);
     let _ = fs::remove_file(db_path.with_extension("db-wal"));
@@ -248,7 +248,11 @@ async fn metadata_example() -> Result<(), Box<dyn std::error::Error>> {
             "  - {} ({}) {}{}",
             col.name,
             col.data_type,
-            if col.is_primary_key { "PRIMARY KEY " } else { "" },
+            if col.is_primary_key {
+                "PRIMARY KEY "
+            } else {
+                ""
+            },
             if col.nullable { "NULL" } else { "NOT NULL" }
         );
     }
@@ -258,9 +262,7 @@ async fn metadata_example() -> Result<(), Box<dyn std::error::Error>> {
         .execute_query("INSERT INTO customers (name) VALUES ('John Doe'), ('Jane Smith')")
         .await?;
 
-    let table_info = adapter
-        .get_table_info(None, None, "customers")
-        .await?;
+    let table_info = adapter.get_table_info(None, None, "customers").await?;
     println!("\n✓ Table info for 'customers':");
     println!("  - Name: {}", table_info.name);
     println!("  - Type: {}", table_info.table_type);

src-tauri/examples/sqlserver_usage.rs

@@ -14,7 +14,7 @@
 //! ```
 
 use sqlkit_lib::database::{
-    ConnectionConfig, DatabaseAdapter, DatabaseType, SqlServerAdapter, PoolConfig, SslMode,
+    ConnectionConfig, DatabaseAdapter, DatabaseType, PoolConfig, SqlServerAdapter, SslMode,
 };
 use std::env;
 use std::time::Duration;
@@ -61,11 +61,15 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let status = adapter.test_connection().await?;
     println!(
         "Server version: {}",
-        status.server_version.unwrap_or_else(|| "Unknown".to_string())
+        status
+            .server_version
+            .unwrap_or_else(|| "Unknown".to_string())
     );
     println!(
         "Current database: {}",
-        status.current_database.unwrap_or_else(|| "Unknown".to_string())
+        status
+            .current_database
+            .unwrap_or_else(|| "Unknown".to_string())
     );
     println!(
         "Current user: {}",
@@ -109,7 +113,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Example: Create a temporary table and query it
     println!("\n=== Example: Working with temporary tables ===");
-    
+
     // Create table
     adapter
         .execute_query(
@@ -132,17 +136,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 ('charlie', 'charlie@example.com')",
         )
         .await?;
-    println!(
-        "Inserted {} rows",
-        insert_result.rows_affected.unwrap_or(0)
-    );
+    println!("Inserted {} rows", insert_result.rows_affected.unwrap_or(0));
 
     // Query data
     let result = adapter
         .execute_query("SELECT * FROM #demo_users ORDER BY id")
         .await?;
     println!("Query returned {} rows:", result.rows.len());
-    println!("Execution time: {}ms", result.execution_time.unwrap_or(0));
+    println!(
+        "Execution time: {}ms",
+        result.execution_time_ms.unwrap_or(0)
+    );
 
     // Display results
     for row in result.rows {
@@ -151,7 +155,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Example: Complex types
     println!("\n=== Example: Working with complex types ===");
-    
+
     adapter
         .execute_query(
             "CREATE TABLE #demo_complex (
@@ -162,18 +166,16 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             )",
         )
         .await?;
-    
+
     adapter
         .execute_query(
             r#"INSERT INTO #demo_complex (xml_data, json_data) VALUES 
                 ('<root><name>Test</name></root>', '{"type": "example", "status": "active"}')"#,
         )
         .await?;
-    
-    let complex_result = adapter
-        .execute_query("SELECT * FROM #demo_complex")
-        .await?;
-    
+
+    let complex_result = adapter.execute_query("SELECT * FROM #demo_complex").await?;
+
     println!("Complex types data:");
     for row in complex_result.rows {
         println!("  - XML: {:?}", row.get("xml_data"));