test(datagrid): lock sort cache invalidation on row mutations

Four tests cover the four mutation pathways through the now-merged querySortCache:
- addNewRow invalidates the cache (was view-side sortCache before merge — silently stale)
- duplicateSelectedRow invalidates
- deleteSelectedRows invalidates when physically removing inserted rows
- deleteSelectedRows preserves the cache on soft-delete of existing rows (sortedIDs reference rows by ID, soft-delete only changes appearance, not order)

Documents the soft-delete-preserves invariant that emerged during test writing — guards a future contributor from "helpfully" invalidating on every delete and breaking sort persistence.

Author: datlechin

TableProTests/Views/Main/SortCacheInvalidationTests.swift

@@ -0,0 +1,98 @@
+//
+//  SortCacheInvalidationTests.swift
+//  TableProTests
+//
+//  Locks the contract that row mutations invalidate querySortCache for the
+//  affected tab. Pre-merge, only the coordinator-side cache was invalidated;
+//  the view-side @State sortCache stayed stale, so a sorted small table
+//  returned out-of-date sortedIDs after add / undo / paste / delete. After
+//  the merge there is one cache and these tests guard the invalidation set.
+//
+
+import Foundation
+import Testing
+@testable import TablePro
+
+@Suite("querySortCache invalidation on row mutations")
+@MainActor
+struct SortCacheInvalidationTests {
+    private func makeCoordinator() -> (MainContentCoordinator, QueryTabManager, UUID) {
+        let tabManager = QueryTabManager()
+        let coordinator = MainContentCoordinator(
+            connection: TestFixtures.makeConnection(),
+            tabManager: tabManager,
+            changeManager: DataChangeManager(),
+            filterStateManager: FilterStateManager(),
+            columnVisibilityManager: ColumnVisibilityManager(),
+            toolbarState: ConnectionToolbarState()
+        )
+        tabManager.addTableTab(tableName: "users")
+        let tabIndex = tabManager.selectedTabIndex ?? 0
+        tabManager.tabs[tabIndex].tableContext.isEditable = true
+        let tabId = tabManager.tabs[tabIndex].id
+        return (coordinator, tabManager, tabId)
+    }
+
+    private func seedCache(_ coordinator: MainContentCoordinator, for tabId: UUID) {
+        coordinator.querySortCache[tabId] = QuerySortCacheEntry(
+            sortedIDs: [.existing(0), .existing(1), .existing(2)],
+            columnIndex: 1,
+            direction: .ascending,
+            schemaVersion: 0
+        )
+    }
+
+    private func seedRows(_ coordinator: MainContentCoordinator, for tabId: UUID, count: Int) {
+        let columns = ["id", "name"]
+        let rows = (0..<count).map { i in ["\(i)", "name\(i)"] }
+        let columnTypes: [ColumnType] = Array(repeating: .text(rawType: nil), count: columns.count)
+        let tableRows = TableRows.from(queryRows: rows, columns: columns, columnTypes: columnTypes)
+        coordinator.setActiveTableRows(tableRows, for: tabId)
+    }
+
+    @Test("addNewRow clears querySortCache for the tab")
+    func addNewRowInvalidatesCache() {
+        let (coordinator, _, tabId) = makeCoordinator()
+        seedRows(coordinator, for: tabId, count: 3)
+        seedCache(coordinator, for: tabId)
+
+        coordinator.addNewRow()
+
+        #expect(coordinator.querySortCache[tabId] == nil)
+    }
+
+    @Test("deleteSelectedRows clears querySortCache when physically removing inserted rows")
+    func physicalDeleteInvalidatesCache() {
+        let (coordinator, _, tabId) = makeCoordinator()
+        seedRows(coordinator, for: tabId, count: 3)
+        coordinator.addNewRow()
+        let insertedIndex = coordinator.tableRowsStore.tableRows(for: tabId).count - 1
+        seedCache(coordinator, for: tabId)
+
+        coordinator.deleteSelectedRows(indices: [insertedIndex])
+
+        #expect(coordinator.querySortCache[tabId] == nil)
+    }
+
+    @Test("deleteSelectedRows preserves querySortCache on soft delete of existing rows")
+    func softDeletePreservesCache() {
+        let (coordinator, _, tabId) = makeCoordinator()
+        seedRows(coordinator, for: tabId, count: 5)
+        seedCache(coordinator, for: tabId)
+
+        coordinator.deleteSelectedRows(indices: [0, 1])
+
+        #expect(coordinator.querySortCache[tabId] != nil)
+    }
+
+    @Test("duplicateSelectedRow clears querySortCache for the tab")
+    func duplicateRowInvalidatesCache() {
+        let (coordinator, _, tabId) = makeCoordinator()
+        seedRows(coordinator, for: tabId, count: 3)
+        seedCache(coordinator, for: tabId)
+
+        coordinator.duplicateSelectedRow(index: 0)
+
+        #expect(coordinator.querySortCache[tabId] == nil)
+    }
+}