refactor(datagrid): drop DataGridIdentity + version-counter bridge (#938)

* refactor(datagrid): drop DataGridIdentity early-return + version-counter bridge (Phase D-b)

Completes Phase D. The remaining metadataChanged (FK column reload) and paginationChanged (scroll-to-top) branches in updateNSView were the last consumers of DataGridIdentity. Both convert to explicit dispatch on TableViewCoordinating:

- refreshForeignKeyColumns(): reloads visible FK column cells (lifted verbatim from the metadataChanged branch). Called from MainContentCoordinator+QueryHelpers after the columnEnumValues mutation that bumps metadataVersion. The other metadataVersion bump (in setupResultsForExecutedQuery) is followed immediately by setActiveTableRows, which already dispatches applyFullReplace and renders FK columns fresh — no extra dispatch needed there.

- scrollToTop(): scrolls to row 0 if any rows exist. Trickier than refreshFK because pagination bumps the version BEFORE runQuery is fired; the scroll has to wait until the new data lands. Added pendingScrollToTopAfterReplace flag on MainContentCoordinator. paginateAfterConfirmation sets it; notifyFullReplaceIfActive checks and clears it after applyFullReplace fires.

With both branches gone, DataGridIdentity has no consumers. Drops:
- struct DataGridIdentity (entire type, 25 LOC)
- var lastIdentity on TableViewCoordinator
- The early-return short-circuit in updateNSView
- previousIdentity capture and the metadataChanged / paginationChanged variables
- metadataVersion / paginationVersion / schemaVersion props on DataGridView (no remaining readers)
- The matching call-site args in MainEditorContentView.dataGridView and TableStructureView
- DataGridIdentityTests entirely (-105 LOC test file)

The 'initial pre-warm display cache' check (was `previousIdentity == nil || previousIdentity?.rowCount == 0`) becomes `oldRowCount == 0, rowDisplayCount > 0` — same intent, derived from the existing cachedRowCount instead of the dropped identity.

Without the early-return, every SwiftUI body re-eval runs updateNSView's full body. After previous Phase D + the cachedTableRows / sort-cache / FK-routing PRs, that body is mostly cheap idempotent assignments and Equatable guards. Smoke-tested cell edit + undo, add row + undo, table switch, FK column display, pagination scroll, sort. Net -165 LOC including the deleted test file.

* fix(datagrid): scope pendingScrollToTopAfterReplace per-tabId, add dispatch tests

The original Bool flag could strand if pagination's runQuery failed before setActiveTableRows fired — the flag would stay set, and the next setActiveTableRows from any other code path (undo, FK navigation, multi-statement query) would unexpectedly scroll to top.

Changing to Set<UUID> scopes the intent per-tab. Pagination inserts the tabId; notifyFullReplaceIfActive checks via remove() and only dispatches scrollToTop on a matching hit. A stranded entry stays scoped to that one tab and only fires when that tab next receives a full replace — narrow blast radius.

Adds three regression tests:
- scrollToTopFiresOnPendingFlag: setActiveTableRows on the active tab WITH the flag set dispatches scrollToTop and clears the flag
- scrollToTopFlagIsScopedPerTab: a flag set for tab A doesn't fire when tab B is replaced; tab A's entry stays
- scrollToTopSkippedWhenFlagAbsent: setActiveTableRows without the flag doesn't scroll

Author: datlechin

TablePro/Views/Main/Child/MainEditorContentView.swift

@@ -504,9 +504,6 @@ struct MainEditorContentView: View {
                 }
             },
             changeManager: currentChangeManager,
-            schemaVersion: tab.schemaVersion,
-            metadataVersion: tab.metadataVersion,
-            paginationVersion: tab.paginationVersion,
             isEditable: isEditable,
             configuration: DataGridConfiguration(
                 connectionId: connection.id,

TablePro/Views/Main/Extensions/MainContentCoordinator+Pagination.swift

@@ -97,6 +97,7 @@ extension MainContentCoordinator {
 
             mutate(&self.tabManager.tabs[idx].pagination)
             self.tabManager.tabs[idx].paginationVersion += 1
+            self.pendingScrollToTopAfterReplace.insert(tabId)
             self.reloadCurrentPage()
         }
     }

TablePro/Views/Main/Extensions/MainContentCoordinator+QueryHelpers.swift

@@ -493,6 +493,11 @@ extension MainContentCoordinator {
                             return .columnsReplaced
                         }
                         tabManager.tabs[idx].metadataVersion += 1
+                        if let activeIdx = tabManager.selectedTabIndex,
+                           activeIdx < tabManager.tabs.count,
+                           tabManager.tabs[activeIdx].id == tabId {
+                            dataTabDelegate?.tableViewCoordinator?.refreshForeignKeyColumns()
+                        }
                     }
                 }
             }

TablePro/Views/Main/Extensions/MainContentCoordinator+TableRowsMutation.swift

@@ -45,5 +45,8 @@ extension MainContentCoordinator {
               idx < tabManager.tabs.count,
               tabManager.tabs[idx].id == tabId else { return }
         dataTabDelegate?.tableViewCoordinator?.applyFullReplace()
+        if pendingScrollToTopAfterReplace.remove(tabId) != nil {
+            dataTabDelegate?.tableViewCoordinator?.scrollToTop()
+        }
     }
 }

TablePro/Views/Main/MainContentCoordinator.swift

@@ -147,6 +147,8 @@ final class MainContentCoordinator {
     /// Cache for async-sorted query tab rows (large datasets sorted on background thread)
     @ObservationIgnored var querySortCache: [UUID: QuerySortCacheEntry] = [:]
 
+    @ObservationIgnored var pendingScrollToTopAfterReplace: Set<UUID> = []
+
     // MARK: - Internal State
 
     /// Cached column types per table for selective queries (avoids refetching schema).

TablePro/Views/Results/DataGridCoordinator.swift

@@ -60,7 +60,6 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
 
     @Binding var selectedRowIndices: Set<Int>
 
-    var lastIdentity: DataGridIdentity?
     private(set) var cachedRowCount: Int = 0
     private(set) var cachedColumnCount: Int = 0
     private(set) var enumOrSetColumns: Set<Int> = []
@@ -213,15 +212,13 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         rebuildVisualStateCache()
         updateCache()
         tableView.insertRows(at: indices, withAnimation: .slideDown)
-        lastIdentity = nil
     }
 
     func applyRemovedRows(_ indices: IndexSet) {
         guard let tableView else { return }
         rebuildVisualStateCache()
         updateCache()
         tableView.removeRows(at: indices, withAnimation: .slideUp)
-        lastIdentity = nil
     }
 
     func applyFullReplace() {
@@ -230,7 +227,6 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         rebuildVisualStateCache()
         updateCache()
         tableView.reloadData()
-        lastIdentity = nil
     }
 
     func displayRow(at displayIndex: Int) -> Row? {
@@ -422,6 +418,32 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         tableView.editColumn(displayCol, row: displayRow, with: nil, select: true)
     }
 
+    func refreshForeignKeyColumns() {
+        guard let tableView else { return }
+        let tableRows = tableRowsProvider()
+        let fkColumnIndices = IndexSet(
+            tableView.tableColumns.enumerated().compactMap { displayIndex, tableColumn in
+                guard tableColumn.identifier.rawValue != "__rowNumber__",
+                      let modelIndex = DataGridView.dataColumnIndex(from: tableColumn.identifier),
+                      modelIndex < tableRows.columns.count else { return nil }
+                let columnName = tableRows.columns[modelIndex]
+                return tableRows.columnForeignKeys[columnName] != nil ? displayIndex : nil
+            }
+        )
+        guard !fkColumnIndices.isEmpty else { return }
+        let visibleRange = tableView.rows(in: tableView.visibleRect)
+        guard visibleRange.length > 0 else { return }
+        let visibleRows = IndexSet(
+            integersIn: visibleRange.location..<(visibleRange.location + visibleRange.length)
+        )
+        tableView.reloadData(forRowIndexes: visibleRows, columnIndexes: fkColumnIndices)
+    }
+
+    func scrollToTop() {
+        guard let tableView, tableView.numberOfRows > 0 else { return }
+        tableView.scrollRowToVisible(0)
+    }
+
     func rebuildColumnMetadataCache(from tableRows: TableRows) {
         var enumSet = Set<Int>()
         var fkSet = Set<Int>()

TablePro/Views/Results/DataGridView.swift

@@ -22,40 +22,10 @@ struct RowVisualState {
     static let empty = RowVisualState(isDeleted: false, isInserted: false, modifiedColumns: [])
 }
 
-struct DataGridIdentity: Equatable {
-    let schemaVersion: Int
-    let metadataVersion: Int
-    let paginationVersion: Int
-    let rowCount: Int
-    let columnCount: Int
-    let isEditable: Bool
-    let tabType: TabType?
-    let tableName: String?
-    let primaryKeyColumns: [String]
-    let hiddenColumns: Set<String>
-
-    init(schemaVersion: Int, metadataVersion: Int, paginationVersion: Int,
-         rowCount: Int, columnCount: Int, isEditable: Bool, configuration: DataGridConfiguration) {
-        self.schemaVersion = schemaVersion
-        self.metadataVersion = metadataVersion
-        self.paginationVersion = paginationVersion
-        self.rowCount = rowCount
-        self.columnCount = columnCount
-        self.isEditable = isEditable
-        self.tabType = configuration.tabType
-        self.tableName = configuration.tableName
-        self.primaryKeyColumns = configuration.primaryKeyColumns
-        self.hiddenColumns = configuration.hiddenColumns
-    }
-}
-
 struct DataGridView: NSViewRepresentable {
     var tableRowsProvider: @MainActor () -> TableRows = { TableRows() }
     var tableRowsMutator: @MainActor (@MainActor (inout TableRows) -> Void) -> Void = { _ in }
     var changeManager: AnyChangeManager
-    var schemaVersion: Int = 0
-    var metadataVersion: Int = 0
-    var paginationVersion: Int = 0
     let isEditable: Bool
     var configuration: DataGridConfiguration = .init()
     var sortedIDs: [RowID]?
@@ -228,27 +198,6 @@ struct DataGridView: NSViewRepresentable {
         let rowDisplayCount = sortedIDs?.count ?? latestRows.count
         let columnCount = latestRows.columns.count
 
-        let currentIdentity = DataGridIdentity(
-            schemaVersion: schemaVersion,
-            metadataVersion: metadataVersion,
-            paginationVersion: paginationVersion,
-            rowCount: rowDisplayCount,
-            columnCount: columnCount,
-            isEditable: isEditable,
-            configuration: configuration
-        )
-        if currentIdentity == coordinator.lastIdentity {
-            coordinator.delegate = delegate
-            coordinator.tableRowsProvider = tableRowsProvider
-            coordinator.tableRowsMutator = tableRowsMutator
-            coordinator.sortedIDs = sortedIDs
-            coordinator.syncDisplayFormats(displayFormats)
-            delegate?.dataGridAttach(tableViewCoordinator: coordinator)
-            return
-        }
-        let previousIdentity = coordinator.lastIdentity
-        coordinator.lastIdentity = currentIdentity
-
         let settings = AppSettingsManager.shared.dataGrid
         if tableView.rowHeight != CGFloat(settings.rowHeight.rawValue) {
             tableView.rowHeight = CGFloat(settings.rowHeight.rawValue)
@@ -257,7 +206,6 @@ struct DataGridView: NSViewRepresentable {
             tableView.usesAlternatingRowBackgroundColors = settings.showAlternateRows
         }
 
-        let metadataChanged = previousIdentity.map { $0.metadataVersion != metadataVersion } ?? false
         let oldRowCount = coordinator.cachedRowCount
         let oldColumnCount = coordinator.cachedColumnCount
 
@@ -267,7 +215,7 @@ struct DataGridView: NSViewRepresentable {
         coordinator.updateCache()
         coordinator.rebuildColumnMetadataCache(from: latestRows)
 
-        if previousIdentity == nil || previousIdentity?.rowCount == 0 {
+        if oldRowCount == 0, rowDisplayCount > 0 {
             let rowH = tableView.rowHeight
             if rowH > 0 {
                 let visibleRows = Int(tableView.visibleRect.height / rowH) + 5
@@ -315,15 +263,10 @@ struct DataGridView: NSViewRepresentable {
 
         syncSortDescriptors(tableView: tableView, coordinator: coordinator, columns: latestRows.columns)
 
-        let paginationChanged = previousIdentity.map { $0.paginationVersion != paginationVersion } ?? false
-
         reloadAndSyncSelection(
             tableView: tableView,
             coordinator: coordinator,
-            tableRows: latestRows,
-            needsFullReload: needsFullReload,
-            metadataChanged: metadataChanged,
-            paginationChanged: paginationChanged
+            needsFullReload: needsFullReload
         )
     }
 
@@ -493,36 +436,10 @@ struct DataGridView: NSViewRepresentable {
     private func reloadAndSyncSelection(
         tableView: NSTableView,
         coordinator: TableViewCoordinator,
-        tableRows: TableRows,
-        needsFullReload: Bool,
-        metadataChanged: Bool = false,
-        paginationChanged: Bool = false
+        needsFullReload: Bool
     ) {
         if needsFullReload {
             tableView.reloadData()
-        } else if metadataChanged {
-            let fkColumnIndices = IndexSet(
-                tableView.tableColumns.enumerated().compactMap { displayIndex, tableColumn in
-                    guard tableColumn.identifier.rawValue != "__rowNumber__",
-                          let modelIndex = Self.dataColumnIndex(from: tableColumn.identifier),
-                          modelIndex < tableRows.columns.count else { return nil }
-                    let columnName = tableRows.columns[modelIndex]
-                    return tableRows.columnForeignKeys[columnName] != nil ? displayIndex : nil
-                }
-            )
-            if !fkColumnIndices.isEmpty {
-                let visibleRange = tableView.rows(in: tableView.visibleRect)
-                if visibleRange.length > 0 {
-                    let visibleRows = IndexSet(
-                        integersIn: visibleRange.location..<(visibleRange.location + visibleRange.length)
-                    )
-                    tableView.reloadData(forRowIndexes: visibleRows, columnIndexes: fkColumnIndices)
-                }
-            }
-        }
-
-        if paginationChanged && tableView.numberOfRows > 0 {
-            tableView.scrollRowToVisible(0)
         }
 
         let currentSelection = tableView.selectedRowIndexes

TablePro/Views/Results/TableViewCoordinating.swift

@@ -9,6 +9,8 @@ protocol TableViewCoordinating: AnyObject {
     func invalidateCachesForUndoRedo()
     func commitActiveCellEdit()
     func beginEditing(displayRow: Int, column: Int)
+    func refreshForeignKeyColumns()
+    func scrollToTop()
 }
 
 extension TableViewCoordinator: TableViewCoordinating {}

TablePro/Views/Structure/TableStructureView.swift

@@ -271,7 +271,6 @@ struct TableStructureView: View {
         return DataGridView(
             tableRowsProvider: { tableRows },
             changeManager: wrappedChangeManager,
-            schemaVersion: displayVersion,
             isEditable: canEdit,
             configuration: DataGridConfiguration(
                 dropdownColumns: allDropdownColumns,

TableProTests/Views/Main/Child/DataTabGridDelegateTests.swift

@@ -46,6 +46,12 @@ private final class FakeTableViewCoordinator: TableViewCoordinating {
     func beginEditing(displayRow: Int, column: Int) {
         beginEditingCalls.append((row: displayRow, column: column))
     }
+
+    var refreshFKCount: Int = 0
+    var scrollToTopCount: Int = 0
+
+    func refreshForeignKeyColumns() { refreshFKCount += 1 }
+    func scrollToTop() { scrollToTopCount += 1 }
 }
 
 @Suite("DataTabGridDelegate row-delta forwarding")