diff --git a/apps/desktop/src/components/sidebar/TreeItem.vue b/apps/desktop/src/components/sidebar/TreeItem.vue index aab0cc289f..a5774e74ff 100644 --- a/apps/desktop/src/components/sidebar/TreeItem.vue +++ b/apps/desktop/src/components/sidebar/TreeItem.vue @@ -1411,6 +1411,17 @@ function disconnectConnection() { } } +async function closeDatabaseConnection() { + const node = props.node; + if (node.type !== "database" || !node.connectionId || node.database == null) return; + try { + await connectionStore.closeDatabaseConnection(node.connectionId, node.database); + toast(t("connection.databaseConnectionClosed", { name: node.label }), 2000); + } catch (e: any) { + toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000); + } +} + function openTransfer() { if (props.node.connectionId) { connectionStore.transferSource = { @@ -1593,6 +1604,18 @@ const isConnected = computed( !!props.node.connectionId && connectionStore.connectedIds.has(props.node.connectionId), ); +const canCloseDatabaseConnection = computed( + () => + props.node.type === "database" && + !!props.node.connectionId && + props.node.database != null && + connectionStore.isTreeNodeChildrenLoaded(props.node.id), +); +const nodeIconClass = computed(() => { + const infoClass = getIconInfo(props.node)?.colorClass; + if (props.node.type !== "database") return infoClass; + return canCloseDatabaseConnection.value ? infoClass : "text-muted-foreground/65"; +}); const canConfigureVisibleDatabases = computed(() => { if (props.node.type !== "connection" || !props.node.connectionId) return false; return connectionStore.getConfig(props.node.connectionId)?.db_type !== "elasticsearch"; @@ -2040,6 +2063,10 @@ function treeItemMenuItems(): ContextMenuItem[] { items.push({ label: t("diff.title"), action: openSchemaDiff, icon: ArrowRightLeft }); items.push({ label: t("dataCompare.title"), action: openDataCompare, icon: ArrowRightLeft }); items.push({ label: t("contextMenu.exportDatabase"), action: openDatabaseExport, icon: Download }); + if (canCloseDatabaseConnection.value) { + items.push({ label: "", separator: true }); + items.push({ label: t("contextMenu.closeDatabaseConnection"), action: closeDatabaseConnection, icon: Unplug }); + } if (canDropDatabase.value || canDropSchema.value) { items.push({ label: "", separator: true }); } @@ -2258,8 +2285,8 @@ function treeItemMenuItems(): ContextMenuItem[] { (name: K): Backend[K] { export const testConnection = forward("testConnection"); export const connectDb = forward("connectDb"); export const disconnectDb = forward("disconnectDb"); +export const closeDatabaseConnection = forward("closeDatabaseConnection"); export const refreshConnections = forward("refreshConnections"); export const saveConnections = forward("saveConnections"); export const loadConnections = forward("loadConnections"); diff --git a/apps/desktop/src/lib/http.ts b/apps/desktop/src/lib/http.ts index aadef2304e..c03d83f737 100644 --- a/apps/desktop/src/lib/http.ts +++ b/apps/desktop/src/lib/http.ts @@ -148,6 +148,10 @@ export async function disconnectDb(connectionId: string): Promise { return post("/api/connection/disconnect", { connectionId }); } +export async function closeDatabaseConnection(connectionId: string, database: string): Promise { + return post("/api/connection/close-database", { connectionId, database }); +} + export async function saveConnections(configs: ConnectionConfig[]): Promise { return post("/api/connection/save", { configs }); } diff --git a/apps/desktop/src/lib/tauri.ts b/apps/desktop/src/lib/tauri.ts index f16ce007d0..aa7fb15bbf 100644 --- a/apps/desktop/src/lib/tauri.ts +++ b/apps/desktop/src/lib/tauri.ts @@ -371,6 +371,10 @@ export async function disconnectDb(connectionId: string): Promise { return invoke("disconnect_db", { connectionId }); } +export async function closeDatabaseConnection(connectionId: string, database: string): Promise { + return invoke("close_database_connection", { connectionId, database }); +} + export async function listDatabases(connectionId: string): Promise { return invoke("list_databases", { connectionId }); } diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.ts index 2c01c380d2..7f31403f42 100644 --- a/apps/desktop/src/stores/connectionStore.ts +++ b/apps/desktop/src/stores/connectionStore.ts @@ -427,6 +427,10 @@ export const useConnectionStore = defineStore("connection", () => { return true; } + function isTreeNodeChildrenLoaded(nodeId: string): boolean { + return loadedTreeNodeChildrenIds.value.has(nodeId); + } + function clearLoadedChildrenCache(prefix: string) { for (const id of loadedTreeNodeChildrenIds.value) { if (id === prefix || id.startsWith(`${prefix}:`)) { @@ -509,16 +513,17 @@ export const useConnectionStore = defineStore("connection", () => { stopCreatingConnectionInGroup(); } - function invalidateCompletionCache(connectionId: string) { - const cachePrefix = `${connectionId}:`; + function invalidateCompletionCache(connectionId: string, database?: string) { + const cachePrefix = database == null ? `${connectionId}:` : `${connectionId}:${database}:`; + const exactCacheKey = database == null ? null : `${connectionId}:${database}`; for (const key of Object.keys(completionTablesCache.value)) { - if (key.startsWith(cachePrefix)) delete completionTablesCache.value[key]; + if (key === exactCacheKey || key.startsWith(cachePrefix)) delete completionTablesCache.value[key]; } for (const key of Object.keys(completionColumnsCache.value)) { - if (key.startsWith(cachePrefix)) delete completionColumnsCache.value[key]; + if (key === exactCacheKey || key.startsWith(cachePrefix)) delete completionColumnsCache.value[key]; } for (const key of Object.keys(schemaListCache.value)) { - if (key.startsWith(cachePrefix)) delete schemaListCache.value[key]; + if (key === exactCacheKey || key.startsWith(cachePrefix)) delete schemaListCache.value[key]; } } @@ -670,6 +675,17 @@ export const useConnectionStore = defineStore("connection", () => { } } + async function closeDatabaseConnection(connectionId: string, database: string) { + await api.closeDatabaseConnection(connectionId, database); + const node = findDatabaseTreeNode(treeNodes.value, connectionId, database); + if (node) { + node.isExpanded = false; + node.children = []; + clearLoadedChildrenCache(node.id); + } + invalidateCompletionCache(connectionId, database); + } + async function ensureConnected(connectionId: string) { if (connectedIds.value.has(connectionId)) return; let config = getConfig(connectionId); @@ -1841,7 +1857,9 @@ export const useConnectionStore = defineStore("connection", () => { stopCreatingConnectionInGroup, connect, disconnect, + closeDatabaseConnection, ensureConnected, + isTreeNodeChildrenLoaded, setBeforeConnectHandler, initFromDisk, loadDatabases, diff --git a/crates/dbx-core/src/connection.rs b/crates/dbx-core/src/connection.rs index d23c8e9874..77f70e2add 100644 --- a/crates/dbx-core/src/connection.rs +++ b/crates/dbx-core/src/connection.rs @@ -509,6 +509,33 @@ impl AppState { } } + pub async fn close_database_pool(&self, connection_id: &str, database: Option<&str>) -> Result { + let db_type = { + let configs = self.configs.read().await; + configs.get(connection_id).map(|c| c.db_type) + }; + let base_pool_key = base_pool_key_for(db_type, connection_id, database, false); + let session_prefix = format!("{base_pool_key}:session:"); + let mut conns = self.connections.write().await; + let keys_to_remove: Vec = conns + .keys() + .filter(|key| *key == &base_pool_key || key.starts_with(&session_prefix)) + .cloned() + .collect(); + let mut removed = Vec::with_capacity(keys_to_remove.len()); + for key in keys_to_remove { + if let Some(pool) = conns.remove(&key) { + removed.push(pool); + } + } + drop(conns); + let closed = !removed.is_empty(); + for pool in removed { + close_pool_kind(pool).await; + } + Ok(closed) + } + pub async fn duckdb_existing_pool_is_usable_for_config(&self, config: &ConnectionConfig) -> Result { if config.db_type != DatabaseType::DuckDb { return Ok(false); @@ -1434,6 +1461,33 @@ mod tests { let _ = std::fs::remove_dir_all(dir); } + #[tokio::test] + async fn close_database_pool_removes_database_and_session_scoped_pools_only() { + let (state, dir) = test_app_state().await; + let mut config = mysql_config(None); + config.id = "conn".to_string(); + state.configs.write().await.insert(config.id.clone(), config); + let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap(); + + { + let mut conns = state.connections.write().await; + conns.insert("conn".to_string(), PoolKind::Sqlite(pool.clone())); + conns.insert("conn:analytics".to_string(), PoolKind::Sqlite(pool.clone())); + conns.insert("conn:analytics:session:tab-1".to_string(), PoolKind::Sqlite(pool.clone())); + conns.insert("conn:billing".to_string(), PoolKind::Sqlite(pool)); + } + + assert!(state.close_database_pool("conn", Some("analytics")).await.unwrap()); + + let conns = state.connections.read().await; + assert!(conns.contains_key("conn")); + assert!(!conns.contains_key("conn:analytics")); + assert!(!conns.contains_key("conn:analytics:session:tab-1")); + assert!(conns.contains_key("conn:billing")); + + let _ = std::fs::remove_dir_all(dir); + } + #[tokio::test] async fn proxy_connection_uses_local_forward_endpoint() { let (state, dir) = test_app_state().await; diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs index cbeb7eaf13..6d8ca074c2 100644 --- a/crates/dbx-web/src/main.rs +++ b/crates/dbx-web/src/main.rs @@ -83,6 +83,7 @@ async fn main() { .route("/connection/test", post(routes::connection::test_connection)) .route("/connection/connect", post(routes::connection::connect_db)) .route("/connection/disconnect", post(routes::connection::disconnect_db)) + .route("/connection/close-database", post(routes::connection::close_database_connection)) .route("/connection/save", post(routes::connection::save_connections)) .route("/connection/list", get(routes::connection::load_connections)) .route("/plugins", get(routes::plugins::list_plugins)) diff --git a/crates/dbx-web/src/routes/connection.rs b/crates/dbx-web/src/routes/connection.rs index f82d9d0711..912f8cb68d 100644 --- a/crates/dbx-web/src/routes/connection.rs +++ b/crates/dbx-web/src/routes/connection.rs @@ -20,6 +20,13 @@ pub struct DisconnectRequest { pub connection_id: String, } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CloseDatabaseConnectionRequest { + pub connection_id: String, + pub database: String, +} + #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct SaveConnectionsRequest { @@ -92,6 +99,15 @@ pub async fn disconnect_db( Ok(Json(())) } +pub async fn close_database_connection( + State(state): State>, + Json(body): Json, +) -> Result, AppError> { + let database = body.database.trim(); + let database = if database.is_empty() { None } else { Some(database) }; + state.app.close_database_pool(&body.connection_id, database).await.map(Json).map_err(AppError) +} + pub async fn save_connections( State(state): State>, Json(body): Json, diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rs index 1d0de2284c..7c9d4140a3 100644 --- a/src-tauri/src/commands/connection.rs +++ b/src-tauri/src/commands/connection.rs @@ -515,6 +515,17 @@ pub async fn disconnect_db(state: State<'_, Arc>, connection_id: Strin Ok(()) } +#[tauri::command] +pub async fn close_database_connection( + state: State<'_, Arc>, + connection_id: String, + database: String, +) -> Result { + let database = database.trim(); + let database = if database.is_empty() { None } else { Some(database) }; + state.close_database_pool(&connection_id, database).await +} + #[tauri::command] pub async fn refresh_connections(state: State<'_, Arc>) -> Result<(), String> { state.refresh_connections().await; diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index a4d4c4d6d0..f04cb46b5f 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -276,6 +276,7 @@ pub fn run() { commands::connection::test_connection, commands::connection::connect_db, commands::connection::disconnect_db, + commands::connection::close_database_connection, commands::connection::refresh_connections, commands::connection::save_connections, commands::connection::load_connections,