fix: resolve 26 anti-patterns across window lifecycle, memory, connections, and SwiftUI (#441)

* fix: MongoDB Atlas auth failure due to wrong authSource default (#438)

* fix: resolve 26 anti-patterns across window lifecycle, memory, connections, and SwiftUI

P0 (Critical):
- Skip selected tab during memory eviction to prevent visible refresh on window re-focus
- Wrap reconnectDriver in trackOperation to prevent health monitor race condition

P1 (High):
- Cancel redisDatabaseSwitchTask in coordinator teardown
- Add deinit to AIChatViewModel to cancel streaming task
- Replace 5x fire-and-forget SSH tunnel closes with error logging
- Log schema/database switch errors instead of silently discarding
- Re-fetch session for driver disconnect to avoid stale reference
- Add WindowAccessor NSViewRepresentable for reliable window capture
- Use viewWindow instead of NSApp.keyWindow in command actions

P2 (Medium):
- Fix weak self in LicenseManager/AnalyticsService periodic task loops
- Remove imprecise global changeManager check from eviction scheduling
- Add query staleness detection so stuck queries don't mask dead connections
- Log warning for synchronous plugin loading fallback
- Add deinit to AppSettingsManager for observer cleanup
- Split clearChanges/clearChangesAndUndoHistory for undo preservation
- Make TabDiskActor.save() throw so callers can handle disk errors
- Remove fragile subtitle-based window matching fallback
- Use viewDidMoveToWindow for synchronous window capture

P3 (Low):
- Remove stale isKeyWindow snapshot from configureWindow
- Centralize window identifier constants with exact matching
- Remove unnecessary DispatchQueue.main.async in AppDelegate handlers
- Add warning log for WindowLifecycleMonitor re-registration
- Unify exponential backoff via shared ExponentialBackoff utility
- Return startup command failures from executeStartupCommands
- Replace recursive asyncAfter with cancellable Task loop

* fix: address review feedback on anti-patterns PR

- WindowAccessor: deduplicate viewDidMoveToWindow calls, update closure in updateNSView
- AIChatViewModel: add comment explaining nonisolated(unsafe) requirement
- CHANGELOG: add user-visible behavioral changes under [Unreleased]

* chore: remove anti-patterns tracker doc

* fix: guard clearChangesAndUndoHistory with tab ID check

Prevent clearing another tab's undo state when a background query or
multi-statement execution completes after the user has switched tabs.

Author: datlechin

CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- MongoDB Atlas connections failing to authenticate (#438)
+- MongoDB TLS certificate verification skipped for SRV connections
+- Active tab data no longer refreshes when switching back to the app window
+- Undo history preserved when switching between database tables
+- Health monitor now detects stuck queries beyond the configured timeout
+- SSH tunnel closure errors now logged instead of silently discarded
+- Schema/database restore errors during reconnect now logged
+
 ## [0.23.1] - 2026-03-24
 
 ### Added

Plugins/MongoDBDriverPlugin/MongoDBConnection.swift

@@ -190,6 +190,8 @@ final class MongoDBConnection: @unchecked Sendable {
         let effectiveAuthSource: String
         if let source = authSource, !source.isEmpty {
             effectiveAuthSource = source
+        } else if useSrv {
+            effectiveAuthSource = "admin"
         } else if !database.isEmpty {
             effectiveAuthSource = database
         } else {
@@ -206,8 +208,7 @@ final class MongoDBConnection: @unchecked Sendable {
         let sslEnabled = ["Preferred", "Required", "Verify CA", "Verify Identity"].contains(sslMode)
         if sslEnabled {
             params.append("tls=true")
-            let verifiesCert = sslMode == "Verify CA" || sslMode == "Verify Identity"
-            if !verifiesCert {
+            if sslMode == "Preferred" {
                 params.append("tlsAllowInvalidCertificates=true")
             }
             if !sslCACertPath.isEmpty {

TablePro/AppDelegate+WindowConfig.swift

@@ -100,18 +100,22 @@ extension AppDelegate {
 
     // MARK: - Window Identification
 
+    private enum WindowId {
+        static let main = "main"
+        static let welcome = "welcome"
+        static let connectionForm = "connection-form"
+    }
+
     func isMainWindow(_ window: NSWindow) -> Bool {
-        guard let identifier = window.identifier?.rawValue else { return false }
-        return identifier.contains("main")
+        window.identifier?.rawValue == WindowId.main
     }
 
     func isWelcomeWindow(_ window: NSWindow) -> Bool {
-        window.identifier?.rawValue == "welcome" ||
-            window.title.lowercased().contains("welcome")
+        window.identifier?.rawValue == WindowId.welcome
     }
 
     private func isConnectionFormWindow(_ window: NSWindow) -> Bool {
-        window.identifier?.rawValue.contains("connection-form") == true
+        window.identifier?.rawValue == WindowId.connectionForm
     }
 
     // MARK: - Welcome Window
@@ -259,10 +263,7 @@ extension AppDelegate {
 
             if remainingMainWindows == 0 {
                 NotificationCenter.default.post(name: .mainWindowWillClose, object: nil)
-
-                DispatchQueue.main.async {
-                    self.openWelcomeWindow()
-                }
+                openWelcomeWindow()
             }
         }
     }
@@ -273,13 +274,9 @@ extension AppDelegate {
 
         if isWelcomeWindow(window),
            window.occlusionState.contains(.visible),
-           NSApp.windows.contains(where: { isMainWindow($0) && $0.isVisible }) {
-            DispatchQueue.main.async { [weak self] in
-                guard let self else { return }
-                if self.isWelcomeWindow(window), window.isVisible {
-                    window.close()
-                }
-            }
+           NSApp.windows.contains(where: { isMainWindow($0) && $0.isVisible }),
+           window.isVisible {
+            window.close()
         }
     }
 

TablePro/Core/ChangeTracking/DataChangeManager.swift

@@ -125,7 +125,8 @@ final class DataChangeManager {
 
     // MARK: - Configuration
 
-    /// Clear all changes (called after successful save)
+    /// Clear all tracked changes, preserving undo/redo history.
+    /// Use when changes are invalidated but undo context may still be relevant.
     func clearChanges() {
         changes.removeAll()
         changeIndex.removeAll()
@@ -134,11 +135,18 @@ final class DataChangeManager {
         modifiedCells.removeAll()
         insertedRowData.removeAll()
         changedRowIndices.removeAll()
-        undoManager.clearAll()
         hasChanges = false
         reloadVersion += 1
     }
 
+    /// Clear all tracked changes AND undo/redo history.
+    /// Use after successful save, explicit discard, or new query execution
+    /// where undo context is no longer meaningful.
+    func clearChangesAndUndoHistory() {
+        clearChanges()
+        undoManager.clearAll()
+    }
+
     /// Atomically configure the manager for a new table
     func configureForTable(
         tableName: String,

TablePro/Core/Database/ConnectionHealthMonitor.swift

@@ -35,7 +35,6 @@ actor ConnectionHealthMonitor {
     // MARK: - Configuration
 
     private static let pingInterval: TimeInterval = 30.0
-    private static let initialBackoffDelays: [TimeInterval] = [2.0, 4.0, 8.0]
     private static let maxBackoffDelay: TimeInterval = 120.0
 
     // MARK: - Dependencies
@@ -227,15 +226,7 @@ actor ConnectionHealthMonitor {
     /// Uses the initial delay table for the first few attempts, then doubles
     /// the previous delay for subsequent attempts, capped at `maxBackoffDelay`.
     private func backoffDelay(for attempt: Int) -> TimeInterval {
-        let delays = Self.initialBackoffDelays
-        if attempt <= delays.count {
-            return delays[attempt - 1]
-        }
-        // Exponential: last seed delay * 2^(attempt - seedCount)
-        let lastSeed = delays[delays.count - 1]
-        let exponent = attempt - delays.count
-        let computed = lastSeed * pow(2.0, Double(exponent))
-        return min(computed, Self.maxBackoffDelay)
+        ExponentialBackoff.delay(for: attempt, maxDelay: Self.maxBackoffDelay)
     }
 
     // MARK: - State Transitions

TablePro/Core/Database/DatabaseDriver.swift

@@ -315,12 +315,15 @@ extension DatabaseDriver {
 /// Factory for creating database drivers via plugin lookup
 @MainActor
 enum DatabaseDriverFactory {
+    private static let logger = Logger(subsystem: "com.TablePro", category: "DatabaseDriverFactory")
+
     static func createDriver(for connection: DatabaseConnection) throws -> DatabaseDriver {
         let pluginId = connection.type.pluginTypeId
         // If the plugin isn't registered yet and background loading hasn't finished,
         // fall back to synchronous loading for this critical code path.
         if PluginManager.shared.driverPlugins[pluginId] == nil,
            !PluginManager.shared.hasFinishedInitialLoad {
+            logger.warning("Plugin '\(pluginId)' not loaded yet — performing synchronous load")
             PluginManager.shared.loadPendingPlugins()
         }
         guard let plugin = PluginManager.shared.driverPlugins[pluginId] else {

TablePro/Core/Database/DatabaseManager.swift

@@ -49,6 +49,8 @@ final class DatabaseManager {
     /// The health monitor skips pings while a query is running to avoid
     /// racing on non-thread-safe driver connections.
     @ObservationIgnored private var queriesInFlight: [UUID: Int] = [:]
+    /// Tracks when the first query started for each session (used for staleness detection).
+    @ObservationIgnored private var queryStartTimes: [UUID: Date] = [:]
 
     /// Current session (computed from currentSessionId)
     var currentSession: ConnectionSession? {
@@ -130,7 +132,11 @@ final class DatabaseManager {
             // Close tunnel if SSH was established
             if connection.sshConfig.enabled {
                 Task {
-                    try? await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+                    do {
+                        try await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+                    } catch {
+                        Self.logger.warning("SSH tunnel cleanup failed for \(connection.name): \(error.localizedDescription)")
+                    }
                 }
             }
             removeSessionEntry(for: connection.id)
@@ -220,7 +226,11 @@ final class DatabaseManager {
             // Close tunnel if connection failed
             if connection.sshConfig.enabled {
                 Task {
-                    try? await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+                    do {
+                        try await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+                    } catch {
+                        Self.logger.warning("SSH tunnel cleanup failed for \(connection.name): \(error.localizedDescription)")
+                    }
                 }
             }
 
@@ -256,7 +266,11 @@ final class DatabaseManager {
 
         // Close SSH tunnel if exists
         if session.connection.sshConfig.enabled {
-            try? await SSHTunnelManager.shared.closeTunnel(connectionId: session.connection.id)
+            do {
+                try await SSHTunnelManager.shared.closeTunnel(connectionId: session.connection.id)
+            } catch {
+                Self.logger.warning("SSH tunnel cleanup failed for \(session.connection.name): \(error.localizedDescription)")
+            }
         }
 
         // Stop health monitoring
@@ -343,11 +357,15 @@ final class DatabaseManager {
         operation: () async throws -> T
     ) async throws -> T {
         queriesInFlight[sessionId, default: 0] += 1
+        if queriesInFlight[sessionId] == 1 {
+            queryStartTimes[sessionId] = Date()
+        }
         defer {
             if let count = queriesInFlight[sessionId], count > 1 {
                 queriesInFlight[sessionId] = count - 1
             } else {
                 queriesInFlight.removeValue(forKey: sessionId)
+                queryStartTimes.removeValue(forKey: sessionId)
             }
         }
         return try await operation()
@@ -402,13 +420,21 @@ final class DatabaseManager {
             result = try await driver.testConnection()
         } catch {
             if connection.sshConfig.enabled {
-                try? await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+                do {
+                    try await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+                } catch {
+                    Self.logger.warning("SSH tunnel cleanup failed for \(connection.name): \(error.localizedDescription)")
+                }
             }
             throw error
         }
 
         if connection.sshConfig.enabled {
-            try? await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+            do {
+                try await SSHTunnelManager.shared.closeTunnel(connectionId: connection.id)
+            } catch {
+                Self.logger.warning("SSH tunnel cleanup failed for \(connection.name): \(error.localizedDescription)")
+            }
         }
 
         return result
@@ -532,7 +558,16 @@ final class DatabaseManager {
                 guard let self else { return false }
                 // Skip ping while a user query is in-flight to avoid racing
                 // on the same non-thread-safe driver connection.
-                guard await self.queriesInFlight[connectionId] == nil else { return true }
+                // Allow ping if the query appears stuck (exceeds timeout + grace period).
+                if await self.queriesInFlight[connectionId] != nil {
+                    let queryTimeout = await TimeInterval(AppSettingsManager.shared.general.queryTimeoutSeconds)
+                    let maxStale = max(queryTimeout, 300) // At least 5 minutes
+                    if let startTime = await self.queryStartTimes[connectionId],
+                       Date().timeIntervalSince(startTime) < maxStale {
+                        return true // Query still within expected time
+                    }
+                    // Query appears stuck — fall through to ping
+                }
                 guard let mainDriver = await self.activeSessions[connectionId]?.driver else {
                     return false
                 }
@@ -547,12 +582,13 @@ final class DatabaseManager {
                 guard let self else { return false }
                 guard let session = await self.activeSessions[connectionId] else { return false }
                 do {
-                    let driver = try await self.reconnectDriver(for: session)
+                    let driver = try await self.trackOperation(sessionId: connectionId) {
+                        try await self.reconnectDriver(for: session)
+                    }
                     await self.updateSession(connectionId) { session in
                         session.driver = driver
                         session.status = .connected
                     }
-
                     return true
                 } catch {
                     return false
@@ -619,13 +655,21 @@ final class DatabaseManager {
 
         if let savedSchema = session.currentSchema,
            let schemaDriver = driver as? SchemaSwitchable {
-            try? await schemaDriver.switchSchema(to: savedSchema)
+            do {
+                try await schemaDriver.switchSchema(to: savedSchema)
+            } catch {
+                Self.logger.warning("Failed to restore schema '\(savedSchema)' on reconnect: \(error.localizedDescription)")
+            }
         }
 
         // Restore database for MSSQL if session had a non-default database
         if let savedDatabase = session.currentDatabase,
            let adapter = driver as? PluginDriverAdapter {
-            try? await adapter.switchDatabase(to: savedDatabase)
+            do {
+                try await adapter.switchDatabase(to: savedDatabase)
+            } catch {
+                Self.logger.warning("Failed to restore database '\(savedDatabase)' on reconnect: \(error.localizedDescription)")
+            }
         }
 
         return driver
@@ -659,8 +703,8 @@ final class DatabaseManager {
         await stopHealthMonitor(for: sessionId)
 
         do {
-            // Disconnect existing drivers
-            session.driver?.disconnect()
+            // Disconnect existing driver (re-fetch to avoid stale local reference)
+            activeSessions[sessionId]?.driver?.disconnect()
 
             // Recreate SSH tunnel if needed and build effective connection
             let effectiveConnection = try await buildEffectiveConnection(for: session.connection)
@@ -681,13 +725,21 @@ final class DatabaseManager {
 
             if let savedSchema = activeSessions[sessionId]?.currentSchema,
                let schemaDriver = driver as? SchemaSwitchable {
-                try? await schemaDriver.switchSchema(to: savedSchema)
+                do {
+                    try await schemaDriver.switchSchema(to: savedSchema)
+                } catch {
+                    Self.logger.warning("Failed to restore schema '\(savedSchema)' on reconnect: \(error.localizedDescription)")
+                }
             }
 
             // Restore database for MSSQL if session had a non-default database
             if let savedDatabase = activeSessions[sessionId]?.currentDatabase,
                let adapter = driver as? PluginDriverAdapter {
-                try? await adapter.switchDatabase(to: savedDatabase)
+                do {
+                    try await adapter.switchDatabase(to: savedDatabase)
+                } catch {
+                    Self.logger.warning("Failed to restore database '\(savedDatabase)' on reconnect: \(error.localizedDescription)")
+                }
             }
 
             // Update session
@@ -741,8 +793,7 @@ final class DatabaseManager {
 
         let maxRetries = 5
         for retryCount in 0..<maxRetries {
-            // Exponential backoff: 2s, 4s, 8s, 16s, 32s (capped at 60s)
-            let delay = min(60.0, 2.0 * pow(2.0, Double(retryCount)))
+            let delay = ExponentialBackoff.delay(for: retryCount + 1, maxDelay: 60)
             Self.logger.info("SSH reconnect attempt \(retryCount + 1)/\(maxRetries) in \(delay)s for: \(session.connection.name)")
             try? await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
 
@@ -768,18 +819,20 @@ final class DatabaseManager {
 
     nonisolated private static let startupLogger = Logger(subsystem: "com.TablePro", category: "DatabaseManager")
 
+    @discardableResult
     nonisolated private func executeStartupCommands(
         _ commands: String?, on driver: DatabaseDriver, connectionName: String
-    ) async {
+    ) async -> [(statement: String, error: String)] {
         guard let commands, !commands.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
-            return
+            return []
         }
 
         let statements = commands
             .components(separatedBy: CharacterSet(charactersIn: ";\n"))
             .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
             .filter { !$0.isEmpty }
 
+        var failures: [(statement: String, error: String)] = []
         for statement in statements {
             do {
                 _ = try await driver.execute(query: statement)
@@ -790,8 +843,10 @@ final class DatabaseManager {
                 Self.startupLogger.warning(
                     "Startup command failed for '\(connectionName)': \(statement) — \(error.localizedDescription)"
                 )
+                failures.append((statement: statement, error: error.localizedDescription))
             }
         }
+        return failures
     }
 
     // MARK: - Schema Changes