feat: add option to group all connection tabs in one window (#546)

datlechin · web-flow · commit e71869baf6b2 · 2026-04-01T14:25:39.000+07:00
* feat: add option to group all connection tabs in one window

* fix: scope auto-reconnect failure cleanup to connection and document runtime toggle
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Option to group all connection tabs in one window instead of separate windows per connection
+
 ## [0.27.1] - 2026-04-01
 
 ### Fixed
diff --git a/TablePro/AppDelegate+ConnectionHandler.swift b/TablePro/AppDelegate+ConnectionHandler.swift
@@ -316,7 +316,7 @@ extension AppDelegate {
 
     private func openNewConnectionWindow(for connection: DatabaseConnection) {
         let hadExistingMain = NSApp.windows.contains { isMainWindow($0) && $0.isVisible }
-        if hadExistingMain {
+        if hadExistingMain && !AppSettingsManager.shared.tabs.groupAllConnectionTabs {
             NSWindow.allowsAutomaticWindowTabbing = false
         }
         let payload = EditorTabPayload(connectionId: connection.id)
diff --git a/TablePro/AppDelegate+FileOpen.swift b/TablePro/AppDelegate+FileOpen.swift
@@ -176,7 +176,7 @@ extension AppDelegate {
         }
 
         let hadExistingMain = NSApp.windows.contains { isMainWindow($0) && $0.isVisible }
-        if hadExistingMain {
+        if hadExistingMain && !AppSettingsManager.shared.tabs.groupAllConnectionTabs {
             NSWindow.allowsAutomaticWindowTabbing = false
         }
 
diff --git a/TablePro/AppDelegate+WindowConfig.swift b/TablePro/AppDelegate+WindowConfig.swift
@@ -80,10 +80,12 @@ extension AppDelegate {
             } catch {
                 windowLogger.error("Dock connection failed for '\(connection.name)': \(error.localizedDescription)")
 
-                for window in NSApp.windows where self.isMainWindow(window) {
+                for window in WindowLifecycleMonitor.shared.windows(for: connection.id) {
                     window.close()
                 }
-                self.openWelcomeWindow()
+                if !NSApp.windows.contains(where: { self.isMainWindow($0) && $0.isVisible }) {
+                    self.openWelcomeWindow()
+                }
             }
         }
     }
@@ -251,18 +253,27 @@ extension AppDelegate {
             // If no code opened this window (pendingId is nil), this is a
             // SwiftUI WindowGroup state restoration — not a window we created.
             // Hide it (orderOut, not close) to break the close→restore loop.
+            // Exception: if the window is already part of a tab group, it was
+            // attached by our addTabbedWindow call — not a restoration orphan.
+            // Ordering it out would crash NSWindowStackController.
             if pendingId == nil && !isAutoReconnecting {
                 configuredWindows.insert(windowId)
+                if let tabbedWindows = window.tabbedWindows, tabbedWindows.count > 1 {
+                    // Already in a tab group — leave it alone
+                    return
+                }
                 window.orderOut(nil)
                 return
             }
 
             let existingIdentifier = NSApp.windows
                 .first { $0 !== window && isMainWindow($0) && $0.isVisible }?
                 .tabbingIdentifier
+            let groupAll = MainActor.assumeIsolated { AppSettingsManager.shared.tabs.groupAllConnectionTabs }
             let resolvedIdentifier = TabbingIdentifierResolver.resolve(
                 pendingConnectionId: pendingId,
-                existingIdentifier: existingIdentifier
+                existingIdentifier: existingIdentifier,
+                groupAllConnections: groupAll
             )
             window.tabbingIdentifier = resolvedIdentifier
             configuredWindows.insert(windowId)
@@ -273,10 +284,25 @@ extension AppDelegate {
 
             // Explicitly attach to existing tab group — automatic tabbing
             // doesn't work when tabbingIdentifier is set after window creation.
-            if let existingWindow = NSApp.windows.first(where: {
-                $0 !== window && isMainWindow($0) && $0.isVisible
-                    && $0.tabbingIdentifier == resolvedIdentifier
-            }) {
+            let matchingWindow: NSWindow?
+            if groupAll {
+                // When grouping all connections, attach to any visible main window
+                // and normalize all existing windows' tabbingIdentifiers so future
+                // windows also match (not just the first one found).
+                let existingMainWindows = NSApp.windows.filter {
+                    $0 !== window && isMainWindow($0) && $0.isVisible
+                }
+                for existing in existingMainWindows {
+                    existing.tabbingIdentifier = resolvedIdentifier
+                }
+                matchingWindow = existingMainWindows.first
+            } else {
+                matchingWindow = NSApp.windows.first {
+                    $0 !== window && isMainWindow($0) && $0.isVisible
+                        && $0.tabbingIdentifier == resolvedIdentifier
+                }
+            }
+            if let existingWindow = matchingWindow {
                 let targetWindow = existingWindow.tabbedWindows?.last ?? existingWindow
                 targetWindow.addTabbedWindow(window, ordered: .above)
                 window.makeKeyAndOrderFront(nil)
@@ -339,18 +365,21 @@ extension AppDelegate {
                     window.close()
                 }
             } catch is CancellationError {
-                for window in NSApp.windows where self.isMainWindow(window) {
+                for window in WindowLifecycleMonitor.shared.windows(for: connection.id) {
                     window.close()
                 }
-                self.openWelcomeWindow()
+                if !NSApp.windows.contains(where: { self.isMainWindow($0) && $0.isVisible }) {
+                    self.openWelcomeWindow()
+                }
             } catch {
                 windowLogger.error("Auto-reconnect failed for '\(connection.name)': \(error.localizedDescription)")
 
-                for window in NSApp.windows where self.isMainWindow(window) {
+                for window in WindowLifecycleMonitor.shared.windows(for: connection.id) {
                     window.close()
                 }
-
-                self.openWelcomeWindow()
+                if !NSApp.windows.contains(where: { self.isMainWindow($0) && $0.isVisible }) {
+                    self.openWelcomeWindow()
+                }
             }
         }
     }
diff --git a/TablePro/Core/Services/Infrastructure/WindowOpener.swift b/TablePro/Core/Services/Infrastructure/WindowOpener.swift
@@ -48,8 +48,16 @@ internal enum TabbingIdentifierResolver {
     /// - Parameters:
     ///   - pendingConnectionId: The connectionId from WindowOpener (if a tab was just opened)
     ///   - existingIdentifier: The tabbingIdentifier from an existing visible main window (if any)
+    ///   - groupAllConnections: When true, all windows share one tab group regardless of connection
     /// - Returns: The tabbingIdentifier to assign to the new window
-    internal static func resolve(pendingConnectionId: UUID?, existingIdentifier: String?) -> String {
+    internal static func resolve(
+        pendingConnectionId: UUID?,
+        existingIdentifier: String?,
+        groupAllConnections: Bool = false
+    ) -> String {
+        if groupAllConnections {
+            return "com.TablePro.main"
+        }
         if let connectionId = pendingConnectionId {
             return "com.TablePro.main.\(connectionId.uuidString)"
         }
diff --git a/TablePro/Models/Settings/AppSettings.swift b/TablePro/Models/Settings/AppSettings.swift
@@ -451,14 +451,17 @@ struct HistorySettings: Codable, Equatable {
 /// Tab behavior settings
 struct TabSettings: Codable, Equatable {
     var enablePreviewTabs: Bool = true
+    var groupAllConnectionTabs: Bool = false
     static let `default` = TabSettings()
 
-    init(enablePreviewTabs: Bool = true) {
+    init(enablePreviewTabs: Bool = true, groupAllConnectionTabs: Bool = false) {
         self.enablePreviewTabs = enablePreviewTabs
+        self.groupAllConnectionTabs = groupAllConnectionTabs
     }
 
     init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         enablePreviewTabs = try container.decodeIfPresent(Bool.self, forKey: .enablePreviewTabs) ?? true
+        groupAllConnectionTabs = try container.decodeIfPresent(Bool.self, forKey: .groupAllConnectionTabs) ?? false
     }
 }
diff --git a/TablePro/Resources/Localizable.xcstrings b/TablePro/Resources/Localizable.xcstrings
@@ -14626,6 +14626,9 @@
           }
         }
       }
+    },
+    "Group all connections in one window" : {
+
     },
     "Group name" : {
       "localizations" : {
@@ -33971,6 +33974,9 @@
           }
         }
       }
+    },
+    "When enabled, tabs from different connections share the same window instead of opening separate windows." : {
+
     },
     "When enabled, this favorite is visible in all connections" : {
       "localizations" : {
diff --git a/TablePro/ViewModels/WelcomeViewModel.swift b/TablePro/ViewModels/WelcomeViewModel.swift
@@ -217,7 +217,7 @@ final class WelcomeViewModel {
                 try await dbManager.connectToSession(connection)
             } catch is CancellationError {
                 // User cancelled password prompt — return to welcome
-                NSApplication.shared.closeWindows(withId: "main")
+                closeConnectionWindows(for: connection.id)
                 self.openWindow?(id: "welcome")
             } catch {
                 if case PluginError.pluginNotInstalled = error {
@@ -226,7 +226,7 @@ final class WelcomeViewModel {
                 } else {
                     Self.logger.error(
                         "Failed to connect: \(error.localizedDescription, privacy: .public)")
-                    handleConnectionFailure(error: error)
+                    handleConnectionFailure(error: error, connectionId: connection.id)
                 }
             }
         }
@@ -242,12 +242,12 @@ final class WelcomeViewModel {
             do {
                 try await dbManager.connectToSession(connection)
             } catch is CancellationError {
-                NSApplication.shared.closeWindows(withId: "main")
+                closeConnectionWindows(for: connection.id)
                 self.openWindow?(id: "welcome")
             } catch {
                 Self.logger.error(
                     "Failed to connect after plugin install: \(error.localizedDescription, privacy: .public)")
-                handleConnectionFailure(error: error)
+                handleConnectionFailure(error: error, connectionId: connection.id)
             }
         }
     }
@@ -511,9 +511,9 @@ final class WelcomeViewModel {
 
     // MARK: - Private Helpers
 
-    private func handleConnectionFailure(error: Error) {
+    private func handleConnectionFailure(error: Error, connectionId: UUID) {
         guard let openWindow else { return }
-        NSApplication.shared.closeWindows(withId: "main")
+        closeConnectionWindows(for: connectionId)
         openWindow(id: "welcome")
 
         AlertHelper.showErrorSheet(
@@ -525,8 +525,15 @@ final class WelcomeViewModel {
 
     private func handleMissingPlugin(connection: DatabaseConnection) {
         guard let openWindow else { return }
-        NSApplication.shared.closeWindows(withId: "main")
+        closeConnectionWindows(for: connection.id)
         openWindow(id: "welcome")
         pluginInstallConnection = connection
     }
+
+    /// Close windows for a specific connection only, preserving other connections' windows.
+    private func closeConnectionWindows(for connectionId: UUID) {
+        for window in WindowLifecycleMonitor.shared.windows(for: connectionId) {
+            window.close()
+        }
+    }
 }
diff --git a/TablePro/Views/Connection/ConnectionFormView.swift b/TablePro/Views/Connection/ConnectionFormView.swift
@@ -966,7 +966,7 @@ struct ConnectionFormView: View {
             handleMissingPlugin(connection: connection)
             return
         }
-        NSApplication.shared.closeWindows(withId: "main")
+        closeConnectionWindows(for: connection.id)
         openWindow(id: "welcome")
         guard !(error is CancellationError) else { return }
         Self.logger.error("Failed to connect: \(error.localizedDescription, privacy: .public)")
@@ -977,11 +977,17 @@ struct ConnectionFormView: View {
     }
 
     private func handleMissingPlugin(connection: DatabaseConnection) {
-        NSApplication.shared.closeWindows(withId: "main")
+        closeConnectionWindows(for: connection.id)
         openWindow(id: "welcome")
         pluginInstallConnection = connection
     }
 
+    private func closeConnectionWindows(for connectionId: UUID) {
+        for window in WindowLifecycleMonitor.shared.windows(for: connectionId) {
+            window.close()
+        }
+    }
+
     private func connectAfterInstall(_ connection: DatabaseConnection) {
         WindowOpener.shared.pendingConnectionId = connection.id
         openWindow(id: "main", value: EditorTabPayload(connectionId: connection.id))
diff --git a/TablePro/Views/Main/Extensions/MainContentCoordinator+MultiStatement.swift b/TablePro/Views/Main/Extensions/MainContentCoordinator+MultiStatement.swift
@@ -202,8 +202,13 @@ extension MainContentCoordinator {
             let safeRows = selectResult.rows.map { row in
                 row.map { $0.map { String($0) } }
             }
-            let tableName = lastSelectSQL.flatMap {
-                extractTableName(from: $0)
+            // For table tabs, preserve existing tableName instead of re-extracting
+            // from SQL — extractTableName can fail on schema-qualified/quoted names
+            let tableName: String?
+            if updatedTab.tabType == .table, let existing = updatedTab.tableName {
+                tableName = existing
+            } else {
+                tableName = lastSelectSQL.flatMap { extractTableName(from: $0) }
             }
 
             updatedTab.resultColumns = safeColumns
@@ -215,7 +220,10 @@ extension MainContentCoordinator {
             updatedTab.resultColumns = []
             updatedTab.columnTypes = []
             updatedTab.resultRows = []
-            updatedTab.tableName = nil
+            // Preserve tableName for table tabs even when no SELECT result
+            if updatedTab.tabType != .table {
+                updatedTab.tableName = nil
+            }
             updatedTab.isEditable = false
         }
 
diff --git a/TablePro/Views/Main/Extensions/MainContentCoordinator+Navigation.swift b/TablePro/Views/Main/Extensions/MainContentCoordinator+Navigation.swift
@@ -62,8 +62,10 @@ extension MainContentCoordinator {
 
         // Check if another native window tab already has this table open — switch to it
         if let keyWindow = NSApp.keyWindow {
+            let ownWindows = Set(WindowLifecycleMonitor.shared.windows(for: connectionId).map { ObjectIdentifier($0) })
             let tabbedWindows = keyWindow.tabbedWindows ?? [keyWindow]
-            for window in tabbedWindows where window.title == tableName {
+            for window in tabbedWindows
+                where window.title == tableName && ownWindows.contains(ObjectIdentifier(window)) {
                 window.makeKeyAndOrderFront(nil)
                 return
             }
@@ -219,8 +221,25 @@ extension MainContentCoordinator {
             }
         }
 
-        // No preview window exists but current tab is already a preview: replace in-place
-        if let selectedTab = tabManager.selectedTab, selectedTab.isPreview {
+        // No preview window exists but current tab can be reused: replace in-place.
+        // This covers: preview tabs, non-preview table tabs with no active work,
+        // and empty/default query tabs (no user-entered content).
+        let isReusableTab: Bool = {
+            guard let tab = tabManager.selectedTab else { return false }
+            if tab.isPreview { return true }
+            // Table tab with no active work
+            if tab.tabType == .table && !changeManager.hasChanges
+                && !filterStateManager.hasAppliedFilters && !tab.sortState.isSorting {
+                return true
+            }
+            // Empty/default query tab (no user content, no results, never executed)
+            if tab.tabType == .query && tab.lastExecutedAt == nil
+                && tab.query.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                return true
+            }
+            return false
+        }()
+        if let selectedTab = tabManager.selectedTab, isReusableTab {
             // Skip if already showing this table
             if selectedTab.tableName == tableName, selectedTab.databaseName == databaseName {
                 return
@@ -346,7 +365,11 @@ extension MainContentCoordinator {
     private func closeSiblingNativeWindows() {
         guard let keyWindow = NSApp.keyWindow else { return }
         let siblings = keyWindow.tabbedWindows ?? []
+        let ownWindows = Set(WindowLifecycleMonitor.shared.windows(for: connectionId).map { ObjectIdentifier($0) })
         for sibling in siblings where sibling !== keyWindow {
+            // Only close windows belonging to this connection to avoid
+            // destroying tabs from other connections when groupAllConnectionTabs is ON
+            guard ownWindows.contains(ObjectIdentifier(sibling)) else { continue }
             sibling.close()
         }
     }
diff --git a/TablePro/Views/Main/MainContentCoordinator.swift b/TablePro/Views/Main/MainContentCoordinator.swift
@@ -845,6 +845,11 @@ final class MainContentCoordinator {
         if usesNoSQLBrowsing {
             tableName = tabManager.selectedTab?.tableName
             isEditable = tableName != nil
+        } else if tab.tabType == .table, let existingName = tab.tableName {
+            // Table tabs already know their table name — don't re-extract from SQL
+            // which can fail for schema-qualified or quoted identifiers
+            tableName = existingName
+            isEditable = true
         } else {
             tableName = extractTableName(from: effectiveSQL)
             isEditable = tableName != nil
diff --git a/TablePro/Views/Main/MainContentView.swift b/TablePro/Views/Main/MainContentView.swift
@@ -623,7 +623,9 @@ struct MainContentView: View {
         } else {
             window.subtitle = connection.name
         }
-        window.tabbingIdentifier = "com.TablePro.main.\(connection.id.uuidString)"
+        window.tabbingIdentifier = AppSettingsManager.shared.tabs.groupAllConnectionTabs
+            ? "com.TablePro.main"
+            : "com.TablePro.main.\(connection.id.uuidString)"
         window.tabbingMode = .preferred
         coordinator.windowId = windowId
 
diff --git a/TablePro/Views/Settings/GeneralSettingsView.swift b/TablePro/Views/Settings/GeneralSettingsView.swift
@@ -82,6 +82,12 @@ struct GeneralSettingsView: View {
                 Text("Single-clicking a table opens a temporary tab that gets replaced on next click.")
                     .font(.caption)
                     .foregroundStyle(.secondary)
+
+                Toggle("Group all connections in one window", isOn: $settingsManager.tabs.groupAllConnectionTabs)
+
+                Text("When enabled, tabs from different connections share the same window instead of opening separate windows.")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
             }
 
             Section {
diff --git a/TablePro/Views/Toolbar/ConnectionSwitcherPopover.swift b/TablePro/Views/Toolbar/ConnectionSwitcherPopover.swift
diff --git a/TableProTests/Core/Services/WindowTabGroupingTests.swift b/TableProTests/Core/Services/WindowTabGroupingTests.swift
diff --git a/docs/customization/settings.mdx b/docs/customization/settings.mdx

Original file line number	Diff line number	Diff line change
`@@ -316,7 +316,7 @@ extension AppDelegate {`
`316`	`316`
`317`	`317`	`private func openNewConnectionWindow(for connection: DatabaseConnection) {`
`318`	`318`	`let hadExistingMain = NSApp.windows.contains { isMainWindow($0) && $0.isVisible }`
`319`		`- if hadExistingMain {`
	`319`	`+ if hadExistingMain && !AppSettingsManager.shared.tabs.groupAllConnectionTabs {`
`320`	`320`	`NSWindow.allowsAutomaticWindowTabbing = false`
`321`	`321`	`}`
`322`	`322`	`let payload = EditorTabPayload(connectionId: connection.id)`
Original file line number	Diff line number	Diff line change
`@@ -176,7 +176,7 @@ extension AppDelegate {`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`let hadExistingMain = NSApp.windows.contains { isMainWindow($0) && $0.isVisible }`
`179`		`- if hadExistingMain {`
	`179`	`+ if hadExistingMain && !AppSettingsManager.shared.tabs.groupAllConnectionTabs {`
`180`	`180`	`NSWindow.allowsAutomaticWindowTabbing = false`
`181`	`181`	`}`
`182`	`182`
Original file line number	Diff line number	Diff line change
`@@ -451,14 +451,17 @@ struct HistorySettings: Codable, Equatable {`
`451`	`451`	`/// Tab behavior settings`
`452`	`452`	`struct TabSettings: Codable, Equatable {`
`453`	`453`	`var enablePreviewTabs: Bool = true`
	`454`	`+ var groupAllConnectionTabs: Bool = false`
`454`	`455`	static let `default` = TabSettings()
`455`	`456`
`456`		`- init(enablePreviewTabs: Bool = true) {`
	`457`	`+ init(enablePreviewTabs: Bool = true, groupAllConnectionTabs: Bool = false) {`
`457`	`458`	`self.enablePreviewTabs = enablePreviewTabs`
	`459`	`+ self.groupAllConnectionTabs = groupAllConnectionTabs`
`458`	`460`	`}`
`459`	`461`
`460`	`462`	`init(from decoder: Decoder) throws {`
`461`	`463`	`let container = try decoder.container(keyedBy: CodingKeys.self)`
`462`	`464`	`enablePreviewTabs = try container.decodeIfPresent(Bool.self, forKey: .enablePreviewTabs) ?? true`
	`465`	`+ groupAllConnectionTabs = try container.decodeIfPresent(Bool.self, forKey: .groupAllConnectionTabs) ?? false`
`463`	`466`	`}`
`464`	`467`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14626,6 +14626,9 @@`
`14626`	`14626`	`}`
`14627`	`14627`	`}`
`14628`	`14628`	`}`
	`14629`	`+ },`
	`14630`	`+ "Group all connections in one window" : {`
	`14631`	`+`
`14629`	`14632`	`},`
`14630`	`14633`	`"Group name" : {`
`14631`	`14634`	`"localizations" : {`
`@@ -33971,6 +33974,9 @@`
`33971`	`33974`	`}`
`33972`	`33975`	`}`
`33973`	`33976`	`}`
	`33977`	`+ },`
	`33978`	`+ "When enabled, tabs from different connections share the same window instead of opening separate windows." : {`
	`33979`	`+`
`33974`	`33980`	`},`
`33975`	`33981`	`"When enabled, this favorite is visible in all connections" : {`
`33976`	`33982`	`"localizations" : {`