master..58be682 · parseable-macos

git.iko.soy/parseable-macos

on 58be682 help sign in

ParseableViewer/App/AppState.swift+3−100

since splitsnapshots

unifiedsplit

@@ -15,10 +15,6 @@ 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?

23 // MARK: - Stream State

19 // MARK: - Stream State

24 var streams: [LogStream] = []

20 var streams: [LogStream] = []

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

100

101 if let activeID = ConnectionStore.loadActiveConnectionID(),

97 if let activeID = ConnectionStore.loadActiveConnectionID(),

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

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

103− connectingConnectionID = connection.id

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

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

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

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

106 }

101 }

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

120 existing.cancel()

115 existing.cancel()

121 _ = await existing.value

116 _ = await existing.value

122 }

117 }

123− connectingConnectionID = connection.id

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

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

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

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

126 }

120 }

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

130

124

131 @MainActor

125 @MainActor

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

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

133− defer {

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

135− }

136 guard !isConnecting else { return false }

127 guard !isConnecting else { return false }

137

128

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.

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

129+ if !isNetworkAvailable {

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

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

144 self.showError = true

131 self.showError = true

145 return false

132 return false

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

147

134

148 isConnecting = true

135 isConnecting = true

149 defer { isConnecting = false }

136 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".

154 errorMessage = nil

137 errorMessage = nil

155− showError = false

156

138

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

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

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

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

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

182

164

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

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

184 try await newClient.checkHealth()

166 try await newClient.checkHealth()

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

186

167

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

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

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

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

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

219 case .success(let list):

200 case .success(let list):

220 self.streams = list

201 self.streams = list

221 self.streamLoadError = nil

202 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− }

228 case .failure(let error):

203 case .failure(let error):

229 self.streams = []

204 self.streams = []

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

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

@@ -276,28 +251,10 @@ final class AppState {

276 @MainActor

251 @MainActor

277 func refreshStreams() async {

252 func refreshStreams() async {

278 guard let client else { return }

253 guard let client else { return }

279− // Capture the connection this fetch belongs to. A disconnect during the

280− // await would otherwise let the (now-stale) result overwrite the cleanup

281− // disconnect() just performed (streams = [], client = nil, etc.), leaving

282− // the disconnected UI showing the old server's streams and re-enabling

283− // stream-scoped tabs. Mirrors the connID guard used in performConnect,

284− // AlertsView.loadAlerts, UsersView.loadUsers, StreamDetailView.loadData,

285− // and ServerInfoView.loadInfo.

286− let connID = activeConnection?.id

287 isLoadingStreams = true

254 isLoadingStreams = true

288 streamLoadError = nil

255 streamLoadError = nil

289 do {

256 do {

290− let loaded = try await client.listStreams()

257+ streams = try await client.listStreams()

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

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

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.

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

297− isLoadingStreams = false

298− return

299− }

300− streams = loaded

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

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

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

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

303 // querying a missing stream and surface 404s.

260 // querying a missing stream and surface 404s.

@@ -305,10 +262,6 @@ final class AppState {

305 selectedStream = nil

262 selectedStream = nil

306 }

263 }

307 } catch {

264 } catch {

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

309− isLoadingStreams = false

310− return

311− }

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

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

313 streamLoadError = message

266 streamLoadError = message

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

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

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

375 ConnectionStore.saveConnections(connections)

328 ConnectionStore.saveConnections(connections)

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

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

377 disconnect()

330 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.

412 }

331 }

413 }

332 }

414

333

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−

421 // MARK: - Stream Management

334 // MARK: - Stream Management

422

335

423 @MainActor

336 @MainActor

@@ -443,18 +356,8 @@ final class AppState {

443 @MainActor

356 @MainActor

444 func refreshFilters() async {

357 func refreshFilters() async {

445 guard let client else { return }

358 guard let client else { return }

446− // Capture the connection this fetch belongs to. A disconnect during the

447− // await would otherwise let the (now-stale) result overwrite the cleanup

448− // disconnect() performed, resurrecting the old server's filters in the

449− // disconnected sidebar. Same guard pattern as refreshStreams.

450− let connID = activeConnection?.id

451 isLoadingFilters = true

359 isLoadingFilters = true

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

360+ filters = (try? await client.listFilters()) ?? []

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

454− isLoadingFilters = false

455− return

456− }

457− filters = loaded

458 isLoadingFilters = false

361 isLoadingFilters = false

459 }

362 }

460

363

ParseableViewer/App/ParseableViewerApp.swift+1−13

@@ -4,13 +4,6 @@ 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−

14 var body: some Scene {

7 var body: some Scene {

15 WindowGroup {

8 WindowGroup {

16 ContentView()

9 ContentView()

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

24 AboutCommand()

17 AboutCommand()

25 }

18 }

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.

32− CommandGroup(replacing: .newItem) {

20+ CommandGroup(after: .newItem) {

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

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

34 appState.editingConnection = nil

22 appState.editingConnection = nil

35 appState.showConnectionSheet = true

23 appState.showConnectionSheet = true

ParseableViewer/Info.plist−5

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

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>

32 <key>NSMainNibFile</key>

27 <key>NSMainNibFile</key>

33 <string></string>

28 <string></string>

34 <key>NSPrincipalClass</key>

29 <key>NSPrincipalClass</key>

ParseableViewer/Models/AlertModels.swift−21

@@ -85,27 +85,6 @@ 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− }

109}

88}

110

111struct AlertTarget: Codable, Sendable {

90struct AlertTarget: Codable, Sendable {

ParseableViewer/Models/LogStream.swift+11−97

@@ -80,39 +80,11 @@ 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 = Self.describeArrowType(typeObj)

83+ self.dataType = typeObj.displayString

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− }

116}

88}

117

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

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

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

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

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

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

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

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

108/// 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

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

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

110+/// unchanged.

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

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

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

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

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

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

144− }

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

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

146 return value

114 return value

147}

115}

148

116

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−

190struct StreamStats: Codable, Sendable {

117struct StreamStats: Codable, Sendable {

191 let ingestion: IngestionStats?

118 let ingestion: IngestionStats?

192 let storage: StorageStats?

119 let storage: StorageStats?

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

238

165

239 init(from decoder: Decoder) throws {

166 init(from decoder: Decoder) throws {

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

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

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

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

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")

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

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

247 self.size = formatByteSize(s)

170 self.size = formatByteSize(s)

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

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

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

285 }

208 }

286

209

287 init(from decoder: Decoder) throws {

210 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".

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

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

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

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

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

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

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

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

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

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

300− self.staticSchemaFlag = container.firstBool(

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

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

302− )

303 }

217 }

304}

218}

ParseableViewer/Models/SQLTokenizer.swift+5−33

@@ -80,20 +80,13 @@ struct SQLTokenizer: Sendable {

81 switch c {

82 // Whitespace

83− case _ where isWhitespace(c):

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

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

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

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

87 // Line comment

88 case "-" where peek(sql, at: i, offset: 1) == "-":

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. 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.

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

89+ advance(&i, in: sql, while: { $0 != "\n" })

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

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

99 // Block comment

92 // Block comment

@@ -138,8 +131,8 @@ struct SQLTokenizer: Sendable {

138 tokens.append(Token(kind: .number(String(sql[start..<i])), range: start..<i))

131 tokens.append(Token(kind: .number(String(sql[start..<i])), range: start..<i))

139

132

140 // Identifier or keyword

133 // Identifier or keyword

141− case _ where isASCIILetter(c) || c == "_":

134+ case _ where c.isLetter || c == "_":

142− advance(&i, in: sql, while: { isASCIILetter($0) || isASCIIDigit($0) || $0 == "_" })

135+ advance(&i, in: sql, while: { $0.isLetter || $0.isNumber || $0 == "_" })

143 let word = String(sql[start..<i])

136 let word = String(sql[start..<i])

144 if keywords.contains(word.uppercased()) {

137 if keywords.contains(word.uppercased()) {

145 tokens.append(Token(kind: .keyword(word.uppercased()), range: start..<i))

138 tokens.append(Token(kind: .keyword(word.uppercased()), range: start..<i))

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

262 return value // unterminated

255 return value // unterminated

263 }

256 }

264

257

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−

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

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

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

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

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

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

@@ -282,16 +264,6 @@ struct SQLTokenizer: Sendable {

282 c.isASCII && c.isNumber

264 c.isASCII && c.isNumber

283 }

265 }

284

266

285− /// Bare (unquoted) SQL identifiers use only ASCII letters. `Character.isLetter`

286− /// matches the full Unicode letter range (`café`, `naïve`, etc.), which

287− /// DataFusion's lexer would require to be double-quoted — accepting them bare

288− /// here would tokenize them as identifiers and diverge token offsets from the

289− /// server, throwing off `errorHighlightRange` mapping (same rationale as

290− /// `isASCIIDigit`).

291− private static func isASCIILetter(_ c: Character) -> Bool {

292− c.isASCII && c.isLetter

293− }

294−

295 private static func consumeNumber(_ i: inout String.Index, in sql: String) {

267 private static func consumeNumber(_ i: inout String.Index, in sql: String) {

296 // Digits with at most one decimal point, so malformed input like

268 // Digits with at most one decimal point, so malformed input like

297 // `1.2.3` doesn't get swallowed into a single number token.

269 // `1.2.3` doesn't get swallowed into a single number token.

ParseableViewer/Models/ServerConnection.swift+2−19

@@ -56,32 +56,15 @@ 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 let schemeRange = Self.urlSchemeRange(in: urlString) {

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

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 {

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

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

65 }

61 }

66 while urlString.hasSuffix("/") {

62 while urlString.hasSuffix("/") {

67 urlString.removeLast()

63 urlString.removeLast()

68 }

64 }

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

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

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

71 return nil

66 return nil

72 }

67 }

73 return parsed

68 return parsed

74 }

69 }

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− }

87}

70}

ParseableViewer/Models/ServerInfo.swift+10−47

@@ -15,59 +15,33 @@ 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.

23 private enum CodingKeys: String, CodingKey {

18 private enum CodingKeys: String, CodingKey {

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

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

25− case uiVersion

20+ case uiVersion = "ui_version"

26− case deploymentId

21+ case deploymentId = "deployment_id"

27− case grpcPort

22+ case grpcPort = "grpc_port"

28 case updateAvailable

23 case updateAvailable

29 case latestVersion

24 case latestVersion

30 case llmActive

25 case llmActive

31 case oidcActive

26 case oidcActive

32 }

27 }

34− private enum SnakeCaseKeys: String, CodingKey {

35− case uiVersion = "ui_version"

36− case deploymentId = "deployment_id"

37− case grpcPort = "grpc_port"

38− }

39−

40 init(from decoder: Decoder) throws {

29 init(from decoder: Decoder) throws {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

60 }

44 }

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− }

71}

45}

73struct StoreInfo: Codable, Sendable {

47struct StoreInfo: Codable, Sendable {

@@ -111,20 +85,9 @@ struct UserInfo: Identifiable, Codable, Sendable {

111 }

85 }

112

113 init(from decoder: Decoder) throws {

87 init(from decoder: Decoder) throws {

114− // Handle both {"id": "x", ...} and a bare "x" string element.

88+ // Handle both {"id": "x", ...} and variations

115− if let container = try? decoder.container(keyedBy: CodingKeys.self),

89+ if let container = try? decoder.container(keyedBy: CodingKeys.self) {

116− container.contains(.id) {

117− // Decode `id` defensively: the server may quote it as a string or

118− // send it as a number/other JSON. Fall back to JSONValue.displayString

119− // so a single odd entry doesn't fail the whole user list (matching the

120− // file's otherwise-defensive decoding).

121− if let stringID = try? container.decode(String.self, forKey: .id) {

90+ self.id = try container.decode(String.self, forKey: .id)

122− self.id = stringID

123− } else if let valueID = try? container.decode(JSONValue.self, forKey: .id) {

124− self.id = valueID.displayString

125− } else {

126− self.id = ""

127− }

128 self.method = try? container.decode(String.self, forKey: .method)

91 self.method = try? container.decode(String.self, forKey: .method)

129 } else {

92 } else {

130 let container = try decoder.singleValueContainer()

93 let container = try decoder.singleValueContainer()

ParseableViewer/Services/ParseableClient.swift+7−114

@@ -88,58 +88,6 @@ private actor ResponseCache {

88 }

89}

91−/// Strips the `Authorization` header on redirects that cross to a different

92−/// origin. By default `URLSession` re-sends the original request's headers —

93−/// including the `Basic` credentials this client attaches to every request —

94−/// to the redirect target. A server (or a malicious/misconfigured proxy)

95−/// answering with a 3xx to an unrelated host would otherwise harvest the user's

96−/// credentials. Same-origin redirects keep the header so normal auth still works.

97−///

98−/// Holds only an immutable `URL`, so it is safely `Sendable` despite the

99−/// NSObject base (which isn't formally `Sendable`).

100−private final class RedirectSanitizer: NSObject, URLSessionTaskDelegate, @unchecked Sendable {

101− private let baseURL: URL

102−

103− init(baseURL: URL) {

104− self.baseURL = baseURL

105− }

106−

107− func urlSession(

108− _ session: URLSession,

109− task: URLSessionTask,

110− willPerformHTTPRedirection response: HTTPURLResponse,

111− newRequest request: URLRequest,

112− completionHandler: @escaping (URLRequest?) -> Void

113− ) {

114− guard !RedirectSanitizer.sameOrigin(baseURL, request.url) else {

115− completionHandler(request)

116− return

117− }

118− var sanitized = request

119− sanitized.setValue(nil, forHTTPHeaderField: "Authorization")

120− completionHandler(sanitized)

121− }

122−

123− /// Origin equality per scheme/host/port, normalizing the implicit default

124− /// port so `https://host` and `https://host:443` are treated as the same

125− /// origin (and aren't stripped on a legitimate same-host redirect).

126− static func sameOrigin(_ a: URL, _ b: URL?) -> Bool {

127− guard let b else { return false }

128− return a.scheme?.lowercased() == b.scheme?.lowercased()

129− && a.host?.lowercased() == b.host?.lowercased()

130− && effectivePort(a) == effectivePort(b)

131− }

132−

133− private static func effectivePort(_ url: URL) -> Int? {

134− if let port = url.port { return port }

135− switch url.scheme?.lowercased() {

136− case "https": return 443

137− case "http": return 80

138− default: return nil

139− }

140− }

141−}

142−

143final class ParseableClient: Sendable {

91final class ParseableClient: Sendable {

144 let baseURL: URL

92 let baseURL: URL

145 let username: String

93 let username: String

@@ -153,15 +101,11 @@ final class ParseableClient: Sendable {

153 // so a single shared instance would be a data race. Constructing one is cheap.

101 // so a single shared instance would be a data race. Constructing one is cheap.

154 private static var jsonDecoder: JSONDecoder { JSONDecoder() }

102 private static var jsonDecoder: JSONDecoder { JSONDecoder() }

155

103

156− // A fresh formatter per access, for the same reason as `jsonDecoder` above:

157− // `query` can run concurrently and `ISO8601DateFormatter.string(from:)` isn't

158− // documented as thread-safe, so a single shared instance would contradict the

159− // file's per-call concurrency discipline. Constructing one is cheap.

160− private static var isoFormatter: ISO8601DateFormatter {

104+ private static nonisolated(unsafe) let isoFormatter: ISO8601DateFormatter = {

161 let f = ISO8601DateFormatter()

105 let f = ISO8601DateFormatter()

162 f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]

106 f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]

163 return f

107 return f

164− }

108+ }()

165

109

166 init(url: URL, username: String, password: String) {

110 init(url: URL, username: String, password: String) {

167 self.baseURL = url

111 self.baseURL = url

@@ -178,15 +122,7 @@ final class ParseableClient: Sendable {

178 let config = URLSessionConfiguration.default

122 let config = URLSessionConfiguration.default

179 config.timeoutIntervalForRequest = 30

123 config.timeoutIntervalForRequest = 30

180 config.timeoutIntervalForResource = 120

124 config.timeoutIntervalForResource = 120

181− // Install a delegate that drops the Authorization header on cross-origin

182− // redirects so Basic credentials can't be forwarded to an unrelated host.

183− // The session retains the delegate until `finishTasksAndInvalidate()` in

184− // deinit releases it, so there's no leak.

185− self.session = URLSession(

125+ self.session = URLSession(configuration: config)

186− configuration: config,

187− delegate: RedirectSanitizer(baseURL: url),

188− delegateQueue: nil

189− )

190 }

126 }

191

127

192 convenience init(connection: ServerConnection) throws {

128 convenience init(connection: ServerConnection) throws {

@@ -352,11 +288,10 @@ final class ParseableClient: Sendable {

352 // MARK: - Query

288 // MARK: - Query

353

289

354 func query(sql: String, startTime: Date, endTime: Date) async throws -> [LogRecord] {

290 func query(sql: String, startTime: Date, endTime: Date) async throws -> [LogRecord] {

355− let formatter = Self.isoFormatter

356 let body: [String: Any] = [

291 let body: [String: Any] = [

357 "query": sql,

292 "query": sql,

358− "startTime": formatter.string(from: startTime),

293+ "startTime": Self.isoFormatter.string(from: startTime),

359− "endTime": formatter.string(from: endTime)

294+ "endTime": Self.isoFormatter.string(from: endTime)

360 ]

295 ]

361

296

362 let bodyData = try JSONSerialization.data(withJSONObject: body)

297 let bodyData = try JSONSerialization.data(withJSONObject: body)

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

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

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

410 }

345 }

411

346

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−

455 do {

347 do {

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

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

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

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

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

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

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

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

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

ParseableViewer/ViewModels/LiveTailViewModel.swift+46−124

@@ -27,26 +27,14 @@ 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] = []

36 private var currentStream: String?

30 private var currentStream: String?

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

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

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

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

40 nonisolated(unsafe) private var timer: Timer?

34 nonisolated(unsafe) private var timer: Timer?

41 private var lastTimestamp: Date?

35 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.

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

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

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

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

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

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

51 private var seenFingerprintOrder: [String] = []

39 private var seenFingerprintOrder: [String] = []

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

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

@@ -69,15 +57,7 @@ final class LiveTailViewModel {

69 private var pollGeneration = 0

57 private var pollGeneration = 0

71 deinit {

59 deinit {

72− // Timer.invalidate() must run on the run loop the timer was scheduled on

60+ timer?.invalidate()

73− // (RunLoop.main, see start()). deinit is nonisolated and can run off the

74− // main thread, so hop to the main queue rather than invalidating inline.

75− // The scheduled timer only weakly references self, so deferring teardown

76− // past deallocation is safe — at worst it fires once more as a no-op

77− // before being invalidated. stop() remains the normal teardown path.

78− if let timer {

79− DispatchQueue.main.async { timer.invalidate() }

80− }

81 }

61 }

83 // Cached formatters — nonisolated(unsafe) so static methods can use them from Task.detached

63 // Cached formatters — nonisolated(unsafe) so static methods can use them from Task.detached

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

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

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

177 // tail silently empties.

157 // tail silently empties.

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

158 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− }

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

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

189 rebuildFilteredEntries()

160 rebuildFilteredEntries()

190 }

161 }

@@ -214,14 +185,9 @@ final class LiveTailViewModel {

214 pollGeneration += 1

185 pollGeneration += 1

215 isRunning = true

186 isRunning = true

216 isPaused = false

187 isPaused = false

217− // Reset the in-flight guard: if a poll was awaiting its network round-trip

218− // when the tail was stopped, its `defer { isPolling = false }` only runs when

219− // that request finally returns. Without clearing it here, the new timer's

220− // first tick would hit `guard !isPolling` and be skipped for a whole interval.

221− isPolling = false

222 errorMessage = nil

188 errorMessage = nil

223 entries = []

189 entries = []

224− seenFingerprints = [:]

190+ seenFingerprints = []

225 seenFingerprintOrder = []

191 seenFingerprintOrder = []

226 allKnownKeys = []

192 allKnownKeys = []

227 droppedCount = 0

193 droppedCount = 0

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

232 columnOrder = []

198 columnOrder = []

233 hiddenColumns = []

199 hiddenColumns = []

234 savedHiddenColumns = []

200 savedHiddenColumns = []

235− savedColumnOrder = []

236 columnFilters = []

201 columnFilters = []

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

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

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

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

@@ -270,17 +235,13 @@ final class LiveTailViewModel {

270

235

271 func clear() {

236 func clear() {

272 pollGeneration += 1

237 pollGeneration += 1

273− // Match start(): drop the in-flight guard so a poll still awaiting its

274− // response (whose results this generation bump will discard) can't make the

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

276− isPolling = false

277 entries = []

238 entries = []

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

239+ seenFingerprints = []

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

240+ seenFingerprintOrder = []

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

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

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

242+ // from the old `lastTimestamp` with an empty fingerprint set and re-inserts

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

243+ // every just-cleared record still inside the ~90 s window, repopulating the

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

244+ // view the user just emptied. Matches start()'s reset.

284 lastTimestamp = Date()

245 lastTimestamp = Date()

285 allKnownKeys = []

246 allKnownKeys = []

286 droppedCount = 0

247 droppedCount = 0

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

295 columnOrder = []

256 columnOrder = []

296 hiddenColumns = []

257 hiddenColumns = []

297 savedHiddenColumns = []

258 savedHiddenColumns = []

298− savedColumnOrder = []

299 columnFilters = []

259 columnFilters = []

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

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

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

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

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

351

311

352 func resetColumnConfig() {

312 func resetColumnConfig() {

353 columnOrder = columns

313 columnOrder = columns

354− savedColumnOrder = []

355 hiddenColumns.removeAll()

314 hiddenColumns.removeAll()

356 savedHiddenColumns.removeAll()

315 savedHiddenColumns.removeAll()

357 saveColumnConfig()

316 saveColumnConfig()

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

365

324

366 private func saveColumnConfig() {

325 private func saveColumnConfig() {

367 guard let stream = currentStream else { return }

326 guard let stream = currentStream else { return }

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

327+ // Persist the full intended hidden set (including columns not yet seen

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

328+ // this session) so it survives across 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

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

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

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

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

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

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

380 }

332 }

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

416 merged.append(col)

368 merged.append(col)

417 }

369 }

418 columnOrder = merged

370 columnOrder = merged

419− savedColumnOrder = config.order

420 savedHiddenColumns = config.hidden

371 savedHiddenColumns = config.hidden

421 hiddenColumns = config.hidden.intersection(extractedSet)

372 hiddenColumns = config.hidden.intersection(extractedSet)

422 } else {

373 } else {

423 columnOrder = extracted

374 columnOrder = extracted

424− savedColumnOrder = []

425 savedHiddenColumns = []

375 savedHiddenColumns = []

426 hiddenColumns = []

376 hiddenColumns = []

427 }

377 }

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

434 }

384 }

435 if !newCols.isEmpty {

385 if !newCols.isEmpty {

436 columns.append(contentsOf: newCols)

386 columns.append(contentsOf: newCols)

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

387+ columnOrder.append(contentsOf: newCols)

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

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

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

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

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

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

@@ -453,18 +403,10 @@ final class LiveTailViewModel {

453 }

403 }

454

404

455 private func poll(client: ParseableClient, stream: String) async {

405 private func poll(client: ParseableClient, stream: String) async {

456− let generation = pollGeneration

457 guard !isPolling else { return }

406 guard !isPolling else { return }

458 isPolling = true

407 isPolling = true

459− // Only release the guard if this poll is still the current generation. A

408+ defer { isPolling = false }

460− // stop()/start() during the network await can supersede this poll while a

461− // newer-generation poll is already in flight; clearing isPolling

462− // unconditionally would let a subsequent timer tick start a second poll

463− // that overlaps the newer one, racing writes to lastTimestamp /

464− // consecutiveErrors. start()/clear() reset isPolling on their own

465− // generation bump, so a superseded poll leaving it set can't wedge the

466− // new timer.

467− defer { if generation == pollGeneration { isPolling = false } }

409+ let generation = pollGeneration

468

410

469 let now = Date()

411 let now = Date()

470 // The Parseable server truncates query time-ranges to minute

412 // The Parseable server truncates query time-ranges to minute

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

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

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

493 let seenSnapshot = seenFingerprints

435 let seenSnapshot = seenFingerprints

494 let pollTime = now

436 let pollTime = now

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

437+ let candidateEntries = await Task.detached(priority: .userInitiated) {

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

438+ var results: [LiveTailEntry] = []

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

498 for record in records {

439 for record in records {

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

440 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.

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

441+ guard !seenSnapshot.contains(fp) else { continue }

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

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

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

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

507− results.append((LiveTailEntry(

444+ results.append(LiveTailEntry(

508 timestamp: timestamp,

445 timestamp: timestamp,

509 record: record,

446 record: record,

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

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

511 summary: summary,

448 summary: summary,

512 fingerprint: fp

449 fingerprint: fp

513− ), occurrence))

450+ ))

514 }

451 }

515− return (results, counts)

452+ return results

516 }.value

453 }.value

517

454

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

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

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

521

458

522 // Authoritative dedup on main actor

459 // Authoritative dedup on main actor

523 var newEntries: [LiveTailEntry] = []

460 var newEntries: [LiveTailEntry] = []

524− for candidate in candidateEntries

461+ for entry in candidateEntries {

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

462+ if seenFingerprints.insert(entry.fingerprint).inserted {

526− newEntries.append(candidate.entry)

527− }

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

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

463+ seenFingerprintOrder.append(entry.fingerprint)

530− seenFingerprints[fp] = count

464+ newEntries.append(entry)

465+ }

531 }

466 }

532

467

533 if !newEntries.isEmpty {

468 if !newEntries.isEmpty {

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

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

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

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

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

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

486 // 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.

557− if seenFingerprints.count > maxSeenFingerprints {

487+ if seenFingerprints.count > maxSeenFingerprints {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

566− let overflow = seenFingerprints.count - maxSeenFingerprints

496+ let overflow = seenFingerprints.count - maxSeenFingerprints

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

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

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

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

569− .subtracting(buffered)

499+ .subtracting(buffered)

570− if !toDrop.isEmpty {

500+ if !toDrop.isEmpty {

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

501+ seenFingerprints.subtract(toDrop)

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

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

503+ }

573 }

504 }

574 }

505 }

575

506

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

724 return nil

655 return nil

725 }

656 }

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

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

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

658+ if let date = isoFractional.date(from: str) {

728 return date

659 return date

729 }

660 }

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"

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

661+ return isoBasic.date(from: str)

740 }

662 }

741 return nil

663 return nil

742 }

664 }

ParseableViewer/ViewModels/QueryViewModel.swift+57−330

@@ -17,8 +17,6 @@ final class QueryViewModel {

17 // Build search texts asynchronously

18 searchTextTask?.cancel()

19 cachedSearchTexts = []

20− searchTextGeneration &+= 1

21− let generation = searchTextGeneration

22 // Apply the current filter immediately using the inline fallback path

20 // Apply the current filter immediately using the inline fallback path

23 // (the cache was just invalidated). Calling updateFilteredResults()

21 // (the cache was just invalidated). Calling updateFilteredResults()

24 // rather than `filteredResults = results` avoids briefly showing

22 // rather than `filteredResults = results` avoids briefly showing

@@ -38,12 +36,6 @@ final class QueryViewModel {

38 }

36 }

39 }.value

37 }.value

40 guard let self, !Task.isCancelled else { return }

38 guard let self, !Task.isCancelled else { return }

41− // Reject a stale write: if `results` was reassigned while this task

42− // was awaiting, a newer didSet bumped the generation. Task.isCancelled

43− // alone isn't sufficient because two re-queries producing result sets

44− // of identical count would otherwise let this stale, same-length

45− // cachedSearchTexts slip past updateFilteredResults's count guard.

46− guard generation == self.searchTextGeneration else { return }

47 self.cachedSearchTexts = texts

39 self.cachedSearchTexts = texts

48 if !self.filterText.isEmpty {

40 if !self.filterText.isEmpty {

49 self.updateFilteredResults()

41 self.updateFilteredResults()

@@ -53,35 +45,12 @@ final class QueryViewModel {

53 }

45 }

54 private var cachedSearchTexts: [String] = []

46 private var cachedSearchTexts: [String] = []

55 private var searchTextTask: Task<Void, Never>?

47 private var searchTextTask: Task<Void, Never>?

56− /// Bumped on every `results` reassignment so the async search-text builder can

57− /// detect it was superseded and drop a stale write (see results.didSet).

58− private var searchTextGeneration = 0

59 var columns: [String] = []

48 var columns: [String] = []

60 var columnOrder: [String] = []

49 var columnOrder: [String] = []

61 var hiddenColumns: Set<String> = []

50 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] = []

72 var autoHiddenColumns: Set<String> = []

51 var autoHiddenColumns: Set<String> = []

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

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

74 var pendingColumnConfig: ColumnConfiguration?

53 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?

85 private var currentStream: String?

54 private var currentStream: String?

86 var isLoading = false

55 var isLoading = false

87 var errorMessage: String?

56 var errorMessage: String?

@@ -99,23 +68,10 @@ final class QueryViewModel {

99 var schemaFields: [SchemaField] = []

68 var schemaFields: [SchemaField] = []

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

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

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

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

102− private(set) var latestSchemaStream: String?

71+ private 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

109 // Query task for cancellation

73 // Query task for cancellation

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

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

111− /// Bumped at the start of every `executeQuery`. The task captures this value

112− /// and only clears `isLoading` on exit if it's still the active query — so a

113− /// superseded query's late cleanup doesn't drop the loading indicator that

114− /// the newer query set. Without this, `isLoading = false` had to live in

115− /// every caller of `cancel()` (cancelQuery, clearResults, superseding

116− /// executeQuery) and a future cancel path that forgot to set it would wedge

117− /// the spinner indefinitely.

118− private var queryGeneration = 0

119

120 // Time range

76 // Time range

121 var timeRangeOption: TimeRangeOption = .last1Hour

77 var timeRangeOption: TimeRangeOption = .last1Hour

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

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

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

213 }

169 }

214

170

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−

221 func toggleColumnVisibility(_ column: String) {

171 func toggleColumnVisibility(_ column: String) {

222 if hiddenColumns.contains(column) {

172 if hiddenColumns.contains(column) {

223 hiddenColumns.remove(column)

173 hiddenColumns.remove(column)

224− savedHiddenColumns.remove(column)

225 } else if autoHiddenColumns.contains(column) {

174 } else if autoHiddenColumns.contains(column) {

226 autoHiddenColumns.remove(column)

175 autoHiddenColumns.remove(column)

227 } else {

176 } else {

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

230 let visibleCount = columnOrder.count - allHidden.count

179 let visibleCount = columnOrder.count - allHidden.count

231 if visibleCount > 1 {

180 if visibleCount > 1 {

232 hiddenColumns.insert(column)

181 hiddenColumns.insert(column)

233− savedHiddenColumns.insert(column)

234 }

182 }

235 }

183 }

236 saveColumnConfig()

184 saveColumnConfig()

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

239

187

240 func showAllColumns() {

188 func showAllColumns() {

241 hiddenColumns.removeAll()

189 hiddenColumns.removeAll()

242− savedHiddenColumns.removeAll()

243 autoHiddenColumns.removeAll()

190 autoHiddenColumns.removeAll()

244 saveColumnConfig()

191 saveColumnConfig()

245 updateSQLColumns()

192 updateSQLColumns()

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

269

216

270 func resetColumnConfig() {

217 func resetColumnConfig() {

271 columnOrder = columns

218 columnOrder = columns

272− savedColumnOrder = []

273 hiddenColumns.removeAll()

219 hiddenColumns.removeAll()

274− savedHiddenColumns.removeAll()

275 autoHiddenColumns.removeAll()

220 autoHiddenColumns.removeAll()

276 saveColumnConfig()

221 saveColumnConfig()

277 updateSQLColumns()

222 updateSQLColumns()

278 }

223 }

279

224

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

225+ /// Rewrites the SELECT clause of `sqlQuery` to reflect the current `visibleColumns`.

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

282 func updateSQLColumns() {

226 func updateSQLColumns() {

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

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

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

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) }

291− guard !visible.isEmpty else { return }

292

228

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

229+ let visible = visibleColumns

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

230+ guard !visible.isEmpty else { return }

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

231

307 let newColumnList: String

232 let newColumnList: String

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

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

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

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

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

235+ // 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.

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

236+ if visible.count == columns.count && Set(visible) == Set(columns) {

314 newColumnList = "*"

237 newColumnList = "*"

315 } else {

238 } else {

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

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

317 }

240 }

318

241

319 sqlQuery.replaceSubrange(range, with: newColumnList)

242 sqlQuery.replaceSubrange(range, with: newColumnList)

320 }

243 }

321

244

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−

382 // MARK: - Column Configuration Persistence

245 // MARK: - Column Configuration Persistence

383

246

384 struct ColumnConfiguration: Codable {

247 struct ColumnConfiguration: Codable {

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

392

255

393 private func saveColumnConfig() {

256 private func saveColumnConfig() {

394 guard let stream = currentStream else { return }

257 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

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

258+ let config = ColumnConfiguration(order: columnOrder, hidden: hiddenColumns)

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

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

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

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

407 }

261 }

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

430

284

431 guard let config else {

285 guard let config else {

432 columnOrder = extractedColumns

286 columnOrder = extractedColumns

433− savedColumnOrder = []

434 hiddenColumns = []

287 hiddenColumns = []

435− savedHiddenColumns = []

436 return

288 return

437 }

289 }

438

290

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

445 merged.append(col)

297 merged.append(col)

446 }

298 }

447 columnOrder = merged

299 columnOrder = merged

448− savedColumnOrder = config.order

449− savedHiddenColumns = config.hidden

450 hiddenColumns = config.hidden.intersection(extractedSet)

300 hiddenColumns = config.hidden.intersection(extractedSet)

451

301

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

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

@@ -540,13 +390,6 @@ final class QueryViewModel {

540

390

541 // Cancel any in-flight query

391 // Cancel any in-flight query

542 queryTask?.cancel()

392 queryTask?.cancel()

543− // Bump the generation so the in-flight task's cleanup can detect that

544− // it has been superseded and skip its `isLoading = false` (which would

545− // otherwise race with the `isLoading = true` below and briefly drop

546− // the loading indicator during this query).

547− queryGeneration &+= 1

548− let generation = queryGeneration

549− latestQueryStream = stream

550

393

551 isLoading = true

394 isLoading = true

552 errorMessage = nil

395 errorMessage = nil

@@ -555,16 +398,6 @@ final class QueryViewModel {

555 let startTime = CFAbsoluteTimeGetCurrent()

398 let startTime = CFAbsoluteTimeGetCurrent()

556

399

557 let task = Task {

400 let task = Task {

558− // Always clear the spinner on exit when this is still the active

559− // query. The defer runs on every path (success, error, and the

560− // cancellation cases that previously returned before reaching the

561− // trailing `isLoading = false`), so the spinner can never wedge

562− // even if a new cancel path is added without resetting it.

563− defer {

564− if generation == queryGeneration {

565− isLoading = false

566− }

567− }

568 do {

401 do {

569 try Task.checkCancellation()

402 try Task.checkCancellation()

570 let queryResults = try await client.query(sql: sql, startTime: startDate, endTime: endDate)

403 let queryResults = try await client.query(sql: sql, startTime: startDate, endTime: endDate)

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

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

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

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

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

576 guard !Task.isCancelled else { return }

409 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 }

580

410

581 results = queryResults

411 results = queryResults

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

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

@@ -586,13 +416,9 @@ final class QueryViewModel {

586 queryDuration = CFAbsoluteTimeGetCurrent() - startTime

416 queryDuration = CFAbsoluteTimeGetCurrent() - startTime

587 resultCount = results.count

417 resultCount = results.count

588

418

589− // Detect if results were likely truncated. We know the cap for

419+ // Detect if results were likely truncated (only meaningful

590− // auto-generated queries; for user-entered SQL (which includes the

420+ // for auto-generated queries where we control the LIMIT)

591− // default query `setDefaultQuery` writes into the editor — the common

421+ resultsTruncated = usedAutoLimit && results.count == limit

592− // stream-selection path), parse a trailing `LIMIT n` so the indicator

593− // still fires when the row count lands exactly on the limit.

594− let effectiveLimit = usedAutoLimit ? limit : Self.trailingLimit(in: sql)

595− resultsTruncated = effectiveLimit.map { results.count == $0 } ?? false

596

422

597 // Extract columns in a single pass, with priority fields first,

423 // Extract columns in a single pass, with priority fields first,

598 // then apply any saved column configuration for this stream

424 // then apply any saved column configuration for this stream

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

619 return

445 return

620 } catch {

446 } catch {

621 guard !Task.isCancelled else { return }

447 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 }

625 errorMessage = ParseableError.userFriendlyMessage(for: error)

448 errorMessage = ParseableError.userFriendlyMessage(for: error)

626 if let serverError = error as? ParseableError,

449 if let serverError = error as? ParseableError,

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

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

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

451+ 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.)

637 errorRange = SQLTokenizer.errorHighlightRange(

452 errorRange = SQLTokenizer.errorHighlightRange(

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

453+ line: pos.line, column: pos.column, in: sqlQuery

639 )

454 )

640 }

455 }

641 results = []

456 results = []

@@ -645,10 +460,10 @@ final class QueryViewModel {

645 // report stale column names after the failure.

460 // report stale column names after the failure.

646 columnOrder = []

461 columnOrder = []

647 hiddenColumns = []

462 hiddenColumns = []

648− savedHiddenColumns = []

649− savedColumnOrder = []

650 autoHiddenColumns = []

463 autoHiddenColumns = []

651 }

464 }

465+

466+ isLoading = false

652 }

467 }

653 queryTask = task

468 queryTask = task

654 await task.value

469 await task.value

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

813 columns = []

628 columns = []

814 columnOrder = []

629 columnOrder = []

815 hiddenColumns = []

630 hiddenColumns = []

816− savedHiddenColumns = []

817− savedColumnOrder = []

818 autoHiddenColumns = []

631 autoHiddenColumns = []

819 currentStream = nil

632 currentStream = nil

820 resultCount = 0

633 resultCount = 0

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

824 errorRange = nil

637 errorRange = nil

825 resultsTruncated = false

638 resultsTruncated = false

826 schemaFields = []

639 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

832 }

640 }

833

641

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

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

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

838 let condition: String

646 let condition: String

839 if let value, value != .null {

647 if let value, value != .null {

840 let literal = value.sqlLiteral

648 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)"

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

649+ condition = exclude ? "\(escapedCol) <> \(literal)" : "\(escapedCol) = \(literal)"

848 } else {

650 } else {

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

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

850 }

652 }

851

653

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

654+ var sql = sqlQuery.trimmingCharacters(in: .whitespacesAndNewlines)

853 if sql.isEmpty { return }

655 if sql.isEmpty { return }

854

656

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

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

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

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

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

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

858− let tokens = SQLTokenizer.tokenize(sql)

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

859 var depth = 0

661 var depth = 0

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

662+ var whereEnd: String.Index?

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

663+ var tailStart: String.Index?

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?

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

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

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

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

869 var bodyHasTopLevelOr = false

666 var bodyHasTopLevelOr = false

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

667+ for token in SQLTokenizer.tokenize(sql) {

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 }

902 switch token.kind {

668 switch token.kind {

903 case .leftParen:

669 case .leftParen:

904 depth += 1

670 depth += 1

905 case .rightParen:

671 case .rightParen:

906 depth = max(0, depth - 1)

672 depth = max(0, depth - 1)

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

908− fromSeen = true

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

673+ case .keyword(let kw) where depth == 0:

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

674+ if kw == "WHERE", whereEnd == nil {

911− whereIndex = idx

675+ whereEnd = token.range.upperBound

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

676+ } else if tailKeywords.contains(kw), tailStart == nil {

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

677+ tailStart = token.range.lowerBound

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

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

678+ } else if kw == "OR", whereEnd != nil, tailStart == nil {

921 bodyHasTopLevelOr = true

679 bodyHasTopLevelOr = true

922 }

680 }

923 default:

681 default:

924 break

682 break

925 }

683 }

926 }

684 }

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

685+

928− guard let lastSignificant else { return }

686+ if let whereEnd {

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]) }) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

694+ let bodyEnd = tailStart ?? sql.endIndex

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

695+ let head = sql[..<whereEnd]

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

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

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

697+ let tail = sql[bodyEnd...].trimmingCharacters(in: .whitespacesAndNewlines)

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

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

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

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

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

702+ if body.isEmpty {

703+ sql = "\(head) \(condition)"

959 } else {

704 } else {

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

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

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

706+ sql = "\(head) \(wrappedBody) AND \(condition)"

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

707+ }

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

708+ if !tail.isEmpty {

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

709+ sql += " \(tail)"

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

966 }

710 }

967− } else if let tailIndex {

711+ } else if let tailStart {

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

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

712+ sql.insert(contentsOf: "WHERE \(condition) ", at: tailStart)

970 } else {

713 } else {

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

714+ sql += " WHERE \(condition)"

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

973 }

715 }

716+

717+ sqlQuery = sql

974 }

718 }

975

719

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

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

@@ -998,26 +742,9 @@ final class QueryViewModel {

998 "\"\(identifier.replacingOccurrences(of: "\"", with: "\"\""))\""

742 "\"\(identifier.replacingOccurrences(of: "\"", with: "\"\""))\""

999 }

743 }

1000

744

1001− /// Extracts the row cap from a trailing `LIMIT n` clause (tolerating a trailing

1002− /// semicolon/whitespace), used to detect when a result set was truncated.

1003− /// Returns nil when there's no recognizable trailing `LIMIT` — e.g. when the

1004− /// query uses `LIMIT n OFFSET m` — so we never report a false truncation.

1005− nonisolated static func trailingLimit(in sql: String) -> Int? {

1006− let pattern = #"(?i)\bLIMIT\s+(\d+)\s*;?\s*$"#

1007− guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }

1008− let range = NSRange(sql.startIndex..<sql.endIndex, in: sql)

1009− guard let match = regex.firstMatch(in: sql, range: range),

1010− let numberRange = Range(match.range(at: 1), in: sql) else { return nil }

1011− return Int(sql[numberRange])

1012− }

1013−

1014 // MARK: - Query History

745 // MARK: - Query History

1015

746

1016 private func addToHistory(_ entry: QueryHistoryEntry) {

747 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()

1021 // Deduplicate consecutive identical queries

748 // Deduplicate consecutive identical queries

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

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

1023 queryHistory.insert(entry, at: 0)

750 queryHistory.insert(entry, at: 0)

ParseableViewer/Views/AlertsView.swift+2−13

@@ -5,10 +5,6 @@ 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

13 var body: some View {

9 var body: some View {

14 Group {

10 Group {

@@ -67,7 +63,7 @@ struct AlertsView: View {

67 .frame(maxWidth: .infinity, maxHeight: .infinity)

63 .frame(maxWidth: .infinity, maxHeight: .infinity)

68 }

64 }

69 }

65 }

70− .task(id: "\(appState.activeConnection?.id.uuidString ?? "")|\(stream)") {

66+ .task(id: stream) {

71 await loadAlerts(stream: stream)

67 await loadAlerts(stream: stream)

72 }

68 }

73 } else {

69 } else {

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

81 private func loadAlerts(stream: String) async {

77 private func loadAlerts(stream: String) async {

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

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

83 let connID = appState.activeConnection?.id

79 let connID = appState.activeConnection?.id

84− loadGeneration &+= 1

85− let generation = loadGeneration

86 isLoading = true

80 isLoading = true

87 errorMessage = nil

81 errorMessage = nil

88 alertConfig = nil

82 alertConfig = nil

90 do {

84 do {

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

85 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 }

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

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

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

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

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

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

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

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

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

103 alertConfig = config

95 alertConfig = config

104 } catch {

96 } catch {

105− guard generation == loadGeneration else { return }

106 guard stream == appState.selectedStream,

97 guard stream == appState.selectedStream,

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

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

108 errorMessage = ParseableError.userFriendlyMessage(for: error)

99 errorMessage = ParseableError.userFriendlyMessage(for: error)

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

212 private var stateColor: Color {

203 private var stateColor: Color {

213 switch alert.state?.lowercased() {

204 switch alert.state?.lowercased() {

214 case "triggered": return .red

205 case "triggered": return .red

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

206+ case "disabled": return .gray

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

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

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

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

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

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

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

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

ParseableViewer/Views/ConnectionSheet.swift+7−27

@@ -18,10 +18,6 @@ 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

26 enum TestResult {

22 enum TestResult {

27 case success(String)

23 case success(String)

@@ -47,7 +43,7 @@ struct ConnectionSheet: View {

47 TextField("Name:", text: $name)

43 TextField("Name:", text: $name)

48 .textFieldStyle(.roundedBorder)

44 .textFieldStyle(.roundedBorder)

49 .accessibilityLabel("Connection name")

45 .accessibilityLabel("Connection name")

50− .onChange(of: name) { _, _ in invalidateTestResult() }

46+ .onChange(of: name) { _, _ in testResult = nil }

52 TextField("Server URL:", text: $url)

48 TextField("Server URL:", text: $url)

53 .textFieldStyle(.roundedBorder)

49 .textFieldStyle(.roundedBorder)

@@ -55,7 +51,7 @@ struct ConnectionSheet: View {

55 .onChange(of: url) { _, newValue in

51 .onChange(of: url) { _, newValue in

56 urlValidationError = Self.validateURL(newValue)

52 urlValidationError = Self.validateURL(newValue)

57 // A prior test result no longer reflects the edited fields.

53 // A prior test result no longer reflects the edited fields.

58− invalidateTestResult()

54+ testResult = nil

59 }

55 }

61 if let urlError = urlValidationError, !url.isEmpty {

57 if let urlError = urlValidationError, !url.isEmpty {

@@ -67,12 +63,12 @@ struct ConnectionSheet: View {

67 TextField("Username:", text: $username)

63 TextField("Username:", text: $username)

68 .textFieldStyle(.roundedBorder)

64 .textFieldStyle(.roundedBorder)

69 .accessibilityLabel("Username")

65 .accessibilityLabel("Username")

70− .onChange(of: username) { _, _ in invalidateTestResult() }

66+ .onChange(of: username) { _, _ in testResult = nil }

72 SecureField("Password:", text: $password)

68 SecureField("Password:", text: $password)

73 .textFieldStyle(.roundedBorder)

69 .textFieldStyle(.roundedBorder)

74 .accessibilityLabel("Password")

70 .accessibilityLabel("Password")

75− .onChange(of: password) { _, _ in invalidateTestResult() }

71+ .onChange(of: password) { _, _ in testResult = nil }

76 }

72 }

77 .formStyle(.grouped)

73 .formStyle(.grouped)

78 .padding()

74 .padding()

@@ -169,16 +165,9 @@ struct ConnectionSheet: View {

169 }

165 }

170 }

166 }

171

167

172− private func invalidateTestResult() {

173− testGeneration += 1

174− testResult = nil

175− }

176−

177 private func testConnection() {

168 private func testConnection() {

178 isTesting = true

169 isTesting = true

179 testResult = nil

170 testResult = nil

180− testGeneration += 1

181− let generation = testGeneration

182

171

183 Task {

172 Task {

184 do {

173 do {

@@ -190,19 +179,14 @@ struct ConnectionSheet: View {

190 )

179 )

191 let client = try ParseableClient(connection: conn)

180 let client = try ParseableClient(connection: conn)

192 try await client.checkHealth()

181 try await client.checkHealth()

193− // The health endpoint doesn't check credentials; see

194− // AppState.verifyCredentials.

195− try await AppState.verifyCredentials(with: client)

196 await MainActor.run {

182 await MainActor.run {

197− isTesting = false

198− guard generation == testGeneration else { return }

199 testResult = .success("Connection successful")

183 testResult = .success("Connection successful")

184+ isTesting = false

200 }

185 }

201 } catch {

186 } catch {

202 await MainActor.run {

187 await MainActor.run {

203− isTesting = false

204− guard generation == testGeneration else { return }

205 testResult = .failure(ParseableError.userFriendlyMessage(for: error))

188 testResult = .failure(ParseableError.userFriendlyMessage(for: error))

189+ isTesting = false

206 }

190 }

207 }

191 }

208 }

192 }

@@ -237,10 +221,6 @@ struct ConnectionSheet: View {

237 dismiss()

221 dismiss()

238 } else {

222 } else {

239 testResult = .failure(appState.errorMessage ?? "Connection failed")

223 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

244 }

224 }

245 }

225 }

246 }

226 }

@@ -251,7 +231,7 @@ struct ConnectionSheet: View {

251 guard !trimmed.isEmpty else { return nil }

231 guard !trimmed.isEmpty else { return nil }

252

232

253 var normalized = trimmed

233 var normalized = trimmed

254− if !ServerConnection.hasURLScheme(normalized) {

234+ if !normalized.hasPrefix("http://") && !normalized.hasPrefix("https://") {

255 normalized = "https://\(normalized)"

235 normalized = "https://\(normalized)"

256 }

236 }

257

237

ParseableViewer/Views/ContentView.swift+2−30

@@ -19,10 +19,7 @@ struct ContentView: View {

19 ConnectionSheet(connection: appState.editingConnection)

20 }

21 .alert("Error", isPresented: $appState.showError) {

22− Button("OK") {

23− appState.showError = false

22+ Button("OK") { appState.showError = false }

24− appState.errorMessage = nil

25− }

26 } message: {

23 } message: {

27 Text(appState.errorMessage ?? "An unknown error occurred")

24 Text(appState.errorMessage ?? "An unknown error occurred")

28 }

25 }

@@ -31,18 +28,6 @@ struct ContentView: View {

32struct MainContentView: View {

29struct MainContentView: View {

33 @Environment(AppState.self) private var appState

30 @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− }

47 var body: some View {

32 var body: some View {

48 @Bindable var appState = appState

33 @Bindable var appState = appState

@@ -75,7 +60,7 @@ struct MainContentView: View {

75 } else {

60 } else {

76 switch appState.currentTab {

61 switch appState.currentTab {

77 case .query:

62 case .query:

78− QueryView(viewModel: queryViewModel)

63+ QueryView()

79 .id(AppState.AppTab.query)

64 .id(AppState.AppTab.query)

80 case .liveTail:

65 case .liveTail:

81 LiveTailView()

66 LiveTailView()

@@ -95,19 +80,6 @@ struct MainContentView: View {

95 }

80 }

96 }

81 }

97 }

82 }

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− }

111 }

83 }

112}

84}

113

ParseableViewer/Views/LiveTailView.swift+7−18

@@ -123,10 +123,7 @@ 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.

129− .keyboardShortcut("k", modifiers: .command)

126+ .keyboardShortcut(.delete, modifiers: .command)

130 .accessibilityLabel("Clear all entries")

127 .accessibilityLabel("Clear all entries")

131 }

128 }

132 .padding(8)

129 .padding(8)

@@ -275,7 +272,6 @@ struct LiveTailView: View {

275 }

272 }

276 .onDisappear {

273 .onDisappear {

277 viewModel.stop()

274 viewModel.stop()

278− liveTailSortTask?.cancel()

279 }

275 }

280 .onChange(of: appState.selectedStream) { _, _ in

276 .onChange(of: appState.selectedStream) { _, _ in

281 if viewModel.isRunning {

277 if viewModel.isRunning {

@@ -287,14 +283,7 @@ struct LiveTailView: View {

287 columnWidths = [:]

283 columnWidths = [:]

288 cachedSorted = []

284 cachedSorted = []

289 }

285 }

290− .onChange(of: viewModel.visibleColumns) { _, newColumns in

286+ .onChange(of: viewModel.visibleColumns) { _, _ 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− }

298 // Showing/hiding a column changes the severity column set, so rebuild

287 // Showing/hiding a column changes the severity column set, so rebuild

299 // (which also fills in widths for any newly visible columns). A

288 // (which also fills in widths for any newly visible columns). A

300 // width-only update would leave row severity tinting stale until the

289 // width-only update would leave row severity tinting stale until the

@@ -314,6 +303,11 @@ struct LiveTailView: View {

314 }

303 }

315 }

304 }

316

305

306+ /// Computes widths for any visible columns that don't have one yet. Covers

307+ /// the case where switching to a stream with an identical column set doesn't

308+ /// fire `onChange(of: visibleColumns)`, which would otherwise leave widths

309+ /// empty (falling back to the default width) after `selectedStream` cleared

310+ /// them.

317 /// Starts (or restarts) the streaming-status pulse. Resetting `pulseOpacity`

311 /// Starts (or restarts) the streaming-status pulse. Resetting `pulseOpacity`

318 /// to 1.0 before animating to 0.3 guarantees a value delta so the repeating

312 /// to 1.0 before animating to 0.3 guarantees a value delta so the repeating

319 /// animation re-triggers even when called after a pause/resume cycle.

313 /// animation re-triggers even when called after a pause/resume cycle.

@@ -324,11 +318,6 @@ struct LiveTailView: View {

324 }

318 }

325 }

319 }

326

320

327− /// Computes widths for any visible columns that don't have one yet. Covers

328− /// the case where switching to a stream with an identical column set doesn't

329− /// fire `onChange(of: visibleColumns)`, which would otherwise leave widths

330− /// empty (falling back to the default width) after `selectedStream` cleared

331− /// them.

332 private func ensureColumnWidths() {

321 private func ensureColumnWidths() {

333 let records = viewModel.cachedFilteredRecords

322 let records = viewModel.cachedFilteredRecords

334 for col in viewModel.visibleColumns where columnWidths[col] == nil {

323 for col in viewModel.visibleColumns where columnWidths[col] == nil {

ParseableViewer/Views/LogTableView.swift+6−53

@@ -315,23 +315,7 @@ 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− }

326 .onAppear {

318 .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− }

335 recomputeColumnWidths(columns: columns, records: records)

319 recomputeColumnWidths(columns: columns, records: records)

336 rebuildSort()

320 rebuildSort()

337 }

321 }

@@ -417,9 +401,6 @@ struct LogTableView: View {

417 }

401 }

418

402

419 private func rebuildSort() {

403 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()

423 let sevCols = buildSeverityColumnSet(columns: columns)

404 let sevCols = buildSeverityColumnSet(columns: columns)

424 let enumerated = Array(records.enumerated())

405 let enumerated = Array(records.enumerated())

425 let sorted: [(offset: Int, element: LogRecord)]

406 let sorted: [(offset: Int, element: LogRecord)]

@@ -495,28 +476,12 @@ struct LogHeaderView: View {

495

476

496 @State private var draggedColumn: String?

477 @State private var draggedColumn: String?

497 @State private var dropTargetColumn: String?

478 @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.

504− @State private var uniqueValuesCache = UniqueValuesCache()

479+ @State private var uniqueValuesCache: [String: [JSONValue]] = [:]

505− @State private var recordsGeneration = 0

506−

507− private final class UniqueValuesCache {

508− var generation = -1

509− var values: [String: [JSONValue]] = [:]

510− }

511

480

512 private static let maxFilterValues = 20

481 private static let maxFilterValues = 20

513

482

514 private func uniqueValues(for column: String) -> [JSONValue] {

483 private func uniqueValues(for column: String) -> [JSONValue] {

515− if uniqueValuesCache.generation != recordsGeneration {

516− uniqueValuesCache.generation = recordsGeneration

517− uniqueValuesCache.values = [:]

518− }

519− if let cached = uniqueValuesCache.values[column] {

484+ if let cached = uniqueValuesCache[column] {

520 return cached

485 return cached

521 }

486 }

522 var seen = Set<JSONValue>()

487 var seen = Set<JSONValue>()

@@ -528,7 +493,7 @@ struct LogHeaderView: View {

528 }

493 }

529 }

494 }

530 let sorted = result.sorted()

495 let sorted = result.sorted()

531− uniqueValuesCache.values[column] = sorted

496+ uniqueValuesCache[column] = sorted

532 return sorted

497 return sorted

533 }

498 }

534

499

@@ -671,7 +636,7 @@ struct LogHeaderView: View {

671 .background(Color(nsColor: .controlBackgroundColor))

636 .background(Color(nsColor: .controlBackgroundColor))

672 .border(Color.secondary.opacity(0.2), width: 0.5)

637 .border(Color.secondary.opacity(0.2), width: 0.5)

673 .onChange(of: records) { _, _ in

638 .onChange(of: records) { _, _ in

674− recordsGeneration &+= 1

639+ uniqueValuesCache = [:]

675 }

640 }

676 }

641 }

677}

642}

@@ -704,26 +669,14 @@ private struct ColumnDropDelegate: DropDelegate {

704 }

669 }

705

670

706 func performDrop(info: DropInfo) -> Bool {

671 func performDrop(info: DropInfo) -> Bool {

707− guard let dragged = draggedColumn, dragged != column,

672+ guard let dragged = draggedColumn, dragged != column else {

708− let provider = info.itemProviders(for: [UTType.plainText]).first else {

709 draggedColumn = nil

673 draggedColumn = nil

710 dropTargetColumn = nil

674 dropTargetColumn = nil

711 return false

675 return false

712 }

676 }

677+ onMoveColumn?(dragged, column)

713 draggedColumn = nil

678 draggedColumn = nil

714 dropTargetColumn = nil

679 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− }

727 return true

680 return true

728 }

681 }

729

682

ParseableViewer/Views/QueryView.swift+10−49

@@ -12,11 +12,7 @@ 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.

19− let viewModel: QueryViewModel

15+ @State private var viewModel = QueryViewModel()

20 @State private var showSaveFilterSheet = false

16 @State private var showSaveFilterSheet = false

21 @State private var saveFilterName = ""

17 @State private var saveFilterName = ""

22 @State private var isSavingFilter = false

18 @State private var isSavingFilter = false

@@ -251,23 +247,6 @@ struct QueryView: View {

251 isLoading: viewModel.isLoading,

247 isLoading: viewModel.isLoading,

252 wrapText: wrapText,

248 wrapText: wrapText,

253 onCellFilter: { column, value, exclude in

249 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− }

271 viewModel.addColumnFilter(column: column, value: value, exclude: exclude)

250 viewModel.addColumnFilter(column: column, value: value, exclude: exclude)

272 Task {

251 Task {

273 await viewModel.executeQuery(

252 await viewModel.executeQuery(

@@ -290,9 +269,6 @@ struct QueryView: View {

290 let streamChanged = old.stream != new.stream

269 let streamChanged = old.stream != new.stream

291 if streamChanged {

270 if streamChanged {

292 viewModel.clearResults()

271 viewModel.clearResults()

293− viewModel.boundContext = QueryViewModel.BoundContext(

294− connectionID: appState.activeConnection?.id, stream: stream

295− )

296 Task {

272 Task {

297 await viewModel.loadSchema(client: appState.client, stream: stream)

273 await viewModel.loadSchema(client: appState.client, stream: stream)

298 }

274 }

@@ -327,27 +303,7 @@ struct QueryView: View {

327 }

303 }

328 .onAppear {

304 .onAppear {

329 if let stream = appState.selectedStream {

305 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

345− // Reload the schema when it's missing OR when the loaded schema

346− // belongs to a different stream than the current one — otherwise a

347− // viewModel that survives with another stream's schema would keep

348− // autocomplete pointed at the wrong stream's fields until the next

349− // stream switch.

350− if viewModel.schemaFields.isEmpty || viewModel.latestSchemaStream != stream {

306+ if viewModel.schemaFields.isEmpty {

351 Task {

307 Task {

352 await viewModel.loadSchema(client: appState.client, stream: stream)

308 await viewModel.loadSchema(client: appState.client, stream: stream)

353 }

309 }

@@ -367,7 +323,7 @@ struct QueryView: View {

367 )

323 )

368 }

324 }

369 } else {

325 } else {

370− let didSetDefault = viewModel.setDefaultQuery(stream: stream, previousStream: previousStream)

326+ let didSetDefault = viewModel.setDefaultQuery(stream: stream)

371 if didSetDefault && viewModel.results.isEmpty {

327 if didSetDefault && viewModel.results.isEmpty {

372 Task {

328 Task {

373 await viewModel.executeQuery(

329 await viewModel.executeQuery(

@@ -379,6 +335,11 @@ struct QueryView: View {

379 }

335 }

380 }

336 }

381 }

337 }

338+ .onDisappear {

339+ if viewModel.isLoading {

340+ viewModel.cancelQuery()

341+ }

342+ }

382 .onChange(of: appState.queryRefreshToken) { _, _ in

343 .onChange(of: appState.queryRefreshToken) { _, _ in

383 // Guard on a selected stream like every sibling query trigger in this

344 // Guard on a selected stream like every sibling query trigger in this

384 // view. Without it, a refresh (Cmd+R) with no stream selected and an

345 // view. Without it, a refresh (Cmd+R) with no stream selected and an

@@ -496,7 +457,7 @@ struct ColumnManagerView: View {

496 Text("Columns")

457 Text("Columns")

497 .font(.headline)

458 .font(.headline)

498 Spacer()

459 Spacer()

499− if viewModel.hasHiddenColumns || viewModel.columnOrder != viewModel.columns {

460+ if !viewModel.hiddenColumns.isEmpty || !viewModel.autoHiddenColumns.isEmpty || viewModel.columnOrder != viewModel.columns {

500 Button("Reset") {

461 Button("Reset") {

501 viewModel.resetColumnConfig()

462 viewModel.resetColumnConfig()

502 }

463 }

@@ -550,7 +511,7 @@ struct ColumnManagerView: View {

550 }

511 }

551 .listStyle(.plain)

512 .listStyle(.plain)

552

513

553− if viewModel.hasHiddenColumns {

514+ if !viewModel.hiddenColumns.isEmpty || !viewModel.autoHiddenColumns.isEmpty {

554 Divider()

515 Divider()

555 Button("Show All Columns") {

516 Button("Show All Columns") {

556 viewModel.showAllColumns()

517 viewModel.showAllColumns()

ParseableViewer/Views/SQLAutoComplete.swift+11−98

@@ -105,32 +105,23 @@ 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−

116 let context = determineContext(text: text, position: wordStart)

108 let context = determineContext(text: text, position: wordStart)

117

109

118− // Table (and column) completions supply their own quoting. If the user has

110+ // A table completion supplies its own surrounding quotes. If the user has

119 // already typed quotes directly around the word (common for stream names

111 // already typed quotes directly around the word (common for stream names

120 // with spaces, e.g. `FROM "my"`), absorb them into the replacement range so

112 // with spaces, e.g. `FROM "my"`), absorb them into the replacement range so

121 // the inserted `"name"` replaces the stray quotes instead of producing

113 // the inserted `"name"` replaces the stray quotes instead of producing

122 // `""name""`. Mirror `insertCompletion`, which absorbs leading and trailing

114 // `""name""`. Mirror `insertCompletion`, which absorbs leading and trailing

123− // quotes independently for any `.table`/`.column` item — so apply this

115+ // quotes independently for any `.table` item — so apply this wherever table

124− // wherever those completions are offered (`.tableRef`, `.columnRef` and

116+ // completions are offered (`.tableRef` and `.general`), not just `.tableRef`.

125− // `.general`).

126 var replaceStart = wordStart

117 var replaceStart = wordStart

127 var replaceEnd = wordEnd

118 var replaceEnd = wordEnd

128− let offersIdentifiers: Bool

119+ let offersTable: Bool

129 switch context {

120 switch context {

130− case .tableRef, .columnRef, .general: offersIdentifiers = true

121+ case .tableRef, .general: offersTable = true

131− case .afterOrder, .afterGroup: offersIdentifiers = false

122+ default: offersTable = false

132 }

123 }

133− if offersIdentifiers {

124+ if offersTable {

134 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

125 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

135 replaceStart -= 1

126 replaceStart -= 1

136 }

127 }

@@ -156,7 +147,7 @@ enum SQLCompletionProvider {

156 case .columnRef:

147 case .columnRef:

157 for field in schemaFields.sorted(by: { $0.name < $1.name })

148 for field in schemaFields.sorted(by: { $0.name < $1.name })

158 where field.name.uppercased().hasPrefix(uppercasePrefix) {

149 where field.name.uppercased().hasPrefix(uppercasePrefix) {

159− items.append(columnItem(for: field))

150+ items.append(SQLCompletionItem(text: field.name, kind: .column, detail: field.dataType))

160 }

151 }

161 for fn in SQLSyntaxHighlighter.sortedFunctions where fn.hasPrefix(uppercasePrefix) {

152 for fn in SQLSyntaxHighlighter.sortedFunctions where fn.hasPrefix(uppercasePrefix) {

162 items.append(SQLCompletionItem(text: fn, kind: .function))

153 items.append(SQLCompletionItem(text: fn, kind: .function))

@@ -186,87 +177,20 @@ enum SQLCompletionProvider {

186 }

177 }

187 for field in schemaFields.sorted(by: { $0.name < $1.name })

178 for field in schemaFields.sorted(by: { $0.name < $1.name })

188 where field.name.uppercased().hasPrefix(uppercasePrefix) {

179 where field.name.uppercased().hasPrefix(uppercasePrefix) {

189− items.append(columnItem(for: field))

180+ items.append(SQLCompletionItem(text: field.name, kind: .column, detail: field.dataType))

190 }

181 }

191 }

182 }

192

183

193 // Don't show the popup when the only match is an exact hit. Compare the

184 // Don't show the popup when the only match is an exact hit. Compare the

194 // match text (unquoted), not the display text — a table's display text is

185 // match text (unquoted), not the display text — a table's display text is

195 // wrapped in quotes (`"name"`) and would never match the bare prefix.

186 // 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

204− : only.matchText.uppercased() == uppercasePrefix

187+ if items.count == 1 && items[0].matchText.uppercased() == uppercasePrefix {

205− if isExactHit { return ([], prefix, range) }

188+ return ([], prefix, range)

206 }

189 }

207

190

208 return (items, prefix, range)

191 return (items, prefix, range)

209 }

192 }

210

193

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−

270 // MARK: - Context Detection

194 // MARK: - Context Detection

271

195

272 static func determineContext(text: String, position: Int) -> SQLCompletionContext {

196 static func determineContext(text: String, position: Int) -> SQLCompletionContext {

@@ -529,17 +453,6 @@ final class SQLCompletionPopup: NSObject, NSTableViewDataSource, NSTableViewDele

529

453

530 // MARK: - NSTableViewDelegate

454 // MARK: - NSTableViewDelegate

531

455

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−

543 func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {

456 func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {

544 guard row < items.count else { return nil }

457 guard row < items.count else { return nil }

545 let item = items[row]

458 let item = items[row]

ParseableViewer/Views/SQLEditorView.swift+6−41

@@ -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− context.coordinator.replaceText(with: text, in: textView)

60+ textView.string = text

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,11 +101,6 @@ 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

109

104

110 init(text: Binding<String>, streamNames: [String], schemaFields: [SchemaField]) {

105 init(text: Binding<String>, streamNames: [String], schemaFields: [SchemaField]) {

111 self.text = text

106 self.text = text

@@ -121,8 +116,7 @@ struct SQLEditorView: NSViewRepresentable {

121 // MARK: - NSTextViewDelegate

116 // MARK: - NSTextViewDelegate

122

117

123 func textDidChange(_ notification: Notification) {

118 func textDidChange(_ notification: Notification) {

124− guard let textView = notification.object as? NSTextView,

119+ guard let textView = notification.object as? NSTextView else { return }

125− !isApplyingModelChange else { return }

126 isEditing = true

120 isEditing = true

127 clearErrorHighlight(in: textView)

121 clearErrorHighlight(in: textView)

128 text.wrappedValue = textView.string

122 text.wrappedValue = textView.string

@@ -134,34 +128,6 @@ struct SQLEditorView: NSViewRepresentable {

134 }

128 }

135 }

129 }

136

130

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−

165 func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {

131 func textView(_ textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {

166 guard completionPopup.isVisible else { return false }

132 guard completionPopup.isVisible else { return false }

167

133

@@ -257,13 +223,12 @@ struct SQLEditorView: NSViewRepresentable {

257 }

223 }

258 }

224 }

259

225

260− // Table and column completions carry their own quoting (a column is

261− // quoted only when it needs it); absorb any double-quote the user typed

226+ // A table completion carries its own quotes; absorb any double-quote the

262− // directly around the word so the inserted identifier replaces it

227+ // user typed directly around the word so the inserted `"name"` replaces

263− // instead of leaving a stray quote. Leading and trailing are handled

228+ // it instead of leaving a stray quote. Leading and trailing are handled

264 // independently: a closing quote can exist without an opening one (e.g.

229 // independently: a closing quote can exist without an opening one (e.g.

265 // `FROM my"`), which would otherwise produce a dangling `"name""`.

230 // `FROM my"`), which would otherwise produce a dangling `"name""`.

266− if item.kind == .table || item.kind == .column {

231+ if item.kind == .table {

267 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

232 if wordStart > 0, nsText.character(at: wordStart - 1) == 0x22 {

268 wordStart -= 1

233 wordStart -= 1

269 }

234 }

ParseableViewer/Views/ServerInfoView.swift+4−20

@@ -3,15 +3,9 @@ import SwiftUI

3struct ServerInfoView: View {

4 @Environment(AppState.self) private var appState

5 @State private var about: ServerAbout?

6− // Start in the loading state: the `.task` always runs `loadInfo()` on appear, so

7− // initializing to `false` would paint the `else` branch's red "Unhealthy" dot for

8− // one frame before the check begins. Begin neutral ("Checking…") instead.

9− @State private var isLoading = true

6+ @State private var isLoading = false

10 @State private var isHealthy = false

7 @State private var isHealthy = false

11 @State private var errorMessage: String?

8 @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

16 var body: some View {

10 var body: some View {

17 ScrollView {

11 ScrollView {

@@ -22,7 +16,7 @@ struct ServerInfoView: View {

22 .fontWeight(.semibold)

16 .fontWeight(.semibold)

23 Spacer()

17 Spacer()

24 Button {

18 Button {

25− Task { await loadInfo(forceRefresh: true) }

19+ Task { await loadInfo() }

26 } label: {

20 } label: {

27 Image(systemName: "arrow.clockwise")

21 Image(systemName: "arrow.clockwise")

28 }

22 }

@@ -156,18 +150,9 @@ struct ServerInfoView: View {

156 }

150 }

157 }

151 }

158

152

159− private func loadInfo(forceRefresh: Bool = false) async {

153+ private func loadInfo() async {

160− // Clear isLoading on the no-client path: since isLoading now starts `true`

161− // (to avoid a red "Unhealthy" flash before the first check), an early return

162− // without resetting it would wedge the spinner permanently.

163− guard let client = appState.client else { isLoading = false; return }

154+ guard let client = appState.client else { return }

164− // `getAbout()` is cached for 60 s; the Refresh button must bypass that.

165− if forceRefresh {

166− await client.invalidateCache()

167− }

168 let connID = appState.activeConnection?.id

155 let connID = appState.activeConnection?.id

169− loadGeneration &+= 1

170− let generation = loadGeneration

171 isLoading = true

156 isLoading = true

172 errorMessage = nil

157 errorMessage = nil

173 // Seed from the app-wide cache so first load isn't blank, but never fall

158 // Seed from the app-wide cache so first load isn't blank, but never fall

@@ -198,7 +183,6 @@ struct ServerInfoView: View {

198 // load for the previous server can't overwrite the current one's state.

183 // load for the previous server can't overwrite the current one's state.

199 // Still clear isLoading: this task owns the spinner it set, and leaving it

184 // Still clear isLoading: this task owns the spinner it set, and leaving it

200 // true on the stale path wedges the ProgressView and disables Refresh.

185 // true on the stale path wedges the ProgressView and disables Refresh.

201− guard generation == loadGeneration else { return }

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

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

203 isHealthy = healthy

187 isHealthy = healthy

204 about = aboutValue

188 about = aboutValue

ParseableViewer/Views/SidebarView.swift+1−19

@@ -6,14 +6,6 @@ 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?

17 @State private var deleteStreamDetail: String?

9 @State private var deleteStreamDetail: String?

19 /// Validates a stream name, returning an error message or nil if valid.

11 /// Validates a stream name, returning an error message or nil if valid.

@@ -73,10 +65,7 @@ struct SidebarView: View {

73 // would show the wrong stats on a destructive

65 // would show the wrong stats on a destructive

74 // confirmation.

66 // confirmation.

75 let target = stream.name

67 let target = stream.name

76− let targetConnectionID = appState.activeConnection?.id

77 streamToDelete = target

68 streamToDelete = target

78− streamToDeleteConnectionID = targetConnectionID

79− streamToDeleteClient = appState.client

80 deleteStreamDetail = nil

69 deleteStreamDetail = nil

81 Task {

70 Task {

82 if let client = appState.client,

71 if let client = appState.client,

@@ -92,9 +81,7 @@ struct SidebarView: View {

92 deleteStreamDetail = parts.joined(separator: ", ")

81 deleteStreamDetail = parts.joined(separator: ", ")

93 }

82 }

94 }

83 }

95− if streamToDelete == target,

84+ if streamToDelete == target {

96− appState.activeConnection?.id == targetConnectionID,

97− appState.client === streamToDeleteClient {

98 showDeleteConfirm = true

85 showDeleteConfirm = true

99 }

86 }

100 }

87 }

@@ -200,11 +187,6 @@ struct SidebarView: View {

200 .alert("Delete Stream", isPresented: $showDeleteConfirm) {

187 .alert("Delete Stream", isPresented: $showDeleteConfirm) {

201 Button("Delete", role: .destructive) {

188 Button("Delete", role: .destructive) {

202 if let name = streamToDelete {

189 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− }

208 Task {

190 Task {

209 do {

191 do {

210 try await appState.deleteStream(name: name)

192 try await appState.deleteStream(name: name)

ParseableViewer/Views/StreamDetailView.swift+4−18

@@ -8,9 +8,6 @@ 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

15 var body: some View {

12 var body: some View {

16 Group {

13 Group {

@@ -28,7 +25,7 @@ struct StreamDetailView: View {

28 Spacer()

25 Spacer()

30 Button {

27 Button {

31− Task { await loadData(stream: stream, forceRefresh: true) }

28+ Task { await loadData(stream: stream) }

32 } label: {

29 } label: {

33 Image(systemName: "arrow.clockwise")

30 Image(systemName: "arrow.clockwise")

34 }

31 }

@@ -47,7 +44,7 @@ struct StreamDetailView: View {

47 Text(error)

44 Text(error)

48 Spacer()

45 Spacer()

49 Button("Retry") {

46 Button("Retry") {

50− Task { await loadData(stream: stream, forceRefresh: true) }

47+ Task { await loadData(stream: stream) }

51 }

48 }

52 .buttonStyle(.bordered)

49 .buttonStyle(.bordered)

53 .controlSize(.small)

50 .controlSize(.small)

@@ -177,22 +174,13 @@ struct StreamDetailView: View {

177 }

174 }

178 }

175 }

179

176

180− private func loadData(stream: String, forceRefresh: Bool = false) async {

177+ private func loadData(stream: String) async {

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

178 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− }

189 // Capture the connection this fetch belongs to. Two servers can expose a

179 // Capture the connection this fetch belongs to. Two servers can expose a

190 // same-named stream, so guarding on the stream name alone would let a

180 // same-named stream, so guarding on the stream name alone would let a

191 // slow fetch write the previous server's data under the new server's

181 // slow fetch write the previous server's data under the new server's

192 // stream after a server switch.

182 // stream after a server switch.

193 let connID = appState.activeConnection?.id

183 let connID = appState.activeConnection?.id

194− loadGeneration &+= 1

195− let generation = loadGeneration

196 isLoading = true

184 isLoading = true

197 errorMessage = nil

185 errorMessage = nil

198 // Clear previous stream's data so it isn't shown under the new header

186 // Clear previous stream's data so it isn't shown under the new header

@@ -228,9 +216,7 @@ struct StreamDetailView: View {

228 // resolve after the user switched. Drop stale results instead of writing

216 // resolve after the user switched. Drop stale results instead of writing

229 // them under the new stream's header. Also check the connection so a

217 // them under the new stream's header. Also check the connection so a

230 // same-named stream on a different server doesn't accept the old server's

218 // same-named stream on a different server doesn't accept the old server's

231− // data. Reset `isLoading` on the stale path or the spinner wedges forever —

219+ // 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 }

234 guard stream == appState.selectedStream, connID == appState.activeConnection?.id else {

220 guard stream == appState.selectedStream, connID == appState.activeConnection?.id else {

235 isLoading = false

221 isLoading = false

236 return

222 return

ParseableViewer/Views/SyntaxHighlighting.swift+58−32

@@ -49,23 +49,10 @@ 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).

60− private static let literalOrCommentRegex = try! NSRegularExpression(

52+ private static let commentRegex = try! NSRegularExpression(pattern: "--[^\n]*", options: [.caseInsensitive])

61− pattern: "('[^']*(?:''[^']*)*')|(\"[^\"]*(?:\"\"[^\"]*)*\")|(--[^\\n]*|/\\*[\\s\\S]*?(?:\\*/|\\z))",

53+ private static let singleQuoteRegex = try! NSRegularExpression(pattern: "'[^']*(?:''[^']*)*'", options: [.caseInsensitive])

62− options: []

54+ private static let doubleQuoteRegex = try! NSRegularExpression(pattern: "\"[^\"]*(?:\"\"[^\"]*)*\"", options: [.caseInsensitive])

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.

68− private static let numberRegex = try! NSRegularExpression(pattern: "(?<![\\w.])(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?", options: [])

55+ private static let numberRegex = try! NSRegularExpression(pattern: "\\b\\d+(?:\\.\\d+)?\\b", options: [])

69 private static let keywordRegex: NSRegularExpression = {

56 private static let keywordRegex: NSRegularExpression = {

70 let pattern = "\\b(?:" + sortedKeywords.joined(separator: "|") + ")\\b"

57 let pattern = "\\b(?:" + sortedKeywords.joined(separator: "|") + ")\\b"

71 return try! NSRegularExpression(pattern: pattern, options: [.caseInsensitive])

58 return try! NSRegularExpression(pattern: pattern, options: [.caseInsensitive])

@@ -89,21 +76,20 @@ enum SQLSyntaxHighlighter {

89 let nsText = text as NSString

76 let nsText = text as NSString

90 var protectedRanges: [NSRange] = []

77 var protectedRanges: [NSRange] = []

92− // 1–3. Single-quoted strings, double-quoted identifiers, and comments, in

79+ // 1. Single-quoted strings

93− // one pass so none of them can start inside another (`'a--b'` stays a

80+ applyRegex(singleQuoteRegex, to: textStorage, text: nsText,

94− // string, `-- don't` stays a comment).

81+ color: .systemRed, protectedRanges: &protectedRanges)

95− let literalMatches = literalOrCommentRegex.matches(

82+

96− in: text, range: NSRange(location: 0, length: nsText.length)

83+ // 2. Double-quoted identifiers

97− )

84+ applyRegex(doubleQuoteRegex, to: textStorage, text: nsText,

98− for match in literalMatches {

85+ color: .systemRed, protectedRanges: &protectedRanges)

99− let isComment = match.range(at: 3).location != NSNotFound

86+

100− textStorage.addAttribute(

87+ // 3. Comments (-- to end of line). Highlighted AFTER strings, and a `--`

101− .foregroundColor,

88+ // that begins inside a string literal (protectedRanges currently holds

102− value: isComment ? NSColor.secondaryLabelColor : NSColor.systemRed,

89+ // only string ranges) is skipped — otherwise `'a--b' AND y = 5` would

103− range: match.range

90+ // bleed a gray comment over the trailing real SQL.

104− )

91+ applyCommentRegex(commentRegex, to: textStorage, text: nsText,

105− protectedRanges.append(match.range)

92+ color: .secondaryLabelColor, protectedRanges: &protectedRanges)

106− }

107

108 // 4. Numbers (outside protected ranges)

94 // 4. Numbers (outside protected ranges)

109 applyUnprotectedRegex(numberRegex, to: textStorage, text: nsText,

95 applyUnprotectedRegex(numberRegex, to: textStorage, text: nsText,

@@ -120,6 +106,46 @@ enum SQLSyntaxHighlighter {

120 protectedRanges: protectedRanges)

106 protectedRanges: protectedRanges)

121 }

107 }

122

108

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+

123 private static func applyUnprotectedRegex(

149 private static func applyUnprotectedRegex(

124 _ regex: NSRegularExpression,

150 _ regex: NSRegularExpression,

125 to textStorage: NSTextStorage,

151 to textStorage: NSTextStorage,

ParseableViewer/Views/UsersView.swift−6

@@ -5,9 +5,6 @@ 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

12 var body: some View {

9 var body: some View {

13 VStack(spacing: 0) {

10 VStack(spacing: 0) {

@@ -85,8 +82,6 @@ struct UsersView: View {

85 private func loadUsers() async {

82 private func loadUsers() async {

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

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

87 let connID = appState.activeConnection?.id

84 let connID = appState.activeConnection?.id

88− loadGeneration &+= 1

89− let generation = loadGeneration

90 isLoading = true

85 isLoading = true

91 errorMessage = nil

86 errorMessage = nil

92 // Clear the previous server's list up front so it can't briefly show through

87 // Clear the previous server's list up front so it can't briefly show through

@@ -107,7 +102,6 @@ struct UsersView: View {

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

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

108 // isLoading: this task set the spinner, so leaving it true on the stale path

103 // isLoading: this task set the spinner, so leaving it true on the stale path

109 // wedges the ProgressView and disables Refresh.

104 // wedges the ProgressView and disables Refresh.

110− guard generation == loadGeneration else { return }

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

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

112 if let loaded { users = loaded }

106 if let loaded { users = loaded }

113 errorMessage = loadError

107 errorMessage = loadError

ParseableViewerTests/LiveTailViewModelTests.swift+1−39

@@ -404,23 +404,10 @@ final class LiveTailViewModelTests: XCTestCase {

404 XCTAssertEqual(vm.columnFilters.count, 1)

405 }

406

407− func testAddFilterSameColumnIncludeReplaces() {

407+ func testAddFilterDifferentValueIsAdditive() {

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.

413 vm.addColumnFilter(column: "level", value: .string("warn"), exclude: false)

410 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)

424 XCTAssertEqual(vm.columnFilters.count, 2)

411 XCTAssertEqual(vm.columnFilters.count, 2)

425 }

412 }

426

413

@@ -461,29 +448,4 @@ final class LiveTailViewModelTests: XCTestCase {

461 let filter = LiveTailViewModel.ColumnFilter(column: "field", value: nil, exclude: false)

448 let filter = LiveTailViewModel.ColumnFilter(column: "field", value: nil, exclude: false)

462 XCTAssertEqual(filter.displayLabel, "field = null")

449 XCTAssertEqual(filter.displayLabel, "field = null")

463 }

450 }

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− }

489}

451}

ParseableViewerTests/ParseableClientTests.swift−58

@@ -646,62 +646,4 @@ 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− }

707}

649}

ParseableViewerTests/QueryViewModelTests.swift+2−122

@@ -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\" IS DISTINCT FROM 'debug'"))

238+ XCTAssertTrue(vm.sqlQuery.contains("WHERE \"level\" <> '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\" IS DISTINCT FROM 'warn'"))

291+ XCTAssertTrue(vm.sqlQuery.contains("WHERE \"level\" <> 'warn'"))

292 }

293

294 func testAddColumnFilterEscapesSingleQuotesInValue() {

@@ -671,125 +671,5 @@ 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− }

794}

674}

795

675

ParseableViewerTests/SQLAutoCompleteTests.swift−56

@@ -275,62 +275,6 @@ 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− }

334}

278}

335

279

336// Make SQLCompletionContext Equatable for assertions

280// Make SQLCompletionContext Equatable for assertions

ParseableViewerTests/SQLTokenizerTests.swift−15

@@ -348,19 +348,4 @@ 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− }

366}

351}

ParseableViewerTests/ServerConnectionTests.swift−10

@@ -77,14 +77,4 @@ 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− }

90}

80}

ParseableViewerTests/SyntaxHighlightingTests.swift−10

@@ -140,16 +140,6 @@ 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−

153 // MARK: - JSON Highlighting

143 // MARK: - JSON Highlighting

154

144

155 func testJSONHighlightProducesOutput() {

145 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+K` | Clear live tail entries |

146+| `Cmd+Delete` | Clear live tail entries |

147| `Cmd+Ctrl+S` | Toggle sidebar |

148

149## License