feat(nacos): add Nacos management console (#1456)

src-tauri/src/commands/connection.rs

@@ -433,17 +433,20 @@ async fn save_connection_configs(state: &AppState, configs: &[ConnectionConfig])
     state.storage.save_connections(configs).await?;
     let sync = sync_connection_configs(state, configs).await;
     remove_connection_pools_for_connection_ids(state, &sync.connection_pool_ids_to_drop).await;
+    drop_nacos_adapters_for_connection_ids(state, &sync.nacos_adapter_ids_to_drop).await;
     drop_mq_adapters_for_connection_ids(state, &sync.mq_adapter_ids_to_drop).await;
     Ok(())
 }
 
 struct ConnectionConfigSync {
+    nacos_adapter_ids_to_drop: Vec<String>,
     mq_adapter_ids_to_drop: Vec<String>,
     connection_pool_ids_to_drop: Vec<String>,
 }
 
 async fn sync_connection_configs(state: &AppState, configs: &[ConnectionConfig]) -> ConnectionConfigSync {
     let saved_ids: HashSet<&str> = configs.iter().map(|config| config.id.as_str()).collect();
+    let mut nacos_adapter_ids_to_drop = HashSet::new();
     let mut mq_adapter_ids_to_drop = HashSet::new();
     let mut connection_pool_ids_to_drop = HashSet::new();
     let mut runtime_configs = state.configs.write().await;
@@ -452,6 +455,9 @@ async fn sync_connection_configs(state: &AppState, configs: &[ConnectionConfig])
             true
         } else {
             connection_pool_ids_to_drop.insert(id.clone());
+            if existing.db_type == DatabaseType::Nacos {
+                nacos_adapter_ids_to_drop.insert(id.clone());
+            }
             if existing.db_type == DatabaseType::MessageQueue {
                 mq_adapter_ids_to_drop.insert(id.clone());
             }
@@ -459,10 +465,16 @@ async fn sync_connection_configs(state: &AppState, configs: &[ConnectionConfig])
         }
     });
     for config in configs {
+        if config.db_type == DatabaseType::Nacos {
+            nacos_adapter_ids_to_drop.insert(config.id.clone());
+        }
         if config.db_type == DatabaseType::MessageQueue {
             mq_adapter_ids_to_drop.insert(config.id.clone());
         }
         if let Some(previous) = runtime_configs.insert(config.id.clone(), config.clone()) {
+            if previous.db_type == DatabaseType::Nacos {
+                nacos_adapter_ids_to_drop.insert(config.id.clone());
+            }
             if previous.db_type == DatabaseType::MessageQueue {
                 mq_adapter_ids_to_drop.insert(config.id.clone());
             }
@@ -472,6 +484,7 @@ async fn sync_connection_configs(state: &AppState, configs: &[ConnectionConfig])
         }
     }
     ConnectionConfigSync {
+        nacos_adapter_ids_to_drop: nacos_adapter_ids_to_drop.into_iter().collect(),
         mq_adapter_ids_to_drop: mq_adapter_ids_to_drop.into_iter().collect(),
         connection_pool_ids_to_drop: connection_pool_ids_to_drop.into_iter().collect(),
     }
@@ -481,6 +494,12 @@ fn is_transient_runtime_config_id(id: &str) -> bool {
     id.starts_with("__test_") || id.starts_with("__visible_draft_")
 }
 
+async fn drop_nacos_adapters_for_connection_ids(state: &AppState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.nacos_registry.drop_connection(connection_id).await;
+    }
+}
+
 #[cfg(feature = "mq-admin")]
 async fn drop_mq_adapters_for_connection_ids(state: &AppState, connection_ids: &[String]) {
     for connection_id in connection_ids {
@@ -507,6 +526,7 @@ async fn load_connection_configs(state: &AppState) -> Result<Vec<ConnectionConfi
         state.storage.load_connections().await?.into_iter().map(|config| config.canonicalized()).collect();
     let sync = sync_connection_configs(state, &configs).await;
     remove_connection_pools_for_connection_ids(state, &sync.connection_pool_ids_to_drop).await;
+    drop_nacos_adapters_for_connection_ids(state, &sync.nacos_adapter_ids_to_drop).await;
     drop_mq_adapters_for_connection_ids(state, &sync.mq_adapter_ids_to_drop).await;
     Ok(configs)
 }
@@ -762,6 +782,12 @@ pub async fn test_connection(state: State<'_, Arc<AppState>>, config: Connection
                     .await
                     .map(|_| "Connection successful".to_string())
             }
+            DatabaseType::Nacos => {
+                let admin_config = state.nacos_admin_config_for_connection(connection_id, &config).await?;
+                let adapter = state.nacos_registry.build_transient_config(admin_config).await?;
+                adapter.test_connection().await?;
+                Ok("Connection successful".to_string())
+            }
             #[cfg(feature = "mq-admin")]
             DatabaseType::MessageQueue => {
                 let mqc = state.mq_admin_config_for_connection(connection_id, &config).await?;
@@ -1028,6 +1054,12 @@ pub async fn connect_db(state: State<'_, Arc<AppState>>, config: ConnectionConfi
             db::influxdb_driver::test_connection(&client, connect_timeout).await?;
             PoolKind::InfluxDb(client)
         }
+        DatabaseType::Nacos => {
+            let admin_config = state.nacos_admin_config_for_connection(&id, &config).await?;
+            let adapter = state.nacos_registry.build_transient_config(admin_config).await?;
+            adapter.test_connection().await?;
+            PoolKind::Nacos
+        }
         #[cfg(feature = "mq-admin")]
         DatabaseType::MessageQueue => {
             let mqc = state.mq_admin_config_for_connection(&id, &config).await?;
@@ -1080,6 +1112,7 @@ pub async fn connection_final_proxy_port(
 #[tauri::command]
 pub async fn disconnect_db(state: State<'_, Arc<AppState>>, connection_id: String) -> Result<(), String> {
     state.remove_connection_pools(&connection_id).await;
+    drop_nacos_adapters_for_connection_ids(state.inner(), std::slice::from_ref(&connection_id)).await;
     drop_mq_adapters_for_connection_ids(state.inner(), std::slice::from_ref(&connection_id)).await;
     state.reset_connection_transport(&connection_id).await;
     if connection_id.starts_with("__visible_draft_") {

src-tauri/src/commands/mod.rs

@@ -20,6 +20,7 @@ pub mod mcp_bridge;
 pub mod mongo_cmd;
 #[cfg(feature = "mq-admin")]
 pub mod mq_cmd;
+pub mod nacos_cmd;
 pub mod plugins;
 pub mod query;
 pub mod query_cancel;

src-tauri/src/commands/nacos_cmd.rs

@@ -0,0 +1,138 @@
+use std::sync::Arc;
+
+use tauri::State;
+
+use crate::commands::connection::AppState;
+
+#[tauri::command]
+pub async fn nacos_test_connection(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<dbx_core::nacos::NacosConnectionInfo, String> {
+    dbx_core::nacos::service::nacos_test_connection_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_namespaces(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<dbx_core::nacos::NacosNamespaceInfo>, String> {
+    dbx_core::nacos::service::nacos_list_namespaces_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn nacos_create_namespace(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosNamespaceCreate,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_create_namespace_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_update_namespace(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosNamespaceUpdate,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_update_namespace_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_configs(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosConfigQuery,
+) -> Result<dbx_core::nacos::NacosConfigList, String> {
+    dbx_core::nacos::service::nacos_list_configs_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_get_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigKey,
+) -> Result<dbx_core::nacos::NacosConfigItem, String> {
+    dbx_core::nacos::service::nacos_get_config_core(&state, &connection_id, key).await
+}
+
+#[tauri::command]
+pub async fn nacos_publish_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosConfigUpsert,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_publish_config_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_delete_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigKey,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_delete_config_core(&state, &connection_id, key).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_config_history(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosConfigHistoryQuery,
+) -> Result<dbx_core::nacos::NacosConfigHistoryList, String> {
+    dbx_core::nacos::service::nacos_list_config_history_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_get_config_history(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigHistoryKey,
+) -> Result<dbx_core::nacos::NacosConfigItem, String> {
+    dbx_core::nacos::service::nacos_get_config_history_core(&state, &connection_id, key).await
+}
+
+#[tauri::command]
+pub async fn nacos_rollback_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosConfigRollbackRequest,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_rollback_config_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_services(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosServiceQuery,
+) -> Result<dbx_core::nacos::NacosServiceList, String> {
+    dbx_core::nacos::service::nacos_list_services_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_instances(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosInstanceQuery,
+) -> Result<Vec<dbx_core::nacos::NacosInstanceInfo>, String> {
+    dbx_core::nacos::service::nacos_list_instances_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_update_instance(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosInstanceUpdate,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_update_instance_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_raw_request(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosRawRequest,
+) -> Result<dbx_core::nacos::NacosRawResponse, String> {
+    dbx_core::nacos::service::nacos_raw_request_core(&state, &connection_id, req).await
+}