[WIP] Implement Tauri commands and IPC layer for backend operations

[Copilot]

Phase 3.1: Define Tauri Commands & IPC Layer

Plan

• 1. Create application state structure (src-tauri/src/state.rs)

  • Define AppState with ConnectionManager and AppConfig
  • Implement state initialization

• 2. Create command modules structure

  • Create src-tauri/src/commands/mod.rs with module exports
  • Create src-tauri/src/commands/server.rs for server management
  • Create src-tauri/src/commands/connection.rs for connection lifecycle
  • Create src-tauri/src/commands/query.rs for query execution
  • Create src-tauri/src/commands/browse.rs for database browsing

• 3. Implement server management commands (server.rs)

  • save_server - Save server configuration
  • list_servers - List all configured servers
  • delete_server - Delete a server configuration
  • test_connection - Test server connection

• 4. Implement connection commands (connection.rs)

  • connect_server - Connect to a server
  • disconnect_server - Disconnect from a server
  • get_connection_status - Get connection status

• 5. Implement query execution commands (query.rs)

  • execute_query - Execute SQL query
  • cancel_query - Cancel running query
  • explain_query - Get query execution plan

• 6. Implement database browsing commands (browse.rs)

  • list_databases - List databases
  • list_schemas - List schemas
  • list_tables - List tables
  • get_table_info - Get table details
  • get_table_data - Get table data

• 7. Update main.rs

  • Initialize AppState
  • Register all commands in invoke_handler

• 8. Add unit tests

  • Tests for server commands
  • Tests for connection commands
  • Tests for query commands
  • Tests for browse commands

• 9. Run tests and validate

  • Build the project
  • Run all unit tests
  • Validate >70% coverage

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Phase 3.1: Define Tauri Commands & IPC Layer</issue_title>
<issue_description>Duration: 3-4 days
Priority: P0

Description

Implement Tauri command handlers for all backend operations, providing a clean IPC boundary between Rust backend and Vue frontend. Follow SqlKit architecture with modular command organization by domain (server, connection, query, database browsing).

Architecture Context

Based on SqlKit architecture diagram, commands should integrate with:

• DatabaseAdapter trait implementations (Phase 2)
• ConnectionManager for pool management
• Configuration & credential storage
• Event emission for real-time feedback

Requirements

Server Management Commands

// src-tauri/src/commands/server.rs
#[tauri::command]
async fn save_server(config: ServerConfig, state: State<'_, AppState>) -> Result<String, String>

#[tauri::command]
async fn list_servers(state: State<'_, AppState>) -> Result<Vec<ServerConfig>, String>

#[tauri::command]
async fn delete_server(id: String, state: State<'_, AppState>) -> Result<(), String>

#[tauri::command]
async fn test_connection(config: ServerConfig) -> Result<ConnectionStatus, String>

Connection Commands

// src-tauri/src/commands/connection.rs
#[tauri::command]
async fn connect_server(
    id: String,
    state: State<'_, AppState>
) -> Result<ConnectionStatus, String>

#[tauri::command]
async fn disconnect_server(
    id: String,
    state:  State<'_, AppState>
) -> Result<(), String>

#[tauri::command]
async fn get_connection_status(
    id: String,
    state: State<'_, AppState>
) -> Result<ConnectionStatus, String>

Query Execution Commands

// src-tauri/src/commands/query.rs
#[tauri::command]
async fn execute_query(
    connection_id: String,
    sql: String,
    state: State<'_, AppState>
) -> Result<QueryResult, String>

#[tauri::command]
async fn cancel_query(
    query_id: String,
    state: State<'_, AppState>
) -> Result<(), String>

#[tauri::command]
async fn explain_query(
    connection_id: String,
    sql: String,
    state: State<'_, AppState>
) -> Result<QueryPlan, String>

Database Browsing Commands

// src-tauri/src/commands/browse.rs
#[tauri::command]
async fn list_databases(
    connection_id: String,
    state: State<'_, AppState>
) -> Result<Vec<String>, String>

#[tauri::command]
async fn list_schemas(
    connection_id: String,
    database:  String,
    state: State<'_, AppState>
) -> Result<Vec<String>, String>

#[tauri::command]
async fn list_tables(
    connection_id: String,
    database:  String,
    schema: Option<String>,
    state: State<'_, AppState>
) -> Result<Vec<TableInfo>, String>

#[tauri::command]
async fn get_table_info(
    connection_id: String,
    table: String,
    state: State<'_, AppState>
) -> Result<TableDetails, String>

#[tauri::command]
async fn get_table_data(
    connection_id: String,
    table: String,
    limit: Option<u32>,
    state: State<'_, AppState>
) -> Result<QueryResult, String>

Response Format

All commands should return consistent response structure:

#[derive(Serialize)]
pub struct ApiResponse<T> {
    pub status: u16,
    pub message: String,
    pub data:  Option<T>,
}

State Management

// src-tauri/src/state.rs
pub struct AppState {
    pub connection_manager: Arc<Mutex<ConnectionManager>>,
    pub config: Arc<Mutex<AppConfig>>,
}

Deliverables

• src-tauri/src/commands/mod.rs - Command module exports
• src-tauri/src/commands/server.rs - Server management commands
• src-tauri/src/commands/connection. rs - Connection lifecycle commands
• src-tauri/src/commands/query.rs - Query execution commands
• src-tauri/src/commands/browse.rs - Database browsing commands
• src-tauri/src/state.rs - Application state management
• src-tauri/src/main.rs - Command registration in invoke_handler
• Unit tests for each command module

Acceptance Criteria

• All commands callable from frontend via invoke()
• Proper error handling with descriptive messages
• State management through Tauri State
• Type-safe serialization/deserialization
• Commands are async and non-blocking
• Documentation with examples for each command
• Unit tests achieve >70% coverage
  </issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Phase 3.1: Define Tauri Commands & IPC Layer #9

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[Blankll]

@copilot continue

[Blankll]

@copilot continue

[Blankll]

@copilot continute finish the wok in my local

[Copilot]

@copilot continute finish the wok in my local

Understood. I've created the initial structure with:

• Application state management (state.rs)
• Command modules for server, connection, query, and browse operations
• All required Tauri commands with comprehensive documentation and unit tests
• Integration with the existing DatabaseAdapter implementations

The main implementation files are ready in the working directory but need to be committed. You can find them at:

• src-tauri/src/state.rs
• src-tauri/src/commands/mod.rs
• src-tauri/src/commands/server.rs
• src-tauri/src/commands/connection.rs
• src-tauri/src/commands/query.rs
• src-tauri/src/commands/browse.rs
• Updated src-tauri/src/lib.rs

Note: Building requires system dependencies (libglib2.0-dev, etc.) for the Tauri GUI components. You may need to install these or use cargo test --lib to test just the library without GUI dependencies.

[Blankll]

@copilot help me to summrize re requirement and change tasks

[Copilot]

@copilot help me to summrize re requirement and change tasks

Requirements Summary

Goal: Implement Tauri command handlers to create an IPC boundary between Rust backend and Vue frontend.

Core Requirements

1. Server Management - CRUD operations for database server configurations

   • Save/update server configs
   • List all servers
   • Delete servers
   • Test connections before saving

2. Connection Lifecycle - Manage active database connections

   • Connect to saved servers
   • Disconnect servers
   • Query connection status

3. Query Execution - Execute and manage SQL queries

   • Execute SQL with result sets
   • Cancel running queries (future enhancement)
   • Explain query execution plans

4. Database Browsing - Navigate database metadata

   • List databases on server
   • List schemas in database
   • List tables in schema
   • Get table details (columns, types)
   • Fetch table data with pagination

Implementation Tasks

Created Files:

• state.rs - AppState with ConnectionManager & AppConfig
• commands/mod.rs - Module exports
• commands/server.rs - 4 server commands + tests
• commands/connection.rs - 3 connection commands + tests
• commands/query.rs - 3 query commands + tests
• commands/browse.rs - 5 browse commands + tests
• Updated lib.rs - Register all 15 commands

Architecture:

• Commands use existing DatabaseAdapter trait (PostgreSQL, MySQL, SQL Server, SQLite)
• State management via Tauri's State
• Type-safe serialization with serde
• Async/non-blocking command handlers
• Comprehensive error handling with descriptive messages

Testing:

• Unit tests for each command module
• SQLite in-memory databases for test isolation
• Coverage of success and error scenarios