d947711..master · parseable-macos

git.iko.soy/parseable-macos

on master help sign in

ParseableViewer/App/AppState.swift+81−5

since splitsnapshots

unifiedsplit

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

15 private let networkMonitor = NWPathMonitor()

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

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

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

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

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

21+ private var connectingConnectionID: UUID?

19 // MARK: - Stream State

23 // MARK: - Stream State

20 var streams: [LogStream] = []

24 var streams: [LogStream] = []

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

100

97 if let activeID = ConnectionStore.loadActiveConnectionID(),

101 if let activeID = ConnectionStore.loadActiveConnectionID(),

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

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

103+ connectingConnectionID = connection.id

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

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

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

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

101 }

106 }

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

115 existing.cancel()

120 existing.cancel()

116 _ = await existing.value

121 _ = await existing.value

117 }

122 }

123+ connectingConnectionID = connection.id

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

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

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

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

120 }

126 }

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

124

130

125 @MainActor

131 @MainActor

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

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

133+ defer {

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

135+ }

127 guard !isConnecting else { return false }

136 guard !isConnecting else { return false }

128

137

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

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

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

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

129− if !isNetworkAvailable {

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

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

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

131 self.showError = true

144 self.showError = true

132 return false

145 return false

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

134

147

135 isConnecting = true

148 isConnecting = true

136 defer { isConnecting = false }

149 defer { isConnecting = false }

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

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

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

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

137 errorMessage = nil

154 errorMessage = nil

155+ showError = false

138

156

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

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

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

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

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

164

182

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

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

166 try await newClient.checkHealth()

184 try await newClient.checkHealth()

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

167

186

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

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

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

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

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

200 case .success(let list):

219 case .success(let list):

201 self.streams = list

220 self.streams = list

202 self.streamLoadError = nil

221 self.streamLoadError = nil

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

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

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

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

226+ selectedStream = nil

227+ }

203 case .failure(let error):

228 case .failure(let error):

204 self.streams = []

229 self.streams = []

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

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

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

265 let loaded = try await client.listStreams()

290 let loaded = try await client.listStreams()

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

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

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

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

268− // wedges the indicator and disables Refresh.

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

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

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

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

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

297+ isLoadingStreams = false

298+ return

299+ }

270 streams = loaded

300 streams = loaded

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

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

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

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

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

275 selectedStream = nil

305 selectedStream = nil

276 }

306 }

277 } catch {

307 } catch {

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

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

309+ isLoadingStreams = false

310+ return

311+ }

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

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

280 streamLoadError = message

313 streamLoadError = message

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

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

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

342 ConnectionStore.saveConnections(connections)

375 ConnectionStore.saveConnections(connections)

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

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

344 disconnect()

377 disconnect()

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

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

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

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

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

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

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

385+ connectTask?.cancel()

386+ connectTask = nil

387+ connectingConnectionID = nil

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

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

390+ if client != nil {

391+ Task { @MainActor [weak self] in

392+ await self?.refreshStreams()

393+ await self?.refreshFilters()

394+ }

395+ }

396+ }

397+ }

398+

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

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

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

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

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

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

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

406+ do {

407+ _ = try await client.getAbout()

408+ } catch ParseableError.unauthorized {

409+ throw ParseableError.unauthorized

410+ } catch {

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

345 }

412 }

346 }

413 }

347

414

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

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

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

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

419+ }

420+

348 // MARK: - Stream Management

421 // MARK: - Stream Management

349

422

350 @MainActor

423 @MainActor

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

377 let connID = activeConnection?.id

450 let connID = activeConnection?.id

378 isLoadingFilters = true

451 isLoadingFilters = true

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

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

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

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

454+ isLoadingFilters = false

455+ return

456+ }

381 filters = loaded

457 filters = loaded

382 isLoadingFilters = false

458 isLoadingFilters = false

383 }

459 }

ParseableViewer/App/ParseableViewerApp.swift+13−1

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

4struct ParseableViewerApp: App {

5 @State private var appState = AppState()

7+ init() {

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

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

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

11+ NSWindow.allowsAutomaticWindowTabbing = false

12+ }

13+

7 var body: some Scene {

14 var body: some Scene {

8 WindowGroup {

15 WindowGroup {

9 ContentView()

16 ContentView()

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

17 AboutCommand()

24 AboutCommand()

18 }

25 }

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

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

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

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

31+ // saved-filter SQL.

20− CommandGroup(after: .newItem) {

32+ CommandGroup(replacing: .newItem) {

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

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

22 appState.editingConnection = nil

34 appState.editingConnection = nil

23 appState.showConnectionSheet = true

35 appState.showConnectionSheet = true

ParseableViewer/Info.plist+5

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

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

25 <key>LSMinimumSystemVersion</key>

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

27+ <key>NSAppTransportSecurity</key>

28+ <dict>

29+ <key>NSAllowsArbitraryLoads</key>

30+ <true/>

31+ </dict>

27 <key>NSMainNibFile</key>

32 <key>NSMainNibFile</key>

28 <string></string>

33 <string></string>

29 <key>NSPrincipalClass</key>

34 <key>NSPrincipalClass</key>

ParseableViewer/Models/AlertModels.swift+21

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

85struct AlertRuleSpec: Codable, Sendable {

86 let type: String?

87 let config: String?

88+

89+ private enum CodingKeys: String, CodingKey {

90+ case type, config

91+ }

92+

93+ init(from decoder: Decoder) throws {

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

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

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

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

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

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

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

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

102+ self.config = string

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

104+ self.config = value.compactJSON

105+ } else {

106+ self.config = nil

107+ }

108+ }

88}

109}

110

90struct AlertTarget: Codable, Sendable {

111struct AlertTarget: Codable, Sendable {

ParseableViewer/Models/LogStream.swift+97−11

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

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

81 self.dataType = typeStr

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

83− self.dataType = typeObj.displayString

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

84 } else {

85 self.dataType = "Unknown"

86 }

87 }

88+

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

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

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

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

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

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

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

96+ switch value {

97+ case .null:

98+ return "None"

99+ case .string(let s):

100+ return s

101+ case .array(let items):

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

103+ case .object(let dict):

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

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

106+ return describeArrowType(fieldType)

107+ }

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

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

110+ }

111+ return value.compactJSON

112+ default:

113+ return value.displayString

114+ }

115+ }

88}

116}

117

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

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

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

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

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

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

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

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

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

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

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

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

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

110−/// unchanged.

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

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

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

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

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

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

144+ }

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

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

114 return value

146 return value

115}

147}

116

148

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

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

151+private struct FlexibleCodingKey: CodingKey {

152+ let stringValue: String

153+ var intValue: Int? { nil }

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

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

156+}

157+

158+private extension KeyedDecodingContainer where Key == FlexibleCodingKey {

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

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

161+ for key in keys {

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

163+ return value

164+ }

165+ }

166+ return nil

167+ }

168+

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

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

171+ /// string "true").

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

173+ for key in keys {

174+ let codingKey = FlexibleCodingKey(stringValue: key)

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

176+ return value

177+ }

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

179+ switch string.lowercased() {

180+ case "true": return true

181+ case "false": return false

182+ default: continue

183+ }

184+ }

185+ }

186+ return nil

187+ }

188+}

189+

117struct StreamStats: Codable, Sendable {

190struct StreamStats: Codable, Sendable {

118 let ingestion: IngestionStats?

191 let ingestion: IngestionStats?

119 let storage: StorageStats?

192 let storage: StorageStats?

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

165

238

166 init(from decoder: Decoder) throws {

239 init(from decoder: Decoder) throws {

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

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

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

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

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

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

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

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

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

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

170 self.size = formatByteSize(s)

247 self.size = formatByteSize(s)

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

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

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

208 }

285 }

209

286

210 init(from decoder: Decoder) throws {

287 init(from decoder: Decoder) throws {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

300+ self.staticSchemaFlag = container.firstBool(

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

302+ )

217 }

303 }

218}

304}

ParseableViewer/Models/ServerConnection.swift+19−2

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

56 var baseURL: URL? {

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

58 if urlString.isEmpty { return nil }

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

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

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

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

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

63+ } else {

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

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

61 }

65 }

62 while urlString.hasSuffix("/") {

66 while urlString.hasSuffix("/") {

63 urlString.removeLast()

67 urlString.removeLast()

64 }

68 }

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

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

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

66 return nil

71 return nil

67 }

72 }

68 return parsed

73 return parsed

69 }

74 }

75+

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

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

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

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

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

81+ urlSchemeRange(in: string) != nil

82+ }

83+

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

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

86+ }

70}

87}

ParseableViewer/Models/ServerInfo.swift+33−7

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

15 let llmActive: Bool?

16 let oidcActive: Bool?

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

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

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

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

22+ // forms are kept as a fallback.

18 private enum CodingKeys: String, CodingKey {

23 private enum CodingKeys: String, CodingKey {

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

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

20− case uiVersion = "ui_version"

25+ case uiVersion

21− case deploymentId = "deployment_id"

26+ case deploymentId

22− case grpcPort = "grpc_port"

27+ case grpcPort

23 case updateAvailable

28 case updateAvailable

24 case latestVersion

29 case latestVersion

25 case llmActive

30 case llmActive

26 case oidcActive

31 case oidcActive

27 }

32 }

34+ private enum SnakeCaseKeys: String, CodingKey {

35+ case uiVersion = "ui_version"

36+ case deploymentId = "deployment_id"

37+ case grpcPort = "grpc_port"

38+ }

39+

29 init(from decoder: Decoder) throws {

40 init(from decoder: Decoder) throws {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

44 }

60 }

61+

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

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

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

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

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

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

68+ }

69+ return name

70+ }

45}

71}

47struct StoreInfo: Codable, Sendable {

73struct StoreInfo: Codable, Sendable {

ParseableViewer/Services/ParseableClient.swift+44−2

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

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

410 }

411

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

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

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

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

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

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

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

419+ let pageSize = 1000

420+ var firstData: Data?

421+ var version: String?

422+ var collected: [AlertRule] = []

423+ var seenIDs = Set<String>()

424+ var offset = 0

425+ for _ in 0..<50 {

426+ let data: Data

427+ do {

428+ data = try await performRequest(

429+ method: "GET",

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

431+ queryItems: [

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

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

434+ ]

435+ )

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

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

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

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

440+ }

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

442+ if firstData == nil {

443+ firstData = data

444+ version = page.version

445+ }

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

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

448+ collected.append(contentsOf: fresh)

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

450+ offset += alerts.count

451+ }

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

453+ }

454+

412 do {

455 do {

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

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

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

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

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

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

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

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

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

ParseableViewer/Views/AlertsView.swift+12−1

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

5 @State private var alertConfig: AlertConfig?

6 @State private var isLoading = false

7 @State private var errorMessage: String?

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

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

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

11+ @State private var loadGeneration = 0

9 var body: some View {

13 var body: some View {

10 Group {

14 Group {

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

77 private func loadAlerts(stream: String) async {

81 private func loadAlerts(stream: String) async {

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

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

79 let connID = appState.activeConnection?.id

83 let connID = appState.activeConnection?.id

84+ loadGeneration &+= 1

85+ let generation = loadGeneration

80 isLoading = true

86 isLoading = true

81 errorMessage = nil

87 errorMessage = nil

82 alertConfig = nil

88 alertConfig = nil

84 do {

90 do {

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

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

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

93+ guard generation == loadGeneration else { return }

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

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

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

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

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

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

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

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

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

95 alertConfig = config

103 alertConfig = config

96 } catch {

104 } catch {

105+ guard generation == loadGeneration else { return }

97 guard stream == appState.selectedStream,

106 guard stream == appState.selectedStream,

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

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

99 errorMessage = ParseableError.userFriendlyMessage(for: error)

108 errorMessage = ParseableError.userFriendlyMessage(for: error)

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

203 private var stateColor: Color {

212 private var stateColor: Color {

204 switch alert.state?.lowercased() {

213 switch alert.state?.lowercased() {

205 case "triggered": return .red

214 case "triggered": return .red

206− case "disabled": return .gray

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

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

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

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

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

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

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

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

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

ParseableViewer/Views/ConnectionSheet.swift+27−7

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

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

19 /// duplicate.

20 @State private var createdConnection: ServerConnection?

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

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

23+ /// success/failure under values that were never tested.

24+ @State private var testGeneration = 0

22 enum TestResult {

26 enum TestResult {

23 case success(String)

27 case success(String)

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

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

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

44 .textFieldStyle(.roundedBorder)

48 .textFieldStyle(.roundedBorder)

45 .accessibilityLabel("Connection name")

49 .accessibilityLabel("Connection name")

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

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

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

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

49 .textFieldStyle(.roundedBorder)

53 .textFieldStyle(.roundedBorder)

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

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

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

52 urlValidationError = Self.validateURL(newValue)

56 urlValidationError = Self.validateURL(newValue)

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

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

54− testResult = nil

58+ invalidateTestResult()

55 }

59 }

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

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

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

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

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

64 .textFieldStyle(.roundedBorder)

68 .textFieldStyle(.roundedBorder)

65 .accessibilityLabel("Username")

69 .accessibilityLabel("Username")

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

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

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

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

69 .textFieldStyle(.roundedBorder)

73 .textFieldStyle(.roundedBorder)

70 .accessibilityLabel("Password")

74 .accessibilityLabel("Password")

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

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

72 }

76 }

73 .formStyle(.grouped)

77 .formStyle(.grouped)

74 .padding()

78 .padding()

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

165 }

169 }

166 }

170 }

167

171

172+ private func invalidateTestResult() {

173+ testGeneration += 1

174+ testResult = nil

175+ }

176+

168 private func testConnection() {

177 private func testConnection() {

169 isTesting = true

178 isTesting = true

170 testResult = nil

179 testResult = nil

180+ testGeneration += 1

181+ let generation = testGeneration

171

182

172 Task {

183 Task {

173 do {

184 do {

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

179 )

190 )

180 let client = try ParseableClient(connection: conn)

191 let client = try ParseableClient(connection: conn)

181 try await client.checkHealth()

192 try await client.checkHealth()

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

194+ // AppState.verifyCredentials.

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

182 await MainActor.run {

196 await MainActor.run {

183− testResult = .success("Connection successful")

184 isTesting = false

197 isTesting = false

198+ guard generation == testGeneration else { return }

199+ testResult = .success("Connection successful")

185 }

200 }

186 } catch {

201 } catch {

187 await MainActor.run {

202 await MainActor.run {

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

189 isTesting = false

203 isTesting = false

204+ guard generation == testGeneration else { return }

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

190 }

206 }

191 }

207 }

192 }

208 }

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

221 dismiss()

237 dismiss()

222 } else {

238 } else {

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

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

240+ // The sheet reports the failure inline; drop the app-wide alert

241+ // performConnect also raised, which would otherwise surface

242+ // behind/after the sheet (or twice, from the Settings window).

243+ appState.showError = false

224 }

244 }

225 }

245 }

226 }

246 }

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

231 guard !trimmed.isEmpty else { return nil }

251 guard !trimmed.isEmpty else { return nil }

232

252

233 var normalized = trimmed

253 var normalized = trimmed

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

254+ if !ServerConnection.hasURLScheme(normalized) {

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

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

236 }

256 }

237

257

ParseableViewer/Views/LogTableView.swift+53−6

@@ -315,7 +315,23 @@ struct LogTableView: View {

315 }

316 .onChange(of: sortColumn) { _, _ in debouncedRebuildSort() }

317 .onChange(of: sortAscending) { _, _ in debouncedRebuildSort() }

318+ .onChange(of: selectedRecord) { _, newValue in

319+ // The owner can drop the selection on its own (QueryViewModel

320+ // clears it after every query). When the new result set equals the

321+ // old one, `onChange(of: records)` doesn't fire, so nothing would

322+ // reconcile the row highlight: the row stayed highlighted with no

323+ // detail pane, and the next click on it merely "deselected" it.

324+ if newValue == nil { selectedIndex = nil }

325+ }

318 .onAppear {

326 .onAppear {

327+ // This branch is unmounted while results are empty (e.g. across a

328+ // stream switch, which clears them first), so `onChange(of: columns)`

329+ // never sees the switch. Drop a sort column the new columns don't

330+ // have — or hide — before sorting, or rows would be ordered by an

331+ // invisible column with no header showing the sort.

332+ if let sortColumn, !columns.contains(sortColumn) {

333+ self.sortColumn = nil

334+ }

319 recomputeColumnWidths(columns: columns, records: records)

335 recomputeColumnWidths(columns: columns, records: records)

320 rebuildSort()

336 rebuildSort()

321 }

337 }

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

401 }

417 }

402

418

403 private func rebuildSort() {

419 private func rebuildSort() {

420+ // A debounced rebuild scheduled before the table unmounted must not land

421+ // after (and overwrite) this synchronous one.

422+ sortTask?.cancel()

404 let sevCols = buildSeverityColumnSet(columns: columns)

423 let sevCols = buildSeverityColumnSet(columns: columns)

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

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

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

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

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

476

495

477 @State private var draggedColumn: String?

496 @State private var draggedColumn: String?

478 @State private var dropTargetColumn: String?

497 @State private var dropTargetColumn: String?

498+ /// `.contextMenu`'s builder runs during body evaluation, so the filter menus

499+ /// compute their values while the view is being rendered. Writing an `@State`

500+ /// dictionary from there is "modifying state during view update" (undefined

501+ /// behavior, and it re-invalidates the header). The cache is therefore a plain

502+ /// reference that isn't observed; `recordsGeneration` — bumped outside body

503+ /// evaluation — is what invalidates it and triggers the re-render.

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

504+ @State private var uniqueValuesCache = UniqueValuesCache()

505+ @State private var recordsGeneration = 0

506+

507+ private final class UniqueValuesCache {

508+ var generation = -1

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

510+ }

480

511

481 private static let maxFilterValues = 20

512 private static let maxFilterValues = 20

482

513

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

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

515+ if uniqueValuesCache.generation != recordsGeneration {

516+ uniqueValuesCache.generation = recordsGeneration

517+ uniqueValuesCache.values = [:]

518+ }

484− if let cached = uniqueValuesCache[column] {

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

485 return cached

520 return cached

486 }

521 }

487 var seen = Set<JSONValue>()

522 var seen = Set<JSONValue>()

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

493 }

528 }

494 }

529 }

495 let sorted = result.sorted()

530 let sorted = result.sorted()

496− uniqueValuesCache[column] = sorted

531+ uniqueValuesCache.values[column] = sorted

497 return sorted

532 return sorted

498 }

533 }

499

534

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

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

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

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

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

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

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

639− uniqueValuesCache = [:]

674+ recordsGeneration &+= 1

640 }

675 }

641 }

676 }

642}

677}

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

669 }

704 }

670

705

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

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

672− guard let dragged = draggedColumn, dragged != column else {

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

708+ let provider = info.itemProviders(for: [UTType.plainText]).first else {

673 draggedColumn = nil

709 draggedColumn = nil

674 dropTargetColumn = nil

710 dropTargetColumn = nil

675 return false

711 return false

676 }

712 }

677− onMoveColumn?(dragged, column)

678 draggedColumn = nil

713 draggedColumn = nil

679 dropTargetColumn = nil

714 dropTargetColumn = nil

715+ // `draggedColumn` is only cleared by a drop on a header, so a header drag

716+ // that was cancelled (or dropped elsewhere) leaves it set, and any later

717+ // plain-text drag onto a header would move that stale column. Only move

718+ // when the dropped payload really is the column header being dragged.

719+ let target = column

720+ let move = onMoveColumn

721+ _ = provider.loadObject(ofClass: NSString.self) { object, _ in

722+ guard let payload = object as? NSString, payload as String == dragged else { return }

723+ DispatchQueue.main.async {

724+ move?(dragged, target)

725+ }

726+ }

680 return true

727 return true

681 }

728 }

682

729

ParseableViewer/Views/ServerInfoView.swift+12−2

@@ -9,6 +9,9 @@ struct ServerInfoView: View {

9 @State private var isLoading = true

10 @State private var isHealthy = false

11 @State private var errorMessage: String?

12+ /// Bumped by every load so a superseded (cancelled) load can't clear the

13+ /// newer load's spinner or overwrite its results.

14+ @State private var loadGeneration = 0

13 var body: some View {

16 var body: some View {

14 ScrollView {

17 ScrollView {

@@ -19,7 +22,7 @@ struct ServerInfoView: View {

19 .fontWeight(.semibold)

22 .fontWeight(.semibold)

20 Spacer()

23 Spacer()

21 Button {

24 Button {

22− Task { await loadInfo() }

25+ Task { await loadInfo(forceRefresh: true) }

23 } label: {

26 } label: {

24 Image(systemName: "arrow.clockwise")

27 Image(systemName: "arrow.clockwise")

25 }

28 }

@@ -153,12 +156,18 @@ struct ServerInfoView: View {

153 }

156 }

154 }

157 }

155

158

156− private func loadInfo() async {

159+ private func loadInfo(forceRefresh: Bool = false) async {

157 // Clear isLoading on the no-client path: since isLoading now starts `true`

160 // Clear isLoading on the no-client path: since isLoading now starts `true`

158 // (to avoid a red "Unhealthy" flash before the first check), an early return

161 // (to avoid a red "Unhealthy" flash before the first check), an early return

159 // without resetting it would wedge the spinner permanently.

162 // without resetting it would wedge the spinner permanently.

160 guard let client = appState.client else { isLoading = false; return }

163 guard let client = appState.client else { isLoading = false; return }

164+ // `getAbout()` is cached for 60 s; the Refresh button must bypass that.

165+ if forceRefresh {

166+ await client.invalidateCache()

167+ }

161 let connID = appState.activeConnection?.id

168 let connID = appState.activeConnection?.id

169+ loadGeneration &+= 1

170+ let generation = loadGeneration

162 isLoading = true

171 isLoading = true

163 errorMessage = nil

172 errorMessage = nil

164 // Seed from the app-wide cache so first load isn't blank, but never fall

173 // Seed from the app-wide cache so first load isn't blank, but never fall

@@ -189,6 +198,7 @@ struct ServerInfoView: View {

189 // load for the previous server can't overwrite the current one's state.

198 // load for the previous server can't overwrite the current one's state.

190 // Still clear isLoading: this task owns the spinner it set, and leaving it

199 // Still clear isLoading: this task owns the spinner it set, and leaving it

191 // true on the stale path wedges the ProgressView and disables Refresh.

200 // true on the stale path wedges the ProgressView and disables Refresh.

201+ guard generation == loadGeneration else { return }

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

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

193 isHealthy = healthy

203 isHealthy = healthy

194 about = aboutValue

204 about = aboutValue

ParseableViewer/Views/SidebarView.swift+19−1

@@ -6,6 +6,14 @@ struct SidebarView: View {

6 @State private var newStreamName = ""

7 @State private var showDeleteConfirm = false

8 @State private var streamToDelete: String?

9+ /// The connection `streamToDelete` was picked on. Stream names aren't unique

10+ /// across servers, and the delete runs against whatever client is current

11+ /// when the user confirms — so a server switch while the stats lookup was in

12+ /// flight could otherwise delete a same-named stream on the *new* server.

13+ @State private var streamToDeleteConnectionID: UUID?

14+ /// The client the stream was picked with. Editing the active connection's URL

15+ /// keeps its id but installs a new client for a possibly different server.

16+ @State private var streamToDeleteClient: ParseableClient?

9 @State private var deleteStreamDetail: String?

17 @State private var deleteStreamDetail: String?

11 /// Validates a stream name, returning an error message or nil if valid.

19 /// Validates a stream name, returning an error message or nil if valid.

@@ -65,7 +73,10 @@ struct SidebarView: View {

65 // would show the wrong stats on a destructive

73 // would show the wrong stats on a destructive

66 // confirmation.

74 // confirmation.

67 let target = stream.name

75 let target = stream.name

76+ let targetConnectionID = appState.activeConnection?.id

68 streamToDelete = target

77 streamToDelete = target

78+ streamToDeleteConnectionID = targetConnectionID

79+ streamToDeleteClient = appState.client

69 deleteStreamDetail = nil

80 deleteStreamDetail = nil

70 Task {

81 Task {

71 if let client = appState.client,

82 if let client = appState.client,

@@ -81,7 +92,9 @@ struct SidebarView: View {

81 deleteStreamDetail = parts.joined(separator: ", ")

92 deleteStreamDetail = parts.joined(separator: ", ")

82 }

93 }

83 }

94 }

84− if streamToDelete == target {

95+ if streamToDelete == target,

96+ appState.activeConnection?.id == targetConnectionID,

97+ appState.client === streamToDeleteClient {

85 showDeleteConfirm = true

98 showDeleteConfirm = true

86 }

99 }

87 }

100 }

@@ -187,6 +200,11 @@ struct SidebarView: View {

187 .alert("Delete Stream", isPresented: $showDeleteConfirm) {

200 .alert("Delete Stream", isPresented: $showDeleteConfirm) {

188 Button("Delete", role: .destructive) {

201 Button("Delete", role: .destructive) {

189 if let name = streamToDelete {

202 if let name = streamToDelete {

203+ guard appState.activeConnection?.id == streamToDeleteConnectionID,

204+ appState.client === streamToDeleteClient else {

205+ appState.showErrorMessage("The server changed since \"\(name)\" was selected, so it was not deleted.")

206+ return

207+ }

190 Task {

208 Task {

191 do {

209 do {

192 try await appState.deleteStream(name: name)

210 try await appState.deleteStream(name: name)

ParseableViewer/Views/StreamDetailView.swift+18−4

@@ -8,6 +8,9 @@ struct StreamDetailView: View {

8 @State private var retention: [RetentionConfig] = []

9 @State private var isLoading = false

10 @State private var errorMessage: String?

11+ /// Bumped by every load. A superseded load (its `.task(id:)` cancelled by a

12+ /// stream switch) still resumes, and must not clear the newer load's spinner.

13+ @State private var loadGeneration = 0

12 var body: some View {

15 var body: some View {

13 Group {

16 Group {

@@ -25,7 +28,7 @@ struct StreamDetailView: View {

25 Spacer()

28 Spacer()

27 Button {

30 Button {

28− Task { await loadData(stream: stream) }

31+ Task { await loadData(stream: stream, forceRefresh: true) }

29 } label: {

32 } label: {

30 Image(systemName: "arrow.clockwise")

33 Image(systemName: "arrow.clockwise")

31 }

34 }

@@ -44,7 +47,7 @@ struct StreamDetailView: View {

44 Text(error)

47 Text(error)

45 Spacer()

48 Spacer()

46 Button("Retry") {

49 Button("Retry") {

47− Task { await loadData(stream: stream) }

50+ Task { await loadData(stream: stream, forceRefresh: true) }

48 }

51 }

49 .buttonStyle(.bordered)

52 .buttonStyle(.bordered)

50 .controlSize(.small)

53 .controlSize(.small)

@@ -174,13 +177,22 @@ struct StreamDetailView: View {

174 }

177 }

175 }

178 }

176

179

177− private func loadData(stream: String) async {

180+ private func loadData(stream: String, forceRefresh: Bool = false) async {

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

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

182+ // The client caches schema/stats/info for 60 s. That's right for the

183+ // automatic load on appear, but an explicit Refresh/Retry must hit the

184+ // server — otherwise it repaints the same cached numbers and looks like a

185+ // refresh that found nothing new.

186+ if forceRefresh {

187+ await client.invalidateCache()

188+ }

179 // Capture the connection this fetch belongs to. Two servers can expose a

189 // Capture the connection this fetch belongs to. Two servers can expose a

180 // same-named stream, so guarding on the stream name alone would let a

190 // same-named stream, so guarding on the stream name alone would let a

181 // slow fetch write the previous server's data under the new server's

191 // slow fetch write the previous server's data under the new server's

182 // stream after a server switch.

192 // stream after a server switch.

183 let connID = appState.activeConnection?.id

193 let connID = appState.activeConnection?.id

194+ loadGeneration &+= 1

195+ let generation = loadGeneration

184 isLoading = true

196 isLoading = true

185 errorMessage = nil

197 errorMessage = nil

186 // Clear previous stream's data so it isn't shown under the new header

198 // Clear previous stream's data so it isn't shown under the new header

@@ -216,7 +228,9 @@ struct StreamDetailView: View {

216 // resolve after the user switched. Drop stale results instead of writing

228 // resolve after the user switched. Drop stale results instead of writing

217 // them under the new stream's header. Also check the connection so a

229 // them under the new stream's header. Also check the connection so a

218 // same-named stream on a different server doesn't accept the old server's

230 // same-named stream on a different server doesn't accept the old server's

219− // data. Reset `isLoading` on the stale path or the spinner wedges forever.

231+ // data. Reset `isLoading` on the stale path or the spinner wedges forever —

232+ // unless a newer load has started, which owns the spinner now.

233+ guard generation == loadGeneration else { return }

220 guard stream == appState.selectedStream, connID == appState.activeConnection?.id else {

234 guard stream == appState.selectedStream, connID == appState.activeConnection?.id else {

221 isLoading = false

235 isLoading = false

222 return

236 return

ParseableViewer/Views/UsersView.swift+6

@@ -5,6 +5,9 @@ struct UsersView: View {

5 @State private var users: [UserInfo] = []

6 @State private var isLoading = false

7 @State private var errorMessage: String?

8+ /// Bumped by every load so a superseded (cancelled) load can't clear the

9+ /// newer load's spinner.

10+ @State private var loadGeneration = 0

9 var body: some View {

12 var body: some View {

10 VStack(spacing: 0) {

13 VStack(spacing: 0) {

@@ -82,6 +85,8 @@ struct UsersView: View {

82 private func loadUsers() async {

85 private func loadUsers() async {

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

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

84 let connID = appState.activeConnection?.id

87 let connID = appState.activeConnection?.id

88+ loadGeneration &+= 1

89+ let generation = loadGeneration

85 isLoading = true

90 isLoading = true

86 errorMessage = nil

91 errorMessage = nil

87 // Clear the previous server's list up front so it can't briefly show through

92 // Clear the previous server's list up front so it can't briefly show through

@@ -102,6 +107,7 @@ struct UsersView: View {

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

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

103 // isLoading: this task set the spinner, so leaving it true on the stale path

108 // isLoading: this task set the spinner, so leaving it true on the stale path

104 // wedges the ProgressView and disables Refresh.

109 // wedges the ProgressView and disables Refresh.

110+ guard generation == loadGeneration else { return }

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

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

106 if let loaded { users = loaded }

112 if let loaded { users = loaded }

107 errorMessage = loadError

113 errorMessage = loadError

ParseableViewerTests/ParseableClientTests.swift+58

@@ -646,4 +646,62 @@ final class ParseableClientTests: XCTestCase {

646 // Carriage returns in values should be wrapped in quotes per RFC 4180

647 XCTAssertTrue(csv.contains("\"line1\r\nline2\""))

648 }

649+

650+ // MARK: - Server response key spellings

651+

652+ func testServerAboutDecodesCamelCaseKeys() throws {

653+ let json = #"{"uiVersion": "v1.2", "deploymentId": "01H", "grpcPort": 8001}"#.data(using: .utf8)!

654+ let about = try JSONDecoder().decode(ServerAbout.self, from: json)

655+ XCTAssertEqual(about.uiVersion, "v1.2")

656+ XCTAssertEqual(about.deploymentId, "01H")

657+ XCTAssertEqual(about.grpcPort, 8001)

658+ }

659+

660+ func testStreamInfoDecodesSnakeCaseKeys() throws {

661+ let json = #"{"created-at": "c", "first-event-at": "f", "time_partition": "ts", "static_schema_flag": "true", "cache_enabled": true}"#

662+ .data(using: .utf8)!

663+ let info = try JSONDecoder().decode(StreamInfo.self, from: json)

664+ XCTAssertEqual(info.createdAt, "c")

665+ XCTAssertEqual(info.firstEventAt, "f")

666+ XCTAssertEqual(info.timePartition, "ts")

667+ XCTAssertEqual(info.staticSchemaFlag, true)

668+ XCTAssertEqual(info.cacheEnabled, true)

669+ }

670+

671+ func testStreamInfoDecodesCamelCaseKeys() throws {

672+ let json = #"{"createdAt": "c", "firstEventAt": "f", "timePartition": "ts", "staticSchemaFlag": "true"}"#

673+ .data(using: .utf8)!

674+ let info = try JSONDecoder().decode(StreamInfo.self, from: json)

675+ XCTAssertEqual(info.createdAt, "c")

676+ XCTAssertEqual(info.firstEventAt, "f")

677+ XCTAssertEqual(info.timePartition, "ts")

678+ XCTAssertEqual(info.staticSchemaFlag, true)

679+ }

680+

681+ func testStorageStatsReadsFormatAndUnitSuffixedSizes() throws {

682+ let json = #"{"storage": {"size": "2048 Bytes", "format": "parquet"}}"#.data(using: .utf8)!

683+ let stats = try JSONDecoder().decode(StreamStats.self, from: json)

684+ XCTAssertEqual(stats.storage?.type, "parquet")

685+ XCTAssertEqual(stats.storage?.size, ByteCountFormatter.string(fromByteCount: 2048, countStyle: .file))

686+ }

687+

688+ func testSchemaFieldDescribesParameterizedArrowTypes() throws {

689+ let json = #"{"name": "p_timestamp", "data_type": {"Timestamp": ["Millisecond", null]}}"#.data(using: .utf8)!

690+ let field = try JSONDecoder().decode(SchemaField.self, from: json)

691+ XCTAssertEqual(field.dataType, "Timestamp(Millisecond, None)")

692+ }

693+

694+ func testLegacyAlertRuleWithObjectConfigKeepsRuleType() throws {

695+ let json = #"{"name": "a", "rule": {"type": "column", "config": {"column": "status", "operator": "=", "value": 500}}}"#

696+ .data(using: .utf8)!

697+ let rule = try JSONDecoder().decode(AlertRule.self, from: json)

698+ XCTAssertEqual(rule.rule?.type, "column")

699+ XCTAssertNotNil(rule.rule?.config)

700+ }

701+

702+ func testServerAboutDecodesObjectLicense() throws {

703+ let json = #"{"license": {"name": "AGPL-3.0-only", "plan": "OSS"}}"#.data(using: .utf8)!

704+ let about = try JSONDecoder().decode(ServerAbout.self, from: json)

705+ XCTAssertEqual(about.license, "AGPL-3.0-only (OSS)")

706+ }

649}

707}

ParseableViewerTests/ServerConnectionTests.swift+10

@@ -77,4 +77,14 @@ final class ServerConnectionTests: XCTestCase {

77 let conn = ServerConnection(name: "test", url: "https://", username: "admin", password: "pass")

78 XCTAssertNil(conn.baseURL)

79 }

80+

81+ func testBaseURLAcceptsUppercaseScheme() {

82+ let conn = ServerConnection(name: "t", url: "HTTP://10.0.0.5:8000", username: "u", password: "p")

83+ XCTAssertEqual(conn.baseURL?.absoluteString, "http://10.0.0.5:8000")

84+ }

85+

86+ func testBaseURLRejectsNonHTTPScheme() {

87+ let conn = ServerConnection(name: "t", url: "ftp://example.com", username: "u", password: "p")

88+ XCTAssertNil(conn.baseURL)

89+ }

80}

90}