fix(mongodb): support legacy driver fallback

crates/dbx-core/src/connection.rs

@@ -8,8 +8,9 @@ use mysql_async::Row as MysqlRow;
 
 use crate::agent_connection::{
     agent_connect_params, h2_file_path_from_jdbc_url, is_h2_file_connection, mongo_legacy_error_with_auth_hint,
-    oracle_alternate_connect_config_labels, oracle_alternate_connect_configs, oracle_auth_fallback_profiles,
-    oracle_error_with_driver_hint, should_retry_oracle_with_10g_driver,
+    mongo_uses_legacy_driver, oracle_alternate_connect_config_labels, oracle_alternate_connect_configs,
+    oracle_auth_fallback_profiles, oracle_error_with_driver_hint, should_retry_mongo_with_legacy_driver,
+    should_retry_oracle_with_10g_driver,
 };
 use crate::agent_manager::{JavaRuntimeMode, DEFAULT_JRE_KEY};
 use crate::database_capabilities;
@@ -437,35 +438,49 @@ impl AppState {
                 return Err("DuckDB support is not compiled in this build. Rebuild with default features.".to_string());
             }
             DatabaseType::MongoDb => {
-                let native_err = match db::mongo_driver::connect(&url, connect_timeout, idle_timeout).await {
-                    Ok(client) => match db::mongo_driver::test_connection(
-                        &client,
-                        connect_timeout,
-                        db_config.effective_database(),
-                    )
-                    .await
-                    {
-                        Ok(()) => {
-                            let mut conns = self.connections.write().await;
-                            // Re-check: another task may have created the pool while we were connecting.
-                            if conns.contains_key(&pool_key) {
-                                return Ok(pool_key);
-                            }
-                            conns.insert(pool_key.clone(), PoolKind::MongoDb(client));
-                            return Ok(pool_key);
-                        }
-                        Err(e) => e,
-                    },
-                    Err(e) => e,
-                };
-                if native_err.contains("wire version") {
-                    log::info!("Native MongoDB driver failed ({native_err}), falling back to agent driver");
+                if mongo_uses_legacy_driver(&db_config) {
+                    log::info!("Using configured MongoDB legacy driver for connection_id={connection_id}");
                     let connect_params = serde_json::json!({ "connection": agent_connect_params(&db_config, &host, port, db_config.effective_database().unwrap_or("")) });
-                    let mut client = self.agent_manager.spawn(&DatabaseType::MongoDb, None).await?;
+                    let mut client = self.agent_manager.spawn(&DatabaseType::MongoDb, Some("mongodb-legacy")).await?;
                     client.connect(connect_params).await.map_err(|err| mongo_legacy_error_with_auth_hint(&err))?;
                     PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client)))
                 } else {
-                    return Err(native_err);
+                    let native_err = match db::mongo_driver::connect(&url, connect_timeout, idle_timeout).await {
+                        Ok(client) => match db::mongo_driver::test_connection(
+                            &client,
+                            connect_timeout,
+                            db_config.effective_database(),
+                        )
+                        .await
+                        {
+                            Ok(()) => {
+                                let mut conns = self.connections.write().await;
+                                // Re-check: another task may have created the pool while we were connecting.
+                                if conns.contains_key(&pool_key) {
+                                    return Ok(pool_key);
+                                }
+                                conns.insert(pool_key.clone(), PoolKind::MongoDb(client));
+                                return Ok(pool_key);
+                            }
+                            Err(e) => e,
+                        },
+                        Err(e) => e,
+                    };
+                    if should_retry_mongo_with_legacy_driver(&native_err) {
+                        log::info!("Native MongoDB driver failed ({native_err}), falling back to agent driver");
+                        let connect_params = serde_json::json!({ "connection": agent_connect_params(&db_config, &host, port, db_config.effective_database().unwrap_or("")) });
+                        let mut client =
+                            self.agent_manager.spawn(&DatabaseType::MongoDb, Some("mongodb-legacy")).await?;
+                        client.connect(connect_params).await.map_err(|err| {
+                            format!(
+                                "{native_err}\n\nFallback with MongoDB (Legacy) driver failed: {}",
+                                mongo_legacy_error_with_auth_hint(&err)
+                            )
+                        })?;
+                        PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client)))
+                    } else {
+                        return Err(native_err);
+                    }
                 }
             }
             DatabaseType::ClickHouse => {
@@ -1297,8 +1312,8 @@ mod tests {
         AppState, PoolKind,
     };
     use crate::agent_connection::{
-        agent_connect_params, mongo_legacy_error_with_auth_hint, oracle_alternate_connect_config,
-        should_retry_oracle_with_10g_driver,
+        agent_connect_params, mongo_legacy_error_with_auth_hint, mongo_uses_legacy_driver,
+        oracle_alternate_connect_config, should_retry_mongo_with_legacy_driver, should_retry_oracle_with_10g_driver,
     };
     use crate::agent_manager::{AgentState, JavaRuntimeConfig, JavaRuntimeMode, DEFAULT_JRE_KEY};
     use crate::db;
@@ -1433,6 +1448,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn mongo_legacy_retry_covers_old_server_handshake_eof() {
+        let err = r#"MongoDB connection failed: Kind: Server selection timeout: No available servers. Topology: { Type: Unknown, Servers: [ { Address: db.example.com:27017, Type: Unknown, Error: Kind: I/O error: unexpected end of file } ] }"#;
+
+        assert!(mongo_uses_legacy_driver(&ConnectionConfig {
+            driver_profile: Some("mongodb-legacy".to_string()),
+            ..mysql_config(None)
+        }));
+        assert!(should_retry_mongo_with_legacy_driver(err));
+        assert!(should_retry_mongo_with_legacy_driver("server reports wire version 5, but this driver requires 8"));
+        assert!(!should_retry_mongo_with_legacy_driver("Authentication failed."));
+    }
+
     #[test]
     fn agent_connect_params_build_oracle_service_connection_string() {
         let mut config = mysql_config(Some("ORCLPDB1"));