c21859a...master · parseable-macos

git.iko.soy/parseable-macos

on master help sign in

ParseableViewer/App/AppState.swift+81−5

since splitsnapshots

unifiedsplit

@@ -15,6 +15,10 @@ final class AppState {

15 private let networkMonitor = NWPathMonitor()

16 private let networkMonitorQueue = DispatchQueue(label: "com.parseableviewer.network-monitor")

17 private var connectTask: Task<Bool, Never>?

18+ /// The connection `connectTask` is connecting to. `activeConnection` only

19+ /// switches once the new server answers, so this is what identifies an

20+ /// in-flight connect whose target the user deletes (see `removeConnection`).

21+ private var connectingConnectionID: UUID?

19 // MARK: - Stream State

23 // MARK: - Stream State

20 var streams: [LogStream] = []

24 var streams: [LogStream] = []

@@ -96,6 +100,7 @@ final class AppState {

100

97 if let activeID = ConnectionStore.loadActiveConnectionID(),

101 if let activeID = ConnectionStore.loadActiveConnectionID(),

98 let connection = connections.first(where: { $0.id == activeID }) {

102 let connection = connections.first(where: { $0.id == activeID }) {

103+ connectingConnectionID = connection.id

99 connectTask = Task { @MainActor [weak self] in

104 connectTask = Task { @MainActor [weak self] in

100 await self?.performConnect(to: connection) ?? false

105 await self?.performConnect(to: connection) ?? false

101 }

106 }

@@ -115,6 +120,7 @@ final class AppState {

115 existing.cancel()

120 existing.cancel()

116 _ = await existing.value

121 _ = await existing.value

117 }

122 }

123+ connectingConnectionID = connection.id

118 let task = Task { @MainActor [weak self] in

124 let task = Task { @MainActor [weak self] in

119 await self?.performConnect(to: connection) ?? false

125 await self?.performConnect(to: connection) ?? false

120 }

126 }

@@ -124,9 +130,16 @@ final class AppState {

124

130

125 @MainActor

131 @MainActor

126 private func performConnect(to connection: ServerConnection) async -> Bool {

132 private func performConnect(to connection: ServerConnection) async -> Bool {

133+ defer {

134+ if connectingConnectionID == connection.id { connectingConnectionID = nil }

135+ }

127 guard !isConnecting else { return false }

136 guard !isConnecting else { return false }

128

137

138+ // NWPathMonitor ignores loopback, so with no active network interface it

139+ // reports "unsatisfied" even though a local server (the common docker /

140+ // dev setup) is reachable. Don't block those; a genuinely unreachable

141+ // host still fails below with the same offline message.

129− if !isNetworkAvailable {

142+ if !isNetworkAvailable && !Self.isLoopback(connection.baseURL) {

130 self.errorMessage = "No internet connection. Check your network and try again."

143 self.errorMessage = "No internet connection. Check your network and try again."

131 self.showError = true

144 self.showError = true

132 return false

145 return false

@@ -134,7 +147,12 @@ final class AppState {

134

147

135 isConnecting = true

148 isConnecting = true

136 defer { isConnecting = false }

149 defer { isConnecting = false }

150+ // Reset the flag with the message: a previous failed connect left

151+ // `showError` set, and if its alert couldn't present (e.g. behind the

152+ // connection sheet), it would pop up later — after a successful retry —

153+ // reading "An unknown error occurred".

137 errorMessage = nil

154 errorMessage = nil

155+ showError = false

138

156

139 // When switching to a different server, clear stream-specific state

157 // When switching to a different server, clear stream-specific state

140 // so stale selections don't reference streams that don't exist.

158 // so stale selections don't reference streams that don't exist.

@@ -164,6 +182,7 @@ final class AppState {

164

182

165 // Test connection — throws on non-200 or network failure

183 // Test connection — throws on non-200 or network failure

166 try await newClient.checkHealth()

184 try await newClient.checkHealth()

185+ try await Self.verifyCredentials(with: newClient)

167

186

168 // If the task was cancelled while awaiting (e.g. user clicked

187 // If the task was cancelled while awaiting (e.g. user clicked

169 // Disconnect during auto-reconnect), bail before installing the

188 // Disconnect during auto-reconnect), bail before installing the

@@ -200,6 +219,12 @@ final class AppState {

200 case .success(let list):

219 case .success(let list):

201 self.streams = list

220 self.streams = list

202 self.streamLoadError = nil

221 self.streamLoadError = nil

222+ // Like refreshStreams: a selection that doesn't exist on this server

223+ // (e.g. one picked from a stale list while the connect was pending)

224+ // would keep every stream tab querying a missing stream.

225+ if let selected = selectedStream, !list.contains(where: { $0.name == selected }) {

226+ selectedStream = nil

227+ }

203 case .failure(let error):

228 case .failure(let error):

204 self.streams = []

229 self.streams = []

205 self.streamLoadError = ParseableError.userFriendlyMessage(for: error)

230 self.streamLoadError = ParseableError.userFriendlyMessage(for: error)

@@ -265,8 +290,13 @@ final class AppState {

265 let loaded = try await client.listStreams()

290 let loaded = try await client.listStreams()

266 // Drop results if the active connection changed while awaiting. Still

291 // Drop results if the active connection changed while awaiting. Still

267 // clear isLoadingStreams: this task set the spinner, so leaving it true

292 // clear isLoadingStreams: this task set the spinner, so leaving it true

268− // wedges the indicator and disables Refresh.

293+ // wedges the indicator and disables Refresh. Compare the client too:

294+ // editing the active connection's URL/credentials keeps its id but

295+ // installs a new client for a possibly different server.

269− guard connID == activeConnection?.id else { isLoadingStreams = false; return }

296+ guard connID == activeConnection?.id, client === self.client else {

297+ isLoadingStreams = false

298+ return

299+ }

270 streams = loaded

300 streams = loaded

271 // Drop a selection that no longer exists server-side (e.g. the stream

301 // Drop a selection that no longer exists server-side (e.g. the stream

272 // was deleted from another client); otherwise the detail tabs keep

302 // was deleted from another client); otherwise the detail tabs keep

@@ -275,7 +305,10 @@ final class AppState {

275 selectedStream = nil

305 selectedStream = nil

276 }

306 }

277 } catch {

307 } catch {

278− guard connID == activeConnection?.id else { isLoadingStreams = false; return }

308+ guard connID == activeConnection?.id, client === self.client else {

309+ isLoadingStreams = false

310+ return

311+ }

279 let message = ParseableError.userFriendlyMessage(for: error)

312 let message = ParseableError.userFriendlyMessage(for: error)

280 streamLoadError = message

313 streamLoadError = message

281 self.errorMessage = "Failed to load streams: \(message)"

314 self.errorMessage = "Failed to load streams: \(message)"

@@ -342,9 +375,49 @@ final class AppState {

342 ConnectionStore.saveConnections(connections)

375 ConnectionStore.saveConnections(connections)

343 if activeConnection?.id == connection.id {

376 if activeConnection?.id == connection.id {

344 disconnect()

377 disconnect()

378+ } else if connectingConnectionID == connection.id {

379+ // The removed connection is still being connected to (e.g. Cancel in the

380+ // connection sheet, or deleting it in Settings during the launch

381+ // reconnect). `activeConnection` doesn't point at it yet, so without

382+ // this the connect would carry on and install a client for a

383+ // connection that no longer exists (or tear down the current session

384+ // when it fails) after the user abandoned it.

385+ connectTask?.cancel()

386+ connectTask = nil

387+ connectingConnectionID = nil

388+ // Starting that connect already cleared the current server's stream

389+ // list and filters; reload them if we're still connected to it.

390+ if client != nil {

391+ Task { @MainActor [weak self] in

392+ await self?.refreshStreams()

393+ await self?.refreshFilters()

394+ }

395+ }

396+ }

397+ }

398+

399+ /// `/api/v1/liveness` is unauthenticated on Parseable (it answers 200 to

400+ /// anyone, for load-balancer / k8s probes), so a health check alone accepts

401+ /// any username and password. Probe an authenticated endpoint and fail on

402+ /// 401. Other failures — e.g. a 403 for a role without the about permission —

403+ /// don't show the credentials are wrong, so they're ignored here. The client

404+ /// caches the response, so the follow-up `getAbout()` load reuses it.

405+ static func verifyCredentials(with client: ParseableClient) async throws {

406+ do {

407+ _ = try await client.getAbout()

408+ } catch ParseableError.unauthorized {

409+ throw ParseableError.unauthorized

410+ } catch {

411+ // Not an authentication failure; leave it to the best-effort loads.

345 }

412 }

346 }

413 }

347

414

415+ private static func isLoopback(_ url: URL?) -> Bool {

416+ guard let host = url?.host?.lowercased() else { return false }

417+ return host == "localhost" || host.hasSuffix(".localhost")

418+ || host == "::1" || host.hasPrefix("127.")

419+ }

420+

348 // MARK: - Stream Management

421 // MARK: - Stream Management

349

422

350 @MainActor

423 @MainActor

@@ -377,7 +450,10 @@ final class AppState {

377 let connID = activeConnection?.id

450 let connID = activeConnection?.id

378 isLoadingFilters = true

451 isLoadingFilters = true

379 let loaded = (try? await client.listFilters()) ?? []

452 let loaded = (try? await client.listFilters()) ?? []

380− guard connID == activeConnection?.id else { isLoadingFilters = false; return }

453+ guard connID == activeConnection?.id, client === self.client else {

454+ isLoadingFilters = false

455+ return

456+ }

381 filters = loaded

457 filters = loaded

382 isLoadingFilters = false

458 isLoadingFilters = false

383 }

459 }

ParseableViewer/App/ParseableViewerApp.swift+13−1

@@ -4,6 +4,13 @@ import SwiftUI

4struct ParseableViewerApp: App {

5 @State private var appState = AppState()

7+ init() {

8+ // All window content shares one AppState (see the File > New group below),

9+ // so don't offer window tabs either: the tab bar's "+" would open a second

10+ // window just like File > New Window.

11+ NSWindow.allowsAutomaticWindowTabbing = false

12+ }

13+

7 var body: some Scene {

14 var body: some Scene {

8 WindowGroup {

15 WindowGroup {

9 ContentView()

16 ContentView()

@@ -17,7 +24,12 @@ struct ParseableViewerApp: App {

17 AboutCommand()

24 AboutCommand()

18 }

25 }

27+ // Replace (rather than extend) the File > New group to drop "New Window":

28+ // connection, sheet, alert, selection and pending-filter state all live

29+ // in the single shared AppState, so a second window would present every

30+ // sheet and alert twice and race the first window's QueryView for

31+ // saved-filter SQL.

20− CommandGroup(after: .newItem) {

32+ CommandGroup(replacing: .newItem) {

21 Button("New Connection...") {

33 Button("New Connection...") {

22 appState.editingConnection = nil

34 appState.editingConnection = nil

23 appState.showConnectionSheet = true

35 appState.showConnectionSheet = true

ParseableViewer/Info.plist+5

@@ -24,6 +24,11 @@

24 <string>public.app-category.developer-tools</string>

25 <key>LSMinimumSystemVersion</key>

26 <string>$(MACOSX_DEPLOYMENT_TARGET)</string>

27+ <key>NSAppTransportSecurity</key>

28+ <dict>

29+ <key>NSAllowsArbitraryLoads</key>

30+ <true/>

31+ </dict>

27 <key>NSMainNibFile</key>

32 <key>NSMainNibFile</key>

28 <string></string>

33 <string></string>

29 <key>NSPrincipalClass</key>

34 <key>NSPrincipalClass</key>

ParseableViewer/Models/AlertModels.swift+21

@@ -85,6 +85,27 @@ struct AlertRule: Identifiable, Codable, Sendable {

85struct AlertRuleSpec: Codable, Sendable {

86 let type: String?

87 let config: String?

88+

89+ private enum CodingKeys: String, CodingKey {

90+ case type, config

91+ }

92+

93+ init(from decoder: Decoder) throws {

94+ let container = try decoder.container(keyedBy: CodingKeys.self)

95+ self.type = try? container.decode(String.self, forKey: .type)

96+ // The legacy per-stream rule is serialized as `{"type": …, "config": …}`

97+ // where only composite rules carry a string config; column rules carry an

98+ // object (`{"column": …, "operator": …, "value": …}`). Decoding that as a

99+ // String threw, which made the whole spec — and its type badge — vanish.

100+ // Keep non-string configs as compact JSON instead.

101+ if let string = try? container.decode(String.self, forKey: .config) {

102+ self.config = string

103+ } else if let value = try? container.decode(JSONValue.self, forKey: .config), value != .null {

104+ self.config = value.compactJSON

105+ } else {

106+ self.config = nil

107+ }

108+ }

88}

109}

110

90struct AlertTarget: Codable, Sendable {

111struct AlertTarget: Codable, Sendable {

ParseableViewer/Models/LogStream.swift+97−11

@@ -80,11 +80,39 @@ struct SchemaField: Identifiable, Codable, Hashable, Sendable {

80 if let typeStr = try? container.decode(String.self, forKey: .dataType) {

81 self.dataType = typeStr

82 } else if let typeObj = try? container.decode(JSONValue.self, forKey: .dataType) {

83− self.dataType = typeObj.displayString

83+ self.dataType = Self.describeArrowType(typeObj)

84 } else {

85 self.dataType = "Unknown"

86 }

87 }

88+

89+ /// Renders a serde-serialized Arrow `DataType`. Parameterized types are

90+ /// externally tagged objects — `p_timestamp`, present in every Parseable

91+ /// stream, arrives as `{"Timestamp": ["Millisecond", null]}` and a list as

92+ /// `{"List": {<field>}}` — which `displayString` collapsed to the placeholder

93+ /// "{1 fields}". Produce Arrow's own notation instead, e.g.

94+ /// `Timestamp(Millisecond, None)` / `List(Utf8)`.

95+ static func describeArrowType(_ value: JSONValue) -> String {

96+ switch value {

97+ case .null:

98+ return "None"

99+ case .string(let s):

100+ return s

101+ case .array(let items):

102+ return items.map { describeArrowType($0) }.joined(separator: ", ")

103+ case .object(let dict):

104+ // A nested `Field` (list/map element, struct member): show its type.

105+ if let fieldType = dict["data_type"] {

106+ return describeArrowType(fieldType)

107+ }

108+ if dict.count == 1, let entry = dict.first {

109+ return "\(entry.key)(\(describeArrowType(entry.value)))"

110+ }

111+ return value.compactJSON

112+ default:

113+ return value.displayString

114+ }

115+ }

88}

116}

117

90/// Formats a byte count that may arrive from the server as a fractional or

118/// Formats a byte count that may arrive from the server as a fractional or

@@ -106,14 +134,59 @@ private func formatByteSize(_ value: Int) -> String? {

106/// Normalizes a byte count that arrived as a JSON *string*. A bare numeric string

134/// Normalizes a byte count that arrived as a JSON *string*. A bare numeric string

107/// (e.g. "1048576") is a raw byte count and is formatted like the numeric branches

135/// (e.g. "1048576") is a raw byte count and is formatted like the numeric branches

108/// so identical sizes render consistently ("1 MB") regardless of whether the server

136/// so identical sizes render consistently ("1 MB") regardless of whether the server

137+/// quoted the value. Parseable 1.x — the versions that quote sizes — sends them as

138+/// "<n> Bytes" (e.g. "1048576 Bytes"), so that unit suffix is accepted too. Any

109−/// quoted the value; an already-formatted string (e.g. "1.2 GB") is passed through

139+/// other already-formatted string (e.g. "1.2 GB") is passed through unchanged.

110−/// unchanged.

111private func formatByteSize(_ value: String) -> String {

140private func formatByteSize(_ value: String) -> String {

112− let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)

141+ var trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)

142+ if trimmed.lowercased().hasSuffix(" bytes") {

143+ trimmed = String(trimmed.dropLast(" bytes".count))

144+ }

113 if let n = Int(trimmed) { return formatByteSize(n) ?? value }

145 if let n = Int(trimmed) { return formatByteSize(n) ?? value }

114 return value

146 return value

115}

147}

116

148

149+/// A string-backed coding key for fields whose name differs across Parseable

150+/// versions (kebab-case, snake_case, and camelCase spellings of the same field).

151+private struct FlexibleCodingKey: CodingKey {

152+ let stringValue: String

153+ var intValue: Int? { nil }

154+ init(stringValue: String) { self.stringValue = stringValue }

155+ init?(intValue: Int) { nil }

156+}

157+

158+private extension KeyedDecodingContainer where Key == FlexibleCodingKey {

159+ /// The first of `keys` that decodes as a string.

160+ func firstString(_ keys: String...) -> String? {

161+ for key in keys {

162+ if let value = try? decode(String.self, forKey: FlexibleCodingKey(stringValue: key)) {

163+ return value

164+ }

165+ }

166+ return nil

167+ }

168+

169+ /// The first of `keys` that decodes as a boolean — either a JSON bool or the

170+ /// strings "true"/"false" (Parseable serializes `static_schema_flag` as the

171+ /// string "true").

172+ func firstBool(_ keys: String...) -> Bool? {

173+ for key in keys {

174+ let codingKey = FlexibleCodingKey(stringValue: key)

175+ if let value = try? decode(Bool.self, forKey: codingKey) {

176+ return value

177+ }

178+ if let string = try? decode(String.self, forKey: codingKey) {

179+ switch string.lowercased() {

180+ case "true": return true

181+ case "false": return false

182+ default: continue

183+ }

184+ }

185+ }

186+ return nil

187+ }

188+}

189+

117struct StreamStats: Codable, Sendable {

190struct StreamStats: Codable, Sendable {

118 let ingestion: IngestionStats?

191 let ingestion: IngestionStats?

119 let storage: StorageStats?

192 let storage: StorageStats?

@@ -165,7 +238,11 @@ struct StreamStats: Codable, Sendable {

165

238

166 init(from decoder: Decoder) throws {

239 init(from decoder: Decoder) throws {

167 let container = try decoder.container(keyedBy: CodingKeys.self)

240 let container = try decoder.container(keyedBy: CodingKeys.self)

168− self.type = try? container.decode(String.self, forKey: .type)

241+ // Parseable names this field `format` (e.g. "parquet") in every

242+ // version; `type` never appears, so "Storage Type" always read N/A.

243+ // Keep `type` as a fallback.

244+ self.type = (try? decoder.container(keyedBy: FlexibleCodingKey.self))?

245+ .firstString("format", "type")

169 if let s = try? container.decode(String.self, forKey: .size) {

246 if let s = try? container.decode(String.self, forKey: .size) {

170 self.size = formatByteSize(s)

247 self.size = formatByteSize(s)

171 } else if let n = try? container.decode(Int.self, forKey: .size) {

248 } else if let n = try? container.decode(Int.self, forKey: .size) {

@@ -208,11 +285,20 @@ struct StreamInfo: Codable, Sendable {

208 }

285 }

209

286

210 init(from decoder: Decoder) throws {

287 init(from decoder: Decoder) throws {

288+ // The /info key spellings vary by Parseable version: 1.x–2.x send

289+ // `created-at`/`first-event-at` with the other fields in snake_case

290+ // (`cache_enabled`, `time_partition`, `static_schema_flag`), while newer

291+ // servers send camelCase throughout (`createdAt`, `timePartition`, …).

292+ // The kebab-case `cache-enabled`/`time-partition`/`static-schema-flag`

293+ // decoded previously were never sent by any version, so those rows always

294+ // showed "N/A". The schema flag also arrives as the string "true".

211− let container = try decoder.container(keyedBy: CodingKeys.self)

295+ let container = try decoder.container(keyedBy: FlexibleCodingKey.self)

212− self.createdAt = try? container.decode(String.self, forKey: .createdAt)

296+ self.createdAt = container.firstString("created-at", "createdAt", "created_at")

213− self.firstEventAt = try? container.decode(String.self, forKey: .firstEventAt)

297+ self.firstEventAt = container.firstString("first-event-at", "firstEventAt", "first_event_at")

214− self.cacheEnabled = try? container.decode(Bool.self, forKey: .cacheEnabled)

298+ self.cacheEnabled = container.firstBool("cache_enabled", "cacheEnabled", "cache-enabled")

215− self.timePartition = try? container.decode(String.self, forKey: .timePartition)

299+ self.timePartition = container.firstString("time_partition", "timePartition", "time-partition")

216− self.staticSchemaFlag = try? container.decode(Bool.self, forKey: .staticSchemaFlag)

300+ self.staticSchemaFlag = container.firstBool(

301+ "static_schema_flag", "staticSchemaFlag", "static-schema-flag"

302+ )

217 }

303 }

218}

304}

ParseableViewer/Models/SQLTokenizer.swift+18−4

@@ -80,8 +80,8 @@ struct SQLTokenizer: Sendable {

81 switch c {

82 // Whitespace

83− case " ", "\t", "\n", "\r":

83+ case _ where isWhitespace(c):

84− advance(&i, in: sql, while: { $0 == " " || $0 == "\t" || $0 == "\n" || $0 == "\r" })

84+ advance(&i, in: sql, while: isWhitespace)

85 tokens.append(Token(kind: .whitespace, range: start..<i))

87 // Line comment

@@ -89,8 +89,11 @@ struct SQLTokenizer: Sendable {

89 // Stop at CR as well as LF: with CRLF (`\r\n`) line endings, consuming

90 // the trailing `\r` into the comment token would push its boundary past

91 // where `characterOffset`/DataFusion treat the line as ending, shifting

92− // the server-error highlight range. `\r` is then tokenized as whitespace.

92+ // the server-error highlight range. The line break is then tokenized as

93+ // whitespace. `isLineBreak` also matches the single `"\r\n"` Character

94+ // Swift forms from a CRLF pair — comparing against "\n"/"\r" alone never

95+ // matches it, so the comment would swallow every following line.

93− advance(&i, in: sql, while: { $0 != "\n" && $0 != "\r" })

96+ advance(&i, in: sql, while: { !isLineBreak($0) })

94 tokens.append(Token(kind: .lineComment, range: start..<i))

97 tokens.append(Token(kind: .lineComment, range: start..<i))

96 // Block comment

99 // Block comment

@@ -259,6 +262,17 @@ struct SQLTokenizer: Sendable {

259 return value // unterminated

262 return value // unterminated

260 }

263 }

261

264

265+ /// Swift iterates grapheme clusters, and a CRLF pair is the single Character

266+ /// `"\r\n"`, which is equal to neither `"\r"` nor `"\n"`. Match it explicitly

267+ /// so Windows line endings (e.g. pasted text) tokenize like LF/CR ones.

268+ private static func isLineBreak(_ c: Character) -> Bool {

269+ c == "\n" || c == "\r" || c == "\r\n"

270+ }

271+

272+ private static func isWhitespace(_ c: Character) -> Bool {

273+ c == " " || c == "\t" || isLineBreak(c)

274+ }

275+

262 /// SQL number literals use only ASCII digits. `Character.isNumber` also

276 /// SQL number literals use only ASCII digits. `Character.isNumber` also

263 /// matches Unicode numerics (`²`, `½`, Arabic-Indic digits, etc.), which

277 /// matches Unicode numerics (`²`, `½`, Arabic-Indic digits, etc.), which

264 /// DataFusion's lexer rejects — accepting them here would tokenize those

278 /// DataFusion's lexer rejects — accepting them here would tokenize those

ParseableViewer/Models/ServerConnection.swift+19−2

@@ -56,15 +56,32 @@ struct ServerConnection: Identifiable, Codable, Hashable, Sendable {

56 var baseURL: URL? {

57 var urlString = url.trimmingCharacters(in: .whitespacesAndNewlines)

58 if urlString.isEmpty { return nil }

59− if !urlString.hasPrefix("http://") && !urlString.hasPrefix("https://") {

59+ if let schemeRange = Self.urlSchemeRange(in: urlString) {

60+ // Normalize the (case-insensitive) scheme so `HTTP://host` behaves

61+ // exactly like `http://host` everywhere downstream.

62+ urlString.replaceSubrange(schemeRange, with: urlString[schemeRange].lowercased())

63+ } else {

60 urlString = "https://\(urlString)"

64 urlString = "https://\(urlString)"

61 }

65 }

62 while urlString.hasSuffix("/") {

66 while urlString.hasSuffix("/") {

63 urlString.removeLast()

67 urlString.removeLast()

64 }

68 }

65− guard let parsed = URL(string: urlString), parsed.host != nil else {

69+ guard let parsed = URL(string: urlString), parsed.host != nil,

70+ parsed.scheme == "http" || parsed.scheme == "https" else {

66 return nil

71 return nil

67 }

72 }

68 return parsed

73 return parsed

69 }

74 }

75+

76+ /// Whether `string` already starts with a URL scheme (`http://`, `HTTPS://`,

77+ /// `ftp://`, …). Schemes are case-insensitive, so a case-sensitive

78+ /// `hasPrefix("http://")` check turned `HTTP://host` into

79+ /// `https://HTTP://host` — a URL whose host is "HTTP".

80+ static func hasURLScheme(_ string: String) -> Bool {

81+ urlSchemeRange(in: string) != nil

82+ }

83+

84+ private static func urlSchemeRange(in string: String) -> Range<String.Index>? {

85+ string.range(of: "^[A-Za-z][A-Za-z0-9+.-]*://", options: .regularExpression)

86+ }

70}

87}

ParseableViewer/Models/ServerInfo.swift+33−7

@@ -15,33 +15,59 @@ struct ServerAbout: Codable, Sendable {

15 let llmActive: Bool?

16 let oidcActive: Bool?

18+ // Parseable's /about handler has always sent camelCase keys (`uiVersion`,

19+ // `deploymentId`, `grpcPort`), like the other fields here. Decoding only the

20+ // snake_case spellings — which the server never sends — left UI Version and

21+ // Deployment ID permanently "N/A" and hid the gRPC Port row. The snake_case

22+ // forms are kept as a fallback.

18 private enum CodingKeys: String, CodingKey {

23 private enum CodingKeys: String, CodingKey {

19 case version, commit, mode, staging, store, license

24 case version, commit, mode, staging, store, license

20− case uiVersion = "ui_version"

25+ case uiVersion

21− case deploymentId = "deployment_id"

26+ case deploymentId

22− case grpcPort = "grpc_port"

27+ case grpcPort

23 case updateAvailable

28 case updateAvailable

24 case latestVersion

29 case latestVersion

25 case llmActive

30 case llmActive

26 case oidcActive

31 case oidcActive

27 }

32 }

34+ private enum SnakeCaseKeys: String, CodingKey {

35+ case uiVersion = "ui_version"

36+ case deploymentId = "deployment_id"

37+ case grpcPort = "grpc_port"

38+ }

39+

29 init(from decoder: Decoder) throws {

40 init(from decoder: Decoder) throws {

30 let container = try decoder.container(keyedBy: CodingKeys.self)

41 let container = try decoder.container(keyedBy: CodingKeys.self)

42+ let snakeCase = try? decoder.container(keyedBy: SnakeCaseKeys.self)

31 self.version = try? container.decode(String.self, forKey: .version)

43 self.version = try? container.decode(String.self, forKey: .version)

32− self.uiVersion = try? container.decode(String.self, forKey: .uiVersion)

44+ self.uiVersion = (try? container.decode(String.self, forKey: .uiVersion))

45+ ?? (try? snakeCase?.decode(String.self, forKey: .uiVersion))

33 self.commit = try? container.decode(String.self, forKey: .commit)

46 self.commit = try? container.decode(String.self, forKey: .commit)

34− self.deploymentId = try? container.decode(String.self, forKey: .deploymentId)

47+ self.deploymentId = (try? container.decode(String.self, forKey: .deploymentId))

48+ ?? (try? snakeCase?.decode(String.self, forKey: .deploymentId))

35 self.mode = try? container.decode(String.self, forKey: .mode)

49 self.mode = try? container.decode(String.self, forKey: .mode)

36 self.staging = try? container.decode(String.self, forKey: .staging)

50 self.staging = try? container.decode(String.self, forKey: .staging)

37 self.store = try? container.decode(StoreInfo.self, forKey: .store)

51 self.store = try? container.decode(StoreInfo.self, forKey: .store)

38− self.license = try? container.decode(String.self, forKey: .license)

52+ self.license = (try? container.decode(String.self, forKey: .license))

53+ ?? (try? container.decode(JSONValue.self, forKey: .license)).flatMap(Self.describeLicense)

39− self.grpcPort = try? container.decode(Int.self, forKey: .grpcPort)

54+ self.grpcPort = (try? container.decode(Int.self, forKey: .grpcPort))

55+ ?? (try? snakeCase?.decode(Int.self, forKey: .grpcPort))

40 self.updateAvailable = try? container.decode(Bool.self, forKey: .updateAvailable)

56 self.updateAvailable = try? container.decode(Bool.self, forKey: .updateAvailable)

41 self.latestVersion = try? container.decode(String.self, forKey: .latestVersion)

57 self.latestVersion = try? container.decode(String.self, forKey: .latestVersion)

42 self.llmActive = try? container.decode(Bool.self, forKey: .llmActive)

58 self.llmActive = try? container.decode(Bool.self, forKey: .llmActive)

43 self.oidcActive = try? container.decode(Bool.self, forKey: .oidcActive)

59 self.oidcActive = try? container.decode(Bool.self, forKey: .oidcActive)

44 }

60 }

61+

62+ /// Current servers send `license` as an object (`{"name": "AGPL-3.0-only",

63+ /// "plan": "OSS", …}`) rather than a string, which decoded to nil ("N/A").

64+ private static func describeLicense(_ value: JSONValue) -> String? {

65+ guard case .object(let fields) = value, let name = fields["name"]?.stringValue else { return nil }

66+ if let plan = fields["plan"]?.stringValue, !plan.isEmpty {

67+ return "\(name) (\(plan))"

68+ }

69+ return name

70+ }

45}

71}

47struct StoreInfo: Codable, Sendable {

73struct StoreInfo: Codable, Sendable {

ParseableViewer/Services/ParseableClient.swift+44−2

@@ -409,9 +409,51 @@ final class ParseableClient: Sendable {

409 return try Self.jsonDecoder.decode(AlertConfig.self, from: data)

410 }

411

412+ // `/api/v1/alerts` paginates (default page size 100, max 1000) over ALL

413+ // alerts server-wide, ordered by state/severity/title. Filtering only the

414+ // first page by stream (below) silently missed any stream whose alerts sort

415+ // past it. Request full pages until a short one. Servers that predate

416+ // pagination ignore the parameters and return everything each time, so a

417+ // page that adds nothing new also ends the loop.

418+ func modernAlerts() async throws -> (data: Data, config: AlertConfig) {

419+ let pageSize = 1000

420+ var firstData: Data?

421+ var version: String?

422+ var collected: [AlertRule] = []

423+ var seenIDs = Set<String>()

424+ var offset = 0

425+ for _ in 0..<50 {

426+ let data: Data

427+ do {

428+ data = try await performRequest(

429+ method: "GET",

430+ path: "/api/v1/alerts",

431+ queryItems: [

432+ URLQueryItem(name: "limit", value: String(pageSize)),

433+ URLQueryItem(name: "offset", value: String(offset)),

434+ ]

435+ )

436+ } catch ParseableError.serverError(let code, _) where code == 400 && offset == 0 {

437+ // A server that rejects the paging parameters: one plain request.

438+ let data = try await performRequest(method: "GET", path: "/api/v1/alerts")

439+ return (data, try Self.jsonDecoder.decode(AlertConfig.self, from: data))

440+ }

441+ let page = try Self.jsonDecoder.decode(AlertConfig.self, from: data)

442+ if firstData == nil {

443+ firstData = data

444+ version = page.version

445+ }

446+ let alerts = page.alerts ?? []

447+ let fresh = alerts.filter { seenIDs.insert($0.id).inserted }

448+ collected.append(contentsOf: fresh)

449+ if alerts.count < pageSize || fresh.isEmpty { break }

450+ offset += alerts.count

451+ }

452+ return (firstData ?? Data(), AlertConfig(alerts: collected, version: version))

453+ }

454+

412 do {

455 do {

413− let data = try await performRequest(method: "GET", path: "/api/v1/alerts")

456+ let (data, config) = try await modernAlerts()

414− let config = try Self.jsonDecoder.decode(AlertConfig.self, from: data)

415 // AlertConfig decodes leniently (every field via try?), so a 200 with

457 // AlertConfig decodes leniently (every field via try?), so a 200 with

416 // an unexpected body yields an empty, non-throwing config rather than

458 // an unexpected body yields an empty, non-throwing config rather than

417 // a DecodingError — indistinguishable from a server that genuinely has

459 // a DecodingError — indistinguishable from a server that genuinely has

ParseableViewer/ViewModels/LiveTailViewModel.swift+96−43

@@ -27,14 +27,26 @@ final class LiveTailViewModel {

27 /// column hidden last session would reappear visible when it shows up in a

28 /// later poll. This retains the intent so it stays hidden when it appears.

29 private var savedHiddenColumns: Set<String> = []

30+ /// The full persisted column order, including columns not yet seen this

31+ /// session — the order counterpart of `savedHiddenColumns`. A column that

32+ /// first shows up in a later poll is slotted back into its saved position

33+ /// (instead of being appended), and saving keeps unseen columns' positions

34+ /// rather than dropping them from the stored order.

35+ private var savedColumnOrder: [String] = []

30 private var currentStream: String?

36 private var currentStream: String?

32 // nonisolated(unsafe) so deinit can invalidate the timer.

38 // nonisolated(unsafe) so deinit can invalidate the timer.

33 // Only mutated from @MainActor methods (start/stop).

39 // Only mutated from @MainActor methods (start/stop).

34 nonisolated(unsafe) private var timer: Timer?

40 nonisolated(unsafe) private var timer: Timer?

35 private var lastTimestamp: Date?

41 private var lastTimestamp: Date?

42+ /// How many records with each content fingerprint have been delivered. A

43+ /// count rather than a set: Parseable stamps every event of one ingest request

44+ /// with the same millisecond `p_timestamp`, so genuinely repeated events (the

45+ /// same log line emitted three times) fingerprint identically. A set collapsed

46+ /// them into one row; counting keeps each occurrence while still suppressing

47+ /// the re-fetch of the same rows by the next overlapping poll window.

36− private var seenFingerprints: Set<String> = []

48+ private var seenFingerprints: [String: Int] = [:]

37− /// Insertion-ordered mirror of `seenFingerprints` (oldest first), used to

49+ /// Insertion-ordered mirror of `seenFingerprints` keys (oldest first), used to

38 /// evict the least-recently-seen fingerprints when the set is trimmed.

50 /// evict the least-recently-seen fingerprints when the set is trimmed.

39 private var seenFingerprintOrder: [String] = []

51 private var seenFingerprintOrder: [String] = []

40 /// Upper bound on the dedup fingerprint set. Kept well above `maxEntries` so

52 /// Upper bound on the dedup fingerprint set. Kept well above `maxEntries` so

@@ -164,6 +176,15 @@ final class LiveTailViewModel {

164 // include↔exclude stacks both and the AND'd filters match zero rows, so the

176 // include↔exclude stacks both and the AND'd filters match zero rows, so the

165 // tail silently empties.

177 // tail silently empties.

166 columnFilters.removeAll { $0.column == column && $0.value == value }

178 columnFilters.removeAll { $0.column == column && $0.value == value }

179+ if !exclude {

180+ // Include filters are AND-combined in rebuildFilteredEntries, but a column

181+ // can only equal one value, so two includes on the same column with

182+ // different values (e.g. level = info then level = error) can never both

183+ // match and the tail would silently empty. A new include therefore

184+ // replaces any prior include on that column. (Excludes legitimately stack:

185+ // col ≠ a AND col ≠ b is meaningful, so they are left untouched here.)

186+ columnFilters.removeAll { $0.column == column && !$0.exclude }

187+ }

167 columnFilters.append(ColumnFilter(column: column, value: value, exclude: exclude))

188 columnFilters.append(ColumnFilter(column: column, value: value, exclude: exclude))

168 rebuildFilteredEntries()

189 rebuildFilteredEntries()

169 }

190 }

@@ -200,7 +221,7 @@ final class LiveTailViewModel {

200 isPolling = false

221 isPolling = false

201 errorMessage = nil

222 errorMessage = nil

202 entries = []

223 entries = []

203− seenFingerprints = []

224+ seenFingerprints = [:]

204 seenFingerprintOrder = []

225 seenFingerprintOrder = []

205 allKnownKeys = []

226 allKnownKeys = []

206 droppedCount = 0

227 droppedCount = 0

@@ -211,6 +232,7 @@ final class LiveTailViewModel {

211 columnOrder = []

232 columnOrder = []

212 hiddenColumns = []

233 hiddenColumns = []

213 savedHiddenColumns = []

234 savedHiddenColumns = []

235+ savedColumnOrder = []

214 columnFilters = []

236 columnFilters = []

215 // Clear the text filter too. Leaving it set while clearing the column-filter

237 // Clear the text filter too. Leaving it set while clearing the column-filter

216 // chips is inconsistent and would let a stale search from a previous stream

238 // chips is inconsistent and would let a stale search from a previous stream

@@ -253,12 +275,12 @@ final class LiveTailViewModel {

253 // next timer tick skip itself via `guard !isPolling`.

275 // next timer tick skip itself via `guard !isPolling`.

254 isPolling = false

276 isPolling = false

255 entries = []

277 entries = []

256− seenFingerprints = []

278+ // Keep the dedup fingerprints (unlike start(), which begins a new session):

257− seenFingerprintOrder = []

279+ // every poll looks back at least 90 s regardless of `lastTimestamp` (see

258− // Advance the look-back floor to now: without this, the next poll queries

280+ // `safeStart` in poll()), so the records just cleared are re-fetched by the

259− // from the old `lastTimestamp` with an empty fingerprint set and re-inserts

281+ // next poll. With an emptied fingerprint set they all passed dedup again and

260− // every just-cleared record still inside the ~90 s window, repopulating the

282+ // the tail refilled with exactly what the user cleared. The set stays

261− // view the user just emptied. Matches start()'s reset.

283+ // bounded by the eviction in poll().

262 lastTimestamp = Date()

284 lastTimestamp = Date()

263 allKnownKeys = []

285 allKnownKeys = []

264 droppedCount = 0

286 droppedCount = 0

@@ -273,6 +295,7 @@ final class LiveTailViewModel {

273 columnOrder = []

295 columnOrder = []

274 hiddenColumns = []

296 hiddenColumns = []

275 savedHiddenColumns = []

297 savedHiddenColumns = []

298+ savedColumnOrder = []

276 columnFilters = []

299 columnFilters = []

277 // Match start(): clear the text filter alongside the column-filter chips so

300 // Match start(): clear the text filter alongside the column-filter chips so

278 // a clear()ed tail isn't immediately re-hidden by a lingering search string.

301 // a clear()ed tail isn't immediately re-hidden by a lingering search string.

@@ -328,6 +351,7 @@ final class LiveTailViewModel {

328

351

329 func resetColumnConfig() {

352 func resetColumnConfig() {

330 columnOrder = columns

353 columnOrder = columns

354+ savedColumnOrder = []

331 hiddenColumns.removeAll()

355 hiddenColumns.removeAll()

332 savedHiddenColumns.removeAll()

356 savedHiddenColumns.removeAll()

333 saveColumnConfig()

357 saveColumnConfig()

@@ -341,9 +365,16 @@ final class LiveTailViewModel {

341

365

342 private func saveColumnConfig() {

366 private func saveColumnConfig() {

343 guard let stream = currentStream else { return }

367 guard let stream = currentStream else { return }

344− // Persist the full intended hidden set (including columns not yet seen

368+ // Persist the full intended hidden set and order (including columns not

345− // this session) so it survives across restarts and incremental discovery.

369+ // yet seen this session) so they survive restarts and incremental discovery.

370+ let seen = Set(columnOrder)

371+ let order = QueryViewModel.mergedColumnOrder(

372+ columnOrder,

373+ inserting: savedColumnOrder.filter { !seen.contains($0) },

374+ reference: savedColumnOrder

375+ )

376+ savedColumnOrder = order

346− let config = QueryViewModel.ColumnConfiguration(order: columnOrder, hidden: savedHiddenColumns)

377+ let config = QueryViewModel.ColumnConfiguration(order: order, hidden: savedHiddenColumns)

347 if let data = try? JSONEncoder().encode(config) {

378 if let data = try? JSONEncoder().encode(config) {

348 UserDefaults.standard.set(data, forKey: Self.columnConfigKey(for: stream))

379 UserDefaults.standard.set(data, forKey: Self.columnConfigKey(for: stream))

349 }

380 }

@@ -385,10 +416,12 @@ final class LiveTailViewModel {

385 merged.append(col)

416 merged.append(col)

386 }

417 }

387 columnOrder = merged

418 columnOrder = merged

419+ savedColumnOrder = config.order

388 savedHiddenColumns = config.hidden

420 savedHiddenColumns = config.hidden

389 hiddenColumns = config.hidden.intersection(extractedSet)

421 hiddenColumns = config.hidden.intersection(extractedSet)

390 } else {

422 } else {

391 columnOrder = extracted

423 columnOrder = extracted

424+ savedColumnOrder = []

392 savedHiddenColumns = []

425 savedHiddenColumns = []

393 hiddenColumns = []

426 hiddenColumns = []

394 }

427 }

@@ -401,7 +434,7 @@ final class LiveTailViewModel {

401 }

434 }

402 if !newCols.isEmpty {

435 if !newCols.isEmpty {

403 columns.append(contentsOf: newCols)

436 columns.append(contentsOf: newCols)

404− columnOrder.append(contentsOf: newCols)

437+ columnOrder = QueryViewModel.mergedColumnOrder(columnOrder, inserting: newCols, reference: savedColumnOrder)

405 // Re-hide any newly appearing column that was hidden in a prior

438 // Re-hide any newly appearing column that was hidden in a prior

406 // session but hadn't been seen yet this run.

439 // session but hadn't been seen yet this run.

407 hiddenColumns.formUnion(newCols.filter { savedHiddenColumns.contains($0) })

440 hiddenColumns.formUnion(newCols.filter { savedHiddenColumns.contains($0) })

@@ -459,22 +492,27 @@ final class LiveTailViewModel {

459 // Process records off the main actor using a snapshot of seen fingerprints

492 // Process records off the main actor using a snapshot of seen fingerprints

460 let seenSnapshot = seenFingerprints

493 let seenSnapshot = seenFingerprints

461 let pollTime = now

494 let pollTime = now

462− let candidateEntries = await Task.detached(priority: .userInitiated) {

495+ let (candidateEntries, batchCounts) = await Task.detached(priority: .userInitiated) {

463− var results: [LiveTailEntry] = []

496+ var results: [(entry: LiveTailEntry, occurrence: Int)] = []

497+ var counts: [String: Int] = [:]

464 for record in records {

498 for record in records {

465 let fp = Self.fingerprint(for: record)

499 let fp = Self.fingerprint(for: record)

500+ let occurrence = (counts[fp] ?? 0) + 1

501+ counts[fp] = occurrence

502+ // The first `seen` occurrences of this content were delivered

503+ // by earlier polls; only later ones are new.

466− guard !seenSnapshot.contains(fp) else { continue }

504+ guard occurrence > (seenSnapshot[fp] ?? 0) else { continue }

467 let timestamp = Self.parseTimestamp(from: record) ?? pollTime

505 let timestamp = Self.parseTimestamp(from: record) ?? pollTime

468 let summary = Self.buildSummary(from: record)

506 let summary = Self.buildSummary(from: record)

469− results.append(LiveTailEntry(

507+ results.append((LiveTailEntry(

470 timestamp: timestamp,

508 timestamp: timestamp,

471 record: record,

509 record: record,

472 displayTimestamp: Self.displayFormatter.string(from: timestamp),

510 displayTimestamp: Self.displayFormatter.string(from: timestamp),

473 summary: summary,

511 summary: summary,

474 fingerprint: fp

512 fingerprint: fp

475− ))

513+ ), occurrence))

476 }

514 }

477− return results

515+ return (results, counts)

478 }.value

516 }.value

479

517

480 // Re-check after the detached processing hop: a stop/clear could have

518 // Re-check after the detached processing hop: a stop/clear could have

@@ -483,11 +521,13 @@ final class LiveTailViewModel {

483

521

484 // Authoritative dedup on main actor

522 // Authoritative dedup on main actor

485 var newEntries: [LiveTailEntry] = []

523 var newEntries: [LiveTailEntry] = []

486− for entry in candidateEntries {

524+ for candidate in candidateEntries

487− if seenFingerprints.insert(entry.fingerprint).inserted {

525+ where candidate.occurrence > (seenFingerprints[candidate.entry.fingerprint] ?? 0) {

526+ newEntries.append(candidate.entry)

527+ }

528+ for (fp, count) in batchCounts where count > (seenFingerprints[fp] ?? 0) {

488− seenFingerprintOrder.append(entry.fingerprint)

529+ if seenFingerprints[fp] == nil { seenFingerprintOrder.append(fp) }

489− newEntries.append(entry)

530+ seenFingerprints[fp] = count

490− }

491 }

531 }

492

532

493 if !newEntries.isEmpty {

533 if !newEntries.isEmpty {

@@ -509,23 +549,27 @@ final class LiveTailViewModel {

509 // would let it pass the dedup check and be re-appended as a

549 // would let it pass the dedup check and be re-appended as a

510 // duplicate. Keep the full seen-set so dedup stays correct;

550 // duplicate. Keep the full seen-set so dedup stays correct;

511 // it is bounded below to avoid unbounded growth.

551 // it is bounded below to avoid unbounded growth.

552+ }

553+

554+ // Bound the seen-set on every poll, not only when the buffer

555+ // overflows: clear() keeps fingerprints while emptying `entries`,

556+ // so the set can outgrow the cap without the buffer ever filling.

512− if seenFingerprints.count > maxSeenFingerprints {

557+ if seenFingerprints.count > maxSeenFingerprints {

513− // Evict the OLDEST surplus fingerprints by insertion order,

558+ // Evict the OLDEST surplus fingerprints by insertion order,

514− // not by what's currently buffered. Collapsing to only the

559+ // not by what's currently buffered. Collapsing to only the

515− // buffered set would drop recently-evicted fingerprints that

560+ // buffered set would drop recently-evicted fingerprints that

516− // still fall inside the next poll's ~90 s look-back window,

561+ // still fall inside the next poll's ~90 s look-back window,

517− // re-admitting those records as duplicates. Keeping the

562+ // re-admitting those records as duplicates. Keeping the

518− // most-recently-seen tail preserves a full window of evicted

563+ // most-recently-seen tail preserves a full window of evicted

519− // fingerprints. Buffered fingerprints are always retained so

564+ // fingerprints. Buffered fingerprints are always retained so

520− // a re-fetch of a buffered record stays deduplicated.

565+ // a re-fetch of a buffered record stays deduplicated.

521− let overflow = seenFingerprints.count - maxSeenFingerprints

566+ let overflow = seenFingerprints.count - maxSeenFingerprints

522− let buffered = Set(entries.map { $0.fingerprint })

567+ let buffered = Set(entries.map { $0.fingerprint })

523− let toDrop = Set(seenFingerprintOrder.prefix(overflow))

568+ let toDrop = Set(seenFingerprintOrder.prefix(overflow))

524− .subtracting(buffered)

569+ .subtracting(buffered)

525− if !toDrop.isEmpty {

570+ if !toDrop.isEmpty {

526− seenFingerprints.subtract(toDrop)

571+ for fp in toDrop { seenFingerprints.removeValue(forKey: fp) }

527− seenFingerprintOrder.removeAll { toDrop.contains($0) }

572+ seenFingerprintOrder.removeAll { toDrop.contains($0) }

528− }

529 }

573 }

530 }

574 }

531

575

@@ -680,10 +724,19 @@ final class LiveTailViewModel {

680 return nil

724 return nil

681 }

725 }

682 if case .string(let str) = value {

726 if case .string(let str) = value {

683− if let date = isoFractional.date(from: str) {

727+ if let date = isoFractional.date(from: str) ?? isoBasic.date(from: str) {

684 return date

728 return date

685 }

729 }

730+ // Parseable stores `p_timestamp` as an Arrow timestamp without a

731+ // timezone, and the query API serializes it as a naive UTC string with

732+ // no offset (e.g. "2024-01-11T09:08:34.290"). `.withInternetDateTime`

733+ // requires a zone designator, so such values never parsed: every entry

734+ // fell back to the poll time, which also scrambled the tail's order

735+ // (each poll's DESC-ordered batch was appended newest-first). Retry as

736+ // UTC; a string that already carries an offset won't parse with an

737+ // extra "Z", so this can't reinterpret zoned timestamps.

738+ let utc = str + "Z"

686− return isoBasic.date(from: str)

739+ return isoFractional.date(from: utc) ?? isoBasic.date(from: utc)

687 }

740 }

688 return nil

741 return nil

689 }

742 }

ParseableViewer/ViewModels/QueryViewModel.swift+274−51

@@ -59,9 +59,29 @@ final class QueryViewModel {

59 var columns: [String] = []

60 var columnOrder: [String] = []

61 var hiddenColumns: Set<String> = []

62+ /// The full persisted set of hidden columns for the current stream, including

63+ /// ones absent from the current result. Hiding a column drops it from the

64+ /// SELECT list, so it's missing from the very next result and `hiddenColumns`

65+ /// (only the columns present) forgets it — the next save would then erase the

66+ /// preference. This keeps the intent, mirroring LiveTailViewModel.

67+ private(set) var savedHiddenColumns: Set<String> = []

68+ /// The persisted column order including columns absent from the current

69+ /// result (the order counterpart of `savedHiddenColumns`), so saving doesn't

70+ /// drop a hidden column's position and it returns to its place when shown.

71+ private var savedColumnOrder: [String] = []

62 var autoHiddenColumns: Set<String> = []

72 var autoHiddenColumns: Set<String> = []

63 /// Column config from a saved query, applied on next query execution.

73 /// Column config from a saved query, applied on next query execution.

64 var pendingColumnConfig: ColumnConfiguration?

74 var pendingColumnConfig: ColumnConfiguration?

75+

76+ /// The connection and stream the editor text and results belong to. The view

77+ /// model outlives QueryView (switching tabs keeps the query), so the view

78+ /// compares this on appear to catch a stream/server change made while another

79+ /// tab was showing.

80+ struct BoundContext: Equatable {

81+ let connectionID: UUID?

82+ let stream: String

83+ }

84+ var boundContext: BoundContext?

65 private var currentStream: String?

85 private var currentStream: String?

66 var isLoading = false

86 var isLoading = false

67 var errorMessage: String?

87 var errorMessage: String?

@@ -80,6 +100,11 @@ final class QueryViewModel {

80 /// The stream of the most recent `loadSchema` call, used to drop a stale

100 /// The stream of the most recent `loadSchema` call, used to drop a stale

81 /// in-flight response when the user rapidly switches streams.

101 /// in-flight response when the user rapidly switches streams.

82 private(set) var latestSchemaStream: String?

102 private(set) var latestSchemaStream: String?

103+ /// The stream of the most recent `executeQuery` call. Defense-in-depth

104+ /// alongside `queryGeneration`/task cancellation: drops a stale in-flight

105+ /// query response if a newer query for a different stream supersedes it

106+ /// without going through the normal cancel path.

107+ private var latestQueryStream: String?

108

84 // Query task for cancellation

109 // Query task for cancellation

85 private var queryTask: Task<Void, Never>?

110 private var queryTask: Task<Void, Never>?

@@ -187,9 +212,16 @@ final class QueryViewModel {

187 return columnOrder.filter { !allHidden.contains($0) }

212 return columnOrder.filter { !allHidden.contains($0) }

188 }

213 }

189

214

215+ /// Whether any column is hidden — including saved-hidden columns that aren't

216+ /// in the current result, which "Show All" can bring back.

217+ var hasHiddenColumns: Bool {

218+ !hiddenColumns.isEmpty || !autoHiddenColumns.isEmpty || !savedHiddenColumns.isEmpty

219+ }

220+

190 func toggleColumnVisibility(_ column: String) {

221 func toggleColumnVisibility(_ column: String) {

191 if hiddenColumns.contains(column) {

222 if hiddenColumns.contains(column) {

192 hiddenColumns.remove(column)

223 hiddenColumns.remove(column)

224+ savedHiddenColumns.remove(column)

193 } else if autoHiddenColumns.contains(column) {

225 } else if autoHiddenColumns.contains(column) {

194 autoHiddenColumns.remove(column)

226 autoHiddenColumns.remove(column)

195 } else {

227 } else {

@@ -198,6 +230,7 @@ final class QueryViewModel {

198 let visibleCount = columnOrder.count - allHidden.count

230 let visibleCount = columnOrder.count - allHidden.count

199 if visibleCount > 1 {

231 if visibleCount > 1 {

200 hiddenColumns.insert(column)

232 hiddenColumns.insert(column)

233+ savedHiddenColumns.insert(column)

201 }

234 }

202 }

235 }

203 saveColumnConfig()

236 saveColumnConfig()

@@ -206,6 +239,7 @@ final class QueryViewModel {

206

239

207 func showAllColumns() {

240 func showAllColumns() {

208 hiddenColumns.removeAll()

241 hiddenColumns.removeAll()

242+ savedHiddenColumns.removeAll()

209 autoHiddenColumns.removeAll()

243 autoHiddenColumns.removeAll()

210 saveColumnConfig()

244 saveColumnConfig()

211 updateSQLColumns()

245 updateSQLColumns()

@@ -235,32 +269,116 @@ final class QueryViewModel {

235

269

236 func resetColumnConfig() {

270 func resetColumnConfig() {

237 columnOrder = columns

271 columnOrder = columns

272+ savedColumnOrder = []

238 hiddenColumns.removeAll()

273 hiddenColumns.removeAll()

274+ savedHiddenColumns.removeAll()

239 autoHiddenColumns.removeAll()

275 autoHiddenColumns.removeAll()

240 saveColumnConfig()

276 saveColumnConfig()

241 updateSQLColumns()

277 updateSQLColumns()

242 }

278 }

243

279

244− /// Rewrites the SELECT clause of `sqlQuery` to reflect the current `visibleColumns`.

280+ /// Rewrites the SELECT clause of `sqlQuery` to reflect the user's column

281+ /// choices (order and hidden columns; auto-hidden columns stay display-only).

245 func updateSQLColumns() {

282 func updateSQLColumns() {

246− guard let range = SQLTokenizer.selectColumnListRange(in: sqlQuery) else { return }

283+ guard let range = SQLTokenizer.selectColumnListRange(in: sqlQuery),

247−

284+ let currentList = Self.parseColumnList(sqlQuery[range]) else { return }

248− let visible = visibleColumns

285+

286+ // Project the user's choices only. `autoHiddenColumns` is a display

287+ // heuristic for the current rows (the field is empty in all of them);

288+ // baking it into the SQL would stop the field from ever being fetched

289+ // again, even for a time range where it has values.

290+ let visible = columnOrder.filter { !hiddenColumns.contains($0) }

249 guard !visible.isEmpty else { return }

291 guard !visible.isEmpty else { return }

250

292

293+ // Columns an explicit list names that aren't in the results: Parseable

294+ // omits all-null fields from query JSON, so a sparse listed field can be

295+ // missing from `columns`. Keep it (unless the user hid it) rather than

296+ // silently dropping it from the SELECT on the next rewrite.

297+ var listedButAbsent: [String] = []

298+ var excludesHiddenColumn = false

299+ if case .identifiers(let names) = currentList {

300+ let present = Set(columns)

301+ listedButAbsent = names.filter { !present.contains($0) && !savedHiddenColumns.contains($0) }

302+ // A column the user hid is absent from these results precisely

303+ // because this list was narrowed to exclude it.

304+ excludesHiddenColumn = !savedHiddenColumns.isSubset(of: present)

305+ }

306+

251 let newColumnList: String

307 let newColumnList: String

252 // Use `*` whenever every column is visible, regardless of display order —

308 // Use `*` whenever every column is visible, regardless of display order —

253 // reordering columns (a set-preserving permutation) must not pin the query

309 // reordering columns (a set-preserving permutation) must not pin the query

254− // to an explicit snapshot that hides newly-appearing fields on re-query.

310+ // to an explicit snapshot that hides newly-appearing fields on re-query —

311+ // unless the list is explicit because it leaves out a hidden column, which

312+ // `*` would fetch again.

255− if visible.count == columns.count && Set(visible) == Set(columns) {

313+ if !excludesHiddenColumn && visible.count == columns.count && Set(visible) == Set(columns) {

256 newColumnList = "*"

314 newColumnList = "*"

257 } else {

315 } else {

258− newColumnList = visible.map { Self.escapeSQLIdentifier($0) }.joined(separator: ", ")

316+ newColumnList = (visible + listedButAbsent).map { Self.escapeSQLIdentifier($0) }.joined(separator: ", ")

259 }

317 }

260

318

261 sqlQuery.replaceSubrange(range, with: newColumnList)

319 sqlQuery.replaceSubrange(range, with: newColumnList)

262 }

320 }

263

321

322+ enum ColumnListShape: Equatable {

323+ case star

324+ /// Plain column references, as the column names they resolve to.

325+ case identifiers([String])

326+ }

327+

328+ /// Parses a SELECT list the column manager can regenerate without changing

329+ /// what the query computes: `*`, or a comma-separated list of plain column

330+ /// references. Anything else — aggregates, expressions, aliases

331+ /// (`count(*) AS n`), qualified names — returns nil: rewriting it with `*` or

332+ /// bare result keys would break the query, so the column manager then only

333+ /// hides/reorders client-side.

334+ nonisolated static func parseColumnList(_ list: Substring) -> ColumnListShape? {

335+ let tokens = SQLTokenizer.tokenize(String(list)).filter { !$0.kind.isTrivia }

336+ if tokens.count == 1, tokens[0].kind == .star { return .star }

337+ guard tokens.count % 2 == 1 else { return nil }

338+ var names: [String] = []

339+ for (index, token) in tokens.enumerated() {

340+ if index % 2 == 1 {

341+ guard token.kind == .comma else { return nil }

342+ continue

343+ }

344+ switch token.kind {

345+ // DataFusion folds unquoted identifiers to lowercase.

346+ case .identifier(let name): names.append(name.lowercased())

347+ case .quotedIdentifier(let name): names.append(name)

348+ default: return nil

349+ }

350+ }

351+ return .identifiers(names)

352+ }

353+

354+ /// Inserts `newColumns` into `order`, placing each one that appears in

355+ /// `reference` (a saved order) right after its nearest saved predecessor

356+ /// that's already placed — or first if none is — and appending the rest.

357+ /// Used to keep the positions of columns that are absent for a while.

358+ nonisolated static func mergedColumnOrder(

359+ _ order: [String], inserting newColumns: [String], reference: [String]

360+ ) -> [String] {

361+ var result = order

362+ let referenceIndex = Dictionary(reference.enumerated().map { ($1, $0) }, uniquingKeysWith: { first, _ in first })

363+ let pending = newColumns.filter { referenceIndex[$0] == nil }

364+ let positioned = newColumns

365+ .filter { referenceIndex[$0] != nil }

366+ .sorted { referenceIndex[$0]! < referenceIndex[$1]! }

367+ for column in positioned where !result.contains(column) {

368+ let savedIndex = referenceIndex[column]!

369+ let predecessor = reference[..<savedIndex].reversed().first { result.contains($0) }

370+ if let predecessor, let position = result.firstIndex(of: predecessor) {

371+ result.insert(column, at: position + 1)

372+ } else {

373+ result.insert(column, at: 0)

374+ }

375+ }

376+ for column in pending where !result.contains(column) {

377+ result.append(column)

378+ }

379+ return result

380+ }

381+

264 // MARK: - Column Configuration Persistence

382 // MARK: - Column Configuration Persistence

265

383

266 struct ColumnConfiguration: Codable {

384 struct ColumnConfiguration: Codable {

@@ -274,7 +392,16 @@ final class QueryViewModel {

274

392

275 private func saveColumnConfig() {

393 private func saveColumnConfig() {

276 guard let stream = currentStream else { return }

394 guard let stream = currentStream else { return }

395+ // Persist the full intended hidden set and order, not just the currently

396+ // present columns (see `savedHiddenColumns` / `savedColumnOrder`).

397+ let present = Set(columnOrder)

398+ let order = Self.mergedColumnOrder(

399+ columnOrder,

400+ inserting: savedColumnOrder.filter { !present.contains($0) },

401+ reference: savedColumnOrder

402+ )

403+ savedColumnOrder = order

277− let config = ColumnConfiguration(order: columnOrder, hidden: hiddenColumns)

404+ let config = ColumnConfiguration(order: order, hidden: savedHiddenColumns.union(hiddenColumns))

278 if let data = try? JSONEncoder().encode(config) {

405 if let data = try? JSONEncoder().encode(config) {

279 UserDefaults.standard.set(data, forKey: Self.columnConfigKey(for: stream))

406 UserDefaults.standard.set(data, forKey: Self.columnConfigKey(for: stream))

280 }

407 }

@@ -303,7 +430,9 @@ final class QueryViewModel {

303

430

304 guard let config else {

431 guard let config else {

305 columnOrder = extractedColumns

432 columnOrder = extractedColumns

433+ savedColumnOrder = []

306 hiddenColumns = []

434 hiddenColumns = []

435+ savedHiddenColumns = []

307 return

436 return

308 }

437 }

309

438

@@ -316,6 +445,8 @@ final class QueryViewModel {

316 merged.append(col)

445 merged.append(col)

317 }

446 }

318 columnOrder = merged

447 columnOrder = merged

448+ savedColumnOrder = config.order

449+ savedHiddenColumns = config.hidden

319 hiddenColumns = config.hidden.intersection(extractedSet)

450 hiddenColumns = config.hidden.intersection(extractedSet)

320

451

321 // The `visibleCount > 1` guard in toggleColumnVisibility only covers

452 // The `visibleCount > 1` guard in toggleColumnVisibility only covers

@@ -415,6 +546,7 @@ final class QueryViewModel {

415 // the loading indicator during this query).

546 // the loading indicator during this query).

416 queryGeneration &+= 1

547 queryGeneration &+= 1

417 let generation = queryGeneration

548 let generation = queryGeneration

549+ latestQueryStream = stream

418

550

419 isLoading = true

551 isLoading = true

420 errorMessage = nil

552 errorMessage = nil

@@ -442,6 +574,9 @@ final class QueryViewModel {

442 // cancellation landing just after the check above would otherwise

574 // cancellation landing just after the check above would otherwise

443 // let a stale query clobber the newer one's results/columns.

575 // let a stale query clobber the newer one's results/columns.

444 guard !Task.isCancelled else { return }

576 guard !Task.isCancelled else { return }

577+ // Drop the response if a newer query (possibly for a different

578+ // stream) has since been launched without cancelling this task.

579+ guard latestQueryStream == stream else { return }

445

580

446 results = queryResults

581 results = queryResults

447 // Drop any prior row selection: the new result set reassigns row

582 // Drop any prior row selection: the new result set reassigns row

@@ -484,12 +619,23 @@ final class QueryViewModel {

484 return

619 return

485 } catch {

620 } catch {

486 guard !Task.isCancelled else { return }

621 guard !Task.isCancelled else { return }

622+ // Same supersession guard as the success path: a stale failed

623+ // query must not clobber a newer query's state.

624+ guard latestQueryStream == stream else { return }

487 errorMessage = ParseableError.userFriendlyMessage(for: error)

625 errorMessage = ParseableError.userFriendlyMessage(for: error)

488 if let serverError = error as? ParseableError,

626 if let serverError = error as? ParseableError,

489 case .serverError(_, let msg) = serverError,

627 case .serverError(_, let msg) = serverError,

490− let pos = SQLErrorPosition.parse(from: msg) {

628+ let pos = SQLErrorPosition.parse(from: msg),

629+ sqlQuery == sql {

630+ // The server's line/column is relative to the *submitted* SQL.

631+ // Only map it back into the editor when the editor still holds

632+ // that same text — if the user edited the query while it was in

633+ // flight, the position no longer corresponds to what's displayed

634+ // and would underline an unrelated span. (`sqlQuery`'s didSet

635+ // already cleared errorRange on that edit, so leaving it nil here

636+ // keeps the editor unmarked.)

491 errorRange = SQLTokenizer.errorHighlightRange(

637 errorRange = SQLTokenizer.errorHighlightRange(

492− line: pos.line, column: pos.column, in: sqlQuery

638+ line: pos.line, column: pos.column, in: sql

493 )

639 )

494 }

640 }

495 results = []

641 results = []

@@ -499,6 +645,8 @@ final class QueryViewModel {

499 // report stale column names after the failure.

645 // report stale column names after the failure.

500 columnOrder = []

646 columnOrder = []

501 hiddenColumns = []

647 hiddenColumns = []

648+ savedHiddenColumns = []

649+ savedColumnOrder = []

502 autoHiddenColumns = []

650 autoHiddenColumns = []

503 }

651 }

504 }

652 }

@@ -665,6 +813,8 @@ final class QueryViewModel {

665 columns = []

813 columns = []

666 columnOrder = []

814 columnOrder = []

667 hiddenColumns = []

815 hiddenColumns = []

816+ savedHiddenColumns = []

817+ savedColumnOrder = []

668 autoHiddenColumns = []

818 autoHiddenColumns = []

669 currentStream = nil

819 currentStream = nil

670 resultCount = 0

820 resultCount = 0

@@ -674,6 +824,11 @@ final class QueryViewModel {

674 errorRange = nil

824 errorRange = nil

675 resultsTruncated = false

825 resultsTruncated = false

676 schemaFields = []

826 schemaFields = []

827+ // Keep the stream trackers consistent with the cleared schema/results so

828+ // a later reload guard never sees a non-nil stream paired with empty data.

829+ latestSchemaStream = nil

830+ latestQueryStream = nil

831+ boundContext = nil

677 }

832 }

678

833

679 /// Modifies `sqlQuery` to add a column-value filter condition.

834 /// Modifies `sqlQuery` to add a column-value filter condition.

@@ -683,75 +838,139 @@ final class QueryViewModel {

683 let condition: String

838 let condition: String

684 if let value, value != .null {

839 if let value, value != .null {

685 let literal = value.sqlLiteral

840 let literal = value.sqlLiteral

841+ // Exclude with `IS DISTINCT FROM`, not `<>`: under SQL's three-valued

842+ // logic `NULL <> 'x'` is NULL, so `<>` also dropped every row where the

843+ // column is missing/NULL — common for sparse fields — which "exclude

844+ // this value" doesn't ask for (the live-tail exclude keeps them too).

845+ condition = exclude

846+ ? "\(escapedCol) IS DISTINCT FROM \(literal)"

686− condition = exclude ? "\(escapedCol) <> \(literal)" : "\(escapedCol) = \(literal)"

847+ : "\(escapedCol) = \(literal)"

687 } else {

848 } else {

688 condition = exclude ? "\(escapedCol) IS NOT NULL" : "\(escapedCol) IS NULL"

849 condition = exclude ? "\(escapedCol) IS NOT NULL" : "\(escapedCol) IS NULL"

689 }

850 }

690

851

691− var sql = sqlQuery.trimmingCharacters(in: .whitespacesAndNewlines)

852+ let sql = sqlQuery.trimmingCharacters(in: .whitespacesAndNewlines)

692 if sql.isEmpty { return }

853 if sql.isEmpty { return }

693

854

694 // Locate the top-level WHERE and the first trailing clause using the

855 // Locate the top-level WHERE and the first trailing clause using the

695 // tokenizer rather than a raw regex, so keywords inside quoted

856 // tokenizer rather than a raw regex, so keywords inside quoted

696 // identifiers, string literals, comments, or subqueries are ignored.

857 // identifiers, string literals, comments, or subqueries are ignored.

697− let tailKeywords: Set<String> = ["ORDER", "GROUP", "HAVING", "LIMIT", "OFFSET"]

858+ let tokens = SQLTokenizer.tokenize(sql)

698 var depth = 0

859 var depth = 0

699− var whereEnd: String.Index?

860+ // WHERE and the trailing clauses only follow the top-level FROM. Keywords

700− var tailStart: String.Index?

861+ // before it belong to the SELECT list — e.g. a field named `offset` or

862+ // `limit` (which the tokenizer reports as keywords) — and must not be

863+ // mistaken for clause starts.

864+ var fromSeen = false

865+ var whereIndex: Int?

866+ var tailIndex: Int?

701 // Track whether the existing WHERE body has a top-level OR — only then does

867 // Track whether the existing WHERE body has a top-level OR — only then does

702 // AND-ing a new condition need parentheses to preserve precedence.

868 // AND-ing a new condition need parentheses to preserve precedence.

703 var bodyHasTopLevelOr = false

869 var bodyHasTopLevelOr = false

704− for token in SQLTokenizer.tokenize(sql) {

870+ // The last token that is actual SQL — not whitespace, a comment, or a

871+ // statement-terminating `;`. New text is spliced in right after such

872+ // tokens (never at the raw end of the string), so a trailing `;` or a

873+ // trailing `-- comment` stays at the end instead of swallowing the

874+ // appended condition: `... LIMIT 10;` must not become `... LIMIT 10; WHERE`,

875+ // and `... -- note` must not become `... -- note WHERE <commented out>`.

876+ func isSignificant(_ token: SQLTokenizer.Token) -> Bool {

877+ !token.kind.isTrivia && token.kind != .other(";")

878+ }

879+ func nextSignificantKind(after index: Int) -> SQLTokenizer.TokenKind? {

880+ tokens[(index + 1)...].first(where: { isSignificant($0) })?.kind

881+ }

882+ // Whether the keyword at `index` actually opens a trailing clause. ORDER and

883+ // GROUP must be followed by BY (so `WITHIN GROUP (…)` or a column named

884+ // `order` doesn't count), and LIMIT/OFFSET by their row count (so a column

885+ // named `offset` in `WHERE offset > 5` doesn't cut the WHERE body short).

886+ func startsTrailingClause(_ keyword: String, at index: Int) -> Bool {

887+ switch keyword {

888+ case "ORDER", "GROUP":

889+ return nextSignificantKind(after: index) == .keyword("BY")

890+ case "LIMIT", "OFFSET":

891+ if case .number = nextSignificantKind(after: index) { return true }

892+ return false

893+ case "HAVING":

894+ return true

895+ default:

896+ return false

897+ }

898+ }

899+ var lastSignificant: Int?

900+ for (idx, token) in tokens.enumerated() {

901+ if isSignificant(token) { lastSignificant = idx }

705 switch token.kind {

902 switch token.kind {

706 case .leftParen:

903 case .leftParen:

707 depth += 1

904 depth += 1

708 case .rightParen:

905 case .rightParen:

709 depth = max(0, depth - 1)

906 depth = max(0, depth - 1)

907+ case .keyword("FROM") where depth == 0:

908+ fromSeen = true

710− case .keyword(let kw) where depth == 0:

909+ case .keyword(let kw) where depth == 0 && fromSeen:

711− if kw == "WHERE", whereEnd == nil {

910+ if kw == "WHERE", whereIndex == nil {

712− whereEnd = token.range.upperBound

911+ whereIndex = idx

713− } else if tailKeywords.contains(kw), tailStart == nil {

912+ // A trailing clause seen *before* the WHERE (e.g. the GROUP BY of

714− tailStart = token.range.lowerBound

913+ // the first SELECT in `... GROUP BY a UNION ALL SELECT ... WHERE`)

914+ // doesn't end this WHERE's body. Keeping it would make the body

915+ // range run backwards (a trapping `Range`), so look for the

916+ // body's end afresh after the WHERE.

917+ tailIndex = nil

918+ } else if tailIndex == nil, startsTrailingClause(kw, at: idx) {

919+ tailIndex = idx

715− } else if kw == "OR", whereEnd != nil, tailStart == nil {

920+ } else if kw == "OR", whereIndex != nil, tailIndex == nil {

716 bodyHasTopLevelOr = true

921 bodyHasTopLevelOr = true

717 }

922 }

718 default:

923 default:

719 break

924 break

720 }

925 }

721 }

926 }

722−

927+ // Nothing but comments/semicolons — there's no statement to filter.

723− if let whereEnd {

928+ guard let lastSignificant else { return }

929+

930+ // Each branch rebuilds the query from slices of the original text, keeping

931+ // the user's line breaks: joining pieces with single spaces would pull the

932+ // text after a `-- comment` onto the comment's line and comment it out.

933+ // Text spliced directly in front of another token (`(a = 1)ORDER BY`) needs

934+ // a space so the two don't fuse (`... IS NULLORDER BY`).

935+ func separated(_ rest: Substring) -> String {

936+ guard let next = rest.first, !next.isWhitespace, next != ";" else { return String(rest) }

937+ return " " + rest

938+ }

939+ if let whereIndex {

940+ // The WHERE body runs up to the first trailing clause, or to the end

941+ // of the statement. Only its significant tokens bound the splice, so a

942+ // comment between the body and ORDER BY stays after the new condition.

943+ let bodyEndIndex = tailIndex ?? (lastSignificant + 1)

944+ let bodyIndices = (whereIndex + 1)..<bodyEndIndex

945+ if let first = bodyIndices.first(where: { isSignificant(tokens[$0]) }),

946+ let last = bodyIndices.last(where: { isSignificant(tokens[$0]) }) {

724− // Parenthesize the existing WHERE body before AND-ing the new

947+ // Parenthesize the existing WHERE body before AND-ing the new

725− // condition only when it has a top-level OR, otherwise the OR

948+ // condition only when it has a top-level OR, otherwise the OR

726− // silently changes meaning: `WHERE a = 1 OR b = 2` would become

949+ // silently changes meaning: `WHERE a = 1 OR b = 2` would become

727− // `WHERE a = 1 OR b = 2 AND c = 3`, which SQL binds as

950+ // `WHERE a = 1 OR b = 2 AND c = 3`, which SQL binds as

728− // `a = 1 OR (b = 2 AND c = 3)` rather than the intended

951+ // `a = 1 OR (b = 2 AND c = 3)` rather than the intended

729− // `(a = 1 OR b = 2) AND c = 3`. A body without a top-level OR is

952+ // `(a = 1 OR b = 2) AND c = 3`. A body without a top-level OR is

730− // left un-parenthesized so simple filters stay readable.

953+ // left un-parenthesized so simple filters stay readable.

731− let bodyEnd = tailStart ?? sql.endIndex

954+ let bodyStart = tokens[first].range.lowerBound

732− let head = sql[..<whereEnd]

955+ let bodyEnd = tokens[last].range.upperBound

733− let body = sql[whereEnd..<bodyEnd].trimmingCharacters(in: .whitespacesAndNewlines)

956+ let body = sql[bodyStart..<bodyEnd]

734− let tail = sql[bodyEnd...].trimmingCharacters(in: .whitespacesAndNewlines)

957+ let wrappedBody = bodyHasTopLevelOr ? "(\(body))" : String(body)

735− // An empty WHERE body (e.g. a half-written `... WHERE` with no

958+ sqlQuery = "\(sql[..<bodyStart])\(wrappedBody) AND \(condition)\(separated(sql[bodyEnd...]))"

736− // condition yet, or `WHERE` immediately followed by ORDER/GROUP/

737− // LIMIT) would otherwise produce `WHERE AND <condition>` — a

738− // dangling AND with no left operand. Drop the AND in that case.

739− if body.isEmpty {

740− sql = "\(head) \(condition)"

741 } else {

959 } else {

742− let wrappedBody = bodyHasTopLevelOr ? "(\(body))" : body

960+ // An empty WHERE body (e.g. a half-written `... WHERE` with no

743− sql = "\(head) \(wrappedBody) AND \(condition)"

961+ // condition yet, or `WHERE` immediately followed by ORDER/GROUP/

962+ // LIMIT) would otherwise produce `WHERE AND <condition>` — a

963+ // dangling AND with no left operand. Drop the AND in that case.

964+ let whereEnd = tokens[whereIndex].range.upperBound

965+ sqlQuery = "\(sql[..<whereEnd]) \(condition)\(separated(sql[whereEnd...]))"

744 }

966 }

745− if !tail.isEmpty {

746− sql += " \(tail)"

747− }

748− } else if let tailStart {

967+ } else if let tailIndex {

968+ let tailStart = tokens[tailIndex].range.lowerBound

749− sql.insert(contentsOf: "WHERE \(condition) ", at: tailStart)

969+ sqlQuery = "\(sql[..<tailStart])WHERE \(condition) \(sql[tailStart...])"

750 } else {

970 } else {

751− sql += " WHERE \(condition)"

971+ let statementEnd = tokens[lastSignificant].range.upperBound

972+ sqlQuery = "\(sql[..<statementEnd]) WHERE \(condition)\(separated(sql[statementEnd...]))"

752 }

973 }

753−

754− sqlQuery = sql

755 }

974 }

756

975

757 /// Sets the default query for the given stream, returning `true` if the

976 /// Sets the default query for the given stream, returning `true` if the

@@ -795,6 +1014,10 @@ final class QueryViewModel {

795 // MARK: - Query History

1014 // MARK: - Query History

796

1015

797 private func addToHistory(_ entry: QueryHistoryEntry) {

1016 private func addToHistory(_ entry: QueryHistoryEntry) {

1017+ // Start from what's persisted, not this instance's copy: a model created

1018+ // earlier (e.g. one whose query finished after a reconnect replaced it)

1019+ // would otherwise overwrite newer entries saved by the current one.

1020+ queryHistory = Self.loadHistory()

798 // Deduplicate consecutive identical queries

1021 // Deduplicate consecutive identical queries

799 if queryHistory.first?.sql == entry.sql { return }

1022 if queryHistory.first?.sql == entry.sql { return }

800 queryHistory.insert(entry, at: 0)

1023 queryHistory.insert(entry, at: 0)

ParseableViewer/Views/AlertsView.swift+12−1

@@ -5,6 +5,10 @@ struct AlertsView: View {

5 @State private var alertConfig: AlertConfig?

6 @State private var isLoading = false

7 @State private var errorMessage: String?

8+ /// Bumped by every load. SwiftUI cancels the previous `.task(id:)` load on a

9+ /// stream switch, but that load still resumes (with a cancellation error) —

10+ /// and must not touch `isLoading`, which now belongs to the newer load.

11+ @State private var loadGeneration = 0

9 var body: some View {

13 var body: some View {

10 Group {

14 Group {

@@ -77,12 +81,16 @@ struct AlertsView: View {

77 private func loadAlerts(stream: String) async {

81 private func loadAlerts(stream: String) async {

78 guard let client = appState.client else { return }

82 guard let client = appState.client else { return }

79 let connID = appState.activeConnection?.id

83 let connID = appState.activeConnection?.id

84+ loadGeneration &+= 1

85+ let generation = loadGeneration

80 isLoading = true

86 isLoading = true

81 errorMessage = nil

87 errorMessage = nil

82 alertConfig = nil

88 alertConfig = nil

84 do {

90 do {

85 let config = try await client.getAlerts(stream: stream)

91 let config = try await client.getAlerts(stream: stream)

92+ // Superseded by a newer load: leave its spinner and state alone.

93+ guard generation == loadGeneration else { return }

86 // The manual Refresh/Retry buttons spawn detached Tasks not tied to

94 // The manual Refresh/Retry buttons spawn detached Tasks not tied to

87 // `.task(id: stream)` cancellation, so a slow refresh for the old stream

95 // `.task(id: stream)` cancellation, so a slow refresh for the old stream

88 // can resolve after a switch. Drop stale results. Check the connection

96 // can resolve after a switch. Drop stale results. Check the connection

@@ -94,6 +102,7 @@ struct AlertsView: View {

94 connID == appState.activeConnection?.id else { isLoading = false; return }

102 connID == appState.activeConnection?.id else { isLoading = false; return }

95 alertConfig = config

103 alertConfig = config

96 } catch {

104 } catch {

105+ guard generation == loadGeneration else { return }

97 guard stream == appState.selectedStream,

106 guard stream == appState.selectedStream,

98 connID == appState.activeConnection?.id else { isLoading = false; return }

107 connID == appState.activeConnection?.id else { isLoading = false; return }

99 errorMessage = ParseableError.userFriendlyMessage(for: error)

108 errorMessage = ParseableError.userFriendlyMessage(for: error)

@@ -203,7 +212,9 @@ struct AlertRowView: View {

203 private var stateColor: Color {

212 private var stateColor: Color {

204 switch alert.state?.lowercased() {

213 switch alert.state?.lowercased() {

205 case "triggered": return .red

214 case "triggered": return .red

206− case "disabled": return .gray

215+ case "disabled", "silenced": return .gray

216+ // Parseable's default, healthy state (and 2.x's "resolved") — not a warning.

217+ case "not-triggered", "resolved": return .green

207 // A reported-but-unrecognized state is a genuine "needs attention" signal,

218 // A reported-but-unrecognized state is a genuine "needs attention" signal,

208 // so tint it orange; a missing state is simply unknown and stays neutral so

219 // so tint it orange; a missing state is simply unknown and stays neutral so

209 // the bell icon isn't painted as a warning for every stateless alert.

220 // the bell icon isn't painted as a warning for every stateless alert.

ParseableViewer/Views/ConnectionSheet.swift+27−7

@@ -18,6 +18,10 @@ struct ConnectionSheet: View {

18 /// retry (after a failed connect) updates it in place rather than appending a

19 /// duplicate.

20 @State private var createdConnection: ServerConnection?

21+ /// Bumped on every field edit and every test run, so an in-flight Test

22+ /// Connection whose fields have since changed doesn't post its (now stale)

23+ /// success/failure under values that were never tested.

24+ @State private var testGeneration = 0

22 enum TestResult {

26 enum TestResult {

23 case success(String)

27 case success(String)

@@ -43,7 +47,7 @@ struct ConnectionSheet: View {

43 TextField("Name:", text: $name)

47 TextField("Name:", text: $name)

44 .textFieldStyle(.roundedBorder)

48 .textFieldStyle(.roundedBorder)

45 .accessibilityLabel("Connection name")

49 .accessibilityLabel("Connection name")

46− .onChange(of: name) { _, _ in testResult = nil }

50+ .onChange(of: name) { _, _ in invalidateTestResult() }

48 TextField("Server URL:", text: $url)

52 TextField("Server URL:", text: $url)

49 .textFieldStyle(.roundedBorder)

53 .textFieldStyle(.roundedBorder)

@@ -51,7 +55,7 @@ struct ConnectionSheet: View {

51 .onChange(of: url) { _, newValue in

55 .onChange(of: url) { _, newValue in

52 urlValidationError = Self.validateURL(newValue)

56 urlValidationError = Self.validateURL(newValue)

53 // A prior test result no longer reflects the edited fields.

57 // A prior test result no longer reflects the edited fields.

54− testResult = nil

58+ invalidateTestResult()

55 }

59 }

57 if let urlError = urlValidationError, !url.isEmpty {

61 if let urlError = urlValidationError, !url.isEmpty {

@@ -63,12 +67,12 @@ struct ConnectionSheet: View {

63 TextField("Username:", text: $username)

67 TextField("Username:", text: $username)

64 .textFieldStyle(.roundedBorder)

68 .textFieldStyle(.roundedBorder)

65 .accessibilityLabel("Username")

69 .accessibilityLabel("Username")

66− .onChange(of: username) { _, _ in testResult = nil }

70+ .onChange(of: username) { _, _ in invalidateTestResult() }

68 SecureField("Password:", text: $password)

72 SecureField("Password:", text: $password)

69 .textFieldStyle(.roundedBorder)

73 .textFieldStyle(.roundedBorder)

70 .accessibilityLabel("Password")

74 .accessibilityLabel("Password")

71− .onChange(of: password) { _, _ in testResult = nil }

75+ .onChange(of: password) { _, _ in invalidateTestResult() }

72 }

76 }

73 .formStyle(.grouped)

77 .formStyle(.grouped)

74 .padding()

78 .padding()

@@ -165,9 +169,16 @@ struct ConnectionSheet: View {

165 }

169 }

166 }

170 }

167

171

172+ private func invalidateTestResult() {

173+ testGeneration += 1

174+ testResult = nil

175+ }

176+

168 private func testConnection() {

177 private func testConnection() {

169 isTesting = true

178 isTesting = true

170 testResult = nil

179 testResult = nil

180+ testGeneration += 1

181+ let generation = testGeneration

171

182

172 Task {

183 Task {

173 do {

184 do {

@@ -179,14 +190,19 @@ struct ConnectionSheet: View {

179 )

190 )

180 let client = try ParseableClient(connection: conn)

191 let client = try ParseableClient(connection: conn)

181 try await client.checkHealth()

192 try await client.checkHealth()

193+ // The health endpoint doesn't check credentials; see

194+ // AppState.verifyCredentials.

195+ try await AppState.verifyCredentials(with: client)

182 await MainActor.run {

196 await MainActor.run {

183− testResult = .success("Connection successful")

184 isTesting = false

197 isTesting = false

198+ guard generation == testGeneration else { return }

199+ testResult = .success("Connection successful")

185 }

200 }

186 } catch {

201 } catch {

187 await MainActor.run {

202 await MainActor.run {

188− testResult = .failure(ParseableError.userFriendlyMessage(for: error))

189 isTesting = false

203 isTesting = false

204+ guard generation == testGeneration else { return }

205+ testResult = .failure(ParseableError.userFriendlyMessage(for: error))

190 }

206 }

191 }

207 }

192 }

208 }

@@ -221,6 +237,10 @@ struct ConnectionSheet: View {

221 dismiss()

237 dismiss()

222 } else {

238 } else {

223 testResult = .failure(appState.errorMessage ?? "Connection failed")

239 testResult = .failure(appState.errorMessage ?? "Connection failed")

240+ // The sheet reports the failure inline; drop the app-wide alert

241+ // performConnect also raised, which would otherwise surface

242+ // behind/after the sheet (or twice, from the Settings window).

243+ appState.showError = false

224 }

244 }

225 }

245 }

226 }

246 }

@@ -231,7 +251,7 @@ struct ConnectionSheet: View {

231 guard !trimmed.isEmpty else { return nil }

251 guard !trimmed.isEmpty else { return nil }

232

252

233 var normalized = trimmed

253 var normalized = trimmed

234− if !normalized.hasPrefix("http://") && !normalized.hasPrefix("https://") {

254+ if !ServerConnection.hasURLScheme(normalized) {

235 normalized = "https://\(normalized)"

255 normalized = "https://\(normalized)"

236 }

256 }

237

257

ParseableViewer/Views/ContentView.swift+26−1

@@ -31,6 +31,18 @@ struct ContentView: View {

32struct MainContentView: View {

33 @Environment(AppState.self) private var appState

34+ /// Kept here rather than inside QueryView so the Query tab's editor text,

35+ /// results and time range survive switching to another tab and back (only

36+ /// the active tab's view is instantiated). Dropped on disconnect, when this

37+ /// view goes away.

38+ @State private var queryViewModel = QueryViewModel()

39+

40+ /// Which server the Query tab's state belongs to. Editing the active

41+ /// connection's URL or user keeps its id (so QueryView's own stream/connection

42+ /// check can't see it), and a rename shouldn't wipe the user's query.

43+ private var serverIdentity: String? {

44+ appState.activeConnection.map { "\($0.id.uuidString)|\($0.url)|\($0.username)" }

45+ }

35 var body: some View {

47 var body: some View {

36 @Bindable var appState = appState

48 @Bindable var appState = appState

@@ -63,7 +75,7 @@ struct MainContentView: View {

63 } else {

75 } else {

64 switch appState.currentTab {

76 switch appState.currentTab {

65 case .query:

77 case .query:

66− QueryView()

78+ QueryView(viewModel: queryViewModel)

67 .id(AppState.AppTab.query)

79 .id(AppState.AppTab.query)

68 case .liveTail:

80 case .liveTail:

69 LiveTailView()

81 LiveTailView()

@@ -83,6 +95,19 @@ struct MainContentView: View {

83 }

95 }

84 }

96 }

85 }

97 }

98+ .onChange(of: serverIdentity) { _, _ in

99+ // The Query tab's model outlives stream and server changes made while

100+ // it isn't on screen. On a new server, drop the old one's results and

101+ // query (cancelling one still in flight) so the tab starts fresh.

102+ queryViewModel.clearResults()

103+ queryViewModel.sqlQuery = ""

104+ queryViewModel.filterText = ""

105+ }

106+ .onDisappear {

107+ // Disconnecting tears this view (and the model) down; don't leave an

108+ // in-flight query running against the server the user just left.

109+ queryViewModel.clearResults()

110+ }

86 }

111 }

87}

112}

113

ParseableViewer/Views/LiveTailView.swift+12−2

@@ -123,7 +123,10 @@ struct LiveTailView: View {

123 Image(systemName: "trash")

124 }

125 .help("Clear entries")

126+ // ⌘K, not ⌘⌫: command-key equivalents are dispatched before the

127+ // focused text field sees the keystroke, so ⌘⌫ (delete to start

128+ // of line) in the Filter field would wipe the whole buffer.

126− .keyboardShortcut(.delete, modifiers: .command)

129+ .keyboardShortcut("k", modifiers: .command)

127 .accessibilityLabel("Clear all entries")

130 .accessibilityLabel("Clear all entries")

128 }

131 }

129 .padding(8)

132 .padding(8)

@@ -284,7 +287,14 @@ struct LiveTailView: View {

284 columnWidths = [:]

287 columnWidths = [:]

285 cachedSorted = []

288 cachedSorted = []

286 }

289 }

287− .onChange(of: viewModel.visibleColumns) { _, _ in

290+ .onChange(of: viewModel.visibleColumns) { _, newColumns in

291+ // Hiding the sort column leaves no header to show or change the sort,

292+ // while rows stay ordered by the invisible value (and auto-scroll stays

293+ // off). Drop it like LogTableView does; the sortColumn change rebuilds.

294+ if let sortColumn, !newColumns.contains(sortColumn) {

295+ self.sortColumn = nil

296+ return

297+ }

288 // Showing/hiding a column changes the severity column set, so rebuild

298 // Showing/hiding a column changes the severity column set, so rebuild

289 // (which also fills in widths for any newly visible columns). A

299 // (which also fills in widths for any newly visible columns). A

290 // width-only update would leave row severity tinting stale until the

300 // width-only update would leave row severity tinting stale until the

ParseableViewer/Views/LogTableView.swift+53−6

@@ -315,7 +315,23 @@ struct LogTableView: View {

315 }

316 .onChange(of: sortColumn) { _, _ in debouncedRebuildSort() }

317 .onChange(of: sortAscending) { _, _ in debouncedRebuildSort() }

318+ .onChange(of: selectedRecord) { _, newValue in

319+ // The owner can drop the selection on its own (QueryViewModel

320+ // clears it after every query). When the new result set equals the

321+ // old one, `onChange(of: records)` doesn't fire, so nothing would

322+ // reconcile the row highlight: the row stayed highlighted with no

323+ // detail pane, and the next click on it merely "deselected" it.

324+ if newValue == nil { selectedIndex = nil }

325+ }

318 .onAppear {

326 .onAppear {

327+ // This branch is unmounted while results are empty (e.g. across a

328+ // stream switch, which clears them first), so `onChange(of: columns)`

329+ // never sees the switch. Drop a sort column the new columns don't

330+ // have — or hide — before sorting, or rows would be ordered by an

331+ // invisible column with no header showing the sort.

332+ if let sortColumn, !columns.contains(sortColumn) {

333+ self.sortColumn = nil

334+ }

319 recomputeColumnWidths(columns: columns, records: records)

335 recomputeColumnWidths(columns: columns, records: records)

320 rebuildSort()

336 rebuildSort()

321 }

337 }

@@ -401,6 +417,9 @@ struct LogTableView: View {

401 }

417 }

402

418

403 private func rebuildSort() {

419 private func rebuildSort() {

420+ // A debounced rebuild scheduled before the table unmounted must not land

421+ // after (and overwrite) this synchronous one.

422+ sortTask?.cancel()

404 let sevCols = buildSeverityColumnSet(columns: columns)

423 let sevCols = buildSeverityColumnSet(columns: columns)

405 let enumerated = Array(records.enumerated())

424 let enumerated = Array(records.enumerated())

406 let sorted: [(offset: Int, element: LogRecord)]

425 let sorted: [(offset: Int, element: LogRecord)]

@@ -476,12 +495,28 @@ struct LogHeaderView: View {

476

495

477 @State private var draggedColumn: String?

496 @State private var draggedColumn: String?

478 @State private var dropTargetColumn: String?

497 @State private var dropTargetColumn: String?

498+ /// `.contextMenu`'s builder runs during body evaluation, so the filter menus

499+ /// compute their values while the view is being rendered. Writing an `@State`

500+ /// dictionary from there is "modifying state during view update" (undefined

501+ /// behavior, and it re-invalidates the header). The cache is therefore a plain

502+ /// reference that isn't observed; `recordsGeneration` — bumped outside body

503+ /// evaluation — is what invalidates it and triggers the re-render.

479− @State private var uniqueValuesCache: [String: [JSONValue]] = [:]

504+ @State private var uniqueValuesCache = UniqueValuesCache()

505+ @State private var recordsGeneration = 0

506+

507+ private final class UniqueValuesCache {

508+ var generation = -1

509+ var values: [String: [JSONValue]] = [:]

510+ }

480

511

481 private static let maxFilterValues = 20

512 private static let maxFilterValues = 20

482

513

483 private func uniqueValues(for column: String) -> [JSONValue] {

514 private func uniqueValues(for column: String) -> [JSONValue] {

515+ if uniqueValuesCache.generation != recordsGeneration {

516+ uniqueValuesCache.generation = recordsGeneration

517+ uniqueValuesCache.values = [:]

518+ }

484− if let cached = uniqueValuesCache[column] {

519+ if let cached = uniqueValuesCache.values[column] {

485 return cached

520 return cached

486 }

521 }

487 var seen = Set<JSONValue>()

522 var seen = Set<JSONValue>()

@@ -493,7 +528,7 @@ struct LogHeaderView: View {

493 }

528 }

494 }

529 }

495 let sorted = result.sorted()

530 let sorted = result.sorted()

496− uniqueValuesCache[column] = sorted

531+ uniqueValuesCache.values[column] = sorted

497 return sorted

532 return sorted

498 }

533 }

499

534

@@ -636,7 +671,7 @@ struct LogHeaderView: View {

636 .background(Color(nsColor: .controlBackgroundColor))

671 .background(Color(nsColor: .controlBackgroundColor))

637 .border(Color.secondary.opacity(0.2), width: 0.5)

672 .border(Color.secondary.opacity(0.2), width: 0.5)

638 .onChange(of: records) { _, _ in

673 .onChange(of: records) { _, _ in

639− uniqueValuesCache = [:]

674+ recordsGeneration &+= 1

640 }

675 }

641 }

676 }

642}

677}

@@ -669,14 +704,26 @@ private struct ColumnDropDelegate: DropDelegate {

669 }

704 }

670

705

671 func performDrop(info: DropInfo) -> Bool {

706 func performDrop(info: DropInfo) -> Bool {

672− guard let dragged = draggedColumn, dragged != column else {

707+ guard let dragged = draggedColumn, dragged != column,

708+ let provider = info.itemProviders(for: [UTType.plainText]).first else {

673 draggedColumn = nil

709 draggedColumn = nil

674 dropTargetColumn = nil

710 dropTargetColumn = nil

675 return false

711 return false

676 }

712 }

677− onMoveColumn?(dragged, column)

678 draggedColumn = nil

713 draggedColumn = nil

679 dropTargetColumn = nil

714 dropTargetColumn = nil

715+ // `draggedColumn` is only cleared by a drop on a header, so a header drag

716+ // that was cancelled (or dropped elsewhere) leaves it set, and any later

717+ // plain-text drag onto a header would move that stale column. Only move

718+ // when the dropped payload really is the column header being dragged.

719+ let target = column

720+ let move = onMoveColumn

721+ _ = provider.loadObject(ofClass: NSString.self) { object, _ in

722+ guard let payload = object as? NSString, payload as String == dragged else { return }

723+ DispatchQueue.main.async {

724+ move?(dragged, target)

725+ }

726+ }

680 return true

727 return true

681 }

728 }

682

729

ParseableViewer/Views/QueryView.swift+43−9

@@ -12,7 +12,11 @@ private struct QueryViewContext: Equatable {

13struct QueryView: View {

14 @Environment(AppState.self) private var appState

15+ /// Owned by MainContentView, not by this view: only the active tab is

16+ /// mounted, so a view-local @State model was rebuilt on every tab switch —

17+ /// discarding the user's query, results, time range and filter and re-running

18+ /// the default query when they came back.

15− @State private var viewModel = QueryViewModel()

19+ let viewModel: QueryViewModel

16 @State private var showSaveFilterSheet = false

20 @State private var showSaveFilterSheet = false

17 @State private var saveFilterName = ""

21 @State private var saveFilterName = ""

18 @State private var isSavingFilter = false

22 @State private var isSavingFilter = false

@@ -247,6 +251,23 @@ struct QueryView: View {

247 isLoading: viewModel.isLoading,

251 isLoading: viewModel.isLoading,

248 wrapText: wrapText,

252 wrapText: wrapText,

249 onCellFilter: { column, value, exclude in

253 onCellFilter: { column, value, exclude in

254+ // Arrays/objects are List/Struct columns on the server; a

255+ // `col = '<json>'` comparison fails to plan, and the failed

256+ // run would clear the results the user is looking at.

257+ if let value, !value.isScalar {

258+ viewModel.errorMessage = "Filtering by an array or object value isn't supported in SQL queries."

259+ return

260+ }

261+ // Results from a blank editor come from the auto-generated

262+ // default query, which `addColumnFilter` can't see (it edits

263+ // `sqlQuery`); put that query in the editor so the filter

264+ // actually applies instead of silently re-running unfiltered.

265+ if viewModel.sqlQuery.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,

266+ let stream = appState.selectedStream {

267+ // (Passing a previous stream forces the replacement even

268+ // when the blank editor holds only whitespace.)

269+ viewModel.setDefaultQuery(stream: stream, previousStream: stream)

270+ }

250 viewModel.addColumnFilter(column: column, value: value, exclude: exclude)

271 viewModel.addColumnFilter(column: column, value: value, exclude: exclude)

251 Task {

272 Task {

252 await viewModel.executeQuery(

273 await viewModel.executeQuery(

@@ -269,6 +290,9 @@ struct QueryView: View {

269 let streamChanged = old.stream != new.stream

290 let streamChanged = old.stream != new.stream

270 if streamChanged {

291 if streamChanged {

271 viewModel.clearResults()

292 viewModel.clearResults()

293+ viewModel.boundContext = QueryViewModel.BoundContext(

294+ connectionID: appState.activeConnection?.id, stream: stream

295+ )

272 Task {

296 Task {

273 await viewModel.loadSchema(client: appState.client, stream: stream)

297 await viewModel.loadSchema(client: appState.client, stream: stream)

274 }

298 }

@@ -303,6 +327,21 @@ struct QueryView: View {

303 }

327 }

304 .onAppear {

328 .onAppear {

305 if let stream = appState.selectedStream {

329 if let stream = appState.selectedStream {

330+ // The view model outlives this view. If the stream (or server)

331+ // changed while another tab was showing, the state it kept belongs

332+ // to the old one — reset it exactly like a stream switch would.

333+ let context = QueryViewModel.BoundContext(

334+ connectionID: appState.activeConnection?.id, stream: stream

335+ )

336+ var previousStream: String?

337+ if let bound = viewModel.boundContext, bound != context {

338+ previousStream = bound.stream

339+ viewModel.clearResults()

340+ // A freshly built model (what this view used to get on every

341+ // mount) had no results filter; don't let an old one hide rows.

342+ viewModel.filterText = ""

343+ }

344+ viewModel.boundContext = context

306 // Reload the schema when it's missing OR when the loaded schema

345 // Reload the schema when it's missing OR when the loaded schema

307 // belongs to a different stream than the current one — otherwise a

346 // belongs to a different stream than the current one — otherwise a

308 // viewModel that survives with another stream's schema would keep

347 // viewModel that survives with another stream's schema would keep

@@ -328,7 +367,7 @@ struct QueryView: View {

328 )

367 )

329 }

368 }

330 } else {

369 } else {

331− let didSetDefault = viewModel.setDefaultQuery(stream: stream)

370+ let didSetDefault = viewModel.setDefaultQuery(stream: stream, previousStream: previousStream)

332 if didSetDefault && viewModel.results.isEmpty {

371 if didSetDefault && viewModel.results.isEmpty {

333 Task {

372 Task {

334 await viewModel.executeQuery(

373 await viewModel.executeQuery(

@@ -340,11 +379,6 @@ struct QueryView: View {

340 }

379 }

341 }

380 }

342 }

381 }

343− .onDisappear {

344− if viewModel.isLoading {

345− viewModel.cancelQuery()

346− }

347− }

348 .onChange(of: appState.queryRefreshToken) { _, _ in

382 .onChange(of: appState.queryRefreshToken) { _, _ in

349 // Guard on a selected stream like every sibling query trigger in this

383 // Guard on a selected stream like every sibling query trigger in this

350 // view. Without it, a refresh (Cmd+R) with no stream selected and an

384 // view. Without it, a refresh (Cmd+R) with no stream selected and an

@@ -462,7 +496,7 @@ struct ColumnManagerView: View {

462 Text("Columns")

496 Text("Columns")

463 .font(.headline)

497 .font(.headline)

464 Spacer()

498 Spacer()

465− if !viewModel.hiddenColumns.isEmpty || !viewModel.autoHiddenColumns.isEmpty || viewModel.columnOrder != viewModel.columns {

499+ if viewModel.hasHiddenColumns || viewModel.columnOrder != viewModel.columns {

466 Button("Reset") {

500 Button("Reset") {

467 viewModel.resetColumnConfig()

501 viewModel.resetColumnConfig()

468 }

502 }

@@ -516,7 +550,7 @@ struct ColumnManagerView: View {

516 }

550 }

517 .listStyle(.plain)

551 .listStyle(.plain)

518

552

519− if !viewModel.hiddenColumns.isEmpty || !viewModel.autoHiddenColumns.isEmpty {

553+ if viewModel.hasHiddenColumns {

520 Divider()

554 Divider()

521 Button("Show All Columns") {

555 Button("Show All Columns") {

522 viewModel.showAllColumns()

556 viewModel.showAllColumns()

ParseableViewer/Views/SQLAutoComplete.swift+98−11

@@ -105,23 +105,32 @@ enum SQLCompletionProvider {

105 return ([], "", NSRange(location: wordStart, length: wordEnd - wordStart))

106 }

107

108+ // Words typed inside a comment or a string literal aren't SQL, so offer

109+ // nothing there. Otherwise the popup opens (e.g. `-- grouped by date`

110+ // matches DATE) and the Return/Tab meant to end the line or keep typing is

111+ // captured to accept a keyword, rewriting the comment or the literal value.

112+ if isInsideCommentOrStringLiteral(text, offset: cursorPosition) {

113+ return ([], prefix, NSRange(location: wordStart, length: wordEnd - wordStart))

114+ }

115+

108 let context = determineContext(text: text, position: wordStart)

116 let context = determineContext(text: text, position: wordStart)

109

117

110− // A table completion supplies its own surrounding quotes. If the user has

118+ // Table (and column) completions supply their own quoting. If the user has

111 // already typed quotes directly around the word (common for stream names

119 // already typed quotes directly around the word (common for stream names

112 // with spaces, e.g. `FROM "my"`), absorb them into the replacement range so

120 // with spaces, e.g. `FROM "my"`), absorb them into the replacement range so

113 // the inserted `"name"` replaces the stray quotes instead of producing

121 // the inserted `"name"` replaces the stray quotes instead of producing

114 // `""name""`. Mirror `insertCompletion`, which absorbs leading and trailing

122 // `""name""`. Mirror `insertCompletion`, which absorbs leading and trailing

115− // quotes independently for any `.table` item — so apply this wherever table

123+ // quotes independently for any `.table`/`.column` item — so apply this

116− // completions are offered (`.tableRef` and `.general`), not just `.tableRef`.

124+ // wherever those completions are offered (`.tableRef`, `.columnRef` and

125+ // `.general`).

117 var replaceStart = wordStart

126 var replaceStart = wordStart

118 var replaceEnd = wordEnd

127 var replaceEnd = wordEnd

119− let offersTable: Bool

128+ let offersIdentifiers: Bool

120 switch context {

129 switch context {

121− case .tableRef, .general: offersTable = true

130+ case .tableRef, .columnRef, .general: offersIdentifiers = true

122− default: offersTable = false

131+ case .afterOrder, .afterGroup: offersIdentifiers = false

123 }

132 }

124− if offersTable {

133+ if offersIdentifiers {

125 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

134 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

126 replaceStart -= 1

135 replaceStart -= 1

127 }

136 }

@@ -147,7 +156,7 @@ enum SQLCompletionProvider {

147 case .columnRef:

156 case .columnRef:

148 for field in schemaFields.sorted(by: { $0.name < $1.name })

157 for field in schemaFields.sorted(by: { $0.name < $1.name })

149 where field.name.uppercased().hasPrefix(uppercasePrefix) {

158 where field.name.uppercased().hasPrefix(uppercasePrefix) {

150− items.append(SQLCompletionItem(text: field.name, kind: .column, detail: field.dataType))

159+ items.append(columnItem(for: field))

151 }

160 }

152 for fn in SQLSyntaxHighlighter.sortedFunctions where fn.hasPrefix(uppercasePrefix) {

161 for fn in SQLSyntaxHighlighter.sortedFunctions where fn.hasPrefix(uppercasePrefix) {

153 items.append(SQLCompletionItem(text: fn, kind: .function))

162 items.append(SQLCompletionItem(text: fn, kind: .function))

@@ -177,20 +186,87 @@ enum SQLCompletionProvider {

177 }

186 }

178 for field in schemaFields.sorted(by: { $0.name < $1.name })

187 for field in schemaFields.sorted(by: { $0.name < $1.name })

179 where field.name.uppercased().hasPrefix(uppercasePrefix) {

188 where field.name.uppercased().hasPrefix(uppercasePrefix) {

180− items.append(SQLCompletionItem(text: field.name, kind: .column, detail: field.dataType))

189+ items.append(columnItem(for: field))

181 }

190 }

182 }

191 }

183

192

184 // Don't show the popup when the only match is an exact hit. Compare the

193 // Don't show the popup when the only match is an exact hit. Compare the

185 // match text (unquoted), not the display text — a table's display text is

194 // match text (unquoted), not the display text — a table's display text is

186 // wrapped in quotes (`"name"`) and would never match the bare prefix.

195 // wrapped in quotes (`"name"`) and would never match the bare prefix.

196+ // Columns are the exception: one that needs quoting but was typed bare

197+ // (`statusCode`, which DataFusion would lowercase) must still be offered,

198+ // so a column only counts as an exact hit when accepting would leave the

199+ // text unchanged (the range already spans any quotes the user typed).

200+ if items.count == 1 {

201+ let only = items[0]

202+ let isExactHit = only.kind == .column

203+ ? nsText.substring(with: range) == only.text

187− if items.count == 1 && items[0].matchText.uppercased() == uppercasePrefix {

204+ : only.matchText.uppercased() == uppercasePrefix

188− return ([], prefix, range)

205+ if isExactHit { return ([], prefix, range) }

189 }

206 }

190

207

191 return (items, prefix, range)

208 return (items, prefix, range)

192 }

209 }

193

210

211+ /// Whether the UTF-16 `offset` falls inside a `--`/`/* */` comment or a

212+ /// `'...'` string literal. The caret at the very end of an unterminated

213+ /// literal/comment (or of a line comment) is still inside it.

214+ static func isInsideCommentOrStringLiteral(_ text: String, offset: Int) -> Bool {

215+ for token in SQLTokenizer.tokenize(text) {

216+ let range = NSRange(token.range, in: text)

217+ // Tokens are in order; one starting at or after the caret can't contain it.

218+ if range.location >= offset { break }

219+ let end = NSMaxRange(range)

220+ let isClosed: Bool

221+ switch token.kind {

222+ case .lineComment:

223+ isClosed = false

224+ case .blockComment:

225+ isClosed = range.length >= 4 && text[token.range].hasSuffix("*/")

226+ case .stringLiteral:

227+ // `''` escapes pair up, so a terminated literal has an even count.

228+ let quotes = text[token.range].filter { $0 == "'" }.count

229+ isClosed = range.length >= 2 && quotes % 2 == 0

230+ default:

231+ continue

232+ }

233+ if offset < end || (offset == end && !isClosed) { return true }

234+ }

235+ return false

236+ }

237+

238+ /// A column completion, double-quoted when the name wouldn't survive as a bare

239+ /// identifier. DataFusion (Parseable's query engine) folds unquoted identifiers

240+ /// to lowercase, so inserting a mixed-case field bare (`statusCode`) queries a

241+ /// nonexistent `statuscode`; names with dots, spaces, or other punctuation

242+ /// (e.g. OTel's `service.name`) wouldn't parse as one identifier at all. Plain

243+ /// lowercase names stay bare so the common case reads naturally.

244+ static func columnItem(for field: SchemaField) -> SQLCompletionItem {

245+ SQLCompletionItem(

246+ text: quotedIdentifierIfNeeded(field.name),

247+ kind: .column,

248+ detail: field.dataType,

249+ matchText: field.name

250+ )

251+ }

252+

253+ static func quotedIdentifierIfNeeded(_ name: String) -> String {

254+ let isPlainLowercase = name.unicodeScalars.enumerated().allSatisfy { index, scalar in

255+ switch scalar {

256+ case "a"..."z", "_": return true

257+ case "0"..."9": return index > 0

258+ default: return false

259+ }

260+ }

261+ // A bare keyword/function name (`order`, `user`, `limit`, `date`) would be

262+ // parsed as SQL syntax rather than as the column, so quote those too.

263+ let upper = name.uppercased()

264+ let isReservedWord = SQLSyntaxHighlighter.keywords.contains(upper)

265+ || SQLSyntaxHighlighter.functions.contains(upper)

266+ if !name.isEmpty && isPlainLowercase && !isReservedWord { return name }

267+ return QueryViewModel.escapeSQLIdentifier(name)

268+ }

269+

194 // MARK: - Context Detection

270 // MARK: - Context Detection

195

271

196 static func determineContext(text: String, position: Int) -> SQLCompletionContext {

272 static func determineContext(text: String, position: Int) -> SQLCompletionContext {

@@ -453,6 +529,17 @@ final class SQLCompletionPopup: NSObject, NSTableViewDataSource, NSTableViewDele

453

529

454 // MARK: - NSTableViewDelegate

530 // MARK: - NSTableViewDelegate

455

531

532+ func tableViewSelectionDidChange(_ notification: Notification) {

533+ // A single click selects a row in the table directly. Keep `selectedIndex`

534+ // — what Return/Tab accept and what the arrow keys move from — in sync,

535+ // otherwise Return inserts the previously highlighted item instead of the

536+ // one the user clicked.

537+ let row = tableView.selectedRow

538+ if row >= 0, row < items.count {

539+ selectedIndex = row

540+ }

541+ }

542+

456 func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {

543 func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {

457 guard row < items.count else { return nil }

544 guard row < items.count else { return nil }

458 let item = items[row]

545 let item = items[row]

ParseableViewer/Views/SQLEditorView.swift+41−6

@@ -57,7 +57,7 @@ struct SQLEditorView: NSViewRepresentable {

57 // Only update when text changed externally (not from user typing)

58 if textView.string != text && !context.coordinator.isEditing {

59 let selectedRanges = textView.selectedRanges

60− textView.string = text

60+ context.coordinator.replaceText(with: text, in: textView)

61 context.coordinator.applyHighlighting(to: textView)

62 // NSRange is UTF-16 based; compare against the NSString length, not

63 // String.count (grapheme count), or wide characters drop the selection.

@@ -101,6 +101,11 @@ struct SQLEditorView: NSViewRepresentable {

101 /// Tracks whether we are inserting a completion so that `textDidChange`

102 /// doesn't re-trigger the popup for the replacement.

103 private var isInsertingCompletion = false

104+ /// Set while `replaceText(with:in:)` pushes a model-side change (history

105+ /// pick, saved filter, cell filter, column toggle…) into the text view, so

106+ /// `textDidChange` doesn't echo it back into the binding or open the

107+ /// completion popup for text the user didn't type.

108+ private var isApplyingModelChange = false

104

109

105 init(text: Binding<String>, streamNames: [String], schemaFields: [SchemaField]) {

110 init(text: Binding<String>, streamNames: [String], schemaFields: [SchemaField]) {

106 self.text = text

111 self.text = text

@@ -116,7 +121,8 @@ struct SQLEditorView: NSViewRepresentable {

116 // MARK: - NSTextViewDelegate

121 // MARK: - NSTextViewDelegate

117

122

118 func textDidChange(_ notification: Notification) {

123 func textDidChange(_ notification: Notification) {

119− guard let textView = notification.object as? NSTextView else { return }

124+ guard let textView = notification.object as? NSTextView,

125+ !isApplyingModelChange else { return }

120 isEditing = true

126 isEditing = true

121 clearErrorHighlight(in: textView)

127 clearErrorHighlight(in: textView)

122 text.wrappedValue = textView.string

128 text.wrappedValue = textView.string

@@ -128,6 +134,34 @@ struct SQLEditorView: NSViewRepresentable {

128 }

134 }

129 }

135 }

130

136

137+ /// Replaces the editor's contents with text set from outside the editor.

138+ /// Assigning `textView.string` directly bypasses the text system's undo

139+ /// registration and leaves the user's earlier typing on the undo stack with

140+ /// ranges that belong to the old text — Cmd+Z would then edit an arbitrary

141+ /// span of the new query (or raise on an out-of-range undo). Routing the

142+ /// change through `shouldChangeText`/`didChangeText` records it as one

143+ /// undoable step, so Cmd+Z restores the previous query instead.

144+ func replaceText(with newText: String, in textView: NSTextView) {

145+ let fullRange = NSRange(location: 0, length: (textView.string as NSString).length)

146+ isApplyingModelChange = true

147+ defer { isApplyingModelChange = false }

148+ textView.breakUndoCoalescing()

149+ if textView.shouldChangeText(in: fullRange, replacementString: newText) {

150+ textView.replaceCharacters(in: fullRange, with: newText)

151+ textView.didChangeText()

152+ } else {

153+ textView.string = newText

154+ }

155+ textView.breakUndoCoalescing()

156+ }

157+

158+ func textDidEndEditing(_ notification: Notification) {

159+ // The popup is a separate child panel; without this it keeps floating

160+ // over the results (and accepting double-clicks) after focus moves to

161+ // another control.

162+ completionPopup.hide()

163+ }

164+

131 func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {

165 func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {

132 guard completionPopup.isVisible else { return false }

166 guard completionPopup.isVisible else { return false }

133

167

@@ -223,12 +257,13 @@ struct SQLEditorView: NSViewRepresentable {

223 }

257 }

224 }

258 }

225

259

260+ // Table and column completions carry their own quoting (a column is

226− // A table completion carries its own quotes; absorb any double-quote the

261+ // quoted only when it needs it); absorb any double-quote the user typed

227− // user typed directly around the word so the inserted `"name"` replaces

262+ // directly around the word so the inserted identifier replaces it

228− // it instead of leaving a stray quote. Leading and trailing are handled

263+ // instead of leaving a stray quote. Leading and trailing are handled

229 // independently: a closing quote can exist without an opening one (e.g.

264 // independently: a closing quote can exist without an opening one (e.g.

230 // `FROM my"`), which would otherwise produce a dangling `"name""`.

265 // `FROM my"`), which would otherwise produce a dangling `"name""`.

231− if item.kind == .table {

266+ if item.kind == .table || item.kind == .column {

232 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

267 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

233 wordStart -= 1

268 wordStart -= 1

234 }

269 }

ParseableViewer/Views/ServerInfoView.swift+12−2

@@ -9,6 +9,9 @@ struct ServerInfoView: View {

9 @State private var isLoading = true

10 @State private var isHealthy = false

11 @State private var errorMessage: String?

12+ /// Bumped by every load so a superseded (cancelled) load can't clear the

13+ /// newer load's spinner or overwrite its results.

14+ @State private var loadGeneration = 0

13 var body: some View {

16 var body: some View {

14 ScrollView {

17 ScrollView {

@@ -19,7 +22,7 @@ struct ServerInfoView: View {

19 .fontWeight(.semibold)

22 .fontWeight(.semibold)

20 Spacer()

23 Spacer()

21 Button {

24 Button {

22− Task { await loadInfo() }

25+ Task { await loadInfo(forceRefresh: true) }

23 } label: {

26 } label: {

24 Image(systemName: "arrow.clockwise")

27 Image(systemName: "arrow.clockwise")

25 }

28 }

@@ -153,12 +156,18 @@ struct ServerInfoView: View {

153 }

156 }

154 }

157 }

155

158

156− private func loadInfo() async {

159+ private func loadInfo(forceRefresh: Bool = false) async {

157 // Clear isLoading on the no-client path: since isLoading now starts `true`

160 // Clear isLoading on the no-client path: since isLoading now starts `true`

158 // (to avoid a red "Unhealthy" flash before the first check), an early return

161 // (to avoid a red "Unhealthy" flash before the first check), an early return

159 // without resetting it would wedge the spinner permanently.

162 // without resetting it would wedge the spinner permanently.

160 guard let client = appState.client else { isLoading = false; return }

163 guard let client = appState.client else { isLoading = false; return }

164+ // `getAbout()` is cached for 60 s; the Refresh button must bypass that.

165+ if forceRefresh {

166+ await client.invalidateCache()

167+ }

161 let connID = appState.activeConnection?.id

168 let connID = appState.activeConnection?.id

169+ loadGeneration &+= 1

170+ let generation = loadGeneration

162 isLoading = true

171 isLoading = true

163 errorMessage = nil

172 errorMessage = nil

164 // Seed from the app-wide cache so first load isn't blank, but never fall

173 // Seed from the app-wide cache so first load isn't blank, but never fall

@@ -189,6 +198,7 @@ struct ServerInfoView: View {

189 // load for the previous server can't overwrite the current one's state.

198 // load for the previous server can't overwrite the current one's state.

190 // Still clear isLoading: this task owns the spinner it set, and leaving it

199 // Still clear isLoading: this task owns the spinner it set, and leaving it

191 // true on the stale path wedges the ProgressView and disables Refresh.

200 // true on the stale path wedges the ProgressView and disables Refresh.

201+ guard generation == loadGeneration else { return }

192 guard connID == appState.activeConnection?.id else { isLoading = false; return }

202 guard connID == appState.activeConnection?.id else { isLoading = false; return }

193 isHealthy = healthy

203 isHealthy = healthy

194 about = aboutValue

204 about = aboutValue

ParseableViewer/Views/SidebarView.swift+19−1

@@ -6,6 +6,14 @@ struct SidebarView: View {

6 @State private var newStreamName = ""

7 @State private var showDeleteConfirm = false

8 @State private var streamToDelete: String?

9+ /// The connection `streamToDelete` was picked on. Stream names aren't unique

10+ /// across servers, and the delete runs against whatever client is current

11+ /// when the user confirms — so a server switch while the stats lookup was in

12+ /// flight could otherwise delete a same-named stream on the *new* server.

13+ @State private var streamToDeleteConnectionID: UUID?

14+ /// The client the stream was picked with. Editing the active connection's URL

15+ /// keeps its id but installs a new client for a possibly different server.

16+ @State private var streamToDeleteClient: ParseableClient?

9 @State private var deleteStreamDetail: String?

17 @State private var deleteStreamDetail: String?

11 /// Validates a stream name, returning an error message or nil if valid.

19 /// Validates a stream name, returning an error message or nil if valid.

@@ -65,7 +73,10 @@ struct SidebarView: View {

65 // would show the wrong stats on a destructive

73 // would show the wrong stats on a destructive

66 // confirmation.

74 // confirmation.

67 let target = stream.name

75 let target = stream.name

76+ let targetConnectionID = appState.activeConnection?.id

68 streamToDelete = target

77 streamToDelete = target

78+ streamToDeleteConnectionID = targetConnectionID

79+ streamToDeleteClient = appState.client

69 deleteStreamDetail = nil

80 deleteStreamDetail = nil

70 Task {

81 Task {

71 if let client = appState.client,

82 if let client = appState.client,

@@ -81,7 +92,9 @@ struct SidebarView: View {

81 deleteStreamDetail = parts.joined(separator: ", ")

92 deleteStreamDetail = parts.joined(separator: ", ")

82 }

93 }

83 }

94 }

84− if streamToDelete == target {

95+ if streamToDelete == target,

96+ appState.activeConnection?.id == targetConnectionID,

97+ appState.client === streamToDeleteClient {

85 showDeleteConfirm = true

98 showDeleteConfirm = true

86 }

99 }

87 }

100 }

@@ -187,6 +200,11 @@ struct SidebarView: View {

187 .alert("Delete Stream", isPresented: $showDeleteConfirm) {

200 .alert("Delete Stream", isPresented: $showDeleteConfirm) {

188 Button("Delete", role: .destructive) {

201 Button("Delete", role: .destructive) {

189 if let name = streamToDelete {

202 if let name = streamToDelete {

203+ guard appState.activeConnection?.id == streamToDeleteConnectionID,

204+ appState.client === streamToDeleteClient else {

205+ appState.showErrorMessage("The server changed since \"\(name)\" was selected, so it was not deleted.")

206+ return

207+ }

190 Task {

208 Task {

191 do {

209 do {

192 try await appState.deleteStream(name: name)

210 try await appState.deleteStream(name: name)

ParseableViewer/Views/StreamDetailView.swift+18−4

@@ -8,6 +8,9 @@ struct StreamDetailView: View {

8 @State private var retention: [RetentionConfig] = []

9 @State private var isLoading = false

10 @State private var errorMessage: String?

11+ /// Bumped by every load. A superseded load (its `.task(id:)` cancelled by a

12+ /// stream switch) still resumes, and must not clear the newer load's spinner.

13+ @State private var loadGeneration = 0

12 var body: some View {

15 var body: some View {

13 Group {

16 Group {

@@ -25,7 +28,7 @@ struct StreamDetailView: View {

25 Spacer()

28 Spacer()

27 Button {

30 Button {

28− Task { await loadData(stream: stream) }

31+ Task { await loadData(stream: stream, forceRefresh: true) }

29 } label: {

32 } label: {

30 Image(systemName: "arrow.clockwise")

33 Image(systemName: "arrow.clockwise")

31 }

34 }

@@ -44,7 +47,7 @@ struct StreamDetailView: View {

44 Text(error)

47 Text(error)

45 Spacer()

48 Spacer()

46 Button("Retry") {

49 Button("Retry") {

47− Task { await loadData(stream: stream) }

50+ Task { await loadData(stream: stream, forceRefresh: true) }

48 }

51 }

49 .buttonStyle(.bordered)

52 .buttonStyle(.bordered)

50 .controlSize(.small)

53 .controlSize(.small)

@@ -174,13 +177,22 @@ struct StreamDetailView: View {

174 }

177 }

175 }

178 }

176

179

177− private func loadData(stream: String) async {

180+ private func loadData(stream: String, forceRefresh: Bool = false) async {

178 guard let client = appState.client else { return }

181 guard let client = appState.client else { return }

182+ // The client caches schema/stats/info for 60 s. That's right for the

183+ // automatic load on appear, but an explicit Refresh/Retry must hit the

184+ // server — otherwise it repaints the same cached numbers and looks like a

185+ // refresh that found nothing new.

186+ if forceRefresh {

187+ await client.invalidateCache()

188+ }

179 // Capture the connection this fetch belongs to. Two servers can expose a

189 // Capture the connection this fetch belongs to. Two servers can expose a

180 // same-named stream, so guarding on the stream name alone would let a

190 // same-named stream, so guarding on the stream name alone would let a

181 // slow fetch write the previous server's data under the new server's

191 // slow fetch write the previous server's data under the new server's

182 // stream after a server switch.

192 // stream after a server switch.

183 let connID = appState.activeConnection?.id

193 let connID = appState.activeConnection?.id

194+ loadGeneration &+= 1

195+ let generation = loadGeneration

184 isLoading = true

196 isLoading = true

185 errorMessage = nil

197 errorMessage = nil

186 // Clear previous stream's data so it isn't shown under the new header

198 // Clear previous stream's data so it isn't shown under the new header

@@ -216,7 +228,9 @@ struct StreamDetailView: View {

216 // resolve after the user switched. Drop stale results instead of writing

228 // resolve after the user switched. Drop stale results instead of writing

217 // them under the new stream's header. Also check the connection so a

229 // them under the new stream's header. Also check the connection so a

218 // same-named stream on a different server doesn't accept the old server's

230 // same-named stream on a different server doesn't accept the old server's

219− // data. Reset `isLoading` on the stale path or the spinner wedges forever.

231+ // data. Reset `isLoading` on the stale path or the spinner wedges forever —

232+ // unless a newer load has started, which owns the spinner now.

233+ guard generation == loadGeneration else { return }

220 guard stream == appState.selectedStream, connID == appState.activeConnection?.id else {

234 guard stream == appState.selectedStream, connID == appState.activeConnection?.id else {

221 isLoading = false

235 isLoading = false

222 return

236 return

ParseableViewer/Views/SyntaxHighlighting.swift+32−58

@@ -49,10 +49,23 @@ enum SQLSyntaxHighlighter {

49 static let sortedFunctions: [String] = functions.sorted()

51 // Pre-compiled regexes (created once, reused every keystroke)

52+ //

53+ // String literals, quoted identifiers, and comments in ONE alternation, so a

54+ // single left-to-right scan claims each span for whichever construct starts

55+ // first — exactly how a SQL lexer reads it. Separate passes can't agree: an

56+ // apostrophe inside a comment (`-- don't`) opened a bogus string that painted

57+ // every following line red, and a `"` inside a string (or any quote inside a

58+ // block comment) did the same. Capture groups: 1 = 'string', 2 = "identifier",

59+ // 3 = `--` line comment or `/* */` block comment (unterminated runs to the end).

52− private static let commentRegex = try! NSRegularExpression(pattern: "--[^\n]*", options: [.caseInsensitive])

60+ private static let literalOrCommentRegex = try! NSRegularExpression(

53− private static let singleQuoteRegex = try! NSRegularExpression(pattern: "'[^']*(?:''[^']*)*'", options: [.caseInsensitive])

61+ pattern: "('[^']*(?:''[^']*)*')|(\"[^\"]*(?:\"\"[^\"]*)*\")|(--[^\\n]*|/\\*[\\s\\S]*?(?:\\*/|\\z))",

54− private static let doubleQuoteRegex = try! NSRegularExpression(pattern: "\"[^\"]*(?:\"\"[^\"]*)*\"", options: [.caseInsensitive])

62+ options: []

63+ )

64+ // Matches the same numeric forms as `SQLTokenizer.consumeNumber`: integers,

65+ // decimals, leading-dot floats (`.5`), and exponents (`1e5`, `1.5e-3`). The

66+ // lookbehind keeps digits that belong to an identifier (`col1`, `t.2`) from

67+ // being highlighted as numbers.

55− private static let numberRegex = try! NSRegularExpression(pattern: "\\b\\d+(?:\\.\\d+)?\\b", options: [])

68+ private static let numberRegex = try! NSRegularExpression(pattern: "(?<![\\w.])(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?", options: [])

56 private static let keywordRegex: NSRegularExpression = {

69 private static let keywordRegex: NSRegularExpression = {

57 let pattern = "\\b(?:" + sortedKeywords.joined(separator: "|") + ")\\b"

70 let pattern = "\\b(?:" + sortedKeywords.joined(separator: "|") + ")\\b"

58 return try! NSRegularExpression(pattern: pattern, options: [.caseInsensitive])

71 return try! NSRegularExpression(pattern: pattern, options: [.caseInsensitive])

@@ -76,20 +89,21 @@ enum SQLSyntaxHighlighter {

76 let nsText = text as NSString

89 let nsText = text as NSString

77 var protectedRanges: [NSRange] = []

90 var protectedRanges: [NSRange] = []

79− // 1. Single-quoted strings

92+ // 1–3. Single-quoted strings, double-quoted identifiers, and comments, in

80− applyRegex(singleQuoteRegex, to: textStorage, text: nsText,

93+ // one pass so none of them can start inside another (`'a--b'` stays a

81− color: .systemRed, protectedRanges: &protectedRanges)

94+ // string, `-- don't` stays a comment).

82−

95+ let literalMatches = literalOrCommentRegex.matches(

83− // 2. Double-quoted identifiers

96+ in: text, range: NSRange(location: 0, length: nsText.length)

84− applyRegex(doubleQuoteRegex, to: textStorage, text: nsText,

97+ )

85− color: .systemRed, protectedRanges: &protectedRanges)

98+ for match in literalMatches {

86−

99+ let isComment = match.range(at: 3).location != NSNotFound

87− // 3. Comments (-- to end of line). Highlighted AFTER strings, and a `--`

100+ textStorage.addAttribute(

88− // that begins inside a string literal (protectedRanges currently holds

101+ .foregroundColor,

89− // only string ranges) is skipped — otherwise `'a--b' AND y = 5` would

102+ value: isComment ? NSColor.secondaryLabelColor : NSColor.systemRed,

90− // bleed a gray comment over the trailing real SQL.

103+ range: match.range

91− applyCommentRegex(commentRegex, to: textStorage, text: nsText,

104+ )

92− color: .secondaryLabelColor, protectedRanges: &protectedRanges)

105+ protectedRanges.append(match.range)

106+ }

107

94 // 4. Numbers (outside protected ranges)

108 // 4. Numbers (outside protected ranges)

95 applyUnprotectedRegex(numberRegex, to: textStorage, text: nsText,

109 applyUnprotectedRegex(numberRegex, to: textStorage, text: nsText,

@@ -106,46 +120,6 @@ enum SQLSyntaxHighlighter {

106 protectedRanges: protectedRanges)

120 protectedRanges: protectedRanges)

107 }

121 }

108

122

109− private static func applyRegex(

110− _ regex: NSRegularExpression,

111− to textStorage: NSTextStorage,

112− text: NSString,

113− color: NSColor,

114− protectedRanges: inout [NSRange]

115− ) {

116− let matches = regex.matches(in: text as String, range: NSRange(location: 0, length: text.length))

117− for match in matches {

118− textStorage.addAttribute(.foregroundColor, value: color, range: match.range)

119− protectedRanges.append(match.range)

120− }

121− }

122−

123− /// Like `applyRegex`, but skips any match whose start falls inside an

124− /// already-claimed range (used for comments so a `--` inside a string literal

125− /// doesn't start a comment).

126− private static func applyCommentRegex(

127− _ regex: NSRegularExpression,

128− to textStorage: NSTextStorage,

129− text: NSString,

130− color: NSColor,

131− protectedRanges: inout [NSRange]

132− ) {

133− let matches = regex.matches(in: text as String, range: NSRange(location: 0, length: text.length))

134− for match in matches where !isStartProtected(match.range.location, by: protectedRanges) {

135− textStorage.addAttribute(.foregroundColor, value: color, range: match.range)

136− protectedRanges.append(match.range)

137− }

138− }

139−

140− private static func isStartProtected(_ location: Int, by protectedRanges: [NSRange]) -> Bool {

141− for protected in protectedRanges {

142− if location >= protected.location && location < NSMaxRange(protected) {

143− return true

144− }

145− }

146− return false

147− }

148−

149 private static func applyUnprotectedRegex(

123 private static func applyUnprotectedRegex(

150 _ regex: NSRegularExpression,

124 _ regex: NSRegularExpression,

151 to textStorage: NSTextStorage,

125 to textStorage: NSTextStorage,

ParseableViewer/Views/UsersView.swift+6

@@ -5,6 +5,9 @@ struct UsersView: View {

5 @State private var users: [UserInfo] = []

6 @State private var isLoading = false

7 @State private var errorMessage: String?

8+ /// Bumped by every load so a superseded (cancelled) load can't clear the

9+ /// newer load's spinner.

10+ @State private var loadGeneration = 0

9 var body: some View {

12 var body: some View {

10 VStack(spacing: 0) {

13 VStack(spacing: 0) {

@@ -82,6 +85,8 @@ struct UsersView: View {

82 private func loadUsers() async {

85 private func loadUsers() async {

83 guard let client = appState.client else { return }

86 guard let client = appState.client else { return }

84 let connID = appState.activeConnection?.id

87 let connID = appState.activeConnection?.id

88+ loadGeneration &+= 1

89+ let generation = loadGeneration

85 isLoading = true

90 isLoading = true

86 errorMessage = nil

91 errorMessage = nil

87 // Clear the previous server's list up front so it can't briefly show through

92 // Clear the previous server's list up front so it can't briefly show through

@@ -102,6 +107,7 @@ struct UsersView: View {

102 // Drop results if the active connection changed while awaiting. Still clear

107 // Drop results if the active connection changed while awaiting. Still clear

103 // isLoading: this task set the spinner, so leaving it true on the stale path

108 // isLoading: this task set the spinner, so leaving it true on the stale path

104 // wedges the ProgressView and disables Refresh.

109 // wedges the ProgressView and disables Refresh.

110+ guard generation == loadGeneration else { return }

105 guard connID == appState.activeConnection?.id else { isLoading = false; return }

111 guard connID == appState.activeConnection?.id else { isLoading = false; return }

106 if let loaded { users = loaded }

112 if let loaded { users = loaded }

107 errorMessage = loadError

113 errorMessage = loadError

ParseableViewerTests/LiveTailViewModelTests.swift+39−1

@@ -404,10 +404,23 @@ final class LiveTailViewModelTests: XCTestCase {

404 XCTAssertEqual(vm.columnFilters.count, 1)

405 }

406

407− func testAddFilterDifferentValueIsAdditive() {

407+ func testAddFilterSameColumnIncludeReplaces() {

408 let vm = LiveTailViewModel()

409 vm.addColumnFilter(column: "level", value: .string("error"), exclude: false)

410+ // A second include on the same column replaces the first: includes are

411+ // AND-combined and a column can only equal one value, so stacking two

412+ // includes would match zero rows and silently empty the tail.

410 vm.addColumnFilter(column: "level", value: .string("warn"), exclude: false)

413 vm.addColumnFilter(column: "level", value: .string("warn"), exclude: false)

414+ XCTAssertEqual(vm.columnFilters.count, 1)

415+ XCTAssertEqual(vm.columnFilters[0].value, .string("warn"))

416+ }

417+

418+ func testAddFilterSameColumnExcludesStack() {

419+ let vm = LiveTailViewModel()

420+ vm.addColumnFilter(column: "level", value: .string("debug"), exclude: true)

421+ // Excludes on the same column legitimately stack: level ≠ debug AND

422+ // level ≠ trace is meaningful, so both filters are retained.

423+ vm.addColumnFilter(column: "level", value: .string("trace"), exclude: true)

411 XCTAssertEqual(vm.columnFilters.count, 2)

424 XCTAssertEqual(vm.columnFilters.count, 2)

412 }

425 }

413

426

@@ -448,4 +461,29 @@ final class LiveTailViewModelTests: XCTestCase {

448 let filter = LiveTailViewModel.ColumnFilter(column: "field", value: nil, exclude: false)

461 let filter = LiveTailViewModel.ColumnFilter(column: "field", value: nil, exclude: false)

449 XCTAssertEqual(filter.displayLabel, "field = null")

462 XCTAssertEqual(filter.displayLabel, "field = null")

450 }

463 }

464+

465+ // MARK: - Zone-less timestamps / saved column order

466+

467+ func testParseTimestampTreatsZonelessAsUTC() {

468+ // Parseable serializes p_timestamp without a zone designator.

469+ let naive = LiveTailViewModel.parseTimestamp(from: ["p_timestamp": .string("2024-06-15T10:30:45.123")])

470+ let zoned = LiveTailViewModel.parseTimestamp(from: ["p_timestamp": .string("2024-06-15T10:30:45.123Z")])

471+ XCTAssertNotNil(naive)

472+ XCTAssertEqual(naive, zoned)

473+ let naiveWhole = LiveTailViewModel.parseTimestamp(from: ["p_timestamp": .string("2024-06-15T10:30:45")])

474+ XCTAssertEqual(naiveWhole, LiveTailViewModel.parseTimestamp(from: ["p_timestamp": .string("2024-06-15T10:30:45Z")]))

475+ }

476+

477+ func testMergedColumnOrderRestoresSavedPosition() {

478+ let merged = QueryViewModel.mergedColumnOrder(

479+ ["p_timestamp", "level", "message"],

480+ inserting: ["trace_id"],

481+ reference: ["p_timestamp", "trace_id", "level", "message"]

482+ )

483+ XCTAssertEqual(merged, ["p_timestamp", "trace_id", "level", "message"])

484+ }

485+

486+ func testMergedColumnOrderAppendsColumnsWithoutSavedPosition() {

487+ XCTAssertEqual(QueryViewModel.mergedColumnOrder(["a"], inserting: ["b"], reference: []), ["a", "b"])

488+ }

451}

489}

ParseableViewerTests/ParseableClientTests.swift+58

@@ -646,4 +646,62 @@ final class ParseableClientTests: XCTestCase {

646 // Carriage returns in values should be wrapped in quotes per RFC 4180

647 XCTAssertTrue(csv.contains("\"line1\r\nline2\""))

648 }

649+

650+ // MARK: - Server response key spellings

651+

652+ func testServerAboutDecodesCamelCaseKeys() throws {

653+ let json = #"{"uiVersion": "v1.2", "deploymentId": "01H", "grpcPort": 8001}"#.data(using: .utf8)!

654+ let about = try JSONDecoder().decode(ServerAbout.self, from: json)

655+ XCTAssertEqual(about.uiVersion, "v1.2")

656+ XCTAssertEqual(about.deploymentId, "01H")

657+ XCTAssertEqual(about.grpcPort, 8001)

658+ }

659+

660+ func testStreamInfoDecodesSnakeCaseKeys() throws {

661+ let json = #"{"created-at": "c", "first-event-at": "f", "time_partition": "ts", "static_schema_flag": "true", "cache_enabled": true}"#

662+ .data(using: .utf8)!

663+ let info = try JSONDecoder().decode(StreamInfo.self, from: json)

664+ XCTAssertEqual(info.createdAt, "c")

665+ XCTAssertEqual(info.firstEventAt, "f")

666+ XCTAssertEqual(info.timePartition, "ts")

667+ XCTAssertEqual(info.staticSchemaFlag, true)

668+ XCTAssertEqual(info.cacheEnabled, true)

669+ }

670+

671+ func testStreamInfoDecodesCamelCaseKeys() throws {

672+ let json = #"{"createdAt": "c", "firstEventAt": "f", "timePartition": "ts", "staticSchemaFlag": "true"}"#

673+ .data(using: .utf8)!

674+ let info = try JSONDecoder().decode(StreamInfo.self, from: json)

675+ XCTAssertEqual(info.createdAt, "c")

676+ XCTAssertEqual(info.firstEventAt, "f")

677+ XCTAssertEqual(info.timePartition, "ts")

678+ XCTAssertEqual(info.staticSchemaFlag, true)

679+ }

680+

681+ func testStorageStatsReadsFormatAndUnitSuffixedSizes() throws {

682+ let json = #"{"storage": {"size": "2048 Bytes", "format": "parquet"}}"#.data(using: .utf8)!

683+ let stats = try JSONDecoder().decode(StreamStats.self, from: json)

684+ XCTAssertEqual(stats.storage?.type, "parquet")

685+ XCTAssertEqual(stats.storage?.size, ByteCountFormatter.string(fromByteCount: 2048, countStyle: .file))

686+ }

687+

688+ func testSchemaFieldDescribesParameterizedArrowTypes() throws {

689+ let json = #"{"name": "p_timestamp", "data_type": {"Timestamp": ["Millisecond", null]}}"#.data(using: .utf8)!

690+ let field = try JSONDecoder().decode(SchemaField.self, from: json)

691+ XCTAssertEqual(field.dataType, "Timestamp(Millisecond, None)")

692+ }

693+

694+ func testLegacyAlertRuleWithObjectConfigKeepsRuleType() throws {

695+ let json = #"{"name": "a", "rule": {"type": "column", "config": {"column": "status", "operator": "=", "value": 500}}}"#

696+ .data(using: .utf8)!

697+ let rule = try JSONDecoder().decode(AlertRule.self, from: json)

698+ XCTAssertEqual(rule.rule?.type, "column")

699+ XCTAssertNotNil(rule.rule?.config)

700+ }

701+

702+ func testServerAboutDecodesObjectLicense() throws {

703+ let json = #"{"license": {"name": "AGPL-3.0-only", "plan": "OSS"}}"#.data(using: .utf8)!

704+ let about = try JSONDecoder().decode(ServerAbout.self, from: json)

705+ XCTAssertEqual(about.license, "AGPL-3.0-only (OSS)")

706+ }

649}

707}

ParseableViewerTests/QueryViewModelTests.swift+122−2

@@ -235,7 +235,7 @@ final class QueryViewModelTests: XCTestCase {

235 let vm = QueryViewModel()

236 vm.sqlQuery = "SELECT * FROM \"logs\" ORDER BY p_timestamp DESC LIMIT 1000"

237 vm.addColumnFilter(column: "level", value: .string("debug"), exclude: true)

238− XCTAssertTrue(vm.sqlQuery.contains("WHERE \"level\" <> 'debug'"))

238+ XCTAssertTrue(vm.sqlQuery.contains("WHERE \"level\" IS DISTINCT FROM 'debug'"))

239 XCTAssertTrue(vm.sqlQuery.contains("ORDER BY"))

240 }

241

@@ -288,7 +288,7 @@ final class QueryViewModelTests: XCTestCase {

288 let vm = QueryViewModel()

289 vm.sqlQuery = "SELECT * FROM \"logs\""

290 vm.addColumnFilter(column: "level", value: .string("warn"), exclude: true)

291− XCTAssertTrue(vm.sqlQuery.contains("WHERE \"level\" <> 'warn'"))

291+ XCTAssertTrue(vm.sqlQuery.contains("WHERE \"level\" IS DISTINCT FROM 'warn'"))

292 }

293

294 func testAddColumnFilterEscapesSingleQuotesInValue() {

@@ -671,5 +671,125 @@ final class QueryViewModelTests: XCTestCase {

671 let empty = vm.emptyColumns(in: records, columns: ["a"])

672 XCTAssertTrue(empty.isEmpty)

673 }

674+

675+ // MARK: - Column filter edge cases

676+

677+ func testAddColumnFilterKeepsTrailingSemicolonLast() {

678+ let vm = QueryViewModel()

679+ vm.sqlQuery = "SELECT * FROM \"logs\";"

680+ vm.addColumnFilter(column: "level", value: .string("error"), exclude: false)

681+ XCTAssertEqual(vm.sqlQuery, "SELECT * FROM \"logs\" WHERE \"level\" = 'error';")

682+ }

683+

684+ func testAddColumnFilterDoesNotLandInTrailingComment() {

685+ let vm = QueryViewModel()

686+ vm.sqlQuery = "SELECT * FROM \"logs\" -- recent"

687+ vm.addColumnFilter(column: "level", value: .string("error"), exclude: false)

688+ XCTAssertEqual(vm.sqlQuery, "SELECT * FROM \"logs\" WHERE \"level\" = 'error' -- recent")

689+ }

690+

691+ func testAddColumnFilterKeepsLineBreakAfterWhereBodyComment() {

692+ let vm = QueryViewModel()

693+ vm.sqlQuery = "SELECT * FROM \"logs\"\nWHERE a = 1 -- note\nORDER BY p_timestamp DESC"

694+ vm.addColumnFilter(column: "host", value: .string("web-1"), exclude: false)

695+ XCTAssertEqual(

696+ vm.sqlQuery,

697+ "SELECT * FROM \"logs\"\nWHERE a = 1 AND \"host\" = 'web-1' -- note\nORDER BY p_timestamp DESC"

698+ )

699+ }

700+

701+ func testAddColumnFilterWithTrailingClauseBeforeWhereDoesNotCrash() {

702+ let vm = QueryViewModel()

703+ vm.sqlQuery = "SELECT a FROM t1 GROUP BY a UNION ALL SELECT a FROM t2 WHERE b = 1"

704+ vm.addColumnFilter(column: "host", value: .string("web-1"), exclude: false)

705+ XCTAssertEqual(

706+ vm.sqlQuery,

707+ "SELECT a FROM t1 GROUP BY a UNION ALL SELECT a FROM t2 WHERE b = 1 AND \"host\" = 'web-1'"

708+ )

709+ }

710+

711+ func testAddColumnFilterIgnoresKeywordNamedColumnsInSelectList() {

712+ let vm = QueryViewModel()

713+ vm.sqlQuery = "SELECT offset, message FROM \"kafka\" WHERE partition = 3"

714+ vm.addColumnFilter(column: "host", value: .string("web-1"), exclude: false)

715+ XCTAssertEqual(

716+ vm.sqlQuery,

717+ "SELECT offset, message FROM \"kafka\" WHERE partition = 3 AND \"host\" = 'web-1'"

718+ )

719+ }

720+

721+ // MARK: - SELECT list rewriting

722+

723+ func testUpdateSQLColumnsLeavesExpressionListsAlone() {

724+ let vm = QueryViewModel()

725+ let sql = "SELECT count(*) AS n, level FROM \"logs\" GROUP BY level"

726+ vm.sqlQuery = sql

727+ vm.columns = ["n", "level"]

728+ vm.columnOrder = ["n", "level"]

729+ vm.toggleColumnVisibility("n")

730+ XCTAssertEqual(vm.sqlQuery, sql)

731+ XCTAssertEqual(vm.visibleColumns, ["level"])

732+ }

733+

734+ func testUpdateSQLColumnsDoesNotBakeInAutoHiddenColumns() {

735+ let vm = QueryViewModel()

736+ vm.sqlQuery = "SELECT * FROM \"logs\""

737+ vm.columns = ["a", "b", "c"]

738+ vm.columnOrder = ["a", "b", "c"]

739+ vm.autoHiddenColumns = ["c"]

740+ vm.moveColumn("b", to: "a")

741+ XCTAssertEqual(vm.sqlQuery, "SELECT * FROM \"logs\"")

742+ }

743+

744+ func testUpdateSQLColumnsKeepsHiddenColumnOutAfterNarrowedRerun() {

745+ // Hiding `c` narrowed the SELECT list, so the re-run's results lack it; a

746+ // later reorder must not switch back to `*` and fetch it again.

747+ let vm = QueryViewModel()

748+ vm.sqlQuery = "SELECT \"a\", \"b\" FROM \"logs\""

749+ vm.pendingColumnConfig = QueryViewModel.ColumnConfiguration(order: ["a", "b", "c"], hidden: ["c"])

750+ vm.applyColumnConfig(extractedColumns: ["a", "b"], stream: nil)

751+ vm.moveColumn("b", to: "a")

752+ XCTAssertEqual(vm.sqlQuery, "SELECT \"b\", \"a\" FROM \"logs\"")

753+ XCTAssertTrue(vm.hasHiddenColumns)

754+ vm.showAllColumns()

755+ XCTAssertEqual(vm.sqlQuery, "SELECT * FROM \"logs\"")

756+ }

757+

758+ func testExcludeFilterKeepsRowsWhereColumnIsNull() {

759+ let vm = QueryViewModel()

760+ vm.sqlQuery = "SELECT * FROM \"logs\""

761+ vm.addColumnFilter(column: "level", value: .string("debug"), exclude: true)

762+ XCTAssertFalse(vm.sqlQuery.contains("<>"), "`<>` would also drop rows where level is NULL")

763+ XCTAssertTrue(vm.sqlQuery.contains("\"level\" IS DISTINCT FROM 'debug'"))

764+ }

765+

766+ func testUpdateSQLColumnsKeepsListedColumnsMissingFromResults() {

767+ // Parseable omits all-null fields from query JSON, so a listed column can

768+ // be absent from `columns`; rewriting must neither refuse nor drop it.

769+ let vm = QueryViewModel()

770+ vm.sqlQuery = "SELECT \"a\", \"b\", \"c\", \"sparse\" FROM \"logs\""

771+ vm.columns = ["a", "b", "c"]

772+ vm.columnOrder = ["a", "b", "c"]

773+ vm.toggleColumnVisibility("c")

774+ XCTAssertEqual(vm.sqlQuery, "SELECT \"a\", \"b\", \"sparse\" FROM \"logs\"")

775+ }

776+

777+ func testReorderKeepsStarWhenSavedHiddenColumnIsAbsentAnyway() {

778+ // Under `SELECT *` a saved-hidden column that's missing is missing for

779+ // other reasons (sparse/removed); a plain reorder must keep `*`.

780+ let vm = QueryViewModel()

781+ vm.sqlQuery = "SELECT * FROM \"logs\""

782+ vm.pendingColumnConfig = QueryViewModel.ColumnConfiguration(order: ["a", "b", "gone"], hidden: ["gone"])

783+ vm.applyColumnConfig(extractedColumns: ["a", "b"], stream: nil)

784+ vm.moveColumn("b", to: "a")

785+ XCTAssertEqual(vm.sqlQuery, "SELECT * FROM \"logs\"")

786+ }

787+

788+ func testMergedColumnOrderKeepsSavedPositionForAbsentColumn() {

789+ XCTAssertEqual(

790+ QueryViewModel.mergedColumnOrder(["b", "a"], inserting: ["x"], reference: ["a", "x", "b"]),

791+ ["b", "a", "x"]

792+ )

793+ }

674}

794}

675

795

ParseableViewerTests/SQLAutoCompleteTests.swift+56

@@ -275,6 +275,62 @@ final class SQLAutoCompleteTests: XCTestCase {

275 let ctx = SQLCompletionProvider.determineContext(text: "SELECT * FROM a LEFT JOIN ", position: 26)

276 XCTAssertEqual(ctx, .tableRef)

277 }

278+

279+ // MARK: - Identifier quoting / non-SQL regions

280+

281+ func testColumnCompletionQuotesNamesThatNeedIt() {

282+ let fields = [SchemaField(name: "statusCode", dataType: "Int64"), SchemaField(name: "status", dataType: "Utf8")]

283+ let result = SQLCompletionProvider.completions(

284+ for: "SELECT * FROM t WHERE stat", cursorPosition: 26,

285+ streamNames: [], schemaFields: fields

286+ )

287+ let columns = result.items.filter { $0.kind == .column }.map(\.text)

288+ XCTAssertEqual(columns, ["status", "\"statusCode\""])

289+ }

290+

291+ func testNoCompletionsInsideLineComment() {

292+ let text = "-- grouped by date"

293+ let result = SQLCompletionProvider.completions(

294+ for: text, cursorPosition: (text as NSString).length,

295+ streamNames: streams, schemaFields: fields

296+ )

297+ XCTAssertTrue(result.items.isEmpty)

298+ }

299+

300+ func testNoCompletionsInsideStringLiteral() {

301+ let text = "SELECT * FROM t WHERE msg LIKE '%sel"

302+ let result = SQLCompletionProvider.completions(

303+ for: text, cursorPosition: (text as NSString).length,

304+ streamNames: streams, schemaFields: fields

305+ )

306+ XCTAssertTrue(result.items.isEmpty)

307+ }

308+

309+ func testFullyTypedMixedCaseColumnStillOffersQuotedForm() {

310+ let fields = [SchemaField(name: "statusCode", dataType: "Int64")]

311+ let bare = "SELECT * FROM t WHERE statusCode"

312+ let result = SQLCompletionProvider.completions(

313+ for: bare, cursorPosition: (bare as NSString).length,

314+ streamNames: [], schemaFields: fields

315+ )

316+ XCTAssertEqual(result.items.map(\.text), ["\"statusCode\""])

317+

318+ // Already quoted: accepting would change nothing, so no popup.

319+ let quoted = "SELECT * FROM t WHERE \"statusCode\""

320+ let quotedResult = SQLCompletionProvider.completions(

321+ for: quoted, cursorPosition: (quoted as NSString).length - 1,

322+ streamNames: [], schemaFields: fields

323+ )

324+ XCTAssertTrue(quotedResult.items.isEmpty)

325+ }

326+

327+ func testReservedWordColumnIsQuoted() {

328+ let fields = [SchemaField(name: "order", dataType: "Utf8")]

329+ let result = SQLCompletionProvider.completions(

330+ for: "SELECT ord", cursorPosition: 10, streamNames: [], schemaFields: fields

331+ )

332+ XCTAssertEqual(result.items.filter { $0.kind == .column }.map(\.text), ["\"order\""])

333+ }

278}

334}

279

335

280// Make SQLCompletionContext Equatable for assertions

336// Make SQLCompletionContext Equatable for assertions

ParseableViewerTests/SQLTokenizerTests.swift+15

@@ -348,4 +348,19 @@ final class SQLTokenizerTests: XCTestCase {

348 let sql = "SELECT * FROM t"

349 XCTAssertNil(SQLTokenizer.errorHighlightRange(line: 99, column: 1, in: sql))

350 }

351+

352+ // MARK: - CRLF line endings

353+

354+ func testCRLFIsWhitespaceAndEndsLineComment() {

355+ // Swift treats "\r\n" as a single Character, equal to neither "\r" nor "\n".

356+ let sql = "SELECT * -- all\r\nFROM t"

357+ let kinds = SQLTokenizer.tokenize(sql).map(\.kind).filter { !$0.isTrivia }

358+ XCTAssertEqual(kinds, [.keyword("SELECT"), .star, .keyword("FROM"), .identifier("t")])

359+ }

360+

361+ func testSelectColumnListRangeExcludesCRLF() {

362+ let sql = "SELECT *\r\nFROM t"

363+ let range = SQLTokenizer.selectColumnListRange(in: sql)

364+ XCTAssertEqual(range.map { String(sql[$0]) }, "*")

365+ }

351}

366}

ParseableViewerTests/ServerConnectionTests.swift+10

@@ -77,4 +77,14 @@ final class ServerConnectionTests: XCTestCase {

77 let conn = ServerConnection(name: "test", url: "https://", username: "admin", password: "pass")

78 XCTAssertNil(conn.baseURL)

79 }

80+

81+ func testBaseURLAcceptsUppercaseScheme() {

82+ let conn = ServerConnection(name: "t", url: "HTTP://10.0.0.5:8000", username: "u", password: "p")

83+ XCTAssertEqual(conn.baseURL?.absoluteString, "http://10.0.0.5:8000")

84+ }

85+

86+ func testBaseURLRejectsNonHTTPScheme() {

87+ let conn = ServerConnection(name: "t", url: "ftp://example.com", username: "u", password: "p")

88+ XCTAssertNil(conn.baseURL)

89+ }

80}

90}

ParseableViewerTests/SyntaxHighlightingTests.swift+10

@@ -140,6 +140,16 @@ final class SyntaxHighlightingTests: XCTestCase {

140 "Double-quoted identifiers should differ from keywords")

141 }

142

143+ func testSQLApostropheInCommentDoesNotStartString() {

144+ // The later quoted literal gives the stray apostrophe a closing partner, so

145+ // separate string/comment passes painted everything in between as a string.

146+ let sql = "-- don't\nSELECT * FROM t WHERE a = 'b'"

147+ let ts = sqlHighlight(sql)

148+ let selectIdx = (sql as NSString).range(of: "SELECT").location

149+ XCTAssertEqual(colorAt(ts, selectIdx), colorAt(sqlHighlight("SELECT x"), 0),

150+ "An apostrophe inside a comment must not open a string literal")

151+ }

152+

143 // MARK: - JSON Highlighting

153 // MARK: - JSON Highlighting

144

154

145 func testJSONHighlightProducesOutput() {

155 func testJSONHighlightProducesOutput() {

README.md+1−1

@@ -143,7 +143,7 @@ ParseableViewer/

143| `Cmd+R` | Refresh streams |

144| `Cmd+Enter` | Run query |

145| `Cmd+P` | Pause/resume live tail |

146−| `Cmd+Delete` | Clear live tail entries |

146+| `Cmd+K` | Clear live tail entries |

147| `Cmd+Ctrl+S` | Toggle sidebar |

148

149## License