f4c4ced...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/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/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/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}