fix(datagrid): open a foreign key reference in its own tab instead of taking over the one it was followed from

Claude-Session: https://claude.ai/code/session_01R4D7UrumqUb2UBpPSbQHMb

Author: datlechin

CHANGELOG.md

@@ -55,6 +55,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - TablePlus import saving a password for a connection TablePlus was set never to store one for.
 - TablePlus import reading the CA certificate and client key paths the wrong way round.
 - MySQL and MariaDB reads of an object in another database answering about the current database's same-named one, including the foreign key picker's column list. (#2769)
+- Foreign key arrow replacing the tab you were reading. (#1421)
+- Applied filter left in the panel after cancelling the unsaved-changes alert on a foreign key jump.
 - Select All painting the whole column header row as selected, and leaving a cell cursor on the first cell.
 - Column header shown as selected after a cell drag reached the first and last row of the page.
 - No outline around a swept cell block whose rows reached both ends of the page.

TablePro/Core/Coordinators/FilterCoordinator.swift

@@ -26,35 +26,63 @@ final class FilterCoordinator {
         let capturedLogicMode = logicMode
         parent.confirmDiscardChangesIfNeeded(action: .filter) { [weak self] confirmed in
             guard let self, confirmed else { return }
-            guard capturedTabIndex < parent.tabManager.tabs.count else { return }
+            commitFilters(
+                capturedFilters,
+                logicMode: capturedLogicMode,
+                tabIndex: capturedTabIndex,
+                tableName: capturedTableName
+            )
+        }
+    }
 
-            if let capturedLogicMode {
-                parent.tabManager.mutate(at: capturedTabIndex) {
-                    $0.filterState.filterLogicMode = capturedLogicMode
-                    $0.filterState.isVisible = true
-                }
+    /// Writes the one predicate a reference jump carries and re-queries for it.
+    ///
+    /// The caller has already taken the discard guard, because it also records the view the tab is
+    /// leaving and both have to land on the same side of a refusal.
+    func commitReferenceFilter(_ filter: TableFilter) {
+        guard let (tab, tabIndex) = parent.tabManager.selectedTabAndIndex,
+              let tableName = tab.tableContext.tableName else { return }
+        setFKFilter(filter)
+        commitFilters([filter], logicMode: nil, tabIndex: tabIndex, tableName: tableName)
+    }
+
+    private func commitFilters(
+        _ filters: [TableFilter],
+        logicMode: FilterLogicMode?,
+        tabIndex: Int,
+        tableName: String
+    ) {
+        guard tabIndex < parent.tabManager.tabs.count else { return }
+
+        if let logicMode {
+            parent.tabManager.mutate(at: tabIndex) {
+                $0.filterState.filterLogicMode = logicMode
+                $0.filterState.isVisible = true
             }
-            parent.tabManager.mutate(at: capturedTabIndex) { $0.pagination.reset() }
+        }
+        parent.tabManager.mutate(at: tabIndex) { $0.pagination.reset() }
 
-            let tab = parent.tabManager.tabs[capturedTabIndex]
-            let queryColumns = parent.queryColumns(for: tab)
-            let newQuery = parent.queryBuilder.buildFilteredQuery(
-                tableName: capturedTableName,
-                schemaName: tab.tableContext.schemaName,
-                filters: capturedFilters,
-                logicMode: tab.filterState.filterLogicMode,
-                sortState: tab.sortState,
-                columns: queryColumns.columns,
-                columnTypes: queryColumns.columnTypes,
-                selectColumns: parent.selectColumns(for: tab),
-                limit: tab.pagination.pageSize,
-                offset: tab.pagination.currentOffset
-            )
+        let tab = parent.tabManager.tabs[tabIndex]
+        let queryColumns = parent.queryColumns(for: tab)
+        let newQuery = parent.queryBuilder.buildFilteredQuery(
+            tableName: tableName,
+            schemaName: tab.tableContext.schemaName,
+            filters: filters,
+            logicMode: tab.filterState.filterLogicMode,
+            sortState: tab.sortState,
+            columns: queryColumns.columns,
+            columnTypes: queryColumns.columnTypes,
+            selectColumns: parent.selectColumns(for: tab),
+            limit: tab.pagination.pageSize,
+            offset: tab.pagination.currentOffset
+        )
 
-            parent.tabManager.mutate(at: capturedTabIndex) { $0.content.query = newQuery }
-            saveLastFilters(for: capturedTableName)
-            parent.runQuery()
+        parent.tabManager.mutate(at: tabIndex) {
+            $0.content.query = newQuery
+            $0.filterState.executedFilters = filters
         }
+        saveLastFilters(for: tableName)
+        parent.runQuery()
     }
 
     func clearFiltersAndReload() {
@@ -81,7 +109,10 @@ final class FilterCoordinator {
                 offset: tab.pagination.currentOffset
             )
 
-            parent.tabManager.mutate(at: capturedTabIndex) { $0.content.query = newQuery }
+            parent.tabManager.mutate(at: capturedTabIndex) {
+                $0.content.query = newQuery
+                $0.filterState.executedFilters = []
+            }
             clearLastFilters(for: capturedTableName)
             parent.runQuery()
         }
@@ -216,7 +247,11 @@ final class FilterCoordinator {
             )
         }
 
-        parent.tabManager.mutate(at: tabIndex) { $0.content.query = newQuery }
+        let executed = hasFilters ? tab.filterState.appliedFilters : []
+        parent.tabManager.mutate(at: tabIndex) {
+            $0.content.query = newQuery
+            $0.filterState.executedFilters = executed
+        }
     }
 
     // MARK: - Filter State

TablePro/Models/Database/TableFilter.swift

@@ -261,6 +261,15 @@ struct TabFilterState: Equatable, Hashable, Codable {
     var keyPattern: String
     var keyTypeScope: String?
 
+    /// The filters the rows on screen were actually fetched with.
+    ///
+    /// `filters` is the panel's editable draft, and `appliedFilters` resolves from it, so both
+    /// describe a query that has not run the moment a reader types into a filter row without
+    /// pressing Apply. Anything asking what a tab is *showing*, rather than what its panel says,
+    /// has to read this. It is written wherever a query is built from the filters and is
+    /// deliberately not persisted: a restored tab rebuilds its query on first load, which fills it.
+    var executedFilters: [TableFilter] = []
+
     init(isVisible: Bool = false) {
         self.filters = []
         self.commit = nil

TablePro/Models/Query/ReferenceNavigationPlan.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+/// What the reader asked for when they followed a foreign key.
+///
+/// A Bool cannot say this. The decision has three destinations, not two, and `false` meaning
+/// "take over the tab I am looking at" read backwards at every call site.
+internal enum ReferenceOpenIntent: Equatable, Sendable {
+    /// The ordinary gesture: a click on the cell's arrow, the row inspector's link, the preview
+    /// popover's button, the menu's plain item.
+    case follow
+    /// Command-click, and the menu item that spells it out. Always its own tab, even when one is
+    /// already open on the same reference.
+    case newTab
+}
+
+/// The one thing a reference jump does with the window's tabs.
+///
+/// No outcome re-points the selected tab at a different table. A reference can only be followed
+/// from a grid, so the tab it is followed from is always one the reader is reading, and retargeting
+/// it left them nowhere to go back to, which is the whole defect. Re-filtering a tab that is
+/// already on the referenced table is not that: it stays in the table they are in, and Back undoes
+/// it.
+internal enum ReferenceNavigationPlan: Equatable, Sendable {
+    /// The selected tab is already on the referenced table, so only its filter changes.
+    case refilterSelectedTab
+    /// Another tab is already showing exactly this reference; bring it forward rather than
+    /// building a second one beside it.
+    case revealExistingTab
+    /// A tab of its own, leaving whatever the reader was looking at where it was.
+    case openNewTab
+}
+
+/// What the window looks like from the jump's point of view.
+internal struct ReferenceNavigationContext: Equatable, Sendable {
+    let intent: ReferenceOpenIntent
+    /// The selected tab is browsing the referenced table already, whatever it is filtered to.
+    let selectedTabShowsTarget: Bool
+    /// Re-filtering that tab in place is safe. Staged structure edits say it is not: the discard
+    /// alert clears cell changes and nothing else, so re-querying under them would promise
+    /// something this path cannot keep.
+    let selectedTabAcceptsRefilter: Bool
+    /// Some tab, in this window or a sibling on the same connection, is already showing exactly
+    /// this reference.
+    let anotherTabShowsReference: Bool
+}
+
+/// Resolves a reference jump to exactly one outcome.
+///
+/// Pure, so the choice can be tested without a window, a coordinator or a tab manager. It used to
+/// be an open-coded chain of guards inside `navigateToFKReference`, which is how it came to take
+/// over a tab that every other way of opening a table would have left alone.
+internal enum ReferenceNavigationPlanner {
+    static func plan(for context: ReferenceNavigationContext) -> ReferenceNavigationPlan {
+        guard context.intent == .follow else { return .openNewTab }
+
+        if context.selectedTabShowsTarget, context.selectedTabAcceptsRefilter {
+            return .refilterSelectedTab
+        }
+        /// Landing on the tab that already answers the question beats building a second one beside
+        /// it, which is also the order `openTableTab` takes with `activateIfAlreadyOpen`.
+        if context.anotherTabShowsReference { return .revealExistingTab }
+        return .openNewTab
+    }
+}

TablePro/Views/Main/Child/DataTabGridDelegate.swift

@@ -92,8 +92,8 @@ final class DataTabGridDelegate: DataGridViewDelegate {
         coordinator?.canClearActiveQueryResults ?? false
     }
 
-    func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, openInNewTab: Bool) {
-        coordinator?.navigateToFKReference(value: value, fkInfo: fkInfo, openInNewTab: openInNewTab)
+    func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, intent: ReferenceOpenIntent) {
+        coordinator?.navigateToFKReference(value: value, fkInfo: fkInfo, intent: intent)
     }
 
     /// The panel reads the selection, not a row this is told about.