From ca60e6e3f9dd0d87c5a1b1ff97b1c4f903616013 Mon Sep 17 00:00:00 2001 From: Nana Kwesi Ofosu-Aikins Date: Tue, 1 Sep 2026 08:05:11 +0000 Subject: [PATCH 1/8] feat(datagrid): show the selected row as JSON, with foreign keys that expand into the rows they reference --- CHANGELOG.md | 4 + .../Services/Query/ForeignKeyRowFetcher.swift | 105 ++++++ TablePro/Models/UI/InspectorContext.swift | 5 +- TablePro/Models/UI/JSON/JSONDisplayRow.swift | 57 ++++ .../JSON/JSONForeignKeyExpansionPolicy.swift | 58 ++++ TablePro/Models/UI/JSON/JSONRowFilter.swift | 98 ++++++ .../Models/UI/JSON/JSONRowFlattener.swift | 158 +++++++++ TablePro/Models/UI/JSON/JSONRowNode.swift | 131 ++++++++ .../Models/UI/JSON/JSONRowNodeBuilder.swift | 149 +++++++++ TablePro/Models/UI/JSON/JSONRowSnapshot.swift | 28 ++ .../Models/UI/JSON/JSONRowTextRenderer.swift | 41 +++ TablePro/Models/UI/JSON/JSONScalarText.swift | 59 ++++ TablePro/Models/UI/RightPanelState.swift | 16 +- TablePro/Models/UI/RightPanelTab.swift | 3 + .../JSONRowInspectorViewModel.swift | 305 ++++++++++++++++++ .../Main/Child/DataTabGridDelegate.swift | 6 + .../MainContentCoordinator+FKNavigation.swift | 17 + .../Extensions/MainContentView+Bindings.swift | 35 ++ .../Extensions/MainContentView+Helpers.swift | 3 +- .../Main/MainContentCommandActions.swift | 8 + .../Views/Main/MainContentCoordinator.swift | 5 + TablePro/Views/Results/DataGridRowView.swift | 14 + .../Views/Results/DataGridViewDelegate.swift | 2 + .../Views/Results/ForeignKeyPreviewView.swift | 39 +-- .../RightSidebar/JSON/JSONNodeRowView.swift | 187 +++++++++++ .../RightSidebar/JSON/JSONRowColors.swift | 42 +++ .../JSON/JSONRowInspectorView.swift | 159 +++++++++ .../RightSidebar/UnifiedRightPanelView.swift | 51 ++- .../JSONForeignKeyExpansionPolicyTests.swift | 59 ++++ .../Models/JSON/JSONRowFilterTests.swift | 141 ++++++++ .../Models/JSON/JSONRowFlattenerTests.swift | 160 +++++++++ .../Models/JSON/JSONRowNodeBuilderTests.swift | 226 +++++++++++++ .../JSON/JSONRowTextRendererTests.swift | 56 ++++ TableProUITests/JSONRowInspectorUITests.swift | 99 ++++++ docs/features/data-grid.mdx | 2 + docs/features/json-viewer.mdx | 14 + 36 files changed, 2502 insertions(+), 40 deletions(-) create mode 100644 TablePro/Core/Services/Query/ForeignKeyRowFetcher.swift create mode 100644 TablePro/Models/UI/JSON/JSONDisplayRow.swift create mode 100644 TablePro/Models/UI/JSON/JSONForeignKeyExpansionPolicy.swift create mode 100644 TablePro/Models/UI/JSON/JSONRowFilter.swift create mode 100644 TablePro/Models/UI/JSON/JSONRowFlattener.swift create mode 100644 TablePro/Models/UI/JSON/JSONRowNode.swift create mode 100644 TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift create mode 100644 TablePro/Models/UI/JSON/JSONRowSnapshot.swift create mode 100644 TablePro/Models/UI/JSON/JSONRowTextRenderer.swift create mode 100644 TablePro/Models/UI/JSON/JSONScalarText.swift create mode 100644 TablePro/ViewModels/JSONRowInspectorViewModel.swift create mode 100644 TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift create mode 100644 TablePro/Views/RightSidebar/JSON/JSONRowColors.swift create mode 100644 TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift create mode 100644 TableProTests/Models/JSON/JSONForeignKeyExpansionPolicyTests.swift create mode 100644 TableProTests/Models/JSON/JSONRowFilterTests.swift create mode 100644 TableProTests/Models/JSON/JSONRowFlattenerTests.swift create mode 100644 TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift create mode 100644 TableProTests/Models/JSON/JSONRowTextRendererTests.swift create mode 100644 TableProUITests/JSONRowInspectorUITests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index 5800bee66c..faed9cea56 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added +- JSON tab in the inspector, showing the selected row as JSON, with Show Row as JSON on a row's right-click menu. +- Foreign key expansion in the JSON tab, fetching the referenced row on click, five levels deep. +- Filter field in the JSON tab, taking text or a regular expression in slashes. +- Always Expand Foreign Keys in the JSON tab, off until turned on. - JavaScript shell for MongoDB queries, with mongosh's `db` API, cursors, variables, functions and `print`. - Per-connection MongoDB shell state, so a variable or function survives from one statement to the next. - Cursor method autocomplete after `find()` and `aggregate()`. diff --git a/TablePro/Core/Services/Query/ForeignKeyRowFetcher.swift b/TablePro/Core/Services/Query/ForeignKeyRowFetcher.swift new file mode 100644 index 0000000000..a0851de082 --- /dev/null +++ b/TablePro/Core/Services/Query/ForeignKeyRowFetcher.swift @@ -0,0 +1,105 @@ +// +// ForeignKeyRowFetcher.swift +// TablePro +// +// The single-row lookup behind Preview Referenced Row and the JSON inspector's +// foreign key expansion. +// + +import Foundation +import os +import TableProPluginKit + +@MainActor +enum ForeignKeyRowFetcher { + struct FetchedRow: Sendable { + let columns: [String] + let columnTypes: [ColumnType] + let values: [PluginCellValue] + let foreignKeys: [String: JSONForeignKeyRef] + } + + enum FetchFailure: Error { + case noConnection + } + + private static let logger = Logger(subsystem: "com.TablePro", category: "ForeignKeyRowFetcher") + + /// The referenced row, or nil when the key matches nothing. Two callers share this so the + /// popover and the inspector cannot end up reading a foreign key two different ways. + /// + /// `includeForeignKeys` costs a metadata read for the referenced table's own constraints, which + /// only the inspector needs: it is what makes a nested key clickable in turn. + static func fetch( + connectionId: UUID, + databaseType: DatabaseType, + reference: JSONForeignKeyRef, + value: String, + includeForeignKeys: Bool = false + ) async throws -> FetchedRow? { + guard let driver = DatabaseManager.shared.driver(for: connectionId) else { + throw FetchFailure.noConnection + } + + let quotedTable: String + if let schema = reference.referencedSchema, !schema.isEmpty { + quotedTable = "\(driver.quoteIdentifier(schema)).\(driver.quoteIdentifier(reference.referencedTable))" + } else { + quotedTable = driver.quoteIdentifier(reference.referencedTable) + } + + let query = ForeignKeyPreviewQuery.singleRow( + quotedTable: quotedTable, + quotedColumn: driver.quoteIdentifier(reference.referencedColumn), + escapedValue: driver.escapeStringLiteral(value), + dialect: PluginManager.shared.sqlDialect(for: databaseType) + ) + + let result = try await driver.execute(query: query) + guard let firstRow = result.rows.first else { return nil } + + let foreignKeys = includeForeignKeys + ? await referencedTableForeignKeys(connectionId: connectionId, reference: reference) + : [:] + + return FetchedRow( + columns: result.columns, + columnTypes: result.columnTypes, + values: firstRow, + foreignKeys: foreignKeys + ) + } + + /// Answers from the schema prefetch when it covers the table, so following a chain of keys in + /// the same schema costs no extra round trips. + private static func referencedTableForeignKeys( + connectionId: UUID, + reference: JSONForeignKeyRef + ) async -> [String: JSONForeignKeyRef] { + guard let scope = DatabaseManager.shared.browseScope(for: connectionId) else { return [:] } + let targetScope = reference.referencedSchema.map { + DatabaseScope(connectionId: connectionId, database: scope.database, schema: $0) + } ?? scope + + if let cached = SchemaForeignKeyStore.shared.foreignKeysByColumn( + for: targetScope, + table: reference.referencedTable + ) { + return cached.mapValues(JSONForeignKeyRef.init) + } + + do { + let table = reference.referencedTable + let fetched = try await DatabaseManager.shared.withMetadataDriver(scope: targetScope) { driver in + try await driver.fetchForeignKeys(table: table) + } + return Dictionary( + fetched.map { ($0.column, JSONForeignKeyRef($0)) }, + uniquingKeysWith: { first, _ in first } + ) + } catch { + logger.error("Nested foreign key metadata fetch failed: \(error.localizedDescription)") + return [:] + } + } +} diff --git a/TablePro/Models/UI/InspectorContext.swift b/TablePro/Models/UI/InspectorContext.swift index 1fa2eea2b4..f47cafaa58 100644 --- a/TablePro/Models/UI/InspectorContext.swift +++ b/TablePro/Models/UI/InspectorContext.swift @@ -17,6 +17,8 @@ struct InspectorContext { let isRowDeleted: Bool let currentQuery: String? let queryResults: String? + /// The same row the details tab shows, carried as raw cell values for the JSON tab. + let jsonRow: JSONRowSnapshot? static let empty = InspectorContext( tableName: nil, @@ -25,6 +27,7 @@ struct InspectorContext { isEditable: false, isRowDeleted: false, currentQuery: nil, - queryResults: nil + queryResults: nil, + jsonRow: nil ) } diff --git a/TablePro/Models/UI/JSON/JSONDisplayRow.swift b/TablePro/Models/UI/JSON/JSONDisplayRow.swift new file mode 100644 index 0000000000..bf2ed35a48 --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONDisplayRow.swift @@ -0,0 +1,57 @@ +// +// JSONDisplayRow.swift +// TablePro +// +// One printed line of the JSON inspector. +// + +import Foundation + +enum JSONForeignKeyFailure: Equatable, Sendable { + case notFound + case cycle + case depthLimit + case failed(String) +} + +struct JSONForeignKeyStates: Sendable { + var fetched: [JSONNodePath: JSONRowNode] = [:] + var loading: Set = [] + var failures: [JSONNodePath: JSONForeignKeyFailure] = [:] +} + +struct JSONDisplayRow: Identifiable, Equatable, Sendable { + enum Token: Equatable, Sendable { + case scalar(JSONScalar) + case openObject + case closeObject + case openArray + case closeArray + case collapsedObject(count: Int) + case collapsedArray(count: Int) + } + + enum Status: Equatable, Sendable { + case none + case loading + case failure(JSONForeignKeyFailure) + } + + let id: String + let path: JSONNodePath + let depth: Int + let key: JSONNodeKey + let token: Token + let needsComma: Bool + let foreignKey: JSONForeignKeyRef? + let isExpandable: Bool + let isExpanded: Bool + let status: Status + + var showsKey: Bool { + switch token { + case .closeObject, .closeArray: false + default: key.text != nil + } + } +} diff --git a/TablePro/Models/UI/JSON/JSONForeignKeyExpansionPolicy.swift b/TablePro/Models/UI/JSON/JSONForeignKeyExpansionPolicy.swift new file mode 100644 index 0000000000..96c25eb049 --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONForeignKeyExpansionPolicy.swift @@ -0,0 +1,58 @@ +// +// JSONForeignKeyExpansionPolicy.swift +// TablePro +// +// How far the JSON inspector follows a chain of foreign keys. +// + +import Foundation + +struct JSONForeignKeyVisit: Hashable, Sendable { + let table: String + let schema: String? + let column: String + let value: String? + + init(table: String, schema: String?, column: String, value: String?) { + self.table = table + self.schema = schema + self.column = column + self.value = value + } + + init(ref: JSONForeignKeyRef, value: String?) { + self.init( + table: ref.referencedTable, + schema: ref.referencedSchema, + column: ref.referencedColumn, + value: value + ) + } +} + +enum JSONForeignKeyExpansionDecision: Equatable, Sendable { + case allowed + case cycle + case depthLimit +} + +/// A row that references itself, directly or through another table, is ordinary schema design, so +/// the chain has to be checked rather than trusted: `employee.manager_id → employee` expands +/// forever otherwise. The depth cap covers the chains that do terminate but only after more +/// round trips than a reader wants. +enum JSONForeignKeyExpansionPolicy { + static let maxChainDepth = 5 + + /// How many levels "Always Expand Foreign Keys" fetches without being asked. One: the setting + /// exists to save the first click, not to walk the schema on every selection change. + static let autoExpandDepth = 1 + + static func decide( + chain: [JSONForeignKeyVisit], + next: JSONForeignKeyVisit + ) -> JSONForeignKeyExpansionDecision { + if chain.contains(next) { return .cycle } + guard chain.count < maxChainDepth else { return .depthLimit } + return .allowed + } +} diff --git a/TablePro/Models/UI/JSON/JSONRowFilter.swift b/TablePro/Models/UI/JSON/JSONRowFilter.swift new file mode 100644 index 0000000000..d14d6ca899 --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONRowFilter.swift @@ -0,0 +1,98 @@ +// +// JSONRowFilter.swift +// TablePro +// +// Text and /regex/ filtering over a row's JSON tree. +// + +import Foundation + +struct JSONRowMatcher: Sendable { + private enum Kind { + case substring(String) + case regex(NSRegularExpression) + } + + private let kind: Kind + + /// `/…/` is read as a regular expression, anything else as a case-insensitive substring. A + /// trailing slash is required, so a reader typing a path such as `a/b` still gets a substring. + static func make(query: String) -> JSONRowFilterQuery { + let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { return .empty } + if trimmed.count >= 2, trimmed.hasPrefix("/"), trimmed.hasSuffix("/") { + let pattern = String(trimmed.dropFirst().dropLast()) + guard !pattern.isEmpty else { return .empty } + guard let regex = try? NSRegularExpression(pattern: pattern, options: [.caseInsensitive]) else { + return .invalidRegex + } + return .matcher(JSONRowMatcher(kind: .regex(regex))) + } + return .matcher(JSONRowMatcher(kind: .substring(trimmed))) + } + + func matches(_ text: String) -> Bool { + guard !text.isEmpty else { return false } + switch kind { + case .substring(let needle): + return text.range(of: needle, options: [.caseInsensitive, .diacriticInsensitive]) != nil + case .regex(let regex): + let range = NSRange(location: 0, length: (text as NSString).length) + return regex.firstMatch(in: text, options: [], range: range) != nil + } + } +} + +enum JSONRowFilterQuery: Sendable { + case empty + case invalidRegex + case matcher(JSONRowMatcher) +} + +enum JSONRowFilter { + /// Paths to keep for a filter: every node that matches, plus every ancestor of one, so a match + /// nested three levels down still arrives with the keys that lead to it. + static func visiblePaths( + root: JSONRowNode, + fetchedForeignKeys: [JSONNodePath: JSONRowNode], + matcher: JSONRowMatcher + ) -> Set { + var visible: Set = [] + _ = collect(node: root, fetched: fetchedForeignKeys, matcher: matcher, into: &visible) + return visible + } + + private static func collect( + node: JSONRowNode, + fetched: [JSONNodePath: JSONRowNode], + matcher: JSONRowMatcher, + into visible: inout Set + ) -> Bool { + var subtreeMatched = false + + for child in children(of: node, fetched: fetched) { + if collect(node: child, fetched: fetched, matcher: matcher, into: &visible) { + subtreeMatched = true + } + } + + if subtreeMatched || matches(node, matcher: matcher) { + visible.insert(node.path) + return true + } + return false + } + + static func children(of node: JSONRowNode, fetched: [JSONNodePath: JSONRowNode]) -> [JSONRowNode] { + if node.foreignKey != nil, let expansion = fetched[node.path] { + return expansion.children + } + return node.children + } + + private static func matches(_ node: JSONRowNode, matcher: JSONRowMatcher) -> Bool { + if let key = node.key.text, matcher.matches(key) { return true } + guard let scalar = node.scalar else { return false } + return matcher.matches(scalar.searchableText) + } +} diff --git a/TablePro/Models/UI/JSON/JSONRowFlattener.swift b/TablePro/Models/UI/JSON/JSONRowFlattener.swift new file mode 100644 index 0000000000..c6e9672cfb --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONRowFlattener.swift @@ -0,0 +1,158 @@ +// +// JSONRowFlattener.swift +// TablePro +// +// Turns the node tree, the expanded set and the fetched foreign keys into printed lines. +// + +import Foundation + +enum JSONRowFlattener { + /// `visiblePaths` is the filter's answer. A filter run expands everything it kept, so a match + /// nested inside a collapsed object is on screen without the reader opening its way down. + static func rows( + root: JSONRowNode, + expanded: Set, + states: JSONForeignKeyStates, + visiblePaths: Set? = nil + ) -> [JSONDisplayRow] { + var rows: [JSONDisplayRow] = [] + append( + node: root, + depth: 0, + needsComma: false, + expanded: expanded, + states: states, + visiblePaths: visiblePaths, + into: &rows + ) + return rows + } + + /// Every path a disclosure control can act on, for Expand All. + static func expandablePaths(root: JSONRowNode, states: JSONForeignKeyStates) -> Set { + var paths: Set = [] + collectExpandable(node: root, states: states, into: &paths) + return paths + } + + private static func collectExpandable( + node: JSONRowNode, + states: JSONForeignKeyStates, + into paths: inout Set + ) { + let children = JSONRowFilter.children(of: node, fetched: states.fetched) + guard !children.isEmpty else { return } + paths.insert(node.path) + for child in children { + collectExpandable(node: child, states: states, into: &paths) + } + } + + private static func append( + node: JSONRowNode, + depth: Int, + needsComma: Bool, + expanded: Set, + states: JSONForeignKeyStates, + visiblePaths: Set?, + into rows: inout [JSONDisplayRow] + ) { + if let visiblePaths, !visiblePaths.contains(node.path) { return } + + let children = JSONRowFilter.children(of: node, fetched: states.fetched) + let visibleChildren = children.filter { visiblePaths?.contains($0.path) ?? true } + let isFiltering = visiblePaths != nil + let isExpanded = isFiltering ? !visibleChildren.isEmpty : expanded.contains(node.path) + let status = status(for: node, states: states) + + guard !children.isEmpty, isExpanded else { + rows.append( + JSONDisplayRow( + id: node.path.rawValue, + path: node.path, + depth: depth, + key: node.key, + token: collapsedToken(for: node, childCount: children.count), + needsComma: needsComma, + foreignKey: node.foreignKey, + isExpandable: isExpandable(node, states: states), + isExpanded: false, + status: status + ) + ) + return + } + + let isArray: Bool + if case .array = node.value { isArray = true } else { isArray = false } + + rows.append( + JSONDisplayRow( + id: node.path.rawValue, + path: node.path, + depth: depth, + key: node.key, + token: isArray ? .openArray : .openObject, + needsComma: false, + foreignKey: node.foreignKey, + isExpandable: true, + isExpanded: true, + status: status + ) + ) + + for (index, child) in visibleChildren.enumerated() { + append( + node: child, + depth: depth + 1, + needsComma: index < visibleChildren.count - 1, + expanded: expanded, + states: states, + visiblePaths: visiblePaths, + into: &rows + ) + } + + rows.append( + JSONDisplayRow( + id: "\(node.path.rawValue)\u{001E}close", + path: node.path, + depth: depth, + key: node.key, + token: isArray ? .closeArray : .closeObject, + needsComma: needsComma, + foreignKey: nil, + isExpandable: false, + isExpanded: true, + status: .none + ) + ) + } + + private static func collapsedToken(for node: JSONRowNode, childCount: Int) -> JSONDisplayRow.Token { + if let scalar = node.scalar { return .scalar(scalar) } + switch node.value { + case .array: return .collapsedArray(count: childCount) + case .object: return .collapsedObject(count: childCount) + case .scalar(let scalar), .foreignKey(_, let scalar): return .scalar(scalar) + } + } + + /// A foreign key with a NULL value references nothing, so it offers no control. An empty object + /// or array has nothing to open either. + private static func isExpandable(_ node: JSONRowNode, states: JSONForeignKeyStates) -> Bool { + if let scalar = node.scalar, node.foreignKey != nil { + if case .null = scalar { return false } + return true + } + return !JSONRowFilter.children(of: node, fetched: states.fetched).isEmpty + } + + private static func status(for node: JSONRowNode, states: JSONForeignKeyStates) -> JSONDisplayRow.Status { + guard node.foreignKey != nil else { return .none } + if states.loading.contains(node.path) { return .loading } + if let failure = states.failures[node.path] { return .failure(failure) } + return .none + } +} diff --git a/TablePro/Models/UI/JSON/JSONRowNode.swift b/TablePro/Models/UI/JSON/JSONRowNode.swift new file mode 100644 index 0000000000..20f4b7f4f1 --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONRowNode.swift @@ -0,0 +1,131 @@ +// +// JSONRowNode.swift +// TablePro +// +// Immutable tree a single result row is rendered from in the JSON inspector. +// + +import Foundation + +struct JSONNodePath: Hashable, Sendable { + let components: [String] + + static let root = JSONNodePath(components: []) + + func appending(_ component: String) -> JSONNodePath { + JSONNodePath(components: components + [component]) + } + + var rawValue: String { + components.joined(separator: "\u{001F}") + } + + var depth: Int { components.count } +} + +enum JSONNodeKey: Equatable, Sendable { + case root + case name(String) + case index(Int) + + var text: String? { + switch self { + case .root: nil + case .name(let name): name + case .index: nil + } + } +} + +enum JSONScalar: Equatable, Sendable { + case string(String) + case number(String) + case bool(Bool) + case null + case binary(Data) + + var searchableText: String { + switch self { + case .string(let text): text + case .number(let text): text + case .bool(let flag): flag ? "true" : "false" + case .null: "null" + case .binary: "" + } + } +} + +/// The parts of a `ForeignKeyInfo` an expansion needs, without its per-instance identity. +/// +/// `ForeignKeyInfo` carries a fresh `UUID` and takes it into `==`, so two descriptions of the same +/// constraint never compare equal. A node tree that has to diff cleanly cannot hold one. +struct JSONForeignKeyRef: Hashable, Sendable { + let column: String + let referencedTable: String + let referencedSchema: String? + let referencedColumn: String + + init(column: String, referencedTable: String, referencedSchema: String?, referencedColumn: String) { + self.column = column + self.referencedTable = referencedTable + self.referencedSchema = referencedSchema + self.referencedColumn = referencedColumn + } + + init(_ info: ForeignKeyInfo) { + self.init( + column: info.column, + referencedTable: info.referencedTable, + referencedSchema: info.referencedSchema, + referencedColumn: info.referencedColumn + ) + } + + var qualifiedTable: String { + guard let referencedSchema, !referencedSchema.isEmpty else { return referencedTable } + return "\(referencedSchema).\(referencedTable)" + } +} + +enum JSONNodeValue: Equatable, Sendable { + case scalar(JSONScalar) + case object([JSONRowNode]) + case array([JSONRowNode]) + /// A scalar the referenced row can be fetched for. Children arrive from the fetch, not from here. + case foreignKey(JSONForeignKeyRef, JSONScalar) +} + +struct JSONRowNode: Identifiable, Equatable, Sendable { + let path: JSONNodePath + let key: JSONNodeKey + let value: JSONNodeValue + + var id: String { path.rawValue } + + var children: [JSONRowNode] { + switch value { + case .object(let nodes), .array(let nodes): nodes + case .scalar, .foreignKey: [] + } + } + + var isContainer: Bool { + switch value { + case .object, .array: true + case .scalar, .foreignKey: false + } + } + + var foreignKey: JSONForeignKeyRef? { + guard case .foreignKey(let ref, _) = value else { return nil } + return ref + } + + var scalar: JSONScalar? { + switch value { + case .scalar(let scalar): scalar + case .foreignKey(_, let scalar): scalar + case .object, .array: nil + } + } +} diff --git a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift new file mode 100644 index 0000000000..0331f044d5 --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift @@ -0,0 +1,149 @@ +// +// JSONRowNodeBuilder.swift +// TablePro +// +// Turns one result row into the JSON inspector's node tree. +// + +import Foundation +import TableProPluginKit + +enum JSONRowNodeBuilder { + /// Root node for a row. `foreignKeys` is keyed by column name, the shape + /// `TableRows.columnForeignKeys` already holds. + static func build( + path: JSONNodePath = .root, + key: JSONNodeKey = .root, + columns: [String], + values: [PluginCellValue], + columnTypes: [ColumnType], + foreignKeys: [String: JSONForeignKeyRef] + ) -> JSONRowNode { + var children: [JSONRowNode] = [] + children.reserveCapacity(columns.count) + + for (index, column) in columns.enumerated() { + let value = index < values.count ? values[index] : .null + let type = index < columnTypes.count ? columnTypes[index] : nil + let childPath = path.appending(column) + children.append( + JSONRowNode( + path: childPath, + key: .name(column), + value: nodeValue( + for: value, + type: type, + foreignKey: foreignKeys[column], + path: childPath + ) + ) + ) + } + + return JSONRowNode(path: path, key: key, value: .object(children)) + } + + private static func nodeValue( + for value: PluginCellValue, + type: ColumnType?, + foreignKey: JSONForeignKeyRef?, + path: JSONNodePath + ) -> JSONNodeValue { + switch value { + case .null: + guard let foreignKey else { return .scalar(.null) } + return .foreignKey(foreignKey, .null) + case .bytes(let data): + return .scalar(.binary(data)) + case .text(let text): + if let foreignKey { + return .foreignKey(foreignKey, scalar(for: text, type: type)) + } + if let document = parsedDocument(text, type: type) { + return documentValue(document, path: path) + } + return .scalar(scalar(for: text, type: type)) + } + } + + /// The scan cap the cell viewer already applies. A column holding a megabyte of JSON is not a + /// tree anyone reads, and the inspector shows the text instead. + static let maxScannedDocumentLength = 100_000 + + /// A JSON column is parsed whatever it holds; any other column only when its text is shaped + /// like a document, which is what makes a `TEXT` column holding JSON expand too. + /// + /// The parse is `JsonSyntaxParser`, the same one the JSON cell viewer reads with, so a document + /// cannot render one way in a cell and another in the row. + private static func parsedDocument(_ text: String, type: ColumnType?) -> JsonSyntaxNode? { + guard (text as NSString).length <= maxScannedDocumentLength else { return nil } + if type?.isJsonType != true, !looksLikeDocument(text) { return nil } + guard let parsed = JsonSyntaxParser.parse(text) else { return nil } + switch parsed { + case .object, .array: return parsed + case .string, .number, .literal: return nil + } + } + + /// A cell holding `42` is a number column, not a JSON document, and treating it as one would + /// nest every integer a level deeper than it belongs. + static func looksLikeDocument(_ text: String) -> Bool { + guard let first = text.first(where: { !$0.isWhitespace && !$0.isNewline }) else { return false } + return first == "{" || first == "[" + } + + private static func documentValue(_ document: JsonSyntaxNode, path: JSONNodePath) -> JSONNodeValue { + switch document { + case .object(let members): + let children = members.enumerated().map { index, member in + let key = JsonSyntaxParser.decodeStringLiteral(member.key) + let childPath = path.appending("\(index).\(key)") + return JSONRowNode( + path: childPath, + key: .name(key), + value: documentValue(member.value, path: childPath) + ) + } + return .object(children) + case .array(let elements): + let children = elements.enumerated().map { index, element in + let childPath = path.appending("[\(index)]") + return JSONRowNode( + path: childPath, + key: .index(index), + value: documentValue(element, path: childPath) + ) + } + return .array(children) + case .string(let raw): + return .scalar(.string(JsonSyntaxParser.decodeStringLiteral(raw))) + case .number(let literal): + return .scalar(.number(literal)) + case .literal(let literal): + switch literal { + case "true": return .scalar(.bool(true)) + case "false": return .scalar(.bool(false)) + default: return .scalar(.null) + } + } + } + + /// The column's own type decides whether a value is quoted, so a `DECIMAL` arriving as `"4.99"` + /// stays a string the way the grid shows it and an `INT` arriving as `"2"` renders bare. + static func scalar(for text: String, type: ColumnType?) -> JSONScalar { + guard let type else { return .string(text) } + switch type { + case .integer, .decimal: + guard let literal = JsonNumberNormalizer.numberLiteral(from: text) else { return .string(text) } + return .number(literal) + case .boolean: + switch PluginSQLLiteral.booleanSynonym(for: text) { + case .isTrue: return .bool(true) + case .isFalse: return .bool(false) + default: return .string(text) + } + case .text, .date, .timestamp, .datetime, .blob, .json, .enumType, .set, .spatial, .array: + return .string(text) + } + } +} diff --git a/TablePro/Models/UI/JSON/JSONRowSnapshot.swift b/TablePro/Models/UI/JSON/JSONRowSnapshot.swift new file mode 100644 index 0000000000..95bf909105 --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONRowSnapshot.swift @@ -0,0 +1,28 @@ +// +// JSONRowSnapshot.swift +// TablePro +// +// The selected row, as the JSON inspector needs it. +// + +import Foundation +import TableProPluginKit + +/// Carries the raw cell values rather than the inspector's formatted strings: the JSON view decides +/// whether a value prints quoted from the column's type, and a string that arrived pre-formatted +/// cannot answer that. +struct JSONRowSnapshot: Equatable, Sendable { + /// Which row this is. A change here is a new selection, so expansions and fetched keys go. + let rowIdentity: String + /// What the row holds. A change here is the same row reloaded, so the tree is rebuilt while + /// the reader's expansions stay where they were. + let contentToken: Int + let columns: [String] + let columnTypes: [ColumnType] + let values: [PluginCellValue] + let foreignKeys: [String: JSONForeignKeyRef] + /// Carried on the snapshot so the panel can hand it to the view model without the view, which + /// is what keeps the model in step with the row a render is about to draw. + let connectionId: UUID + let databaseType: DatabaseType +} diff --git a/TablePro/Models/UI/JSON/JSONRowTextRenderer.swift b/TablePro/Models/UI/JSON/JSONRowTextRenderer.swift new file mode 100644 index 0000000000..c4198b2cac --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONRowTextRenderer.swift @@ -0,0 +1,41 @@ +// +// JSONRowTextRenderer.swift +// TablePro +// +// Prints the lines the inspector is showing, for Copy Visible. +// + +import Foundation + +enum JSONRowTextRenderer { + static let indent = " " + + /// Renders exactly what is on screen: a collapsed object prints as `{…}`, a filtered-out key + /// does not print at all, and an expanded foreign key prints its fetched row. + static func render(rows: [JSONDisplayRow]) -> String { + rows.map(line(for:)).joined(separator: "\n") + } + + private static func line(for row: JSONDisplayRow) -> String { + let padding = String(repeating: indent, count: row.depth) + let keyPrefix = row.showsKey ? "\"\(JSONScalarText.escaped(row.key.text ?? ""))\": " : "" + let comma = row.needsComma ? "," : "" + + switch row.token { + case .scalar(let scalar): + return "\(padding)\(keyPrefix)\(JSONScalarText.printed(scalar))\(comma)" + case .openObject: + return "\(padding)\(keyPrefix){" + case .openArray: + return "\(padding)\(keyPrefix)[" + case .closeObject: + return "\(padding)}\(comma)" + case .closeArray: + return "\(padding)]\(comma)" + case .collapsedObject: + return "\(padding)\(keyPrefix){…}\(comma)" + case .collapsedArray: + return "\(padding)\(keyPrefix)[…]\(comma)" + } + } +} diff --git a/TablePro/Models/UI/JSON/JSONScalarText.swift b/TablePro/Models/UI/JSON/JSONScalarText.swift new file mode 100644 index 0000000000..a600acf80e --- /dev/null +++ b/TablePro/Models/UI/JSON/JSONScalarText.swift @@ -0,0 +1,59 @@ +// +// JSONScalarText.swift +// TablePro +// +// How a scalar prints in the JSON inspector, shared by the view and by Copy Visible. +// + +import Foundation + +enum JSONScalarText { + /// The value as it is printed, quotes included, so the view and the clipboard cannot disagree. + static func printed(_ scalar: JSONScalar) -> String { + switch scalar { + case .string(let text): "\"\(escaped(text))\"" + case .number(let literal): literal + case .bool(let flag): flag ? "true" : "false" + case .null: "null" + case .binary(let data): hex(data) + } + } + + /// The value without its quotes, which is what Copy Value puts on the pasteboard. + static func unquoted(_ scalar: JSONScalar) -> String { + switch scalar { + case .string(let text): text + case .number(let literal): literal + case .bool(let flag): flag ? "true" : "false" + case .null: "NULL" + case .binary(let data): hex(data) + } + } + + static func escaped(_ text: String) -> String { + var output = "" + output.reserveCapacity(text.count + 2) + for character in text.unicodeScalars { + switch character { + case "\"": output += "\\\"" + case "\\": output += "\\\\" + case "\n": output += "\\n" + case "\r": output += "\\r" + case "\t": output += "\\t" + default: + if character.value < 0x20 { + output += String(format: "\\u%04x", character.value) + } else { + output.unicodeScalars.append(character) + } + } + } + return output + } + + private static func hex(_ data: Data) -> String { + let latin1 = String(data: data, encoding: .isoLatin1) ?? "" + guard let formatted = latin1.formattedAsCompactHex() else { return "\"\"" } + return "\"\(formatted)\"" + } +} diff --git a/TablePro/Models/UI/RightPanelState.swift b/TablePro/Models/UI/RightPanelState.swift index 415925f670..d99c515f56 100644 --- a/TablePro/Models/UI/RightPanelState.swift +++ b/TablePro/Models/UI/RightPanelState.swift @@ -20,13 +20,26 @@ import os } } - var inspectorContext: InspectorContext = .empty + /// The JSON tab's model is fed here rather than from the tab's own `onChange`. + /// + /// A view's `onChange` runs after the render that already observed the new value, so the tab + /// drew one frame of the previous record's tree before the model caught up: moving between rows + /// flickered. Writing both in the same turn means every render sees one consistent row. + var inspectorContext: InspectorContext = .empty { + didSet { + jsonViewModel.update(snapshot: inspectorContext.jsonRow) + } + } // Save closure — set by MainContentCommandActions, called by UnifiedRightPanelView var onSave: (() -> Void)? // Owned objects — lifted from MainContentView @StateObject let editState = MultiRowEditState() + + /// Held here rather than as the JSON tab's own `@State` so a switch to Details and back keeps + /// the reader's expansions and the rows already fetched for them. + let jsonViewModel = JSONRowInspectorViewModel() private var _aiViewModel: AIChatViewModel? var aiViewModel: AIChatViewModel { if _aiViewModel == nil { @@ -58,6 +71,7 @@ import os _didTeardown.withLock { $0 = true } onSave = nil _aiViewModel?.clearSessionData() + jsonViewModel.releaseData() editState.releaseData() } } diff --git a/TablePro/Models/UI/RightPanelTab.swift b/TablePro/Models/UI/RightPanelTab.swift index 6a30b1bd25..cdda78821e 100644 --- a/TablePro/Models/UI/RightPanelTab.swift +++ b/TablePro/Models/UI/RightPanelTab.swift @@ -9,11 +9,13 @@ import Foundation enum RightPanelTab: String, CaseIterable, Hashable { case details = "Details" + case json = "JSON" case aiChat = "AI Chat" var localizedTitle: String { switch self { case .details: String(localized: "Details") + case .json: String(localized: "JSON") case .aiChat: String(localized: "AI Chat") } } @@ -21,6 +23,7 @@ enum RightPanelTab: String, CaseIterable, Hashable { var systemImage: String { switch self { case .details: "info.circle" + case .json: "curlybraces" case .aiChat: "sparkles" } } diff --git a/TablePro/ViewModels/JSONRowInspectorViewModel.swift b/TablePro/ViewModels/JSONRowInspectorViewModel.swift new file mode 100644 index 0000000000..6f7730a192 --- /dev/null +++ b/TablePro/ViewModels/JSONRowInspectorViewModel.swift @@ -0,0 +1,305 @@ +// +// JSONRowInspectorViewModel.swift +// TablePro +// +// Expansion, filtering and foreign key fetching for the JSON inspector. +// + +import AppKit +import Foundation +import os + +@MainActor +@Observable +final class JSONRowInspectorViewModel { + private(set) var root: JSONRowNode? + private(set) var states = JSONForeignKeyStates() + /// Session state, not a setting. Following a key costs a query per key, so the tab opens with + /// them closed however the reader left it last time, and turning it on is a deliberate act. + private(set) var alwaysExpandForeignKeys = false + + var filterText: String = "" + + private var expanded: Set = [] + private var chains: [JSONNodePath: [JSONForeignKeyVisit]] = [:] + private var fetches: [JSONNodePath: Task] = [:] + private var snapshotIdentity: String? + private var contentToken: Int? + private var connectionId: UUID? + private var databaseType: DatabaseType? + + private static let logger = Logger(subsystem: "com.TablePro", category: "JSONRowInspector") + + // MARK: - Lifecycle + + /// Drops the tree and every fetched row on disconnect, the way the chat and the edit state do. + func releaseData() { + reset() + filterText = "" + alwaysExpandForeignKeys = false + } + + // MARK: - Input + + func update(snapshot: JSONRowSnapshot?) { + guard let snapshot else { + reset() + return + } + connectionId = snapshot.connectionId + databaseType = snapshot.databaseType + + let isSameRow = snapshot.rowIdentity == snapshotIdentity + guard !isSameRow || snapshot.contentToken != contentToken else { return } + + if !isSameRow { + cancelFetches() + states = JSONForeignKeyStates() + chains = [:] + } + snapshotIdentity = snapshot.rowIdentity + contentToken = snapshot.contentToken + + let rebuilt = JSONRowNodeBuilder.build( + columns: snapshot.columns, + values: snapshot.values, + columnTypes: snapshot.columnTypes, + foreignKeys: snapshot.foreignKeys + ) + root = rebuilt + if isSameRow { + expanded.insert(rebuilt.path) + } else { + expanded = [rebuilt.path] + expandContainers(in: rebuilt) + } + + guard alwaysExpandForeignKeys else { return } + autoExpandForeignKeys(in: rebuilt) + } + + private func reset() { + cancelFetches() + snapshotIdentity = nil + contentToken = nil + root = nil + expanded = [] + chains = [:] + states = JSONForeignKeyStates() + } + + /// An embedded JSON document arrives expanded, the way the grid's own JSON preview shows it. + /// Only foreign keys cost a round trip, so only they start closed. + private func expandContainers(in node: JSONRowNode) { + for child in node.children where child.isContainer { + expanded.insert(child.path) + expandContainers(in: child) + } + } + + // MARK: - Display + + var displayRows: [JSONDisplayRow] { + guard let root else { return [] } + switch JSONRowMatcher.make(query: filterText) { + case .empty, .invalidRegex: + return JSONRowFlattener.rows(root: root, expanded: expanded, states: states) + case .matcher(let matcher): + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: states.fetched, + matcher: matcher + ) + return JSONRowFlattener.rows( + root: root, + expanded: expanded, + states: states, + visiblePaths: visible + ) + } + } + + var isFilterInvalid: Bool { + if case .invalidRegex = JSONRowMatcher.make(query: filterText) { return true } + return false + } + + var isFiltering: Bool { + if case .matcher = JSONRowMatcher.make(query: filterText) { return true } + return false + } + + // MARK: - Expansion + + func toggle(row: JSONDisplayRow) { + guard let root else { return } + if row.foreignKey != nil, states.fetched[row.path] == nil { + expandForeignKey(at: row.path, in: root) + return + } + if expanded.contains(row.path) { + expanded.remove(row.path) + } else { + expanded.insert(row.path) + } + } + + /// Expands what is already in hand. A foreign key that has not been fetched is left alone: + /// walking every key in a wide row would fire one query per column on a single click. + func expandAll() { + guard let root else { return } + expanded = JSONRowFlattener.expandablePaths(root: root, states: states) + } + + func collapseAll() { + expanded = [] + } + + // MARK: - Preferences + + func setAlwaysExpandForeignKeys(_ expand: Bool) { + alwaysExpandForeignKeys = expand + guard expand, let root else { return } + autoExpandForeignKeys(in: root) + } + + // MARK: - Clipboard + + func copyVisible() { + let text = JSONRowTextRenderer.render(rows: displayRows) + guard !text.isEmpty else { return } + let pasteboard = NSPasteboard.general + pasteboard.clearContents() + pasteboard.setString(text, forType: .string) + } + + // MARK: - Foreign Keys + + private func autoExpandForeignKeys(in root: JSONRowNode) { + for child in root.children where child.foreignKey != nil { + guard states.fetched[child.path] == nil, fetches[child.path] == nil else { continue } + expandForeignKey(at: child.path, in: root) + } + } + + private func expandForeignKey(at path: JSONNodePath, in root: JSONRowNode) { + guard fetches[path] == nil, + let connectionId, + let databaseType, + let node = node(at: path, from: root), + let reference = node.foreignKey, + let scalar = node.scalar else { return } + + if case .null = scalar { return } + startFetch( + path: path, + reference: reference, + value: JSONScalarText.unquoted(scalar), + connectionId: connectionId, + databaseType: databaseType + ) + } + + private func startFetch( + path: JSONNodePath, + reference: JSONForeignKeyRef, + value: String, + connectionId: UUID, + databaseType: DatabaseType + ) { + let visit = JSONForeignKeyVisit(ref: reference, value: value) + let chain = chain(endingAt: path) + + switch JSONForeignKeyExpansionPolicy.decide(chain: chain, next: visit) { + case .cycle: + states.failures[path] = .cycle + return + case .depthLimit: + states.failures[path] = .depthLimit + return + case .allowed: + break + } + + states.failures.removeValue(forKey: path) + states.loading.insert(path) + + let identity = snapshotIdentity + fetches[path] = Task { [weak self] in + defer { self?.finishFetch(at: path, identity: identity) } + do { + let fetched = try await ForeignKeyRowFetcher.fetch( + connectionId: connectionId, + databaseType: databaseType, + reference: reference, + value: value, + includeForeignKeys: true + ) + guard let self, !Task.isCancelled, identity == self.snapshotIdentity else { return } + guard let fetched else { + self.states.failures[path] = .notFound + return + } + self.adopt(fetched: fetched, at: path, reference: reference, chain: chain + [visit]) + } catch { + Self.logger.error("Foreign key expansion failed: \(error.localizedDescription)") + guard let self, !Task.isCancelled, identity == self.snapshotIdentity else { return } + self.states.failures[path] = .failed(String(localized: "Failed to load referenced row")) + } + } + } + + private func adopt( + fetched: ForeignKeyRowFetcher.FetchedRow, + at path: JSONNodePath, + reference: JSONForeignKeyRef, + chain: [JSONForeignKeyVisit] + ) { + let expansion = JSONRowNodeBuilder.build( + path: path, + key: .name(reference.column), + columns: fetched.columns, + values: fetched.values, + columnTypes: fetched.columnTypes, + foreignKeys: fetched.foreignKeys + ) + states.fetched[path] = expansion + chains[path] = chain + expanded.insert(path) + expandContainers(in: expansion) + } + + private func finishFetch(at path: JSONNodePath, identity: String?) { + fetches.removeValue(forKey: path) + guard identity == snapshotIdentity else { return } + states.loading.remove(path) + } + + private func cancelFetches() { + for task in fetches.values { task.cancel() } + fetches = [:] + } + + /// The keys already followed to reach `path`, nearest ancestor first, which is what the cycle + /// check needs: the chain lives on the expansion that produced the subtree, not on the node. + private func chain(endingAt path: JSONNodePath) -> [JSONForeignKeyVisit] { + var components = path.components + while !components.isEmpty { + components.removeLast() + if let chain = chains[JSONNodePath(components: components)] { return chain } + } + return [] + } + + private func node(at path: JSONNodePath, from root: JSONRowNode) -> JSONRowNode? { + if path == root.path { return root } + for child in JSONRowFilter.children(of: root, fetched: states.fetched) { + if path.components.count >= child.path.components.count, + Array(path.components.prefix(child.path.components.count)) == child.path.components, + let found = node(at: path, from: child) { + return found + } + } + return nil + } +} diff --git a/TablePro/Views/Main/Child/DataTabGridDelegate.swift b/TablePro/Views/Main/Child/DataTabGridDelegate.swift index f5148b9fb6..8c84be9eea 100644 --- a/TablePro/Views/Main/Child/DataTabGridDelegate.swift +++ b/TablePro/Views/Main/Child/DataTabGridDelegate.swift @@ -88,6 +88,12 @@ final class DataTabGridDelegate: DataGridViewDelegate { coordinator?.navigateToFKReference(value: value, fkInfo: fkInfo, openInNewTab: openInNewTab) } + /// The table view has already retargeted the selection to the clicked row by the time a context + /// menu item fires, so the panel reads the row the reader asked about without being told which. + func dataGridShowRowAsJSON() { + coordinator?.showJSONPanel() + } + func dataGridHideColumn(_ columnName: String) { coordinator?.hideColumn(columnName) } diff --git a/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift b/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift index f3ca8df6dd..9c94250880 100644 --- a/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift +++ b/TablePro/Views/Main/Extensions/MainContentCoordinator+FKNavigation.swift @@ -14,6 +14,23 @@ private let fkNavigationLogger = Logger(subsystem: "com.TablePro", category: "FK extension MainContentCoordinator { // MARK: - Foreign Key Navigation + /// The JSON inspector's own route to the same navigation. It holds a `JSONForeignKeyRef`, + /// which is a `ForeignKeyInfo` without the identity and the referential actions, because a node + /// tree cannot hold a type whose `==` is a fresh `UUID`. + func navigateToFKReference(reference: JSONForeignKeyRef, value: String) { + navigateToFKReference( + value: value, + fkInfo: ForeignKeyInfo( + name: "", + column: reference.column, + referencedTable: reference.referencedTable, + referencedColumn: reference.referencedColumn, + referencedSchema: reference.referencedSchema + ), + openInNewTab: false + ) + } + /// Navigate to the referenced table filtered by the FK value. /// Reuses the current tab when it holds nothing the user authored, and otherwise opens the /// reference in its own tab so the originating query or edits survive. diff --git a/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift b/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift index 45cb8c7a63..3360e49196 100644 --- a/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift +++ b/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift @@ -94,6 +94,41 @@ extension MainContentView { return data } + // MARK: - Selected Row for the JSON Tab + + /// The same selection the details tab reads, carried as raw cell values. + /// + /// The JSON tab decides from the column's own type whether a value prints quoted, which the + /// formatted strings the details tab takes cannot answer. Only the data grid supplies it: the + /// schema grid's rows are label and value pairs with no types and no foreign keys. + var jsonRowSnapshotForSidebar: JSONRowSnapshot? { + guard gridSelectionOwner == .dataGrid, + let tab = coordinator.tabManager.selectedTab, + let firstDisplayIndex = coordinator.selectionState.indices.min() else { return nil } + let tableRows = coordinator.tabSessionRegistry.tableRows(for: tab.id) + guard !tableRows.columns.isEmpty, + let row = DisplayRowMapping.row( + forDisplay: firstDisplayIndex, + displayIDs: coordinator.activeGridDisplayIDs, + in: tableRows + ) else { return nil } + + var contentHasher = Hasher() + contentHasher.combine(row.values) + contentHasher.combine(tableRows.columns) + + return JSONRowSnapshot( + rowIdentity: "\(tab.id.uuidString)\u{001F}\(row.id)", + contentToken: contentHasher.finalize(), + columns: tableRows.columns, + columnTypes: tableRows.columnTypes, + values: Array(row.values), + foreignKeys: tableRows.columnForeignKeys.mapValues(JSONForeignKeyRef.init), + connectionId: coordinator.connection.id, + databaseType: coordinator.connection.type + ) + } + // MARK: - Sidebar Edit State /// Determine if sidebar should be in editable mode diff --git a/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift b/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift index 8c0fc2a2df..bfae81ed40 100644 --- a/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift +++ b/TablePro/Views/Main/Extensions/MainContentView+Helpers.swift @@ -72,7 +72,8 @@ extension MainContentView { isEditable: isSidebarEditable, isRowDeleted: isSelectedRowDeleted, currentQuery: coordinator.tabManager.selectedTab?.content.query, - queryResults: cachedQueryResultsSummary() + queryResults: cachedQueryResultsSummary(), + jsonRow: jsonRowSnapshotForSidebar ) } diff --git a/TablePro/Views/Main/MainContentCommandActions.swift b/TablePro/Views/Main/MainContentCommandActions.swift index 79af61e767..a0c4afd72d 100644 --- a/TablePro/Views/Main/MainContentCommandActions.swift +++ b/TablePro/Views/Main/MainContentCommandActions.swift @@ -1037,6 +1037,14 @@ final class MainContentCommandActions { coordinator?.toggleFKPreviewForFocusedCell() } + func showRowAsJSON() { + coordinator?.showJSONPanel() + } + + func openForeignKeyTable(reference: JSONForeignKeyRef, value: String) { + coordinator?.navigateToFKReference(reference: reference, value: value) + } + func exportTables() { coordinator?.openExportDialog() } diff --git a/TablePro/Views/Main/MainContentCoordinator.swift b/TablePro/Views/Main/MainContentCoordinator.swift index 523c7d8279..d879edbb81 100644 --- a/TablePro/Views/Main/MainContentCoordinator.swift +++ b/TablePro/Views/Main/MainContentCoordinator.swift @@ -764,6 +764,11 @@ final class MainContentCoordinator { rightPanelState?.activeTab = .aiChat } + func showJSONPanel() { + inspectorProxy?.showInspector() + rightPanelState?.activeTab = .json + } + /// Set up the plugin driver for query building dispatch on the query builder and change manager. internal func setupPluginDriver() { guard let driver = services.databaseManager.driver(for: connectionId) else { return } diff --git a/TablePro/Views/Results/DataGridRowView.swift b/TablePro/Views/Results/DataGridRowView.swift index b6018ab1e3..a8e2de8058 100644 --- a/TablePro/Views/Results/DataGridRowView.swift +++ b/TablePro/Views/Results/DataGridRowView.swift @@ -452,6 +452,16 @@ class DataGridRowView: NSTableRowView { menu.addItem(pasteItem) } + menu.addItem(NSMenuItem.separator()) + + let jsonViewItem = NSMenuItem( + title: String(localized: "Show Row as JSON"), + action: #selector(showRowAsJSON), + keyEquivalent: "" + ) + jsonViewItem.target = self + menu.addItem(jsonViewItem) + let tableRows = coordinator.tableRowsProvider() addForeignKeyMenuItems(to: menu, dataColumnIndex: dataColumnIndex, tableRows: tableRows) @@ -702,6 +712,10 @@ class DataGridRowView: NSTableRowView { ) } + @objc private func showRowAsJSON() { + coordinator?.delegate?.dataGridShowRowAsJSON() + } + @objc private func previewForeignKey(_ sender: NSMenuItem) { guard let columnIndex = sender.representedObject as? Int, let coordinator, let tableView = coordinator.tableView, diff --git a/TablePro/Views/Results/DataGridViewDelegate.swift b/TablePro/Views/Results/DataGridViewDelegate.swift index f4c5472bae..44556e08fd 100644 --- a/TablePro/Views/Results/DataGridViewDelegate.swift +++ b/TablePro/Views/Results/DataGridViewDelegate.swift @@ -22,6 +22,7 @@ protocol DataGridViewDelegate: AnyObject { func dataGridSortStateChanged(_ state: SortState) func dataGridFilterColumn(_ columnName: String) func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, openInNewTab: Bool) + func dataGridShowRowAsJSON() func dataGridDuplicateRow() func dataGridExportResults() func dataGridClearResults() @@ -57,6 +58,7 @@ extension DataGridViewDelegate { func dataGridSortStateChanged(_ state: SortState) {} func dataGridFilterColumn(_ columnName: String) {} func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo, openInNewTab: Bool) {} + func dataGridShowRowAsJSON() {} func dataGridDuplicateRow() {} func dataGridExportResults() {} func dataGridClearResults() {} diff --git a/TablePro/Views/Results/ForeignKeyPreviewView.swift b/TablePro/Views/Results/ForeignKeyPreviewView.swift index 210b9ab548..8a0fc2d62f 100644 --- a/TablePro/Views/Results/ForeignKeyPreviewView.swift +++ b/TablePro/Views/Results/ForeignKeyPreviewView.swift @@ -176,35 +176,20 @@ struct ForeignKeyPreviewView: View { return } - guard let driver = DatabaseManager.shared.driver(for: connectionId) else { - Self.logger.error("No active driver for FK preview") - errorMessage = String(localized: "No database connection") - isLoading = false - return - } - - let quotedTable: String - if let schema = fkInfo.referencedSchema { - quotedTable = "\(driver.quoteIdentifier(schema)).\(driver.quoteIdentifier(fkInfo.referencedTable))" - } else { - quotedTable = driver.quoteIdentifier(fkInfo.referencedTable) - } - let quotedColumn = driver.quoteIdentifier(fkInfo.referencedColumn) - let escapedValue = driver.escapeStringLiteral(value) - - let query = ForeignKeyPreviewQuery.singleRow( - quotedTable: quotedTable, - quotedColumn: quotedColumn, - escapedValue: escapedValue, - dialect: PluginManager.shared.sqlDialect(for: databaseType) - ) - do { - let result = try await driver.execute(query: query) - if let firstRow = result.rows.first { - columns = result.columns - values = firstRow.map { $0.asText } + let fetched = try await ForeignKeyRowFetcher.fetch( + connectionId: connectionId, + databaseType: databaseType, + reference: JSONForeignKeyRef(fkInfo), + value: value + ) + if let fetched { + columns = fetched.columns + values = fetched.values.map { $0.asText } } + } catch ForeignKeyRowFetcher.FetchFailure.noConnection { + Self.logger.error("No active driver for FK preview") + errorMessage = String(localized: "No database connection") } catch { Self.logger.error("FK preview query failed: \(error.localizedDescription)") errorMessage = String(localized: "Failed to load referenced row") diff --git a/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift b/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift new file mode 100644 index 0000000000..ec3607d979 --- /dev/null +++ b/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift @@ -0,0 +1,187 @@ +// +// JSONNodeRowView.swift +// TablePro +// +// One printed line of the JSON inspector. +// + +import SwiftUI + +struct JSONNodeRowView: View { + let row: JSONDisplayRow + let colors: JSONRowColors + let onToggle: () -> Void + let onOpenReferencedTable: (JSONForeignKeyRef, String) -> Void + + private static let indentWidth: CGFloat = 14 + private static let controlWidth: CGFloat = 14 + + private var valueFont: Font { ThemeEngine.shared.valueFontSwiftUI } + + var body: some View { + HStack(alignment: .firstTextBaseline, spacing: 0) { + Spacer() + .frame(width: CGFloat(row.depth) * Self.indentWidth) + disclosure + content + Spacer(minLength: 0) + } + .padding(.vertical, 1) + .contentShape(Rectangle()) + .contextMenu { menu } + } + + // MARK: - Disclosure + + @ViewBuilder + private var disclosure: some View { + if row.isExpandable { + Button(action: onToggle) { + Image(systemName: row.isExpanded ? "chevron.down" : "chevron.right") + .font(.system(size: 9, weight: .semibold)) + .foregroundStyle(.secondary) + .frame(width: Self.controlWidth, alignment: .leading) + .contentShape(Rectangle()) + } + .buttonStyle(.plain) + .accessibilityLabel( + row.isExpanded ? String(localized: "Collapse") : String(localized: "Expand") + ) + } else { + Spacer().frame(width: Self.controlWidth) + } + } + + // MARK: - Content + + @ViewBuilder + private var content: some View { + HStack(alignment: .firstTextBaseline, spacing: 0) { + if row.showsKey, let key = row.key.text { + Text("\"\(key)\"") + .font(valueFont) + .foregroundStyle(colors.key) + .lineLimit(1) + Text(": ") + .font(valueFont) + .foregroundStyle(colors.punctuation) + } + token + status + } + .textSelection(.enabled) + } + + @ViewBuilder + private var token: some View { + switch row.token { + case .scalar(let scalar): + Text(JSONScalarText.printed(scalar) + (row.needsComma ? "," : "")) + .font(valueFont) + .foregroundStyle(colors.color(for: scalar)) + .fixedSize(horizontal: false, vertical: true) + case .openObject: + punctuation("{") + case .openArray: + punctuation("[") + case .closeObject: + punctuation("}" + (row.needsComma ? "," : "")) + case .closeArray: + punctuation("]" + (row.needsComma ? "," : "")) + case .collapsedObject(let count): + collapsed(open: "{", close: "}", count: count) + case .collapsedArray(let count): + collapsed(open: "[", close: "]", count: count) + } + } + + private func punctuation(_ text: String) -> some View { + Text(text) + .font(valueFont) + .foregroundStyle(colors.punctuation) + } + + private func collapsed(open: String, close: String, count: Int) -> some View { + HStack(spacing: 4) { + punctuation(open) + Text(count == 1 + ? String(localized: "1 item") + : String(format: String(localized: "%d items"), count)) + .font(.caption) + .foregroundStyle(colors.placeholder) + punctuation(close + (row.needsComma ? "," : "")) + } + } + + @ViewBuilder + private var status: some View { + switch row.status { + case .none: + EmptyView() + case .loading: + ProgressView() + .controlSize(.small) + .scaleEffect(0.6) + .frame(width: 16, height: 12) + .padding(.leading, 4) + case .failure(let failure): + Image(systemName: "exclamationmark.triangle") + .font(.caption) + .foregroundStyle(.secondary) + .padding(.leading, 4) + .help(Self.message(for: failure)) + .accessibilityLabel(Self.message(for: failure)) + } + } + + static func message(for failure: JSONForeignKeyFailure) -> String { + switch failure { + case .notFound: + String(localized: "Referenced row not found") + case .cycle: + String(localized: "This key references a row already shown above") + case .depthLimit: + String( + format: String(localized: "Foreign keys are followed %d levels deep"), + JSONForeignKeyExpansionPolicy.maxChainDepth + ) + case .failed(let message): + message + } + } + + // MARK: - Menu + + @ViewBuilder + private var menu: some View { + if let scalar = row.scalarValue { + Button(String(localized: "Copy Value")) { + copy(JSONScalarText.unquoted(scalar)) + } + } + if let key = row.key.text { + Button(String(localized: "Copy Key")) { + copy(key) + } + } + if let reference = row.foreignKey, let scalar = row.scalarValue, scalar != .null { + Divider() + Button(String(format: String(localized: "Open %@"), reference.qualifiedTable)) { + onOpenReferencedTable(reference, JSONScalarText.unquoted(scalar)) + } + } + } + + private func copy(_ text: String) { + let pasteboard = NSPasteboard.general + pasteboard.clearContents() + pasteboard.setString(text, forType: .string) + } +} + +private extension JSONDisplayRow { + var scalarValue: JSONScalar? { + guard case .scalar(let scalar) = token else { return nil } + return scalar + } +} diff --git a/TablePro/Views/RightSidebar/JSON/JSONRowColors.swift b/TablePro/Views/RightSidebar/JSON/JSONRowColors.swift new file mode 100644 index 0000000000..049a0354bc --- /dev/null +++ b/TablePro/Views/RightSidebar/JSON/JSONRowColors.swift @@ -0,0 +1,42 @@ +// +// JSONRowColors.swift +// TablePro +// +// Syntax colours for the JSON inspector, taken from the active editor theme. +// + +import SwiftUI + +/// The inspector shows stored values, so its font is the Data Grid Font (`ThemeEngine.valueFont`) +/// while its colours come from the editor palette the SQL editor and the JSON preview already use. +/// Naming a system text style here is what makes a value read differently in the grid and in the +/// inspector the moment the two font settings differ. +struct JSONRowColors { + let key: Color + let string: Color + let number: Color + let literal: Color + let punctuation: Color + let placeholder: Color + + @MainActor + static func current() -> JSONRowColors { + let colors = ThemeEngine.shared.colors.editor + return JSONRowColors( + key: colors.keywordSwiftUI, + string: colors.stringSwiftUI, + number: colors.numberSwiftUI, + literal: colors.nullSwiftUI, + punctuation: colors.textSwiftUI, + placeholder: colors.commentSwiftUI + ) + } + + func color(for scalar: JSONScalar) -> Color { + switch scalar { + case .string, .binary: string + case .number: number + case .bool, .null: literal + } + } +} diff --git a/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift b/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift new file mode 100644 index 0000000000..0348f1c3bb --- /dev/null +++ b/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift @@ -0,0 +1,159 @@ +// +// JSONRowInspectorView.swift +// TablePro +// +// The JSON tab of the right panel: the selected row as a filterable JSON tree +// whose foreign keys expand into the rows they reference. +// + +import SwiftUI + +struct JSONRowInspectorView: View { + @Bindable var viewModel: JSONRowInspectorViewModel + + let snapshot: JSONRowSnapshot? + let onOpenReferencedTable: (JSONForeignKeyRef, String) -> Void + + @State private var colors = JSONRowColors.current() + + var body: some View { + VStack(spacing: 0) { + if snapshot != nil { + toolbar + Divider() + tree + } else { + emptyState + } + } + .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading) + .onReceive(AppEvents.shared.themeChanged) { _ in colors = JSONRowColors.current() } + } + + // MARK: - Empty State + + private var emptyState: some View { + ContentUnavailableView( + String(localized: "No Row Selected"), + systemImage: "curlybraces", + description: Text(String(localized: "Select a row to view it as JSON")) + ) + .frame(maxWidth: .infinity, maxHeight: .infinity) + } + + // MARK: - Toolbar + + private var toolbar: some View { + HStack(spacing: 6) { + filterField + optionsMenu + } + .padding(.horizontal, 10) + .padding(.vertical, 6) + } + + private var filterField: some View { + HStack(spacing: 4) { + Image(systemName: "line.3.horizontal.decrease") + .font(.caption) + .foregroundStyle(.secondary) + TextField( + String(localized: "Filter by text or /regex/"), + text: $viewModel.filterText + ) + .textFieldStyle(.plain) + .font(.callout) + if !viewModel.filterText.isEmpty { + Button { + viewModel.filterText = "" + } label: { + Image(systemName: "xmark.circle.fill") + .font(.caption) + .foregroundStyle(.secondary) + } + .buttonStyle(.plain) + .accessibilityLabel(String(localized: "Clear Filter")) + } + } + .padding(.horizontal, 6) + .padding(.vertical, 4) + .background( + RoundedRectangle(cornerRadius: 6) + .fill(Color(nsColor: .textBackgroundColor)) + ) + .overlay( + RoundedRectangle(cornerRadius: 6) + .strokeBorder( + viewModel.isFilterInvalid ? Color.red.opacity(0.6) : Color(nsColor: .separatorColor) + ) + ) + .help(viewModel.isFilterInvalid + ? String(localized: "Not a valid regular expression") + : String(localized: "Filter keys and values. Wrap in slashes for a regular expression.")) + } + + private var optionsMenu: some View { + Menu { + Button(String(localized: "Copy Visible")) { viewModel.copyVisible() } + Divider() + Button(String(localized: "Collapse All")) { viewModel.collapseAll() } + Button(String(localized: "Expand All")) { viewModel.expandAll() } + Divider() + Toggle( + String(localized: "Always Expand Foreign Keys"), + isOn: Binding( + get: { viewModel.alwaysExpandForeignKeys }, + set: { viewModel.setAlwaysExpandForeignKeys($0) } + ) + ) + } label: { + Image(systemName: "ellipsis") + .font(.subheadline) + .symbolRenderingMode(.hierarchical) + .foregroundStyle(.secondary) + .frame(width: 22, height: 20) + .contentShape(Rectangle()) + } + .menuStyle(.borderlessButton) + .menuIndicator(.hidden) + .fixedSize() + .help(String(localized: "JSON view options")) + } + + // MARK: - Tree + + @ViewBuilder + private var tree: some View { + let rows = viewModel.displayRows + if rows.isEmpty { + noMatches + } else { + ScrollView(.vertical) { + LazyVStack(alignment: .leading, spacing: 0) { + ForEach(rows) { row in + JSONNodeRowView( + row: row, + colors: colors, + onToggle: { viewModel.toggle(row: row) }, + onOpenReferencedTable: onOpenReferencedTable + ) + } + } + .padding(.horizontal, 10) + .padding(.vertical, 6) + .frame(maxWidth: .infinity, alignment: .topLeading) + } + .background(Color(nsColor: ThemeEngine.shared.colors.editor.background)) + .accessibilityLabel(String(localized: "Row as JSON")) + } + } + + private var noMatches: some View { + ContentUnavailableView( + String(localized: "No Matches"), + systemImage: "magnifyingglass", + description: Text(String(localized: "No key or value matches this filter")) + ) + .frame(maxWidth: .infinity, maxHeight: .infinity) + } +} diff --git a/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift b/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift index e4504bd8b4..8258fab870 100644 --- a/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift +++ b/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift @@ -10,18 +10,19 @@ struct UnifiedRightPanelView: View { let connection: DatabaseConnection private let settingsManager = AppSettingsManager.shared + @Environment(\.commandActions) private var commandActions @State private var showClearConfirmation = false + /// AI Chat is the only tab a setting can take away, and a tab that is gone cannot stay + /// selected: the picker would show no selection and the panel no content. + private var availableTabs: [RightPanelTab] { + RightPanelTab.allCases.filter { $0 != .aiChat || settingsManager.ai.enabled } + } + var body: some View { - Group { - if settingsManager.ai.enabled { - splitContent - } else { - detailsView - } - } + splitContent .onChange(of: settingsManager.ai.enabled) { - if !settingsManager.ai.enabled { + if !settingsManager.ai.enabled, state.activeTab == .aiChat { state.activeTab = .details } } @@ -42,8 +43,28 @@ struct UnifiedRightPanelView: View { VStack(spacing: 0) { inspectorHeader Divider() + tabContent + } + .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading) + } + + /// Details stays mounted and is hidden rather than rebuilt. + /// + /// Its field list is a `List`, so leaving the tab tears down an `NSTableView` and a field editor + /// per column, and coming back builds them again: the switch cost grows with the row's width. + /// The other two tabs are cheap to rebuild and are left conditional, which also keeps the AI + /// chat's view model and its conversation load off a window that never opens that tab. + private var tabContent: some View { + ZStack(alignment: .topLeading) { + detailsView + .opacity(state.activeTab == .details ? 1 : 0) + .allowsHitTesting(state.activeTab == .details) + .disabled(state.activeTab != .details) + .accessibilityHidden(state.activeTab != .details) + switch state.activeTab { - case .details: detailsView + case .details: EmptyView() + case .json: jsonView case .aiChat: aiChatView } } @@ -65,7 +86,7 @@ struct UnifiedRightPanelView: View { private var tabPicker: some View { Picker("", selection: $state.activeTab) { - ForEach(RightPanelTab.allCases, id: \.self) { tab in + ForEach(availableTabs, id: \.self) { tab in Text(tab.localizedTitle).tag(tab) } } @@ -145,6 +166,16 @@ struct UnifiedRightPanelView: View { ) } + private var jsonView: some View { + JSONRowInspectorView( + viewModel: state.jsonViewModel, + snapshot: state.inspectorContext.jsonRow, + onOpenReferencedTable: { reference, value in + commandActions?.openForeignKeyTable(reference: reference, value: value) + } + ) + } + private var aiChatView: some View { let ctx = state.inspectorContext return AIChatPanelView( diff --git a/TableProTests/Models/JSON/JSONForeignKeyExpansionPolicyTests.swift b/TableProTests/Models/JSON/JSONForeignKeyExpansionPolicyTests.swift new file mode 100644 index 0000000000..4962050cd0 --- /dev/null +++ b/TableProTests/Models/JSON/JSONForeignKeyExpansionPolicyTests.swift @@ -0,0 +1,59 @@ +// +// JSONForeignKeyExpansionPolicyTests.swift +// TableProTests +// +// A self-referencing key must stop, and a long chain must stop too. +// + +import Foundation +import Testing + +@testable import TablePro + +@Suite("JSONForeignKeyExpansionPolicy") +struct JSONForeignKeyExpansionPolicyTests { + private func visit(_ table: String, _ value: String) -> JSONForeignKeyVisit { + JSONForeignKeyVisit(table: table, schema: nil, column: "id", value: value) + } + + @Test("A fresh key expands") + func allowsFreshKeys() { + #expect( + JSONForeignKeyExpansionPolicy.decide(chain: [visit("film", "1")], next: visit("language", "1")) + == .allowed + ) + } + + @Test("The same row twice is a cycle") + func stopsOnCycle() { + let repeated = visit("employee", "7") + #expect( + JSONForeignKeyExpansionPolicy.decide(chain: [visit("employee", "9"), repeated], next: repeated) + == .cycle + ) + } + + @Test("The same table with a different row is not a cycle") + func allowsSameTableDifferentRow() { + #expect( + JSONForeignKeyExpansionPolicy.decide(chain: [visit("employee", "7")], next: visit("employee", "8")) + == .allowed + ) + } + + @Test("A chain stops at the depth cap") + func stopsAtDepthCap() { + let chain = (0.. JSONRowNode { + JSONRowNodeBuilder.build( + columns: ["title", "length", "special_features"], + values: [.text("ANYTHING SAVANNAH"), .text("82"), .text("[\"Trailers\", \"Deleted Scenes\"]")], + columnTypes: [.text(rawType: "VARCHAR"), .integer(rawType: "INT"), .json(rawType: "JSON")], + foreignKeys: [:] + ) + } + + private func matcher(_ query: String) throws -> JSONRowMatcher { + guard case .matcher(let matcher) = JSONRowMatcher.make(query: query) else { + throw FilterTestError.notAMatcher + } + return matcher + } + + private enum FilterTestError: Error { + case notAMatcher + } + + @Test("An empty query is not a filter") + func emptyQuery() { + if case .empty = JSONRowMatcher.make(query: " ") { return } + Issue.record("Whitespace should read as no filter") + } + + @Test("A key match keeps the key") + func matchesKeys() throws { + let visible = JSONRowFilter.visiblePaths( + root: makeRoot(), + fetchedForeignKeys: [:], + matcher: try matcher("length") + ) + #expect(visible.contains(JSONNodePath.root.appending("length"))) + #expect(visible.contains(JSONNodePath.root.appending("title")) == false) + } + + @Test("A value match keeps the key that holds it") + func matchesValues() throws { + let visible = JSONRowFilter.visiblePaths( + root: makeRoot(), + fetchedForeignKeys: [:], + matcher: try matcher("savannah") + ) + #expect(visible.contains(JSONNodePath.root.appending("title"))) + } + + @Test("A nested match keeps its ancestors") + func keepsAncestors() throws { + let root = makeRoot() + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [:], + matcher: try matcher("Deleted") + ) + #expect(visible.contains(root.path)) + #expect(visible.contains(JSONNodePath.root.appending("special_features"))) + #expect(visible.contains(JSONNodePath.root.appending("title")) == false) + } + + @Test("Slashes make the query a regular expression") + func readsRegex() throws { + let visible = JSONRowFilter.visiblePaths( + root: makeRoot(), + fetchedForeignKeys: [:], + matcher: try matcher("/^len/") + ) + #expect(visible.contains(JSONNodePath.root.appending("length"))) + #expect(visible.contains(JSONNodePath.root.appending("title")) == false) + } + + @Test("A broken regular expression is reported, not treated as text") + func reportsInvalidRegex() { + if case .invalidRegex = JSONRowMatcher.make(query: "/[/") { return } + Issue.record("An unclosed class should report as invalid") + } + + @Test("Text that only looks like a path stays a substring") + func treatsPathsAsSubstrings() throws { + let root = JSONRowNodeBuilder.build( + columns: ["path"], + values: [.text("a/b")], + columnTypes: [.text(rawType: "TEXT")], + foreignKeys: [:] + ) + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [:], + matcher: try matcher("a/b") + ) + #expect(visible.contains(JSONNodePath.root.appending("path"))) + } + + @Test("A fetched foreign key's own keys are searched") + func searchesFetchedForeignKeys() throws { + let reference = JSONForeignKeyRef( + column: "language_id", + referencedTable: "language", + referencedSchema: nil, + referencedColumn: "language_id" + ) + let root = JSONRowNodeBuilder.build( + columns: ["language_id"], + values: [.text("1")], + columnTypes: [.integer(rawType: "INT")], + foreignKeys: ["language_id": reference] + ) + let keyPath = JSONNodePath.root.appending("language_id") + let expansion = JSONRowNodeBuilder.build( + path: keyPath, + key: .name("language_id"), + columns: ["name"], + values: [.text("English")], + columnTypes: [.text(rawType: "CHAR")], + foreignKeys: [:] + ) + + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [keyPath: expansion], + matcher: try matcher("English") + ) + #expect(visible.contains(keyPath.appending("name"))) + #expect(visible.contains(keyPath)) + } +} diff --git a/TableProTests/Models/JSON/JSONRowFlattenerTests.swift b/TableProTests/Models/JSON/JSONRowFlattenerTests.swift new file mode 100644 index 0000000000..9fc4e81ad2 --- /dev/null +++ b/TableProTests/Models/JSON/JSONRowFlattenerTests.swift @@ -0,0 +1,160 @@ +// +// JSONRowFlattenerTests.swift +// TableProTests +// +// The printed lines: braces, commas, disclosure state and foreign key status. +// + +import Foundation +import TableProPluginKit +import Testing + +@testable import TablePro + +@Suite("JSONRowFlattener") +struct JSONRowFlattenerTests { + private let reference = JSONForeignKeyRef( + column: "language_id", + referencedTable: "language", + referencedSchema: nil, + referencedColumn: "language_id" + ) + + private func makeRoot(foreignKeys: [String: JSONForeignKeyRef] = [:]) -> JSONRowNode { + JSONRowNodeBuilder.build( + columns: ["film_id", "language_id"], + values: [.text("2"), .text("1")], + columnTypes: [.integer(rawType: "INT"), .integer(rawType: "INT")], + foreignKeys: foreignKeys + ) + } + + private func row(_ rows: [JSONDisplayRow], _ column: String) throws -> JSONDisplayRow { + try #require(rows.first { $0.path == JSONNodePath.root.appending(column) }) + } + + @Test("An expanded root prints its braces around its keys") + func printsBraces() { + let root = makeRoot() + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: JSONForeignKeyStates()) + #expect(rows.count == 4) + #expect(rows.first?.token == .openObject) + #expect(rows.last?.token == .closeObject) + #expect(rows.last?.depth == 0) + } + + @Test("Every key but the last carries a comma") + func printsCommas() throws { + let root = makeRoot() + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: JSONForeignKeyStates()) + #expect(try row(rows, "film_id").needsComma) + #expect(try row(rows, "language_id").needsComma == false) + } + + @Test("A collapsed root prints one line with its key count") + func printsCollapsedRoot() { + let root = makeRoot() + let rows = JSONRowFlattener.rows(root: root, expanded: [], states: JSONForeignKeyStates()) + #expect(rows.count == 1) + #expect(rows.first?.token == .collapsedObject(count: 2)) + #expect(rows.first?.isExpandable == true) + } + + @Test("An unexpanded foreign key prints its value and offers a control") + func printsUnexpandedForeignKey() throws { + let root = makeRoot(foreignKeys: ["language_id": reference]) + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: JSONForeignKeyStates()) + let key = try row(rows, "language_id") + #expect(key.token == .scalar(.number("1"))) + #expect(key.isExpandable) + #expect(key.foreignKey == reference) + } + + @Test("A NULL foreign key offers no control") + func offersNoControlForNullKeys() throws { + let root = JSONRowNodeBuilder.build( + columns: ["original_language_id"], + values: [.null], + columnTypes: [.integer(rawType: "INT")], + foreignKeys: [ + "original_language_id": JSONForeignKeyRef( + column: "original_language_id", + referencedTable: "language", + referencedSchema: nil, + referencedColumn: "language_id" + ), + ] + ) + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: JSONForeignKeyStates()) + #expect(try row(rows, "original_language_id").isExpandable == false) + } + + @Test("A fetched foreign key prints the row it references") + func printsFetchedForeignKey() throws { + let root = makeRoot(foreignKeys: ["language_id": reference]) + let keyPath = JSONNodePath.root.appending("language_id") + var states = JSONForeignKeyStates() + states.fetched[keyPath] = JSONRowNodeBuilder.build( + path: keyPath, + key: .name("language_id"), + columns: ["name"], + values: [.text("English")], + columnTypes: [.text(rawType: "CHAR")], + foreignKeys: [:] + ) + + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path, keyPath], states: states) + #expect(try row(rows, "language_id").token == .openObject) + let nested = try #require(rows.first { $0.path == keyPath.appending("name") }) + #expect(nested.token == .scalar(.string("English"))) + #expect(nested.depth == 2) + } + + @Test("A key being fetched reports as loading") + func reportsLoading() throws { + let root = makeRoot(foreignKeys: ["language_id": reference]) + var states = JSONForeignKeyStates() + states.loading.insert(JSONNodePath.root.appending("language_id")) + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: states) + #expect(try row(rows, "language_id").status == .loading) + } + + @Test("A key that could not be followed reports why") + func reportsFailure() throws { + let root = makeRoot(foreignKeys: ["language_id": reference]) + var states = JSONForeignKeyStates() + states.failures[JSONNodePath.root.appending("language_id")] = .cycle + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: states) + #expect(try row(rows, "language_id").status == .failure(.cycle)) + } + + @Test("A filter expands what it kept, whatever was collapsed before") + func filterExpandsMatches() throws { + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text("{\"inner\": \"found\"}")], + columnTypes: [.json(rawType: "JSON")], + foreignKeys: [:] + ) + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [:], + matcher: try #require(matcher("found")) + ) + let rows = JSONRowFlattener.rows(root: root, expanded: [], states: JSONForeignKeyStates(), visiblePaths: visible) + #expect(rows.contains { $0.token == .scalar(.string("found")) }) + #expect(rows.first?.token == .openObject) + } + + @Test("Expand All names every container, and no unfetched foreign key") + func expandAllSkipsUnfetchedKeys() { + let root = makeRoot(foreignKeys: ["language_id": reference]) + let paths = JSONRowFlattener.expandablePaths(root: root, states: JSONForeignKeyStates()) + #expect(paths == [root.path]) + } + + private func matcher(_ query: String) -> JSONRowMatcher? { + guard case .matcher(let matcher) = JSONRowMatcher.make(query: query) else { return nil } + return matcher + } +} diff --git a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift new file mode 100644 index 0000000000..867728ed42 --- /dev/null +++ b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift @@ -0,0 +1,226 @@ +// +// JSONRowNodeBuilderTests.swift +// TableProTests +// +// Whether a value prints quoted comes from the column's own type, not from the text. +// + +import Foundation +import TableProPluginKit +import Testing + +@testable import TablePro + +@Suite("JSONRowNodeBuilder") +struct JSONRowNodeBuilderTests { + private func reference(column: String, table: String = "language") -> JSONForeignKeyRef { + JSONForeignKeyRef( + column: column, + referencedTable: table, + referencedSchema: nil, + referencedColumn: "\(table)_id" + ) + } + + private func node(_ root: JSONRowNode, _ column: String) throws -> JSONRowNode { + try #require(root.children.first { $0.key == .name(column) }) + } + + @Test("The column type decides the scalar kind") + func typesScalars() throws { + let root = JSONRowNodeBuilder.build( + columns: ["film_id", "rental_rate", "title", "active", "last_update"], + values: [.text("2"), .text("4.99"), .text("ACE GOLDFINGER"), .text("true"), .text("2006-02-15 05:03:42")], + columnTypes: [ + .integer(rawType: "INT"), + .decimal(rawType: "NUMERIC(5,2)"), + .text(rawType: "VARCHAR"), + .boolean(rawType: "BOOL"), + .timestamp(rawType: "TIMESTAMP"), + ], + foreignKeys: [:] + ) + + #expect(try node(root, "film_id").scalar == .number("2")) + #expect(try node(root, "rental_rate").scalar == .number("4.99")) + #expect(try node(root, "title").scalar == .string("ACE GOLDFINGER")) + #expect(try node(root, "active").scalar == .bool(true)) + #expect(try node(root, "last_update").scalar == .string("2006-02-15 05:03:42")) + } + + @Test("A boolean column reads the spellings the drivers emit") + func typesBooleans() throws { + let root = JSONRowNodeBuilder.build( + columns: ["a", "b", "c"], + values: [.text("false"), .text("0"), .text("maybe")], + columnTypes: [ + .boolean(rawType: "BOOL"), + .boolean(rawType: "TINYINT(1)"), + .boolean(rawType: "BOOL"), + ], + foreignKeys: [:] + ) + #expect(try node(root, "a").scalar == .bool(false)) + #expect(try node(root, "b").scalar == .bool(false)) + #expect(try node(root, "c").scalar == .string("maybe")) + } + + @Test("An integer column holding text that is not a number stays a string") + func keepsUnparsableNumbersAsStrings() throws { + let root = JSONRowNodeBuilder.build( + columns: ["n"], + values: [.text("twelve")], + columnTypes: [.integer(rawType: "INT")], + foreignKeys: [:] + ) + #expect(try node(root, "n").scalar == .string("twelve")) + } + + @Test("An integer wider than a Double keeps its digits") + func preservesWideIntegers() throws { + let root = JSONRowNodeBuilder.build( + columns: ["n"], + values: [.text("9007199254740993")], + columnTypes: [.integer(rawType: "BIGINT")], + foreignKeys: [:] + ) + #expect(try node(root, "n").scalar == .number("9007199254740993")) + } + + @Test("NULL and binary values keep their own kinds") + func typesNullAndBinary() throws { + let root = JSONRowNodeBuilder.build( + columns: ["note", "thumb"], + values: [.null, .bytes(Data([0x4C, 0x65]))], + columnTypes: [.text(rawType: "TEXT"), .blob(rawType: "BLOB")], + foreignKeys: [:] + ) + #expect(try node(root, "note").scalar == .null) + #expect(try node(root, "thumb").scalar == .binary(Data([0x4C, 0x65]))) + } + + @Test("A JSON column expands into a subtree") + func expandsJsonColumns() throws { + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text("{\"a\": [1, 2], \"b\": null}")], + columnTypes: [.json(rawType: "JSONB")], + foreignKeys: [:] + ) + let payload = try node(root, "payload") + #expect(payload.isContainer) + #expect(payload.children.count == 2) + #expect(payload.children[0].children.map(\.scalar) == [.number("1"), .number("2")]) + #expect(payload.children[1].scalar == .null) + } + + @Test("A TEXT column holding a document expands too") + func expandsTextColumnsHoldingDocuments() throws { + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text("[\"Trailers\"]")], + columnTypes: [.text(rawType: "TEXT")], + foreignKeys: [:] + ) + let payload = try node(root, "payload") + #expect(payload.isContainer) + #expect(payload.children.map(\.scalar) == [.string("Trailers")]) + } + + @Test("A TEXT column holding ordinary prose stays a string") + func leavesProseAlone() throws { + let root = JSONRowNodeBuilder.build( + columns: ["description"], + values: [.text("A Epic Story of a Pastry Chef")], + columnTypes: [.text(rawType: "TEXT")], + foreignKeys: [:] + ) + #expect(try node(root, "description").scalar == .string("A Epic Story of a Pastry Chef")) + } + + @Test("A foreign key column becomes an expandable node carrying its value") + func marksForeignKeys() throws { + let root = JSONRowNodeBuilder.build( + columns: ["language_id"], + values: [.text("1")], + columnTypes: [.integer(rawType: "INT")], + foreignKeys: ["language_id": reference(column: "language_id")] + ) + let node = try node(root, "language_id") + #expect(node.foreignKey == reference(column: "language_id")) + #expect(node.scalar == .number("1")) + } + + @Test("A NULL foreign key still reports its reference, so the row can say there is none") + func marksNullForeignKeys() throws { + let root = JSONRowNodeBuilder.build( + columns: ["original_language_id"], + values: [.null], + columnTypes: [.integer(rawType: "INT")], + foreignKeys: ["original_language_id": reference(column: "original_language_id")] + ) + let node = try node(root, "original_language_id") + #expect(node.foreignKey != nil) + #expect(node.scalar == .null) + } + + @Test("A foreign key column is a key first, whatever its text looks like") + func foreignKeyBeatsDocumentParsing() throws { + let root = JSONRowNodeBuilder.build( + columns: ["ref"], + values: [.text("{\"a\": 1}")], + columnTypes: [.json(rawType: "JSON")], + foreignKeys: ["ref": reference(column: "ref")] + ) + let node = try node(root, "ref") + #expect(node.foreignKey != nil) + #expect(node.isContainer == false) + } + + @Test("A document past the scan cap stays a string") + func leavesOversizedDocumentsAlone() throws { + let oversized = "[" + String(repeating: "1,", count: JSONRowNodeBuilder.maxScannedDocumentLength) + "1]" + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text(oversized)], + columnTypes: [.json(rawType: "JSON")], + foreignKeys: [:] + ) + #expect(try node(root, "payload").isContainer == false) + } + + @Test("Broken JSON stays a string rather than becoming a partial tree") + func leavesBrokenDocumentsAlone() throws { + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text("{\"a\": 1,}")], + columnTypes: [.json(rawType: "JSON")], + foreignKeys: [:] + ) + #expect(try node(root, "payload").scalar == .string("{\"a\": 1,}")) + } + + @Test("A document's escapes and nested keys are decoded") + func decodesDocumentStrings() throws { + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text(#"{"a\u0041": "line\nbreak"}"#)], + columnTypes: [.json(rawType: "JSON")], + foreignKeys: [:] + ) + let payload = try node(root, "payload") + #expect(payload.children.first?.key == .name("aA")) + #expect(payload.children.first?.scalar == .string("line\nbreak")) + } + + @Test("A row with fewer values than columns reads the missing ones as NULL") + func toleratesShortRows() throws { + let root = JSONRowNodeBuilder.build( + columns: ["a", "b"], + values: [.text("1")], + columnTypes: [.integer(rawType: "INT")], + foreignKeys: [:] + ) + #expect(try node(root, "b").scalar == .null) + } +} diff --git a/TableProTests/Models/JSON/JSONRowTextRendererTests.swift b/TableProTests/Models/JSON/JSONRowTextRendererTests.swift new file mode 100644 index 0000000000..1e2769bcb7 --- /dev/null +++ b/TableProTests/Models/JSON/JSONRowTextRendererTests.swift @@ -0,0 +1,56 @@ +// +// JSONRowTextRendererTests.swift +// TableProTests +// +// Copy Visible writes the lines that are on screen, not the whole row. +// + +import Foundation +import TableProPluginKit +import Testing + +@testable import TablePro + +@Suite("JSONRowTextRenderer") +struct JSONRowTextRendererTests { + private func makeRoot() -> JSONRowNode { + JSONRowNodeBuilder.build( + columns: ["film_id", "title", "special_features", "note"], + values: [.text("2"), .text("ACE \"GOLDFINGER\""), .text("[\"Trailers\"]"), .null], + columnTypes: [ + .integer(rawType: "INT"), + .text(rawType: "VARCHAR"), + .json(rawType: "JSON"), + .text(rawType: "TEXT"), + ], + foreignKeys: [:] + ) + } + + @Test("Renders the expanded tree as JSON") + func rendersExpandedTree() { + let root = makeRoot() + let rows = JSONRowFlattener.rows( + root: root, + expanded: [root.path, JSONNodePath.root.appending("special_features")], + states: JSONForeignKeyStates() + ) + #expect(JSONRowTextRenderer.render(rows: rows) == """ + { + "film_id": 2, + "title": "ACE \\"GOLDFINGER\\"", + "special_features": [ + "Trailers" + ], + "note": null + } + """) + } + + @Test("A collapsed container prints as an ellipsis, the way it is shown") + func rendersCollapsedContainer() { + let root = makeRoot() + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: JSONForeignKeyStates()) + #expect(JSONRowTextRenderer.render(rows: rows).contains("\"special_features\": […],")) + } +} diff --git a/TableProUITests/JSONRowInspectorUITests.swift b/TableProUITests/JSONRowInspectorUITests.swift new file mode 100644 index 0000000000..df38bc2b54 --- /dev/null +++ b/TableProUITests/JSONRowInspectorUITests.swift @@ -0,0 +1,99 @@ +// +// JSONRowInspectorUITests.swift +// TableProUITests +// +// The JSON tab shows the selected row as JSON, and a foreign key in it fetches the row it +// references. Chinook's Album.ArtistId is the reference this drives. +// + +import AppKit +import XCTest + +final class JSONRowInspectorUITests: UITestCase { + func testShowRowAsJSONOpensTheInspectorOnTheJSONTab() throws { + let app = try launchWithSampleDatabase() + let window = try readyWindow(of: app) + let grid = try albumGrid(in: app, window: window) + + openRowAsJSON(in: app, grid: grid) + + XCTAssertTrue( + waitForPredicate(timeout: 20) { self.jsonTab(in: window).exists }, + "Show Row as JSON must reveal the inspector's JSON tab" + ) + XCTAssertTrue( + waitForPredicate(timeout: 20) { window.staticTexts["\"Title\""].exists }, + "The JSON tab must print the row's own keys; Album has a Title column" + ) + } + + func testExpandingAForeignKeyFetchesTheRowItReferences() throws { + let app = try launchWithSampleDatabase() + let window = try readyWindow(of: app) + let grid = try albumGrid(in: app, window: window) + + openRowAsJSON(in: app, grid: grid) + + /// Album's own keys hold no container, so the only closed disclosure in the tree is the + /// foreign key on ArtistId. Its expansion is a query, which is the whole point of the test. + let expand = window.buttons["Expand"] + XCTAssertTrue( + expand.waitToExist(timeout: 20), + "A foreign key column must offer a disclosure control of its own" + ) + clickAtCenter(expand) + + XCTAssertTrue( + waitForPredicate(timeout: 30) { window.staticTexts["\"Name\""].exists }, + "Expanding Album.ArtistId must fetch the Artist row, whose columns include Name" + ) + } + + // MARK: - Helpers + + private func readyWindow(of app: XCUIApplication) throws -> XCUIElement { + let window = app.windows.matching(NSPredicate(format: "identifier != %@", "welcome")).firstMatch + XCTAssertTrue(window.waitToExist(timeout: 60), "The sample database produced no window") + XCTAssertTrue( + waitForPredicate(timeout: 30) { window.outlines.firstMatch.outlineRows.count > 1 }, + "The object browser must list the sample database's tables" + ) + return window + } + + private func albumGrid(in app: XCUIApplication, window: XCUIElement) throws -> XCUIElement { + let row = window.outlines.firstMatch.staticTexts + .matching(NSPredicate(format: "value == %@", "Table: Album")) + .firstMatch + XCTAssertTrue(row.waitToExist(timeout: 20), "The object browser must list Album") + clickAtCenter(row) + + let grid = window.tables.matching(identifier: "data-grid").firstMatch + XCTAssertTrue(grid.waitToExist(timeout: 30), "Album produced no data grid") + XCTAssertTrue( + waitForPredicate(timeout: 30) { !grid.tableRows.allElementsBoundByIndex.isEmpty }, + "Album must load rows before a row can be inspected" + ) + return grid + } + + /// The grid publishes a column as a sibling of its rows, each as tall as every row it spans, so + /// XCUITest reads every row and cell as obscured and refuses to click one. A point offset from + /// the grid itself is the way in, which is what the drawn-cell grid's other suites do too. + private func openRowAsJSON(in app: XCUIApplication, grid: XCUIElement) { + let firstRow = grid.coordinate(withNormalizedOffset: .zero) + .withOffset(CGVector(dx: 60, dy: 12)) + firstRow.click() + Thread.sleep(forTimeInterval: NSEvent.doubleClickInterval) + firstRow.rightClick() + + let item = app.menuItems["Show Row as JSON"] + XCTAssertTrue(item.waitToExist(timeout: 15), "The row's context menu must offer Show Row as JSON") + item.click() + } + + /// The tab strip is a segmented control, which AppKit publishes as radio buttons. + private func jsonTab(in window: XCUIElement) -> XCUIElement { + window.radioButtons["JSON"] + } +} diff --git a/docs/features/data-grid.mdx b/docs/features/data-grid.mdx index 42a8606d00..e39699cc1f 100644 --- a/docs/features/data-grid.mdx +++ b/docs/features/data-grid.mdx @@ -50,6 +50,8 @@ Widths, order, and hidden columns are remembered per table, scoped to the connec A foreign key cell carries an arrow on its right edge. Click it to open the referenced table filtered to the matching row, or right-click for **Preview Referenced Row**, which shows that row in a popover. `Cmd`-click always opens a new tab; otherwise the reference takes over the current tab unless that tab holds a query or unsaved edits. +The inspector's **JSON** tab follows a key without leaving the row: see [Row as JSON](/features/json-viewer#row-as-json). + Step back with the Back and Forward buttons at the leading edge of the toolbar, or **View > Back** (`Ctrl+Cmd+[`) and **View > Forward** (`Ctrl+Cmd+]`). Back restores the table you came from as you left it: same filters, sort, page, and selected row. Each tab keeps its own history, Back never closes a tab, and it is unavailable while a tab holds unsaved edits. diff --git a/docs/features/json-viewer.mdx b/docs/features/json-viewer.mdx index 2c5983ca53..04ac8febcd 100644 --- a/docs/features/json-viewer.mdx +++ b/docs/features/json-viewer.mdx @@ -98,4 +98,18 @@ Right-click a field for its menu; an editable field also shows it on a hover but With no row selected, the inspector describes the table: data, index and total size, row count, average row size, engine, collation, and creation and update dates, as far as the database reports them. On a Structure tab it follows the structure grid. +## Row as JSON + +Right-click a row and choose **Show Row as JSON**, or open the inspector and pick its **JSON** tab. The row prints as one JSON object, keys in the grid's column order: numbers and booleans unquoted, NULL as `null`, binary as hex. A JSON column, and a text column holding a document, arrive as nested keys instead of as a string. + +A foreign key key carries a disclosure control. Click it and the referenced row is fetched and printed underneath; a foreign key inside that row expands the same way, five levels down. A key pointing back at a row already open in the tree, and one past the fifth level, carry a warning icon that says which. A NULL foreign key has no control. + +**Always Expand Foreign Keys**, in the options menu at the trailing end of the filter field, fetches the first level on every row selected from then on. It starts off and stays off until you turn it on, every session, since each key it follows is a query. The rest of that menu is **Copy Visible**, which puts the printed lines on the pasteboard as they stand, **Collapse All**, and **Expand All**. Long values wrap; nothing is truncated. + +The filter field takes text, or a regular expression wrapped in slashes such as `/^rental/`. It matches keys and values, keeps the keys that lead to a match, and opens what was collapsed. An invalid expression outlines the field in red and filters nothing. + +Editing stays on the **Details** tab. Right-click a line for **Copy Value** and **Copy Key**; a foreign key line adds **Open** for the referenced table, filtered to that row. + +Caps: a document over 100,000 characters prints as a string rather than as nested keys, the same cap the [JSON tree](#limits) has. + For whole-row JSON, switch the result to JSON mode with the switcher at the leading edge of the status bar, or from **View > Result View**. It shows what the [grid](/features/data-grid) shows, in the same order, minus hidden columns and rows marked for deletion, which the count line reports separately. Select rows in Data mode first to narrow it, then click **Copy JSON**. From 5fb074ec7f0f61946a75a38998789b81c7b21371 Mon Sep 17 00:00:00 2001 From: Nana Kwesi Ofosu-Aikins Date: Tue, 1 Sep 2026 08:05:19 +0000 Subject: [PATCH 2/8] perf(datagrid): resolve a field's editor once per selection instead of once per body pass --- CHANGELOG.md | 1 + TablePro/Models/UI/MultiRowEditState.swift | 19 +++++++++++++++++++ .../FieldEditors/FieldEditorContext.swift | 3 ++- .../Views/RightSidebar/RightSidebarView.swift | 2 +- .../FieldEditors/FieldEditorResolver.swift | 3 +++ 5 files changed, 26 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index faed9cea56..e329a5931c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -40,6 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed +- Lag switching the inspector's tabs, and on every hover over a field, on a row with long values. - Plugin download reporting no progress at all when a connection or a file needs a driver installed. - Parse error on any MongoDB filter written in shell syntax, such as `db.orders.find({status: 1})`. - MongoDB `.sort()` and `.projection()` silently ignored when written with unquoted keys. diff --git a/TablePro/Models/UI/MultiRowEditState.swift b/TablePro/Models/UI/MultiRowEditState.swift index 5d9061d81d..0d00005f47 100644 --- a/TablePro/Models/UI/MultiRowEditState.swift +++ b/TablePro/Models/UI/MultiRowEditState.swift @@ -25,6 +25,13 @@ struct FieldEditState: Identifiable { /// Set when the owning grid dictates the editor instead of the column type. var editor: FieldEditorKind? + /// Which editor the field's own type and value ask for, resolved once here. + /// + /// Resolving it costs a full `JSONSerialization` parse of the value and a PHP-serialized parse + /// after it, and `FieldEditorResolver` was reached from two view bodies per field. Every hover, + /// every inspector tab switch and every pending-edit keystroke re-parsed every value in the row. + var resolvedEditor: FieldEditorKind? + /// A schema field has no data type, so it offers no type badge and no NULL or DEFAULT state. var isSchemaField: Bool = false @@ -161,6 +168,11 @@ final class MultiRowEditState { if let preservedId { newField.id = preservedId } + newField.resolvedEditor = FieldEditorResolver.resolve( + for: columnTypeEnum, + isLongText: isLongText, + originalValue: originalValue + ) newFields.append(newField) } @@ -198,6 +210,13 @@ final class MultiRowEditState { if index < reusedIds.count { state.id = reusedIds[index] } + if field.editor == nil { + state.resolvedEditor = FieldEditorResolver.resolve( + for: .text(rawType: nil), + isLongText: false, + originalValue: field.value + ) + } return state } } diff --git a/TablePro/Views/RightSidebar/FieldEditors/FieldEditorContext.swift b/TablePro/Views/RightSidebar/FieldEditors/FieldEditorContext.swift index 043a3d4c99..c7dca4bb31 100644 --- a/TablePro/Views/RightSidebar/FieldEditors/FieldEditorContext.swift +++ b/TablePro/Views/RightSidebar/FieldEditors/FieldEditorContext.swift @@ -14,7 +14,8 @@ internal struct FieldEditorContext { let isReadOnly: Bool let commitBytes: ((Data) -> Void)? - /// Set when the owning grid dictates the editor instead of the column type. + /// The editor to build, already resolved by the caller. `FieldEditorResolver` falls back to the + /// column type and the value only when this is nil, and resolving costs a parse of the value. let editor: FieldEditorKind? /// A schema field has no NULL or DEFAULT state and no data type to badge. diff --git a/TablePro/Views/RightSidebar/RightSidebarView.swift b/TablePro/Views/RightSidebar/RightSidebarView.swift index ccaab708f7..6a252e98b5 100644 --- a/TablePro/Views/RightSidebar/RightSidebarView.swift +++ b/TablePro/Views/RightSidebar/RightSidebarView.swift @@ -350,7 +350,7 @@ struct RightSidebarView: View { hasMultipleValues: field.hasMultipleValues, isReadOnly: !isEditable || isPhpField, commitBytes: isEditable ? { data in editState.setFieldToBytes(at: index, data: data) } : nil, - editor: field.editor, + editor: kind, allowsNullAndDefault: !field.isSchemaField, showsTypeBadge: !field.isSchemaField ), diff --git a/TablePro/Views/Shared/FieldEditors/FieldEditorResolver.swift b/TablePro/Views/Shared/FieldEditors/FieldEditorResolver.swift index 08662b8640..722af5623b 100644 --- a/TablePro/Views/Shared/FieldEditors/FieldEditorResolver.swift +++ b/TablePro/Views/Shared/FieldEditors/FieldEditorResolver.swift @@ -6,8 +6,11 @@ import Foundation @MainActor internal enum FieldEditorResolver { + /// Answers from the field's own resolution when it has one. Only a field built before + /// `MultiRowEditState` filled it in pays the detectors here. static func resolve(field: FieldEditState) -> FieldEditorKind { if let editor = field.editor { return editor } + if let resolved = field.resolvedEditor { return resolved } return resolve( for: field.columnTypeEnum, isLongText: field.isLongText, From d3e5e32f79800fb03e957ecaea76abc55b69df55 Mon Sep 17 00:00:00 2001 From: Nana Kwesi Ofosu-Aikins Date: Tue, 1 Sep 2026 08:30:20 +0000 Subject: [PATCH 3/8] fix(datagrid): rebuild the JSON tree whenever the row it is showing changes, and give each column its own path --- .../Models/UI/JSON/JSONRowNodeBuilder.swift | 6 +- TablePro/Models/UI/JSON/JSONRowSnapshot.swift | 10 +-- .../JSONRowInspectorViewModel.swift | 42 ++++++----- .../Extensions/MainContentView+Bindings.swift | 5 -- .../Models/JSON/JSONRowFilterTests.swift | 36 ++++++---- .../Models/JSON/JSONRowFlattenerTests.swift | 16 +++-- .../Models/JSON/JSONRowNodeBuilderTests.swift | 16 +++++ .../JSON/JSONRowSnapshotChangeTests.swift | 69 +++++++++++++++++++ .../JSON/JSONRowTextRendererTests.swift | 2 +- 9 files changed, 154 insertions(+), 48 deletions(-) create mode 100644 TableProTests/Models/JSON/JSONRowSnapshotChangeTests.swift diff --git a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift index 0331f044d5..53418e24f3 100644 --- a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift +++ b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift @@ -25,7 +25,11 @@ enum JSONRowNodeBuilder { for (index, column) in columns.enumerated() { let value = index < values.count ? values[index] : .null let type = index < columnTypes.count ? columnTypes[index] : nil - let childPath = path.appending(column) + /// The column's position leads its path component, because a result set's labels are not + /// unique: an unaliased join selecting two `id` columns gives two of them. Sharing a path + /// gives the two nodes one id in the `ForEach` that draws them, and one entry in the + /// expanded set and the fetched-key map, so neither could be opened on its own. + let childPath = path.appending("\(index).\(column)") children.append( JSONRowNode( path: childPath, diff --git a/TablePro/Models/UI/JSON/JSONRowSnapshot.swift b/TablePro/Models/UI/JSON/JSONRowSnapshot.swift index 95bf909105..ee3cc62e72 100644 --- a/TablePro/Models/UI/JSON/JSONRowSnapshot.swift +++ b/TablePro/Models/UI/JSON/JSONRowSnapshot.swift @@ -12,11 +12,13 @@ import TableProPluginKit /// whether a value prints quoted from the column's type, and a string that arrived pre-formatted /// cannot answer that. struct JSONRowSnapshot: Equatable, Sendable { - /// Which row this is. A change here is a new selection, so expansions and fetched keys go. + /// Which row this is. A change here is a new selection, so the reader's expansions go too. + /// + /// Everything else is compared by value: the whole snapshot is the change test, because a + /// hand-written token of the parts that "matter" gets it wrong. One over the cells and the + /// column names read a late-arriving `columnForeignKeys` as no change at all, so a row selected + /// before the schema fetch landed kept a tree with no keys to expand until the selection moved. let rowIdentity: String - /// What the row holds. A change here is the same row reloaded, so the tree is rebuilt while - /// the reader's expansions stay where they were. - let contentToken: Int let columns: [String] let columnTypes: [ColumnType] let values: [PluginCellValue] diff --git a/TablePro/ViewModels/JSONRowInspectorViewModel.swift b/TablePro/ViewModels/JSONRowInspectorViewModel.swift index 6f7730a192..5b87e6d87e 100644 --- a/TablePro/ViewModels/JSONRowInspectorViewModel.swift +++ b/TablePro/ViewModels/JSONRowInspectorViewModel.swift @@ -23,8 +23,10 @@ final class JSONRowInspectorViewModel { private var expanded: Set = [] private var chains: [JSONNodePath: [JSONForeignKeyVisit]] = [:] private var fetches: [JSONNodePath: Task] = [:] - private var snapshotIdentity: String? - private var contentToken: Int? + private var lastSnapshot: JSONRowSnapshot? + /// Bumped by every rebuild and every reset. A fetch that returns after one discards itself, + /// because `Task.cancel()` cannot interrupt a query already in flight. + private var generation = 0 private var connectionId: UUID? private var databaseType: DatabaseType? @@ -49,16 +51,18 @@ final class JSONRowInspectorViewModel { connectionId = snapshot.connectionId databaseType = snapshot.databaseType - let isSameRow = snapshot.rowIdentity == snapshotIdentity - guard !isSameRow || snapshot.contentToken != contentToken else { return } + guard snapshot != lastSnapshot else { return } + let isSameRow = snapshot.rowIdentity == lastSnapshot?.rowIdentity + lastSnapshot = snapshot - if !isSameRow { - cancelFetches() - states = JSONForeignKeyStates() - chains = [:] - } - snapshotIdentity = snapshot.rowIdentity - contentToken = snapshot.contentToken + /// A fetched row is held against the key node's path, and a rerun or a refresh keeps a row's + /// identity while its values move under it. So any content change drops the fetched keys: + /// leaving them would print the row `artist_id = 1` referenced under a cell that now holds + /// `artist_id = 2`, which is a wrong row presented as this row's own. + cancelFetches() + states = JSONForeignKeyStates() + chains = [:] + generation += 1 let rebuilt = JSONRowNodeBuilder.build( columns: snapshot.columns, @@ -80,8 +84,8 @@ final class JSONRowInspectorViewModel { private func reset() { cancelFetches() - snapshotIdentity = nil - contentToken = nil + generation += 1 + lastSnapshot = nil root = nil expanded = [] chains = [:] @@ -224,9 +228,9 @@ final class JSONRowInspectorViewModel { states.failures.removeValue(forKey: path) states.loading.insert(path) - let identity = snapshotIdentity + let generation = generation fetches[path] = Task { [weak self] in - defer { self?.finishFetch(at: path, identity: identity) } + defer { self?.finishFetch(at: path, generation: generation) } do { let fetched = try await ForeignKeyRowFetcher.fetch( connectionId: connectionId, @@ -235,7 +239,7 @@ final class JSONRowInspectorViewModel { value: value, includeForeignKeys: true ) - guard let self, !Task.isCancelled, identity == self.snapshotIdentity else { return } + guard let self, !Task.isCancelled, generation == self.generation else { return } guard let fetched else { self.states.failures[path] = .notFound return @@ -243,7 +247,7 @@ final class JSONRowInspectorViewModel { self.adopt(fetched: fetched, at: path, reference: reference, chain: chain + [visit]) } catch { Self.logger.error("Foreign key expansion failed: \(error.localizedDescription)") - guard let self, !Task.isCancelled, identity == self.snapshotIdentity else { return } + guard let self, !Task.isCancelled, generation == self.generation else { return } self.states.failures[path] = .failed(String(localized: "Failed to load referenced row")) } } @@ -269,9 +273,9 @@ final class JSONRowInspectorViewModel { expandContainers(in: expansion) } - private func finishFetch(at path: JSONNodePath, identity: String?) { + private func finishFetch(at path: JSONNodePath, generation: Int) { fetches.removeValue(forKey: path) - guard identity == snapshotIdentity else { return } + guard generation == self.generation else { return } states.loading.remove(path) } diff --git a/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift b/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift index 3360e49196..9c3db0d004 100644 --- a/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift +++ b/TablePro/Views/Main/Extensions/MainContentView+Bindings.swift @@ -113,13 +113,8 @@ extension MainContentView { in: tableRows ) else { return nil } - var contentHasher = Hasher() - contentHasher.combine(row.values) - contentHasher.combine(tableRows.columns) - return JSONRowSnapshot( rowIdentity: "\(tab.id.uuidString)\u{001F}\(row.id)", - contentToken: contentHasher.finalize(), columns: tableRows.columns, columnTypes: tableRows.columnTypes, values: Array(row.values), diff --git a/TableProTests/Models/JSON/JSONRowFilterTests.swift b/TableProTests/Models/JSON/JSONRowFilterTests.swift index 9730a73b73..2cd5385309 100644 --- a/TableProTests/Models/JSON/JSONRowFilterTests.swift +++ b/TableProTests/Models/JSON/JSONRowFilterTests.swift @@ -22,6 +22,12 @@ struct JSONRowFilterTests { ) } + /// A column's path carries its position, so a test asks the tree where a key is rather than + /// spelling the path out. + private func path(of column: String, in root: JSONRowNode) throws -> JSONNodePath { + try #require(root.children.first { $0.key == .name(column) }).path + } + private func matcher(_ query: String) throws -> JSONRowMatcher { guard case .matcher(let matcher) = JSONRowMatcher.make(query: query) else { throw FilterTestError.notAMatcher @@ -41,23 +47,25 @@ struct JSONRowFilterTests { @Test("A key match keeps the key") func matchesKeys() throws { + let root = makeRoot() let visible = JSONRowFilter.visiblePaths( - root: makeRoot(), + root: root, fetchedForeignKeys: [:], matcher: try matcher("length") ) - #expect(visible.contains(JSONNodePath.root.appending("length"))) - #expect(visible.contains(JSONNodePath.root.appending("title")) == false) + #expect(visible.contains(try path(of: "length", in: root))) + #expect(visible.contains(try path(of: "title", in: root)) == false) } @Test("A value match keeps the key that holds it") func matchesValues() throws { + let root = makeRoot() let visible = JSONRowFilter.visiblePaths( - root: makeRoot(), + root: root, fetchedForeignKeys: [:], matcher: try matcher("savannah") ) - #expect(visible.contains(JSONNodePath.root.appending("title"))) + #expect(visible.contains(try path(of: "title", in: root))) } @Test("A nested match keeps its ancestors") @@ -69,19 +77,20 @@ struct JSONRowFilterTests { matcher: try matcher("Deleted") ) #expect(visible.contains(root.path)) - #expect(visible.contains(JSONNodePath.root.appending("special_features"))) - #expect(visible.contains(JSONNodePath.root.appending("title")) == false) + #expect(visible.contains(try path(of: "special_features", in: root))) + #expect(visible.contains(try path(of: "title", in: root)) == false) } @Test("Slashes make the query a regular expression") func readsRegex() throws { + let root = makeRoot() let visible = JSONRowFilter.visiblePaths( - root: makeRoot(), + root: root, fetchedForeignKeys: [:], matcher: try matcher("/^len/") ) - #expect(visible.contains(JSONNodePath.root.appending("length"))) - #expect(visible.contains(JSONNodePath.root.appending("title")) == false) + #expect(visible.contains(try path(of: "length", in: root))) + #expect(visible.contains(try path(of: "title", in: root)) == false) } @Test("A broken regular expression is reported, not treated as text") @@ -103,7 +112,7 @@ struct JSONRowFilterTests { fetchedForeignKeys: [:], matcher: try matcher("a/b") ) - #expect(visible.contains(JSONNodePath.root.appending("path"))) + #expect(visible.contains(try path(of: "path", in: root))) } @Test("A fetched foreign key's own keys are searched") @@ -120,7 +129,7 @@ struct JSONRowFilterTests { columnTypes: [.integer(rawType: "INT")], foreignKeys: ["language_id": reference] ) - let keyPath = JSONNodePath.root.appending("language_id") + let keyPath = try path(of: "language_id", in: root) let expansion = JSONRowNodeBuilder.build( path: keyPath, key: .name("language_id"), @@ -135,7 +144,8 @@ struct JSONRowFilterTests { fetchedForeignKeys: [keyPath: expansion], matcher: try matcher("English") ) - #expect(visible.contains(keyPath.appending("name"))) + let nestedPath = try #require(expansion.children.first).path + #expect(visible.contains(nestedPath)) #expect(visible.contains(keyPath)) } } diff --git a/TableProTests/Models/JSON/JSONRowFlattenerTests.swift b/TableProTests/Models/JSON/JSONRowFlattenerTests.swift index 9fc4e81ad2..b6956398e8 100644 --- a/TableProTests/Models/JSON/JSONRowFlattenerTests.swift +++ b/TableProTests/Models/JSON/JSONRowFlattenerTests.swift @@ -30,7 +30,12 @@ struct JSONRowFlattenerTests { } private func row(_ rows: [JSONDisplayRow], _ column: String) throws -> JSONDisplayRow { - try #require(rows.first { $0.path == JSONNodePath.root.appending(column) }) + try #require(rows.first { $0.key == .name(column) && $0.token != .closeObject }) + } + + /// A column's path carries its position, so a test asks the tree for it. + private func path(of column: String, in root: JSONRowNode) throws -> JSONNodePath { + try #require(root.children.first { $0.key == .name(column) }).path } @Test("An expanded root prints its braces around its keys") @@ -92,7 +97,7 @@ struct JSONRowFlattenerTests { @Test("A fetched foreign key prints the row it references") func printsFetchedForeignKey() throws { let root = makeRoot(foreignKeys: ["language_id": reference]) - let keyPath = JSONNodePath.root.appending("language_id") + let keyPath = try path(of: "language_id", in: root) var states = JSONForeignKeyStates() states.fetched[keyPath] = JSONRowNodeBuilder.build( path: keyPath, @@ -105,7 +110,8 @@ struct JSONRowFlattenerTests { let rows = JSONRowFlattener.rows(root: root, expanded: [root.path, keyPath], states: states) #expect(try row(rows, "language_id").token == .openObject) - let nested = try #require(rows.first { $0.path == keyPath.appending("name") }) + let nestedPath = try #require(states.fetched[keyPath]?.children.first).path + let nested = try #require(rows.first { $0.path == nestedPath }) #expect(nested.token == .scalar(.string("English"))) #expect(nested.depth == 2) } @@ -114,7 +120,7 @@ struct JSONRowFlattenerTests { func reportsLoading() throws { let root = makeRoot(foreignKeys: ["language_id": reference]) var states = JSONForeignKeyStates() - states.loading.insert(JSONNodePath.root.appending("language_id")) + states.loading.insert(try path(of: "language_id", in: root)) let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: states) #expect(try row(rows, "language_id").status == .loading) } @@ -123,7 +129,7 @@ struct JSONRowFlattenerTests { func reportsFailure() throws { let root = makeRoot(foreignKeys: ["language_id": reference]) var states = JSONForeignKeyStates() - states.failures[JSONNodePath.root.appending("language_id")] = .cycle + states.failures[try path(of: "language_id", in: root)] = .cycle let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: states) #expect(try row(rows, "language_id").status == .failure(.cycle)) } diff --git a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift index 867728ed42..8c0edb0dc7 100644 --- a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift +++ b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift @@ -213,6 +213,22 @@ struct JSONRowNodeBuilderTests { #expect(payload.children.first?.scalar == .string("line\nbreak")) } + @Test("Two columns with the same label get their own nodes") + func separatesDuplicateColumnLabels() throws { + let root = JSONRowNodeBuilder.build( + columns: ["id", "name", "id"], + values: [.text("1"), .text("Album"), .text("7")], + columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT"), .integer(rawType: "INT")], + foreignKeys: [:] + ) + + let paths = Set(root.children.map(\.path)) + #expect(paths.count == root.children.count) + #expect(root.children.map(\.key) == [.name("id"), .name("name"), .name("id")]) + #expect(root.children[0].scalar == .number("1")) + #expect(root.children[2].scalar == .number("7")) + } + @Test("A row with fewer values than columns reads the missing ones as NULL") func toleratesShortRows() throws { let root = JSONRowNodeBuilder.build( diff --git a/TableProTests/Models/JSON/JSONRowSnapshotChangeTests.swift b/TableProTests/Models/JSON/JSONRowSnapshotChangeTests.swift new file mode 100644 index 0000000000..db09f4e26c --- /dev/null +++ b/TableProTests/Models/JSON/JSONRowSnapshotChangeTests.swift @@ -0,0 +1,69 @@ +// +// JSONRowSnapshotChangeTests.swift +// TableProTests +// +// What counts as a change to the row the JSON tab is showing. A hand-written token over the +// parts that seemed to matter read a late foreign key fetch as no change, and read a rerun that +// moved a row's values as no reason to drop the rows fetched for its keys. +// + +import Foundation +import TableProPluginKit +import Testing + +@testable import TablePro + +@Suite("JSONRowSnapshot change detection") +struct JSONRowSnapshotChangeTests { + private let reference = JSONForeignKeyRef( + column: "ArtistId", + referencedTable: "Artist", + referencedSchema: nil, + referencedColumn: "ArtistId" + ) + + private func snapshot( + rowIdentity: String = "tab\u{001F}existing(0)", + values: [PluginCellValue] = [.text("1"), .text("2")], + columnTypes: [ColumnType] = [.integer(rawType: "INT"), .integer(rawType: "INT")], + foreignKeys: [String: JSONForeignKeyRef] = [:] + ) -> JSONRowSnapshot { + JSONRowSnapshot( + rowIdentity: rowIdentity, + columns: ["AlbumId", "ArtistId"], + columnTypes: columnTypes, + values: values, + foreignKeys: foreignKeys, + connectionId: UUID(uuidString: "00000000-0000-0000-0000-0000000000AA") ?? UUID(), + databaseType: .sqlite + ) + } + + @Test("Foreign keys arriving after the row is on screen is a change") + func foreignKeyMetadataIsAChange() { + #expect(snapshot() != snapshot(foreignKeys: ["ArtistId": reference])) + } + + @Test("Column types arriving after the row is on screen is a change") + func columnTypesAreAChange() { + #expect(snapshot() != snapshot(columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")])) + } + + @Test("The same row with a different value is a change") + func movedValuesAreAChange() { + #expect(snapshot() != snapshot(values: [.text("1"), .text("3")])) + } + + @Test("The same row unchanged is not a change") + func identicalSnapshotsMatch() { + #expect(snapshot() == snapshot()) + } + + @Test("A rerun keeps a row's identity, so identity alone cannot answer the question") + func identityOutlivesTheValues() { + let before = snapshot(values: [.text("1"), .text("1")]) + let after = snapshot(values: [.text("1"), .text("2")]) + #expect(before.rowIdentity == after.rowIdentity) + #expect(before != after) + } +} diff --git a/TableProTests/Models/JSON/JSONRowTextRendererTests.swift b/TableProTests/Models/JSON/JSONRowTextRendererTests.swift index 1e2769bcb7..b083a1cc85 100644 --- a/TableProTests/Models/JSON/JSONRowTextRendererTests.swift +++ b/TableProTests/Models/JSON/JSONRowTextRendererTests.swift @@ -32,7 +32,7 @@ struct JSONRowTextRendererTests { let root = makeRoot() let rows = JSONRowFlattener.rows( root: root, - expanded: [root.path, JSONNodePath.root.appending("special_features")], + expanded: [root.path, root.children[2].path], states: JSONForeignKeyStates() ) #expect(JSONRowTextRenderer.render(rows: rows) == """ From e5359237cf8768223bf34b3ea42fe0e6ee569130 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Tue, 1 Sep 2026 19:22:14 +0700 Subject: [PATCH 4/8] fix(datagrid): correct what the JSON row inspector prints, filters and copies --- CHANGELOG.md | 1 + TablePro/Models/UI/JSON/JSONDisplayRow.swift | 4 ++ TablePro/Models/UI/JSON/JSONRowFilter.swift | 21 +++++++- .../Models/UI/JSON/JSONRowFlattener.swift | 3 ++ .../Models/UI/JSON/JSONRowNodeBuilder.swift | 12 +++-- TablePro/Models/UI/JSON/JSONScalarText.swift | 28 +++++++--- .../RightSidebar/JSON/JSONNodeRowView.swift | 13 ++--- .../Models/JSON/JSONRowFilterTests.swift | 38 +++++++++++++ .../Models/JSON/JSONRowFlattenerTests.swift | 29 ++++++++++ .../Models/JSON/JSONRowNodeBuilderTests.swift | 34 ++++++++++++ .../Models/JSON/JSONScalarTextTests.swift | 53 +++++++++++++++++++ 11 files changed, 214 insertions(+), 22 deletions(-) create mode 100644 TableProTests/Models/JSON/JSONScalarTextTests.swift diff --git a/CHANGELOG.md b/CHANGELOG.md index 258144ed82..8af5554122 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,6 +41,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed +- Row inspector lag on hover, on a tab switch and on every keystroke, from re-parsing each field's value. - The data grid's row commands on a column's right-click menu in Structure, when the column was already selected. - Wrong keyboard shortcuts shown beside Copy Name and Duplicate in the Structure right-click menu. - Plugin download reporting no progress at all when a connection or a file needs a driver installed. diff --git a/TablePro/Models/UI/JSON/JSONDisplayRow.swift b/TablePro/Models/UI/JSON/JSONDisplayRow.swift index bf2ed35a48..f74d3488de 100644 --- a/TablePro/Models/UI/JSON/JSONDisplayRow.swift +++ b/TablePro/Models/UI/JSON/JSONDisplayRow.swift @@ -43,6 +43,10 @@ struct JSONDisplayRow: Identifiable, Equatable, Sendable { let key: JSONNodeKey let token: Token let needsComma: Bool + /// The node's own value, carried beside the token rather than read out of it. An expanded + /// foreign key draws as `{`, and taking the value from the token alone took Copy Value and + /// Open off the line the moment it was opened. + let scalar: JSONScalar? let foreignKey: JSONForeignKeyRef? let isExpandable: Bool let isExpanded: Bool diff --git a/TablePro/Models/UI/JSON/JSONRowFilter.swift b/TablePro/Models/UI/JSON/JSONRowFilter.swift index d14d6ca899..196b623534 100644 --- a/TablePro/Models/UI/JSON/JSONRowFilter.swift +++ b/TablePro/Models/UI/JSON/JSONRowFilter.swift @@ -76,13 +76,32 @@ enum JSONRowFilter { } } - if subtreeMatched || matches(node, matcher: matcher) { + /// A key that matches keeps what it holds. Keeping the container alone left it drawn as + /// `{…}` with a disclosure control that could not open it, because a filtered tree takes + /// its expansion from what survived the filter rather than from the reader's expanded set. + if matches(node, matcher: matcher) { + insertSubtree(node, fetched: fetched, into: &visible) + return true + } + + if subtreeMatched { visible.insert(node.path) return true } return false } + private static func insertSubtree( + _ node: JSONRowNode, + fetched: [JSONNodePath: JSONRowNode], + into visible: inout Set + ) { + visible.insert(node.path) + for child in children(of: node, fetched: fetched) { + insertSubtree(child, fetched: fetched, into: &visible) + } + } + static func children(of node: JSONRowNode, fetched: [JSONNodePath: JSONRowNode]) -> [JSONRowNode] { if node.foreignKey != nil, let expansion = fetched[node.path] { return expansion.children diff --git a/TablePro/Models/UI/JSON/JSONRowFlattener.swift b/TablePro/Models/UI/JSON/JSONRowFlattener.swift index c6e9672cfb..c20f31f890 100644 --- a/TablePro/Models/UI/JSON/JSONRowFlattener.swift +++ b/TablePro/Models/UI/JSON/JSONRowFlattener.swift @@ -75,6 +75,7 @@ enum JSONRowFlattener { key: node.key, token: collapsedToken(for: node, childCount: children.count), needsComma: needsComma, + scalar: node.scalar, foreignKey: node.foreignKey, isExpandable: isExpandable(node, states: states), isExpanded: false, @@ -95,6 +96,7 @@ enum JSONRowFlattener { key: node.key, token: isArray ? .openArray : .openObject, needsComma: false, + scalar: node.scalar, foreignKey: node.foreignKey, isExpandable: true, isExpanded: true, @@ -122,6 +124,7 @@ enum JSONRowFlattener { key: node.key, token: isArray ? .closeArray : .closeObject, needsComma: needsComma, + scalar: nil, foreignKey: nil, isExpandable: false, isExpanded: true, diff --git a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift index 53418e24f3..9c1ce7099a 100644 --- a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift +++ b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift @@ -79,14 +79,16 @@ enum JSONRowNodeBuilder { /// /// The parse is `JsonSyntaxParser`, the same one the JSON cell viewer reads with, so a document /// cannot render one way in a cell and another in the row. + /// + /// A top-level scalar is kept rather than dropped. `42`, `true`, `null` and `"text"` are all + /// valid JSON documents, and a declared JSON column is allowed to hold one; handing them back + /// to the column-type path printed the number as a string and the string with its own quotes + /// still on. The gate below means only a JSON column ever reaches that case: any other column + /// has to start with a brace or a bracket to be parsed at all. private static func parsedDocument(_ text: String, type: ColumnType?) -> JsonSyntaxNode? { guard (text as NSString).length <= maxScannedDocumentLength else { return nil } if type?.isJsonType != true, !looksLikeDocument(text) { return nil } - guard let parsed = JsonSyntaxParser.parse(text) else { return nil } - switch parsed { - case .object, .array: return parsed - case .string, .number, .literal: return nil - } + return JsonSyntaxParser.parse(text) } /// A cell holding `42` is a number column, not a JSON document, and treating it as one would diff --git a/TablePro/Models/UI/JSON/JSONScalarText.swift b/TablePro/Models/UI/JSON/JSONScalarText.swift index a600acf80e..4f2346a651 100644 --- a/TablePro/Models/UI/JSON/JSONScalarText.swift +++ b/TablePro/Models/UI/JSON/JSONScalarText.swift @@ -15,18 +15,21 @@ enum JSONScalarText { case .number(let literal): literal case .bool(let flag): flag ? "true" : "false" case .null: "null" - case .binary(let data): hex(data) + case .binary(let data): "\"\(hex(data, limit: maxDisplayedHexBytes))\"" } } /// The value without its quotes, which is what Copy Value puts on the pasteboard. + /// + /// A blob prints in full here even though the line on screen stops at + /// `maxDisplayedHexBytes`: what the pasteboard carries is the value, not the rendering of it. static func unquoted(_ scalar: JSONScalar) -> String { switch scalar { case .string(let text): text case .number(let literal): literal case .bool(let flag): flag ? "true" : "false" case .null: "NULL" - case .binary(let data): hex(data) + case .binary(let data): hex(data, limit: nil) } } @@ -51,9 +54,22 @@ enum JSONScalarText { return output } - private static func hex(_ data: Data) -> String { - let latin1 = String(data: data, encoding: .isoLatin1) ?? "" - guard let formatted = latin1.formattedAsCompactHex() else { return "\"\"" } - return "\"\(formatted)\"" + /// How much of a blob a printed line carries. A column holding a megabyte of image data is not + /// a value anyone reads byte by byte, and laying the whole of it out as one line costs more + /// than the reader gets back. + static let maxDisplayedHexBytes = 64 + + private static let hexDigits = Array("0123456789ABCDEF") + + private static func hex(_ data: Data, limit: Int?) -> String { + let shown = limit.map { data.prefix($0) } ?? data[...] + var output = "0x" + output.reserveCapacity(shown.count * 2 + 3) + for byte in shown { + output.append(hexDigits[Int(byte >> 4)]) + output.append(hexDigits[Int(byte & 0x0F)]) + } + if let limit, data.count > limit { output.append("…") } + return output } } diff --git a/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift b/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift index ec3607d979..d7f885f7c3 100644 --- a/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift +++ b/TablePro/Views/RightSidebar/JSON/JSONNodeRowView.swift @@ -58,7 +58,7 @@ struct JSONNodeRowView: View { private var content: some View { HStack(alignment: .firstTextBaseline, spacing: 0) { if row.showsKey, let key = row.key.text { - Text("\"\(key)\"") + Text("\"\(JSONScalarText.escaped(key))\"") .font(valueFont) .foregroundStyle(colors.key) .lineLimit(1) @@ -154,7 +154,7 @@ struct JSONNodeRowView: View { @ViewBuilder private var menu: some View { - if let scalar = row.scalarValue { + if let scalar = row.scalar { Button(String(localized: "Copy Value")) { copy(JSONScalarText.unquoted(scalar)) } @@ -164,7 +164,7 @@ struct JSONNodeRowView: View { copy(key) } } - if let reference = row.foreignKey, let scalar = row.scalarValue, scalar != .null { + if let reference = row.foreignKey, let scalar = row.scalar, scalar != .null { Divider() Button(String(format: String(localized: "Open %@"), reference.qualifiedTable)) { onOpenReferencedTable(reference, JSONScalarText.unquoted(scalar)) @@ -178,10 +178,3 @@ struct JSONNodeRowView: View { pasteboard.setString(text, forType: .string) } } - -private extension JSONDisplayRow { - var scalarValue: JSONScalar? { - guard case .scalar(let scalar) = token else { return nil } - return scalar - } -} diff --git a/TableProTests/Models/JSON/JSONRowFilterTests.swift b/TableProTests/Models/JSON/JSONRowFilterTests.swift index 2cd5385309..b85add6e3a 100644 --- a/TableProTests/Models/JSON/JSONRowFilterTests.swift +++ b/TableProTests/Models/JSON/JSONRowFilterTests.swift @@ -148,4 +148,42 @@ struct JSONRowFilterTests { #expect(visible.contains(nestedPath)) #expect(visible.contains(keyPath)) } + + /// A container whose own key matches keeps what it holds. Keeping the container alone drew it + /// as `{…}` with a disclosure control that could not open it, because a filtered tree takes its + /// expansion from what survived the filter. + @Test("A container whose key matches keeps its whole subtree") + func matchedContainerKeepsItsContents() throws { + let root = makeRoot() + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [:], + matcher: try matcher("special_features") + ) + + let containerPath = try path(of: "special_features", in: root) + let container = try #require(root.children.first { $0.path == containerPath }) + #expect(visible.contains(containerPath)) + #expect(container.children.allSatisfy { visible.contains($0.path) }) + } + + @Test("A matched container prints open, not as a collapsed placeholder") + func matchedContainerPrintsExpanded() throws { + let root = makeRoot() + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [:], + matcher: try matcher("special_features") + ) + let rows = JSONRowFlattener.rows( + root: root, + expanded: [root.path], + states: JSONForeignKeyStates(), + visiblePaths: visible + ) + + let container = try #require(rows.first { $0.key == .name("special_features") }) + #expect(container.token == .openArray) + #expect(container.isExpanded) + } } diff --git a/TableProTests/Models/JSON/JSONRowFlattenerTests.swift b/TableProTests/Models/JSON/JSONRowFlattenerTests.swift index b6956398e8..34a883d304 100644 --- a/TableProTests/Models/JSON/JSONRowFlattenerTests.swift +++ b/TableProTests/Models/JSON/JSONRowFlattenerTests.swift @@ -163,4 +163,33 @@ struct JSONRowFlattenerTests { guard case .matcher(let matcher) = JSONRowMatcher.make(query: query) else { return nil } return matcher } + + /// An expanded foreign key draws as `{`, and reading its value out of the token alone took + /// Copy Value and Open off the line the moment the reader opened it. + @Test("An expanded foreign key line still carries the value it was opened from") + func expandedForeignKeyKeepsItsScalar() throws { + let root = makeRoot(foreignKeys: ["language_id": reference]) + let keyPath = try path(of: "language_id", in: root) + var states = JSONForeignKeyStates() + states.fetched[keyPath] = JSONRowNodeBuilder.build( + path: keyPath, + key: .name("language_id"), + columns: ["name"], + values: [.text("English")], + columnTypes: [.text(rawType: "CHAR")], + foreignKeys: [:] + ) + + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path, keyPath], states: states) + let opened = try #require(rows.first { $0.path == keyPath && $0.token == .openObject }) + #expect(opened.scalar == .number("1")) + #expect(opened.foreignKey == reference) + } + + @Test("A collapsed foreign key carries the same value the expanded one does") + func collapsedForeignKeyCarriesItsScalar() throws { + let root = makeRoot(foreignKeys: ["language_id": reference]) + let rows = JSONRowFlattener.rows(root: root, expanded: [root.path], states: JSONForeignKeyStates()) + #expect(try row(rows, "language_id").scalar == .number("1")) + } } diff --git a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift index 8c0edb0dc7..754120bc94 100644 --- a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift +++ b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift @@ -239,4 +239,38 @@ struct JSONRowNodeBuilderTests { ) #expect(try node(root, "b").scalar == .null) } + + /// `42`, `true`, `null` and `"text"` are whole JSON documents, and a JSON column is allowed to + /// hold one. Handing them back to the column-type path printed the number as a string and left + /// the string literal's own quotes inside the printed quotes. + @Test("A JSON column holding a top-level scalar keeps that scalar's kind") + func keepsJsonScalarDocuments() throws { + let root = JSONRowNodeBuilder.build( + columns: ["count", "flag", "missing", "label"], + values: [.text("42"), .text("true"), .text("null"), .text("\"ready\"")], + columnTypes: [ + .json(rawType: "JSON"), + .json(rawType: "JSON"), + .json(rawType: "JSON"), + .json(rawType: "JSON"), + ], + foreignKeys: [:] + ) + + #expect(try node(root, "count").scalar == .number("42")) + #expect(try node(root, "flag").scalar == .bool(true)) + #expect(try node(root, "missing").scalar == .null) + #expect(try node(root, "label").scalar == .string("ready")) + } + + @Test("A text column holding a bare number stays a string, because it is not a document") + func leavesNonJsonTextAlone() throws { + let root = JSONRowNodeBuilder.build( + columns: ["note"], + values: [.text("42")], + columnTypes: [.text(rawType: "VARCHAR")], + foreignKeys: [:] + ) + #expect(try node(root, "note").scalar == .string("42")) + } } diff --git a/TableProTests/Models/JSON/JSONScalarTextTests.swift b/TableProTests/Models/JSON/JSONScalarTextTests.swift new file mode 100644 index 0000000000..6bd2986b8f --- /dev/null +++ b/TableProTests/Models/JSON/JSONScalarTextTests.swift @@ -0,0 +1,53 @@ +// +// JSONScalarTextTests.swift +// TableProTests +// +// What a printed line carries and what Copy Value carries are not the same thing for a blob. +// + +import Foundation +import Testing + +@testable import TablePro + +@Suite("JSONScalarText") +struct JSONScalarTextTests { + private let sample = Data((0..<200).map { UInt8($0 % 256) }) + + @Test("A printed blob is quoted and stops at the display cap") + func printedBlobIsCapped() { + let printed = JSONScalarText.printed(.binary(sample)) + #expect(printed.hasPrefix("\"0x")) + #expect(printed.hasSuffix("…\"")) + #expect(printed.contains("0x000102")) + } + + /// Copy Value puts the value on the pasteboard, so it carries every byte and no quotes. Both + /// were wrong: the clipboard used to receive the truncated hex with the printed quotes still + /// wrapped around it, which round-trips as neither the blob nor valid JSON. + @Test("Copy Value carries the whole blob, unquoted") + func unquotedBlobIsComplete() { + let copied = JSONScalarText.unquoted(.binary(sample)) + #expect(copied.hasPrefix("0x")) + #expect(!copied.contains("\"")) + #expect(!copied.contains("…")) + #expect(copied.count == 2 + sample.count * 2) + } + + @Test("A blob shorter than the cap prints without an ellipsis") + func shortBlobIsNotMarkedTruncated() { + let printed = JSONScalarText.printed(.binary(Data([0x4C, 0x65]))) + #expect(printed == "\"0x4C65\"") + } + + @Test("An empty blob prints as an empty hex value rather than as an empty string") + func emptyBlob() { + #expect(JSONScalarText.unquoted(.binary(Data())) == "0x") + } + + @Test("A string is escaped when printed and raw when copied") + func stringEscaping() { + #expect(JSONScalarText.printed(.string("a\"b\nc")) == "\"a\\\"b\\nc\"") + #expect(JSONScalarText.unquoted(.string("a\"b\nc")) == "a\"b\nc") + } +} From feec455c94bd5447a7256685ba7c67c95e2005be Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Tue, 1 Sep 2026 19:22:18 +0700 Subject: [PATCH 5/8] fix(datagrid): keep a foreign key fetch that replaced a cancelled one cancellable --- .../JSONRowInspectorViewModel.swift | 47 +++- .../Main/Child/DataTabGridDelegate.swift | 8 +- .../JSONRowInspectorViewModelTests.swift | 232 ++++++++++++++++++ 3 files changed, 277 insertions(+), 10 deletions(-) create mode 100644 TableProTests/ViewModels/JSONRowInspectorViewModelTests.swift diff --git a/TablePro/ViewModels/JSONRowInspectorViewModel.swift b/TablePro/ViewModels/JSONRowInspectorViewModel.swift index 5b87e6d87e..fe20a414e5 100644 --- a/TablePro/ViewModels/JSONRowInspectorViewModel.swift +++ b/TablePro/ViewModels/JSONRowInspectorViewModel.swift @@ -9,6 +9,15 @@ import AppKit import Foundation import os +/// The referenced-row lookup a foreign key expansion runs, held as a value so a test can drive the +/// model's cancellation and generation rules without a database behind it. +typealias JSONForeignKeyRowFetch = @MainActor ( + _ connectionId: UUID, + _ databaseType: DatabaseType, + _ reference: JSONForeignKeyRef, + _ value: String +) async throws -> ForeignKeyRowFetcher.FetchedRow? + @MainActor @Observable final class JSONRowInspectorViewModel { @@ -29,9 +38,29 @@ final class JSONRowInspectorViewModel { private var generation = 0 private var connectionId: UUID? private var databaseType: DatabaseType? + @ObservationIgnored private let fetchRow: JSONForeignKeyRowFetch private static let logger = Logger(subsystem: "com.TablePro", category: "JSONRowInspector") + init(fetchRow: @escaping JSONForeignKeyRowFetch = JSONRowInspectorViewModel.fetchThroughDatabase) { + self.fetchRow = fetchRow + } + + private static func fetchThroughDatabase( + connectionId: UUID, + databaseType: DatabaseType, + reference: JSONForeignKeyRef, + value: String + ) async throws -> ForeignKeyRowFetcher.FetchedRow? { + try await ForeignKeyRowFetcher.fetch( + connectionId: connectionId, + databaseType: databaseType, + reference: reference, + value: value, + includeForeignKeys: true + ) + } + // MARK: - Lifecycle /// Drops the tree and every fetched row on disconnect, the way the chat and the edit state do. @@ -232,13 +261,8 @@ final class JSONRowInspectorViewModel { fetches[path] = Task { [weak self] in defer { self?.finishFetch(at: path, generation: generation) } do { - let fetched = try await ForeignKeyRowFetcher.fetch( - connectionId: connectionId, - databaseType: databaseType, - reference: reference, - value: value, - includeForeignKeys: true - ) + guard let fetch = self?.fetchRow else { return } + let fetched = try await fetch(connectionId, databaseType, reference, value) guard let self, !Task.isCancelled, generation == self.generation else { return } guard let fetched else { self.states.failures[path] = .notFound @@ -273,9 +297,16 @@ final class JSONRowInspectorViewModel { expandContainers(in: expansion) } + /// A fetch from an earlier generation cleans up nothing. + /// + /// `cancelFetches()` already dropped its handle, and `Task.cancel()` cannot interrupt a query + /// blocked in the driver, so a cancelled fetch still returns, late. Removing its path + /// unconditionally deleted the handle of the fetch the rebuilt tree had started at the same + /// path: that one could no longer be cancelled, and the next click on the key started a + /// second query for it. private func finishFetch(at path: JSONNodePath, generation: Int) { - fetches.removeValue(forKey: path) guard generation == self.generation else { return } + fetches.removeValue(forKey: path) states.loading.remove(path) } diff --git a/TablePro/Views/Main/Child/DataTabGridDelegate.swift b/TablePro/Views/Main/Child/DataTabGridDelegate.swift index 8c84be9eea..c4057d8d93 100644 --- a/TablePro/Views/Main/Child/DataTabGridDelegate.swift +++ b/TablePro/Views/Main/Child/DataTabGridDelegate.swift @@ -88,8 +88,12 @@ final class DataTabGridDelegate: DataGridViewDelegate { coordinator?.navigateToFKReference(value: value, fkInfo: fkInfo, openInNewTab: openInNewTab) } - /// The table view has already retargeted the selection to the clicked row by the time a context - /// menu item fires, so the panel reads the row the reader asked about without being told which. + /// The panel reads the selection, not a row this is told about. + /// + /// `KeyHandlingTableView.menu(for:)` retargets the selection to a row clicked outside it, so + /// the usual single-row case shows the row the reader asked about. A click inside a multi-row + /// selection keeps that selection on purpose, and the panel then shows its first row, which is + /// the row the Details tab shows too. func dataGridShowRowAsJSON() { coordinator?.showJSONPanel() } diff --git a/TableProTests/ViewModels/JSONRowInspectorViewModelTests.swift b/TableProTests/ViewModels/JSONRowInspectorViewModelTests.swift new file mode 100644 index 0000000000..6bedd98e87 --- /dev/null +++ b/TableProTests/ViewModels/JSONRowInspectorViewModelTests.swift @@ -0,0 +1,232 @@ +// +// JSONRowInspectorViewModelTests.swift +// TableProTests +// +// What the JSON inspector does with a row that changes under it while a foreign key is still +// being fetched. A rerun keeps a row's identity while its values move, so a fetched row held +// against a node path is the wrong row the moment the values do. +// + +import Foundation +import TableProPluginKit +import Testing + +@testable import TablePro + +@MainActor +@Suite("JSONRowInspectorViewModel") +struct JSONRowInspectorViewModelTests { + private static let connectionId = UUID(uuidString: "00000000-0000-0000-0000-0000000000AA") ?? UUID() + + private static let artistReference = JSONForeignKeyRef( + column: "ArtistId", + referencedTable: "Artist", + referencedSchema: nil, + referencedColumn: "ArtistId" + ) + + /// Hands a row back when the test says so rather than when the model asks, so a fetch can be + /// held open across a rebuild the way a query blocked in a driver call is. + @MainActor + private final class FetchGate { + private var pending: [CheckedContinuation] = [] + private(set) var callCount = 0 + + func fetch() async throws -> ForeignKeyRowFetcher.FetchedRow? { + callCount += 1 + return try await withCheckedThrowingContinuation { pending.append($0) } + } + + var pendingCount: Int { pending.count } + + func releaseFirst(with row: ForeignKeyRowFetcher.FetchedRow?) { + guard !pending.isEmpty else { return } + pending.removeFirst().resume(returning: row) + } + + func releaseAll(with row: ForeignKeyRowFetcher.FetchedRow?) { + let waiting = pending + pending = [] + for continuation in waiting { continuation.resume(returning: row) } + } + } + + /// Lets the model's fetch task run up to its first suspension point, which is where it hands + /// the gate its continuation. Nothing can be released before that has happened. + private func settle() async { + for _ in 0..<8 { await Task.yield() } + } + + private static func snapshot( + rowIdentity: String = "tab\u{001F}existing(0)", + artistId: PluginCellValue = .text("1"), + foreignKeys: [String: JSONForeignKeyRef] = ["ArtistId": artistReference] + ) -> JSONRowSnapshot { + JSONRowSnapshot( + rowIdentity: rowIdentity, + columns: ["AlbumId", "ArtistId"], + columnTypes: [.integer(rawType: "INT"), .integer(rawType: "INT")], + values: [.text("7"), artistId], + foreignKeys: foreignKeys, + connectionId: connectionId, + databaseType: .sqlite + ) + } + + private static func artistRow(name: String) -> ForeignKeyRowFetcher.FetchedRow { + ForeignKeyRowFetcher.FetchedRow( + columns: ["ArtistId", "Name"], + columnTypes: [.integer(rawType: "INT"), .text(rawType: "TEXT")], + values: [.text("1"), .text(name)], + foreignKeys: [:] + ) + } + + private func makeModel(gate: FetchGate) -> JSONRowInspectorViewModel { + JSONRowInspectorViewModel { _, _, _, _ in try await gate.fetch() } + } + + private func foreignKeyRow(in model: JSONRowInspectorViewModel) throws -> JSONDisplayRow { + try #require(model.displayRows.first { $0.foreignKey != nil }) + } + + @Test("A fetched referenced row is dropped when the values under its key move") + func rerunDropsFetchedRows() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot(artistId: .text("1"))) + let path = try foreignKeyRow(in: model).path + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + gate.releaseFirst(with: Self.artistRow(name: "AC/DC")) + await settle() + #expect(model.states.fetched[path] != nil) + + /// The same row, rerun: the identity survives, the value under the key does not. + model.update(snapshot: Self.snapshot(artistId: .text("2"))) + + #expect(model.states.fetched.isEmpty, "Artist 1 must not stay printed under a key now holding 2") + #expect(model.states.loading.isEmpty) + } + + @Test("A fetch that returns after a rebuild writes nothing into the new tree") + func lateFetchIsDiscarded() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot(artistId: .text("1"))) + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + #expect(gate.pendingCount == 1) + + model.update(snapshot: Self.snapshot(artistId: .text("2"))) + gate.releaseAll(with: Self.artistRow(name: "AC/DC")) + await settle() + + #expect(model.states.fetched.isEmpty) + #expect(model.states.failures.isEmpty) + } + + @Test("A stale fetch completing late leaves the fetch that replaced it in hand") + func staleCompletionKeepsTheReplacementFetch() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot(artistId: .text("1"))) + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + + model.update(snapshot: Self.snapshot(artistId: .text("2"))) + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + #expect(gate.callCount == 2) + + /// Only the cancelled first query comes back. Its cleanup used to drop the second query's + /// handle, which left the key looking unfetched and open to a third query for the same row. + gate.releaseFirst(with: Self.artistRow(name: "Accept")) + await settle() + + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + #expect(gate.callCount == 2, "A key with a fetch already in flight must not start a second one") + } + + @Test("A NULL foreign key never fetches") + func nullForeignKeyDoesNotFetch() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot(artistId: .null)) + + let row = try foreignKeyRow(in: model) + #expect(!row.isExpandable, "A key that references nothing offers no control") + model.toggle(row: row) + await settle() + #expect(gate.callCount == 0) + } + + @Test("Releasing data drops the tree and every row fetched for it") + func releaseDataClearsEverything() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot()) + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + gate.releaseFirst(with: Self.artistRow(name: "AC/DC")) + await settle() + model.filterText = "Artist" + + model.releaseData() + + #expect(model.root == nil) + #expect(model.states.fetched.isEmpty) + #expect(model.filterText.isEmpty) + #expect(model.displayRows.isEmpty) + } + + @Test("An unchanged snapshot keeps the rows already fetched") + func unchangedSnapshotKeepsFetchedRows() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot()) + let path = try foreignKeyRow(in: model).path + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + gate.releaseFirst(with: Self.artistRow(name: "AC/DC")) + await settle() + + model.update(snapshot: Self.snapshot()) + + #expect(model.states.fetched[path] != nil) + } + + @Test("A key that references a row already open in the chain reports the cycle") + func repeatedVisitReportsACycle() async throws { + let gate = FetchGate() + let model = makeModel(gate: gate) + + model.update(snapshot: Self.snapshot(artistId: .text("1"))) + let path = try foreignKeyRow(in: model).path + model.toggle(row: try foreignKeyRow(in: model)) + await settle() + gate.releaseFirst( + with: ForeignKeyRowFetcher.FetchedRow( + columns: ["ArtistId"], + columnTypes: [.integer(rawType: "INT")], + values: [.text("1")], + foreignKeys: ["ArtistId": Self.artistReference] + ) + ) + await settle() + + let nested = try #require(model.displayRows.first { $0.foreignKey != nil && $0.path != path }) + model.toggle(row: nested) + await settle() + + #expect(model.states.failures[nested.path] == .cycle) + #expect(gate.callCount == 1, "A cycle is refused before it costs a query") + } +} From 09ff19531cfb37f5a397c57279dd0e4792af93bb Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Tue, 1 Sep 2026 19:22:22 +0700 Subject: [PATCH 6/8] fix(hig): filter the JSON tab with a search field, and drop a tab the settings withdrew --- TablePro/Models/UI/RightPanelTab.swift | 15 ++++++ .../JSON/JSONRowInspectorView.swift | 46 ++++++------------- .../RightSidebar/UnifiedRightPanelView.swift | 37 +++++++++------ .../RightPanelTabAvailabilityTests.swift | 45 ++++++++++++++++++ 4 files changed, 99 insertions(+), 44 deletions(-) create mode 100644 TableProTests/Models/RightPanelTabAvailabilityTests.swift diff --git a/TablePro/Models/UI/RightPanelTab.swift b/TablePro/Models/UI/RightPanelTab.swift index cdda78821e..7976fd2166 100644 --- a/TablePro/Models/UI/RightPanelTab.swift +++ b/TablePro/Models/UI/RightPanelTab.swift @@ -27,4 +27,19 @@ enum RightPanelTab: String, CaseIterable, Hashable { case .aiChat: "sparkles" } } + + /// AI Chat is the only tab a setting can take away. + static func available(isAIEnabled: Bool) -> [RightPanelTab] { + allCases.filter { $0 != .aiChat || isAIEnabled } + } + + /// The tab to show for a stored one, which can name a tab the settings no longer offer. + /// + /// The active tab is persisted per connection and restored without asking whether the tab + /// still exists, so a connection last left on AI Chat comes back to it even with the assistant + /// turned off since. Resolving on every read rather than only when the setting changes is what + /// covers the restore, which no change notification ever reaches. + static func resolved(_ tab: RightPanelTab, isAIEnabled: Bool) -> RightPanelTab { + available(isAIEnabled: isAIEnabled).contains(tab) ? tab : .details + } } diff --git a/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift b/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift index 0348f1c3bb..7e157deac3 100644 --- a/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift +++ b/TablePro/Views/RightSidebar/JSON/JSONRowInspectorView.swift @@ -52,40 +52,22 @@ struct JSONRowInspectorView: View { .padding(.vertical, 6) } + /// The same `NSSearchField` the Details tab beside it uses. + /// + /// A plain `TextField` implements none of what a search field is: `Escape` clears the term and + /// only then falls through to the window, the cancel button and the magnifier are drawn by + /// AppKit, and assistive software reads the control as a search field rather than as text. private var filterField: some View { - HStack(spacing: 4) { - Image(systemName: "line.3.horizontal.decrease") - .font(.caption) - .foregroundStyle(.secondary) - TextField( - String(localized: "Filter by text or /regex/"), - text: $viewModel.filterText - ) - .textFieldStyle(.plain) - .font(.callout) - if !viewModel.filterText.isEmpty { - Button { - viewModel.filterText = "" - } label: { - Image(systemName: "xmark.circle.fill") - .font(.caption) - .foregroundStyle(.secondary) - } - .buttonStyle(.plain) - .accessibilityLabel(String(localized: "Clear Filter")) - } - } - .padding(.horizontal, 6) - .padding(.vertical, 4) - .background( - RoundedRectangle(cornerRadius: 6) - .fill(Color(nsColor: .textBackgroundColor)) + NativeSearchField( + text: $viewModel.filterText, + placeholder: String(localized: "Filter by text or /regex/"), + controlSize: .small, + accessibilityIdentifier: "json-row-filter" ) .overlay( RoundedRectangle(cornerRadius: 6) - .strokeBorder( - viewModel.isFilterInvalid ? Color.red.opacity(0.6) : Color(nsColor: .separatorColor) - ) + .strokeBorder(Color.red.opacity(0.6)) + .opacity(viewModel.isFilterInvalid ? 1 : 0) ) .help(viewModel.isFilterInvalid ? String(localized: "Not a valid regular expression") @@ -126,7 +108,9 @@ struct JSONRowInspectorView: View { private var tree: some View { let rows = viewModel.displayRows if rows.isEmpty { - noMatches + /// Only a filter can empty a row that has columns, so anything else that empties the + /// tree is the absence of a row, not the absence of a match. + if viewModel.isFiltering { noMatches } else { emptyState } } else { ScrollView(.vertical) { LazyVStack(alignment: .leading, spacing: 0) { diff --git a/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift b/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift index 8258fab870..df6e33bee4 100644 --- a/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift +++ b/TablePro/Views/RightSidebar/UnifiedRightPanelView.swift @@ -16,16 +16,27 @@ struct UnifiedRightPanelView: View { /// AI Chat is the only tab a setting can take away, and a tab that is gone cannot stay /// selected: the picker would show no selection and the panel no content. private var availableTabs: [RightPanelTab] { - RightPanelTab.allCases.filter { $0 != .aiChat || settingsManager.ai.enabled } + RightPanelTab.available(isAIEnabled: settingsManager.ai.enabled) + } + + /// Every read of the active tab goes through the resolution, because the stored value is + /// restored per connection without asking whether the tab still exists and no change + /// notification fires for a value that was already wrong when the panel appeared. + private var activeTab: RightPanelTab { + RightPanelTab.resolved(state.activeTab, isAIEnabled: settingsManager.ai.enabled) + } + + /// Writes the resolution back so the stored tab stops naming one the panel cannot show, and + /// only when it differs: every assignment persists, and the panel appears on every switch. + private func normalizeActiveTab() { + guard state.activeTab != activeTab else { return } + state.activeTab = activeTab } var body: some View { splitContent - .onChange(of: settingsManager.ai.enabled) { - if !settingsManager.ai.enabled, state.activeTab == .aiChat { - state.activeTab = .details - } - } + .task { normalizeActiveTab() } + .onChange(of: settingsManager.ai.enabled) { normalizeActiveTab() } .alert( String(localized: "Clear All Conversations?"), isPresented: $showClearConfirmation @@ -57,12 +68,12 @@ struct UnifiedRightPanelView: View { private var tabContent: some View { ZStack(alignment: .topLeading) { detailsView - .opacity(state.activeTab == .details ? 1 : 0) - .allowsHitTesting(state.activeTab == .details) - .disabled(state.activeTab != .details) - .accessibilityHidden(state.activeTab != .details) + .opacity(activeTab == .details ? 1 : 0) + .allowsHitTesting(activeTab == .details) + .disabled(activeTab != .details) + .accessibilityHidden(activeTab != .details) - switch state.activeTab { + switch activeTab { case .details: EmptyView() case .json: jsonView case .aiChat: aiChatView @@ -75,7 +86,7 @@ struct UnifiedRightPanelView: View { HStack(alignment: .center, spacing: 4) { tabPicker Spacer(minLength: 8) - if state.activeTab == .aiChat { + if activeTab == .aiChat { historyMenu newConversationButton } @@ -85,7 +96,7 @@ struct UnifiedRightPanelView: View { } private var tabPicker: some View { - Picker("", selection: $state.activeTab) { + Picker("", selection: Binding(get: { activeTab }, set: { state.activeTab = $0 })) { ForEach(availableTabs, id: \.self) { tab in Text(tab.localizedTitle).tag(tab) } diff --git a/TableProTests/Models/RightPanelTabAvailabilityTests.swift b/TableProTests/Models/RightPanelTabAvailabilityTests.swift new file mode 100644 index 0000000000..839e7e1259 --- /dev/null +++ b/TableProTests/Models/RightPanelTabAvailabilityTests.swift @@ -0,0 +1,45 @@ +// +// RightPanelTabAvailabilityTests.swift +// TableProTests +// +// The active tab is persisted per connection and restored without asking whether the tab still +// exists, so a connection last left on AI Chat comes back to it with the assistant turned off. +// + +import Foundation +import Testing + +@testable import TablePro + +@Suite("RightPanelTab availability") +struct RightPanelTabAvailabilityTests { + @Test("AI Chat is the only tab a setting takes away") + func aiChatIsTheOnlyOptionalTab() { + #expect(RightPanelTab.available(isAIEnabled: true) == RightPanelTab.allCases) + #expect(RightPanelTab.available(isAIEnabled: false) == [.details, .json]) + } + + @Test("A restored AI Chat tab resolves to Details while the assistant is off") + func restoredAIChatFallsBack() { + #expect(RightPanelTab.resolved(.aiChat, isAIEnabled: false) == .details) + #expect(RightPanelTab.resolved(.aiChat, isAIEnabled: true) == .aiChat) + } + + @Test("The tabs a setting cannot reach resolve to themselves either way") + func alwaysAvailableTabsAreUntouched() { + for enabled in [true, false] { + #expect(RightPanelTab.resolved(.details, isAIEnabled: enabled) == .details) + #expect(RightPanelTab.resolved(.json, isAIEnabled: enabled) == .json) + } + } + + @Test("A resolved tab is always one the picker offers") + func resolutionIsAlwaysSelectable() { + for enabled in [true, false] { + for tab in RightPanelTab.allCases { + let resolved = RightPanelTab.resolved(tab, isAIEnabled: enabled) + #expect(RightPanelTab.available(isAIEnabled: enabled).contains(resolved)) + } + } + } +} From 77b600478771f4a2298d8cafc3d698c211204489 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Tue, 1 Sep 2026 19:22:26 +0700 Subject: [PATCH 7/8] docs(json-viewer): show the Row as JSON tab, and correct what the page claims --- docs/features/json-viewer.mdx | 15 ++++++++++----- docs/images/row-as-json-dark.png | Bin 0 -> 265789 bytes docs/images/row-as-json.png | Bin 0 -> 265488 bytes 3 files changed, 10 insertions(+), 5 deletions(-) create mode 100644 docs/images/row-as-json-dark.png create mode 100644 docs/images/row-as-json.png diff --git a/docs/features/json-viewer.mdx b/docs/features/json-viewer.mdx index 04ac8febcd..2eaf9272db 100644 --- a/docs/features/json-viewer.mdx +++ b/docs/features/json-viewer.mdx @@ -100,16 +100,21 @@ With no row selected, the inspector describes the table: data, index and total s ## Row as JSON -Right-click a row and choose **Show Row as JSON**, or open the inspector and pick its **JSON** tab. The row prints as one JSON object, keys in the grid's column order: numbers and booleans unquoted, NULL as `null`, binary as hex. A JSON column, and a text column holding a document, arrive as nested keys instead of as a string. +Right-click a row and choose **Show Row as JSON**, or open the inspector and pick its **JSON** tab. The row prints as one JSON object, keys in the result's own column order: numbers and booleans unquoted, NULL as `null`, binary as hex. Like the **Details** tab beside it, it prints every column the result carries, including any you hid in the grid. A JSON column, and a text column holding a document, arrive as nested keys instead of as a string. -A foreign key key carries a disclosure control. Click it and the referenced row is fetched and printed underneath; a foreign key inside that row expands the same way, five levels down. A key pointing back at a row already open in the tree, and one past the fifth level, carry a warning icon that says which. A NULL foreign key has no control. + + Row as JSON + Row as JSON + + +A foreign key carries a disclosure control. Click it and the referenced row is fetched and printed underneath; a foreign key inside that row expands the same way, five levels down. A key pointing back at a row already open in the tree, and one past the fifth level, carry a warning icon that says which. A NULL foreign key has no control. -**Always Expand Foreign Keys**, in the options menu at the trailing end of the filter field, fetches the first level on every row selected from then on. It starts off and stays off until you turn it on, every session, since each key it follows is a query. The rest of that menu is **Copy Visible**, which puts the printed lines on the pasteboard as they stand, **Collapse All**, and **Expand All**. Long values wrap; nothing is truncated. +**Always Expand Foreign Keys**, in the options menu at the trailing end of the filter field, fetches the first level on every row selected from then on. It starts off and stays off until you turn it on, every session, since each key it follows is a query. The rest of that menu is **Copy Visible**, which puts the printed lines on the pasteboard as they stand, **Collapse All**, and **Expand All**. Long text wraps rather than being cut. -The filter field takes text, or a regular expression wrapped in slashes such as `/^rental/`. It matches keys and values, keeps the keys that lead to a match, and opens what was collapsed. An invalid expression outlines the field in red and filters nothing. +The filter field takes text, or a regular expression wrapped in slashes such as `/^rental/`. It matches keys and values, keeps the keys that lead to a match along with everything under a key that matches, and opens what was collapsed. `Escape` clears it. An invalid expression outlines the field in red and filters nothing. Editing stays on the **Details** tab. Right-click a line for **Copy Value** and **Copy Key**; a foreign key line adds **Open** for the referenced table, filtered to that row. -Caps: a document over 100,000 characters prints as a string rather than as nested keys, the same cap the [JSON tree](#limits) has. +Caps: a document over 100,000 characters prints as a string rather than as nested keys, the same cap the [JSON tree](#limits) has. A binary value prints its first 64 bytes followed by an ellipsis; **Copy Value** carries all of it. For whole-row JSON, switch the result to JSON mode with the switcher at the leading edge of the status bar, or from **View > Result View**. It shows what the [grid](/features/data-grid) shows, in the same order, minus hidden columns and rows marked for deletion, which the count line reports separately. Select rows in Data mode first to narrow it, then click **Copy JSON**. diff --git a/docs/images/row-as-json-dark.png b/docs/images/row-as-json-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..42897173c8bdd866e669572a1d931e2e3dda1630 GIT binary patch literal 265789 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�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

eqN&}v+UD@MVRNt1mK1dyTA8V*U;~y4 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

;!vMeB+Em1fuH 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%0D`)HM~j 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 literal 0 HcmV?d00001 diff --git a/docs/images/row-as-json.png b/docs/images/row-as-json.png new file mode 100644 index 0000000000000000000000000000000000000000..90e9141201fd699b129dec66799933d71cd2782e GIT binary patch literal 265488 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

T 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 literal 0 HcmV?d00001 From 49ee20f2036d5489d6105b2214dd931d158bd1a2 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Tue, 1 Sep 2026 19:47:53 +0700 Subject: [PATCH 8/8] fix(datagrid): keep a JSON filter's value match to its own line, and validate a scalar document --- TablePro/Models/UI/JSON/JSONRowFilter.swift | 59 +++++++++-------- .../Models/UI/JSON/JSONRowNodeBuilder.swift | 16 ++++- TablePro/Models/UI/JSON/JSONScalarText.swift | 25 ++++--- .../Models/JSON/JSONRowFilterTests.swift | 65 +++++++++++++++++++ .../Models/JSON/JSONRowNodeBuilderTests.swift | 17 +++++ .../Models/JSON/JSONScalarTextTests.swift | 19 ++++-- docs/features/json-viewer.mdx | 2 +- 7 files changed, 160 insertions(+), 43 deletions(-) diff --git a/TablePro/Models/UI/JSON/JSONRowFilter.swift b/TablePro/Models/UI/JSON/JSONRowFilter.swift index 196b623534..402bf7c928 100644 --- a/TablePro/Models/UI/JSON/JSONRowFilter.swift +++ b/TablePro/Models/UI/JSON/JSONRowFilter.swift @@ -58,48 +58,56 @@ enum JSONRowFilter { matcher: JSONRowMatcher ) -> Set { var visible: Set = [] - _ = collect(node: root, fetched: fetchedForeignKeys, matcher: matcher, into: &visible) + _ = collect( + node: root, + fetched: fetchedForeignKeys, + matcher: matcher, + keepsEverything: false, + into: &visible + ) return visible } + /// One walk, one visit per node. + /// + /// A key that matches keeps what it holds, decided before descending and carried down as + /// `keepsEverything`, so a chain of matching ancestors costs one pass rather than one pass per + /// ancestor over the same leaves. Keeping the container alone left it drawn as `{…}` with a + /// disclosure control that could not open it, because a filtered tree takes its expansion from + /// what survived the filter rather than from the reader's expanded set. + /// + /// Only the *key* keeps a subtree. A value that matches keeps its own line and the keys that + /// lead to it: an expanded foreign key carries both its own scalar and the fetched row's + /// fields, so treating a value match the same way answered a search for `1` with every column + /// of the referenced row. private static func collect( node: JSONRowNode, fetched: [JSONNodePath: JSONRowNode], matcher: JSONRowMatcher, + keepsEverything: Bool, into visible: inout Set ) -> Bool { + let keyMatches = node.key.text.map(matcher.matches) ?? false + let keepsDescendants = keepsEverything || keyMatches var subtreeMatched = false for child in children(of: node, fetched: fetched) { - if collect(node: child, fetched: fetched, matcher: matcher, into: &visible) { + if collect( + node: child, + fetched: fetched, + matcher: matcher, + keepsEverything: keepsDescendants, + into: &visible + ) { subtreeMatched = true } } - /// A key that matches keeps what it holds. Keeping the container alone left it drawn as - /// `{…}` with a disclosure control that could not open it, because a filtered tree takes - /// its expansion from what survived the filter rather than from the reader's expanded set. - if matches(node, matcher: matcher) { - insertSubtree(node, fetched: fetched, into: &visible) - return true + guard keepsDescendants || subtreeMatched || scalarMatches(node, matcher: matcher) else { + return false } - - if subtreeMatched { - visible.insert(node.path) - return true - } - return false - } - - private static func insertSubtree( - _ node: JSONRowNode, - fetched: [JSONNodePath: JSONRowNode], - into visible: inout Set - ) { visible.insert(node.path) - for child in children(of: node, fetched: fetched) { - insertSubtree(child, fetched: fetched, into: &visible) - } + return true } static func children(of node: JSONRowNode, fetched: [JSONNodePath: JSONRowNode]) -> [JSONRowNode] { @@ -109,8 +117,7 @@ enum JSONRowFilter { return node.children } - private static func matches(_ node: JSONRowNode, matcher: JSONRowMatcher) -> Bool { - if let key = node.key.text, matcher.matches(key) { return true } + private static func scalarMatches(_ node: JSONRowNode, matcher: JSONRowMatcher) -> Bool { guard let scalar = node.scalar else { return false } return matcher.matches(scalar.searchableText) } diff --git a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift index 9c1ce7099a..2f99c1a2c3 100644 --- a/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift +++ b/TablePro/Models/UI/JSON/JSONRowNodeBuilder.swift @@ -85,10 +85,24 @@ enum JSONRowNodeBuilder { /// to the column-type path printed the number as a string and the string with its own quotes /// still on. The gate below means only a JSON column ever reaches that case: any other column /// has to start with a brace or a bracket to be parsed at all. + /// + /// A scalar has to be strictly valid before it is retyped, because `JsonSyntaxParser` is a + /// syntax highlighter's parser and not a validator: it drops the backslash from an unknown + /// escape and reads `01` as a number. A column the engine never validated can hold either, and + /// retyping one there would show the reader something the cell does not say. A container keeps + /// the lenient parse it has always had, since its braces are what the tree is built from. private static func parsedDocument(_ text: String, type: ColumnType?) -> JsonSyntaxNode? { guard (text as NSString).length <= maxScannedDocumentLength else { return nil } if type?.isJsonType != true, !looksLikeDocument(text) { return nil } - return JsonSyntaxParser.parse(text) + guard let parsed = JsonSyntaxParser.parse(text) else { return nil } + switch parsed { + case .object, .array: return parsed + case .string, .number, .literal: return isStrictJSON(text) ? parsed : nil + } + } + + private static func isStrictJSON(_ text: String) -> Bool { + (try? JSONSerialization.jsonObject(with: Data(text.utf8), options: [.fragmentsAllowed])) != nil } /// A cell holding `42` is a number column, not a JSON document, and treating it as one would diff --git a/TablePro/Models/UI/JSON/JSONScalarText.swift b/TablePro/Models/UI/JSON/JSONScalarText.swift index 4f2346a651..908932c15d 100644 --- a/TablePro/Models/UI/JSON/JSONScalarText.swift +++ b/TablePro/Models/UI/JSON/JSONScalarText.swift @@ -21,15 +21,17 @@ enum JSONScalarText { /// The value without its quotes, which is what Copy Value puts on the pasteboard. /// - /// A blob prints in full here even though the line on screen stops at - /// `maxDisplayedHexBytes`: what the pasteboard carries is the value, not the rendering of it. + /// A blob is capped here as well, at the same 64 bytes `RowValueCopyFormatter` gives the grid's + /// own Copy: one cell copied two ways cannot come back as two different values. Carrying the + /// whole blob instead would also mean hex-encoding an unbounded value on the main actor while + /// the reader waits for the pasteboard. The quotes are what was wrong, not the cap. static func unquoted(_ scalar: JSONScalar) -> String { switch scalar { case .string(let text): text case .number(let literal): literal case .bool(let flag): flag ? "true" : "false" case .null: "NULL" - case .binary(let data): hex(data, limit: nil) + case .binary(let data): hex(data, limit: maxDisplayedHexBytes) } } @@ -59,15 +61,22 @@ enum JSONScalarText { /// than the reader gets back. static let maxDisplayedHexBytes = 64 - private static let hexDigits = Array("0123456789ABCDEF") + private static let hexDigits: [UInt8] = Array("0123456789ABCDEF".utf8) + /// Written into a byte buffer and decoded once rather than appended a character at a time. + /// Copy Value asks for the whole blob, so this runs over every byte of a value that can be + /// megabytes, on the main thread, while the reader waits for the pasteboard. private static func hex(_ data: Data, limit: Int?) -> String { let shown = limit.map { data.prefix($0) } ?? data[...] - var output = "0x" - output.reserveCapacity(shown.count * 2 + 3) + var bytes: [UInt8] = [0x30, 0x78] + bytes.reserveCapacity(shown.count * 2 + 5) for byte in shown { - output.append(hexDigits[Int(byte >> 4)]) - output.append(hexDigits[Int(byte & 0x0F)]) + bytes.append(hexDigits[Int(byte >> 4)]) + bytes.append(hexDigits[Int(byte & 0x0F)]) + } + var output = String(unsafeUninitializedCapacity: bytes.count) { buffer in + _ = buffer.initialize(from: bytes) + return bytes.count } if let limit, data.count > limit { output.append("…") } return output diff --git a/TableProTests/Models/JSON/JSONRowFilterTests.swift b/TableProTests/Models/JSON/JSONRowFilterTests.swift index b85add6e3a..f52ef8789b 100644 --- a/TableProTests/Models/JSON/JSONRowFilterTests.swift +++ b/TableProTests/Models/JSON/JSONRowFilterTests.swift @@ -186,4 +186,69 @@ struct JSONRowFilterTests { #expect(container.token == .openArray) #expect(container.isExpanded) } + + /// A value that matches keeps its own line and the keys that lead to it, never the subtree + /// under it. An expanded foreign key carries both its own scalar and the referenced row's + /// fields, so treating a value match as a key match answered a search for the key's value with + /// every column of the row it points at. + @Test("A value match keeps its own line, not the rows fetched underneath it") + func valueMatchDoesNotKeepAFetchedSubtree() throws { + let root = JSONRowNodeBuilder.build( + columns: ["title", "language_id"], + values: [.text("ANYTHING SAVANNAH"), .text("1")], + columnTypes: [.text(rawType: "VARCHAR"), .integer(rawType: "INT")], + foreignKeys: ["language_id": JSONForeignKeyRef( + column: "language_id", + referencedTable: "language", + referencedSchema: nil, + referencedColumn: "language_id" + )] + ) + let keyPath = try path(of: "language_id", in: root) + let expansion = JSONRowNodeBuilder.build( + path: keyPath, + key: .name("language_id"), + columns: ["name", "country"], + values: [.text("English"), .text("Ireland")], + columnTypes: [.text(rawType: "CHAR"), .text(rawType: "CHAR")], + foreignKeys: [:] + ) + + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [keyPath: expansion], + matcher: try matcher("1") + ) + + #expect(visible.contains(keyPath)) + for child in expansion.children { + #expect(visible.contains(child.path) == false, "A value match must not drag in the fetched row") + } + } + + /// The filter runs on every keystroke, so a chain of matching ancestors over one large subtree + /// has to stay one pass rather than one pass per ancestor. + @Test("Nested matching containers are visited once each") + func nestedMatchesDoNotRewalkTheSubtree() throws { + var document = "{" + for depth in 0..<40 { document += "\"key\(depth)\": {" } + document += "\"leaf\": 1" + document += String(repeating: "}", count: 41) + + let root = JSONRowNodeBuilder.build( + columns: ["payload"], + values: [.text(document)], + columnTypes: [.json(rawType: "JSON")], + foreignKeys: [:] + ) + + let visible = JSONRowFilter.visiblePaths( + root: root, + fetchedForeignKeys: [:], + matcher: try matcher("key") + ) + + #expect(visible.contains(try path(of: "payload", in: root))) + #expect(visible.count == 43, "Every node once: the root, payload, 40 keys and the leaf") + } } diff --git a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift index 754120bc94..0141b028ed 100644 --- a/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift +++ b/TableProTests/Models/JSON/JSONRowNodeBuilderTests.swift @@ -273,4 +273,21 @@ struct JSONRowNodeBuilderTests { ) #expect(try node(root, "note").scalar == .string("42")) } + + /// `JsonSyntaxParser` highlights, it does not validate: it drops the backslash from an unknown + /// escape and reads a leading zero as a number. A JSON column the engine never validated can + /// hold either, and retyping one would show the reader something the cell does not say. + @Test("A JSON column holding text that is not strictly valid JSON stays the text it holds") + func refusesInvalidJsonScalars() throws { + let root = JSONRowNodeBuilder.build( + columns: ["escape", "leadingZero", "negativeZero"], + values: [.text("\"\\q\""), .text("01"), .text("-01")], + columnTypes: [.json(rawType: "JSON"), .json(rawType: "JSON"), .json(rawType: "JSON")], + foreignKeys: [:] + ) + + #expect(try node(root, "escape").scalar == .string("\"\\q\"")) + #expect(try node(root, "leadingZero").scalar == .string("01")) + #expect(try node(root, "negativeZero").scalar == .string("-01")) + } } diff --git a/TableProTests/Models/JSON/JSONScalarTextTests.swift b/TableProTests/Models/JSON/JSONScalarTextTests.swift index 6bd2986b8f..7ceaa1bf31 100644 --- a/TableProTests/Models/JSON/JSONScalarTextTests.swift +++ b/TableProTests/Models/JSON/JSONScalarTextTests.swift @@ -22,16 +22,21 @@ struct JSONScalarTextTests { #expect(printed.contains("0x000102")) } - /// Copy Value puts the value on the pasteboard, so it carries every byte and no quotes. Both - /// were wrong: the clipboard used to receive the truncated hex with the printed quotes still - /// wrapped around it, which round-trips as neither the blob nor valid JSON. - @Test("Copy Value carries the whole blob, unquoted") - func unquotedBlobIsComplete() { + /// The quotes were the bug, not the cap. Copy Value used to hand the pasteboard the printed + /// form, quotes included, which round-trips as neither the blob nor valid JSON; the 64-byte cap + /// is what `RowValueCopyFormatter` already gives the grid's own Copy for the same cell. + @Test("Copy Value gives unquoted hex, capped the way the grid's own Copy is") + func unquotedBlobIsUnquotedAndCapped() { let copied = JSONScalarText.unquoted(.binary(sample)) #expect(copied.hasPrefix("0x")) #expect(!copied.contains("\"")) - #expect(!copied.contains("…")) - #expect(copied.count == 2 + sample.count * 2) + #expect(copied.hasSuffix("…")) + #expect(copied.count == 2 + JSONScalarText.maxDisplayedHexBytes * 2 + 1) + } + + @Test("A blob within the cap copies whole") + func shortBlobCopiesWhole() { + #expect(JSONScalarText.unquoted(.binary(Data([0x4C, 0x65]))) == "0x4C65") } @Test("A blob shorter than the cap prints without an ellipsis") diff --git a/docs/features/json-viewer.mdx b/docs/features/json-viewer.mdx index 2eaf9272db..6174ddb262 100644 --- a/docs/features/json-viewer.mdx +++ b/docs/features/json-viewer.mdx @@ -115,6 +115,6 @@ The filter field takes text, or a regular expression wrapped in slashes such as Editing stays on the **Details** tab. Right-click a line for **Copy Value** and **Copy Key**; a foreign key line adds **Open** for the referenced table, filtered to that row. -Caps: a document over 100,000 characters prints as a string rather than as nested keys, the same cap the [JSON tree](#limits) has. A binary value prints its first 64 bytes followed by an ellipsis; **Copy Value** carries all of it. +Caps: a document over 100,000 characters prints as a string rather than as nested keys, the same cap the [JSON tree](#limits) has. A binary value shows its first 64 bytes followed by an ellipsis, the same cap the grid's own **Copy** applies. For whole-row JSON, switch the result to JSON mode with the switcher at the leading edge of the status bar, or from **View > Result View**. It shows what the [grid](/features/data-grid) shows, in the same order, minus hidden columns and rows marked for deletion, which the count line reports separately. Select rows in Data mode first to narrow it, then click **Copy JSON**.