Skip to content

A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.

C++

Merge main into codex/feat-69-redis-key-tree

Tobi47c7111aaa4e
diff --cc CHANGELOG.md
index fa5c141,9c1a58b..870d626
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@@ -4,9 -4,10 +4,13 @@@ All notable changes to Gridex are docum
## [Unreleased]
+### Added
+- **Redis namespace key tree (macOS)** — Redis keys can be browsed as a collapsible sidebar tree using a local configurable delimiter (default `:`). Leaf keys open the existing detail view; the flat SCAN-filtered key list remains available.
+
+ ### Fixed
+ - **macOS data grids** — Reloading data with Command-R retains the selected column and ascending/descending server-side sort.
+ - **macOS tabs** — Clicking a tab reliably activates it; Control-Tab and Control-Shift-Tab cycle forward/backward; tab close controls retain their expected left/middle-click behavior.
+ - **macOS MySQL passwordless accounts** — Blank passwords now authenticate correctly for non-TLS caching_sha2_password accounts.
## [0.23.0] - 2026-04-12
### Added
diff --cc macos/App/State/AppState.swift
index 0a47d93,13b5945..35e162d
--- a/macos/App/State/AppState.swift
+++ b/macos/App/State/AppState.swift
@@@ -59,11 -64,11 +64,13 @@@ final class AppState: ObservableObject
// MARK: - Connection State
@Published var activeConnectionId: UUID?
- @Published var activeAdapter: (any DatabaseAdapter)?
+ @Published var activeAdapter: (any DatabaseAdapter)? {
+ didSet { rotateRedisSession(for: activeAdapter) }
+ }
@Published var activeConfig: ConnectionConfig?
@Published var sidebarItems: [SidebarItem] = []
+ @Published private(set) var sidebarSchemas: [String] = []
+ @Published var selectedSidebarSchema: String?
@Published var connectionTitle: String = "Gridex"
@Published var isConnecting: Bool = false
@Published var connectionError: String?
@@@ -271,7 -200,7 +310,8 @@@
let schema: String?
var databaseName: String?
var initialViewMode: String? // "data" or "structure"
- var redisContext: RedisTabContext?
++ var redisContext: RedisTabContext? = nil
+ var sidebarItemType: SidebarItemType? = nil
}
struct TabGroup: Identifiable {
@@@ -384,12 -308,9 +424,12 @@@
connectionTitle = "Gridex — \(config.name)"
statusConnection = config.displayHost
isConnecting = false
+ let redisMetadataToken = config.databaseType == .redis
+ ? currentRedisSessionRevisionToken
+ : nil
// Load sidebar immediately (most important for user)
- await loadSidebar(config: config, adapter: connection.adapter)
+ await reloadSidebar(config: config, adapter: connection.adapter)
// Fetch metadata in background — all parallel
Task { [weak self] in
@@@ -472,19 -373,140 +512,189 @@@
}
}
+ func loadSidebar(config: ConnectionConfig, adapter: any DatabaseAdapter) async {
+ if config.databaseType == .redis {
++ if refreshRedisSidebar(config: config, adapter: adapter) {
++ return
++ }
++ guard activeConnectionId == nil,
++ activeConfig == nil,
++ activeAdapter == nil else { return }
++ sidebarLoadGeneration &+= 1
++ pendingSidebarReload = nil
++ publishedSidebarContext = nil
++ publishedSidebarSnapshot = nil
++ selectedSidebarItem = nil
++ selectedSidebarItemSchema = nil
++ sidebarSchemas = []
++ selectedSidebarSchema = nil
+ sidebarItems = []
+ requestRedisKeyBrowserRefresh()
+ return
+ }
++ await reloadSidebar(config: config, adapter: adapter)
++ }
++
+ func loadSidebarSchemas(
+ config: ConnectionConfig,
+ adapter: any DatabaseAdapter,
+ preferredSchema: String? = nil
+ ) async -> SidebarReloadHandle? {
+ guard let reload = await prepareSidebarReload(
+ config: config,
+ adapter: adapter,
+ preferredSchema: preferredSchema
+ ) else { return nil }
+ pendingSidebarReload = reload
+ return SidebarReloadHandle(generation: reload.generation)
+ }
+
+ func loadSidebar(
+ config: ConnectionConfig,
+ adapter: any DatabaseAdapter,
+ schema: String? = nil,
+ using handle: SidebarReloadHandle?
+ ) async {
+ let connection = sidebarConnectionContext(config: config, adapter: adapter)
+ guard let handle,
+ var reload = pendingSidebarReload,
+ reload.generation == handle.generation,
+ reload.connection == connection,
+ isCurrentSidebarReload(reload) else { return }
+
+ // Consume the exact prepared operation before any item query suspends.
+ // A duplicate or superseded caller can no longer reuse this token.
+ pendingSidebarReload = nil
+ if let schema,
+ config.databaseType == .postgresql,
+ reload.schemas.contains(schema) {
+ reload.schema = schema
+ }
+ await loadSidebarItems(using: reload, adapter: adapter)
+ }
+
+ private func reloadSidebar(
+ config: ConnectionConfig,
+ adapter: any DatabaseAdapter,
+ preferredSchema: String? = nil
+ ) async {
+ guard let reload = await prepareSidebarReload(
+ config: config,
+ adapter: adapter,
+ preferredSchema: preferredSchema
+ ) else { return }
+ await loadSidebarItems(using: reload, adapter: adapter)
+ }
+
+ private func prepareSidebarReload(
+ config: ConnectionConfig,
+ adapter: any DatabaseAdapter,
+ preferredSchema: String?
+ ) async -> SidebarReload? {
++ if config.databaseType == .redis {
++ refreshRedisSidebar(config: config, adapter: adapter)
++ return nil
++ }
++
+ guard var reload = beginSidebarReload(
+ config: config,
+ adapter: adapter,
+ preferredSchema: preferredSchema
+ ) else { return nil }
+
+ do {
+ let schemas: [String]
+ if config.databaseType == .postgresql {
+ schemas = Array(Set(try await adapter.listSchemas(database: config.database))).sorted()
+ } else {
+ schemas = []
+ }
+
+ guard isCurrentSidebarReload(reload) else { return nil }
+ reload.schemas = schemas
+ reload.schema = SidebarSchemaSelection.resolve(
+ previous: reload.requestedSchema,
+ for: config.databaseType,
+ schemas: schemas
+ )
+ return reload
+ } catch {
+ guard isCurrentSidebarReload(reload) else { return nil }
+ publishSidebarSnapshot(reload.previous, using: reload)
+ print("Sidebar schema load error: \(error)")
+ return nil
+ }
+ }
+
++ @discardableResult
++ private func refreshRedisSidebar(
++ config: ConnectionConfig,
++ adapter: any DatabaseAdapter
++ ) -> Bool {
++ let connection = sidebarConnectionContext(config: config, adapter: adapter)
++ guard isActiveSidebarConnection(connection) else { return false }
++
++ sidebarLoadGeneration &+= 1
++ pendingSidebarReload = nil
++ selectedSidebarItem = nil
++ selectedSidebarItemSchema = nil
++ sidebarSchemas = []
++ selectedSidebarSchema = nil
++ sidebarItems = []
++ publishedSidebarContext = connection
++ publishedSidebarSnapshot = .empty
++ requestRedisKeyBrowserRefresh()
++ return true
++ }
++
+ private func beginSidebarReload(
+ config: ConnectionConfig,
+ adapter: any DatabaseAdapter,
+ preferredSchema: String?
+ ) -> SidebarReload? {
+ let connection = sidebarConnectionContext(config: config, adapter: adapter)
+ guard isActiveSidebarConnection(connection) else { return nil }
+
+ let requestedSchema = preferredSchema ?? selectedSidebarSchema
+ let previous: SidebarSnapshot
+ if publishedSidebarContext == connection, let publishedSidebarSnapshot {
+ previous = publishedSidebarSnapshot
+ } else {
+ previous = .empty
+ }
+
+ let connectionChanged = publishedSidebarContext != connection
+ sidebarLoadGeneration &+= 1
+ pendingSidebarReload = nil
+ let reload = SidebarReload(
+ generation: sidebarLoadGeneration,
+ connection: connection,
+ requestedSchema: requestedSchema,
+ previous: previous,
+ schemas: [],
+ schema: nil
+ )
+ guard isCurrentSidebarReload(reload) else { return nil }
+ if connectionChanged {
+ selectedSidebarItem = nil
+ selectedSidebarItemSchema = nil
+ }
+ guard publishSidebarSnapshot(previous, using: reload) else { return nil }
+ return reload
+ }
+
+ private func loadSidebarItems(
+ using reload: SidebarReload,
+ adapter: any DatabaseAdapter
+ ) async {
+ guard isCurrentSidebarReload(reload) else { return }
+ let schema = reload.schema
do {
- // Run all queries in parallel instead of sequential
- async let tablesTask = adapter.listTables(schema: nil)
- async let viewsTask = adapter.listViews(schema: nil)
- async let functionsTask = adapter.listFunctions(schema: nil)
- async let proceduresTask = adapter.listProcedures(schema: nil)
+ async let tablesTask = adapter.listTables(schema: schema)
+ async let viewsTask = adapter.listViews(schema: schema)
+ async let functionsTask = adapter.listFunctions(schema: schema)
+ async let proceduresTask = adapter.listProcedures(schema: schema)
let tables = try await tablesTask
let views = try await viewsTask
@@@ -1295,15 -773,25 +1572,34 @@@
if let db = currentDatabaseName { ensureTabGroup(for: db) }
}
+ func rebindRedisQueryTab(id: UUID, to context: RedisTabContext) {
+ guard let index = tabs.firstIndex(where: {
+ $0.id == id && $0.type == .queryEditor && $0.redisContext != nil
+ }) else { return }
+ tabs[index].databaseName = context.databaseName
+ tabs[index].redisContext = context
+ ensureTabGroup(for: context.databaseName)
+ }
+
+ func selectTab(id: UUID) {
+ guard tabs.contains(where: { $0.id == id }) else { return }
+ activeTabId = id
+ }
+
+ func selectNextTab() {
+ guard let activeTabId,
+ let index = tabs.firstIndex(where: { $0.id == activeTabId }),
+ tabs.count > 1 else { return }
+ self.activeTabId = tabs[(index + 1) % tabs.count].id
+ }
+
+ func selectPreviousTab() {
+ guard let activeTabId,
+ let index = tabs.firstIndex(where: { $0.id == activeTabId }),
+ tabs.count > 1 else { return }
+ self.activeTabId = tabs[(index - 1 + tabs.count) % tabs.count].id
+ }
+
func closeTab(id: UUID) {
tabs.removeAll { $0.id == id }
if let state = dataGridCache.removeValue(forKey: id) {
@@@ -1489,13 -981,15 +1792,21 @@@
redisDBSize = nil
}
- func refreshSidebar() {
+ func refreshSidebar(preferredSchema: String? = nil) {
guard let adapter = activeAdapter, let config = activeConfig else { return }
+ if config.databaseType == .redis {
- requestRedisKeyBrowserRefresh()
++ if !refreshRedisSidebar(config: config, adapter: adapter) {
++ requestRedisKeyBrowserRefresh()
++ }
+ return
+ }
- Task { await loadSidebar(config: config, adapter: adapter) }
+ Task {
+ await reloadSidebar(
+ config: config,
+ adapter: adapter,
+ preferredSchema: preferredSchema
+ )
+ }
}
/// Re-fetch the database list from the active adapter and publish it.
diff --cc macos/Presentation/Views/DataGrid/DataGridView.swift
index d778f7b,e0e8f05..e70e72d
--- a/macos/Presentation/Views/DataGrid/DataGridView.swift
+++ b/macos/Presentation/Views/DataGrid/DataGridView.swift
@@@ -484,118 -480,129 +530,231 @@@ final class DataGridViewState: Observab
static func clearMetadataCache() {
metadataCache.removeAll()
+ metadataCacheGenerations.removeAll()
+ metadataPublicationEpochs.removeAll()
}
+ func bindRedisContext(_ context: AppState.RedisTabContext) {
+ // Redis's flat key grid never owns an editable Details callback. Clear
+ // any SQL grid selection even when this cached grid is rebound to the
+ // same context (for example when reopening its existing tab).
+ appState?.selectedRowDetails = nil
+ appState?.onDetailFieldEdit = nil
+
+ guard redisContext != context else { return }
+
+ redisRequestCoordinator.invalidate()
+ redisContext = context
+ adapter = nil
+ columns = []
+ rows = []
+ totalRows = 0
+ currentPage = 0
+ isLoading = false
+ executionTime = 0
+ errorMessage = nil
+ tableDescription = nil
+ primaryKeyColumns = []
+ foreignKeyColumns = [:]
+ foreignKeyRefColumns = [:]
+ columnDefaults = [:]
+ columnEnumValues = [:]
+ selectedRows = []
+ editingCell = nil
+ insertedRowIndices = []
+ columnWidths = [:]
+ displayCache = []
+ changeTracker.discardAll()
+ commitSQL = []
+ commitError = nil
+ showCommitPreview = false
+ isCommitting = false
+ }
+
+ func performRedisLoad(
+ in context: AppState.RedisTabContext,
+ page: Int = 0,
+ execute: () async -> Result<QueryResult, Error>?
+ ) async {
+ guard redisContext == context else { return }
+
+ isLoading = true
+ totalRows = 0
+ errorMessage = nil
+
+ switch await redisRequestCoordinator.perform(for: context, execute: execute) {
+ case .current(.success(let result)):
+ guard redisContext == context else { return }
+ columns = result.columns
+ rows = result.rows
+ rebuildDisplayCache()
+ totalRows = 0
+ currentPage = page
+ executionTime = result.executionTime
+ errorMessage = nil
+ computeColumnWidths(columns: result.columns, rows: result.rows)
+ isLoading = false
+ case .current(.failure(let error)):
+ guard redisContext == context else { return }
+ totalRows = 0
+ errorMessage = (error as? LocalizedError)?.errorDescription
+ ?? error.localizedDescription
+ isLoading = false
+ case .stale:
+ guard redisContext == context else { return }
+ totalRows = 0
+ isLoading = false
+ case .superseded:
+ break
+ }
+ }
+
struct CellID: Equatable {
let row: Int
let col: Int
}
- func load(tableName: String, schema: String?, adapter: (any DatabaseAdapter)?) async {
+ private var effectiveSortDescriptors: [QuerySortDescriptor]? {
+ if let column = sortColumn {
+ return [QuerySortDescriptor(
+ column: column,
+ direction: sortAscending ? .ascending : .descending
+ )]
+ }
+ if let primaryKey = primaryKeyColumns.first {
+ return [QuerySortDescriptor(column: primaryKey, direction: .ascending)]
+ }
+ return nil
+ }
+
+ private func nextLoadGeneration() -> Int {
+ loadGeneration += 1
+ return loadGeneration
+ }
+
+ private func beginLoading(for generation: Int) {
+ loadingGeneration = generation
+ isLoading = true
+ }
+
+ private func finishLoading(for generation: Int) {
+ guard loadingGeneration == generation else { return }
+ loadingGeneration = nil
+ isLoading = false
+ }
+
+ private func isCurrentMetadataScope(cacheKey: MetadataCacheKey, cacheGeneration: Int) -> Bool {
+ guard let adapter else { return false }
+ let currentCacheKey = metadataCacheKey(
+ adapter: adapter,
+ tableName: tableName,
+ schema: schema
+ )
+ return currentCacheKey == cacheKey
+ && Self.metadataCacheGenerations[cacheKey, default: 0] == cacheGeneration
+ }
+
+ private func isCurrentMetadataPublication(
+ cacheKey: MetadataCacheKey,
+ cacheGeneration: Int,
+ publicationEpoch: Int
+ ) -> Bool {
+ isCurrentMetadataScope(cacheKey: cacheKey, cacheGeneration: cacheGeneration)
+ && Self.metadataPublicationEpochs[cacheKey, default: 0] == publicationEpoch
+ }
+
+ private func isCurrentRowRequest(_ generation: Int, cacheKey: MetadataCacheKey, cacheGeneration: Int) -> Bool {
+ generation == loadGeneration
+ && isCurrentMetadataScope(cacheKey: cacheKey, cacheGeneration: cacheGeneration)
+ }
+
+ private func continueIfCurrentRowRequest(
+ _ generation: Int,
+ cacheKey: MetadataCacheKey,
+ cacheGeneration: Int
+ ) -> Bool {
+ guard isCurrentRowRequest(
+ generation,
+ cacheKey: cacheKey,
+ cacheGeneration: cacheGeneration
+ ) else {
+ finishLoading(for: generation)
+ return false
+ }
+ return true
+ }
+
+ private static func invalidateMetadataCache(for key: MetadataCacheKey) -> Int {
+ metadataCache.removeValue(forKey: key)
+ metadataCacheGenerations[key, default: 0] += 1
+ return metadataCacheGenerations[key, default: 0]
+ }
+
+ private static func nextMetadataPublicationEpoch(for key: MetadataCacheKey) -> Int {
+ metadataPublicationEpochs[key, default: 0] &+= 1
+ return metadataPublicationEpochs[key, default: 0]
+ }
+
+ func load(
+ tableName: String,
+ schema: String?,
+ adapter: (any DatabaseAdapter)?,
+ prefetchedDescription: TableDescription? = nil,
+ generation: Int? = nil,
+ cacheGeneration: Int? = nil,
+ metadataPublicationEpoch: Int? = nil
+ ) async {
guard let adapter else { return }
- self.adapter = adapter
- self.tableName = tableName
- self.schema = schema
+
+ if redisContext != nil || adapter.databaseType == .redis {
++ self.adapter = adapter
++ self.tableName = tableName
++ self.schema = schema
+ guard let redisContext, let appState else {
+ totalRows = 0
+ isLoading = false
+ return
+ }
+ let request = RowFetchRequest(
+ table: tableName,
+ schema: schema,
+ columns: nil,
+ filter: activeFilter,
+ orderBy: nil,
+ limit: pageSize,
+ offset: 0
+ )
+ await performRedisLoad(in: redisContext, page: 0) {
+ await appState.performRedisOperation(for: redisContext) { redis in
+ try await self.redisRowFetcher(redis, request)
+ }
+ }
+ return
+ }
+
- isLoading = true
+ let requestGeneration: Int
+ if let generation {
+ requestGeneration = generation
+ } else {
+ requestGeneration = nextLoadGeneration()
+ latestPageRequest = nil
+ self.adapter = adapter
+ self.tableName = tableName
+ self.schema = schema
+ }
+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: tableName, schema: schema)
+ let requestCacheGeneration = cacheGeneration ?? Self.metadataCacheGenerations[requestCacheKey, default: 0]
+ let requestMetadataPublicationEpoch = metadataPublicationEpoch
+ ?? Self.nextMetadataPublicationEpoch(for: requestCacheKey)
+ guard isCurrentMetadataPublication(
+ cacheKey: requestCacheKey,
+ cacheGeneration: requestCacheGeneration,
+ publicationEpoch: requestMetadataPublicationEpoch
+ ) else {
+ finishLoading(for: requestGeneration)
+ return
+ }
+ let requestFilter = activeFilter
// Apply cache immediately if available (before any query)
let hasCachedMeta: Bool
@@@ -718,10 -775,18 +927,19 @@@
}
func reloadStructure() async {
+ guard redisContext == nil else { return }
guard let adapter else { return }
+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: tableName, schema: schema)
+ let requestCacheGeneration = Self.metadataCacheGenerations[requestCacheKey, default: 0]
+ let requestMetadataPublicationEpoch = Self.nextMetadataPublicationEpoch(for: requestCacheKey)
do {
- tableDescription = try await adapter.describeTable(name: tableName, schema: schema)
+ let description = try await adapter.describeTable(name: tableName, schema: schema)
+ guard isCurrentMetadataPublication(
+ cacheKey: requestCacheKey,
+ cacheGeneration: requestCacheGeneration,
+ publicationEpoch: requestMetadataPublicationEpoch
+ ) else { return }
+ tableDescription = description
} catch {
// Structure reload error — silently ignore
}
@@@ -729,50 -794,107 +947,144 @@@
/// Invalidate cache and reload everything (after structure changes like ADD COLUMN)
func reloadAfterStructureChange() async {
- if redisContext == nil {
- Self.metadataCache.removeValue(forKey: cacheKey)
- }
guard let adapter else { return }
- await load(tableName: tableName, schema: schema, adapter: adapter)
++ if redisContext != nil || adapter.databaseType == .redis {
++ await loadPage(0)
++ return
++ }
+ let requestTableName = tableName
+ let requestSchema = schema
+ let previousPrimaryKeyColumns = primaryKeyColumns
+ let requestGeneration = nextLoadGeneration()
+ latestPageRequest = nil
+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: requestTableName, schema: requestSchema)
+ let requestCacheGeneration = Self.invalidateMetadataCache(for: requestCacheKey)
+ let requestMetadataPublicationEpoch = Self.nextMetadataPublicationEpoch(for: requestCacheKey)
+ beginLoading(for: requestGeneration)
+
+ let description: TableDescription
+ var rowReplayRequest: PageRequest?
+ do {
+ description = try await adapter.describeTable(name: requestTableName, schema: requestSchema)
+ guard isCurrentMetadataPublication(
+ cacheKey: requestCacheKey,
+ cacheGeneration: requestCacheGeneration,
+ publicationEpoch: requestMetadataPublicationEpoch
+ ) else {
+ finishLoading(for: requestGeneration)
+ return
+ }
+ let refreshedPrimaryKeyColumns = description.columns.filter { $0.isPrimaryKey }.map { $0.name }
+ let hasInvalidExplicitSort = sortColumn.map { sortColumn in
+ !description.columns.contains(where: { $0.name == sortColumn })
+ } ?? false
+ let hasChangedImplicitSort = sortColumn == nil
+ && previousPrimaryKeyColumns != refreshedPrimaryKeyColumns
+ if requestGeneration != loadGeneration,
+ (hasInvalidExplicitSort || hasChangedImplicitSort),
+ let latestPageRequest,
+ latestPageRequest.generation == loadGeneration {
+ rowReplayRequest = latestPageRequest
+ }
+
+ self.primaryKeyColumns = refreshedPrimaryKeyColumns
+ self.tableDescription = description
+ if let sortColumn, hasInvalidExplicitSort {
+ pendingProgrammaticSortClear = ProgrammaticSortClear(
+ clearedColumn: sortColumn
+ )
+ self.sortColumn = nil
+ }
+ } catch {
+ guard isCurrentMetadataPublication(
+ cacheKey: requestCacheKey,
+ cacheGeneration: requestCacheGeneration,
+ publicationEpoch: requestMetadataPublicationEpoch
+ ) else {
+ finishLoading(for: requestGeneration)
+ return
+ }
+ errorMessage = Self.detailedErrorMessage(error)
+ finishLoading(for: requestGeneration)
+ return
+ }
+
+ await load(
+ tableName: requestTableName,
+ schema: requestSchema,
+ adapter: adapter,
+ prefetchedDescription: description,
+ generation: requestGeneration,
+ cacheGeneration: requestCacheGeneration,
+ metadataPublicationEpoch: requestMetadataPublicationEpoch
+ )
+
+ if let rowReplayRequest,
+ rowReplayRequest.generation == loadGeneration,
+ isCurrentMetadataPublication(
+ cacheKey: requestCacheKey,
+ cacheGeneration: requestCacheGeneration,
+ publicationEpoch: requestMetadataPublicationEpoch
+ ) {
+ await loadPage(rowReplayRequest.page)
+ }
+ }
+
+ func handleSortColumnChange(from previousSortColumn: String?, to sortColumn: String?) async {
+ if let pendingProgrammaticSortClear {
+ self.pendingProgrammaticSortClear = nil
+ if previousSortColumn == pendingProgrammaticSortClear.clearedColumn,
+ sortColumn == nil {
+ return
+ }
+ }
+ await loadPage(0)
+ }
+
+ func handleSortColumnChange(_ sortColumn: String?) async {
+ await handleSortColumnChange(from: pendingProgrammaticSortClear?.clearedColumn, to: sortColumn)
}
func loadPage(_ page: Int) async {
guard let adapter else { return }
+
+ if redisContext != nil || adapter.databaseType == .redis {
+ guard let redisContext, let appState else {
+ totalRows = 0
+ isLoading = false
+ return
+ }
+ let offset = page * pageSize
+ let sort: [QuerySortDescriptor]? = if let col = sortColumn {
+ [QuerySortDescriptor(
+ column: col,
+ direction: sortAscending ? .ascending : .descending
+ )]
+ } else {
+ nil
+ }
+ let request = RowFetchRequest(
+ table: tableName,
+ schema: schema,
+ columns: nil,
+ filter: activeFilter,
+ orderBy: sort,
+ limit: pageSize,
+ offset: offset
+ )
+ await performRedisLoad(in: redisContext, page: page) {
+ await appState.performRedisOperation(for: redisContext) { redis in
+ try await self.redisRowFetcher(redis, request)
+ }
+ }
+ return
+ }
+
- isLoading = true
- defer { isLoading = false }
+ let requestGeneration = nextLoadGeneration()
+ latestPageRequest = PageRequest(generation: requestGeneration, page: page)
+ let requestCacheKey = metadataCacheKey(adapter: adapter, tableName: tableName, schema: schema)
+ let requestCacheGeneration = Self.metadataCacheGenerations[requestCacheKey, default: 0]
+ beginLoading(for: requestGeneration)
do {
let offset = page * pageSize
diff --cc macos/Tests/GridexTests/RedisAppStateTests.swift
index 5618652,0000000..8091f1a
mode 100644,000000..100644
--- a/macos/Tests/GridexTests/RedisAppStateTests.swift
+++ b/macos/Tests/GridexTests/RedisAppStateTests.swift
@@@ -1,1405 -1,0 +1,1441 @@@
+// RedisAppStateTests.swift
+// Gridex
+
+import XCTest
+@testable import Gridex
+
+@MainActor
+final class RedisAppStateTests: XCTestCase {
+
+ func test_requestRedisKeyBrowserRefresh_incrementsNonce() {
+ let state = AppState()
+ let originalNonce = state.redisKeyBrowserRefreshNonce
+
+ state.requestRedisKeyBrowserRefresh()
+
+ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce + 1)
+ }
+
+ func test_loadSidebar_forRedisClearsGenericItemsAndRequestsBrowserRefresh() async {
+ let state = AppState()
++ let config = redisConfig()
++ let adapter = RedisAdapter()
++ state.activeConnectionId = config.id
++ state.activeConfig = config
++ state.activeAdapter = adapter
+ state.sidebarItems = [
+ SidebarItem(title: "Legacy", type: .group("legacy"))
+ ]
++ state.selectedSidebarSchema = "legacy"
++ state.selectSidebarItem(.table("Legacy"), schema: "legacy")
+ let originalNonce = state.redisKeyBrowserRefreshNonce
+
- await state.loadSidebar(config: redisConfig(), adapter: RedisAdapter())
++ await state.loadSidebar(config: config, adapter: adapter)
+
+ XCTAssertTrue(state.sidebarItems.isEmpty)
++ XCTAssertNil(state.selectedSidebarSchema)
++ XCTAssertNil(state.selectedSidebarItem)
++ XCTAssertNil(state.selectedSidebarItemSchema)
+ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce + 1)
+ }
+
++ func test_loadSidebar_forStaleRedisCannotClearActiveSQLSidebar() async {
++ let state = AppState()
++ let activeConfig = ConnectionConfig(
++ name: "SQLite",
++ databaseType: .sqlite,
++ filePath: ":memory:"
++ )
++ state.activeConnectionId = activeConfig.id
++ state.activeConfig = activeConfig
++ state.activeAdapter = SQLiteAdapter()
++ state.sidebarItems = [
++ SidebarItem(title: "Current", type: .table("Current"), schema: "main")
++ ]
++ state.selectedSidebarSchema = "main"
++ state.selectSidebarItem(.table("Current"), schema: "main")
++ let originalNonce = state.redisKeyBrowserRefreshNonce
++
++ await state.loadSidebar(config: redisConfig(), adapter: RedisAdapter())
++
++ XCTAssertEqual(state.sidebarItems.map(\.title), ["Current"])
++ XCTAssertEqual(state.selectedSidebarSchema, "main")
++ XCTAssertEqual(state.selectedSidebarItem, .table("Current"))
++ XCTAssertEqual(state.selectedSidebarItemSchema, "main")
++ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce)
++ }
++
+ func test_refreshSidebar_forRedisRequestsBrowserRefreshImmediately() {
+ let state = AppState()
+ state.activeAdapter = RedisAdapter()
+ state.activeConfig = redisConfig()
+ let originalNonce = state.redisKeyBrowserRefreshNonce
+
+ state.refreshSidebar()
+
+ XCTAssertEqual(state.redisKeyBrowserRefreshNonce, originalNonce + 1)
+ }
+
+ func test_openRedisFlatKeyList_reusesKeysTabAndShowsItsFilterBar() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+
+ state.openRedisFlatKeyList()
+
+ let firstTabID = try XCTUnwrap(state.activeTabId)
+ XCTAssertEqual(state.tabs.count, 1)
+ XCTAssertEqual(state.tabs.first?.type, .dataGrid)
+ XCTAssertEqual(state.tabs.first?.tableName, "Keys")
+ XCTAssertTrue(state.cachedDataGridState(for: firstTabID).showFilterBar)
+
+ state.cachedDataGridState(for: firstTabID).showFilterBar = false
+ state.openRedisFlatKeyList()
+
+ XCTAssertEqual(state.tabs.count, 1)
+ XCTAssertEqual(state.activeTabId, firstTabID)
+ XCTAssertTrue(state.cachedDataGridState(for: firstTabID).showFilterBar)
+ }
+
+ func test_openRedisFlatKeyList_reusesOnlyWithinTheCurrentDatabase() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+
+ state.openRedisFlatKeyList()
+ let db0TabID = try XCTUnwrap(state.activeTabId)
+
+ state.currentDatabaseName = "db1"
+ state.openRedisFlatKeyList()
+ let db1TabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 2)
+ XCTAssertNotEqual(db1TabID, db0TabID)
+ XCTAssertEqual(state.tabs.first(where: { $0.id == db0TabID })?.databaseName, "db0")
+ XCTAssertEqual(state.tabs.first(where: { $0.id == db1TabID })?.databaseName, "db1")
+
+ state.currentDatabaseName = "db0"
+ state.openRedisFlatKeyList()
+
+ XCTAssertEqual(state.tabs.count, 2)
+ XCTAssertEqual(state.activeTabId, db0TabID)
+ }
+
+ func test_openRedisFlatKeyList_reusesOnlyWithinTheActiveConnection() throws {
+ let firstConnection = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let secondConnection = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!
+ let firstAdapter = RedisAdapter()
+ let secondAdapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: firstConnection,
+ databaseName: "db0"
+ )
+
+ state.openRedisFlatKeyList()
+ let firstConnectionTabID = try XCTUnwrap(state.activeTabId)
+ let firstConnectionContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == firstConnectionTabID })?.redisContext
+ )
+ XCTAssertEqual(firstConnectionContext.connectionID, firstConnection)
+ XCTAssertEqual(firstConnectionContext.databaseName, "db0")
+ XCTAssertTrue(state.activeRedisAdapter(for: firstConnectionContext) === firstAdapter)
+
+ state.activeConnectionId = secondConnection
+ state.activeAdapter = secondAdapter
+ XCTAssertFalse(state.isRedisFlatKeyListOpen)
+ state.openRedisFlatKeyList()
+ let secondConnectionTabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 2)
+ XCTAssertNotEqual(secondConnectionTabID, firstConnectionTabID)
+ let secondConnectionContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == secondConnectionTabID })?.redisContext
+ )
+ XCTAssertEqual(secondConnectionContext.connectionID, secondConnection)
+ XCTAssertEqual(secondConnectionContext.databaseName, "db0")
+ XCTAssertTrue(state.activeRedisAdapter(for: secondConnectionContext) === secondAdapter)
+ XCTAssertTrue(state.isRedisFlatKeyListOpen)
+
+ state.activeConnectionId = firstConnection
+ state.activeAdapter = firstAdapter
+ XCTAssertNil(state.activeRedisAdapter(for: firstConnectionContext))
+ state.openRedisFlatKeyList()
+ let reacceptedFirstConnectionTabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 3)
+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, firstConnectionTabID)
+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, secondConnectionTabID)
+ }
+
+ func test_openRedisKeyDetail_reusesSameNamedKeyOnlyWithinCurrentDatabase() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+
+ state.openRedisKeyDetail(key: "session:42")
+ let db0TabID = try XCTUnwrap(state.activeTabId)
+
+ state.currentDatabaseName = "db1"
+ state.openRedisKeyDetail(key: "session:42")
+ let db1TabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 2)
+ XCTAssertNotEqual(db1TabID, db0TabID)
+ XCTAssertEqual(state.tabs.first(where: { $0.id == db0TabID })?.databaseName, "db0")
+ XCTAssertEqual(state.tabs.first(where: { $0.id == db1TabID })?.databaseName, "db1")
+
+ state.currentDatabaseName = "db0"
+ state.openRedisKeyDetail(key: "session:42")
+
+ XCTAssertEqual(state.tabs.count, 2)
+ XCTAssertEqual(state.activeTabId, db0TabID)
+ }
+
+ func test_openRedisKeyDetail_reusesSameNamedKeyOnlyWithinActiveConnection() throws {
+ let firstConnection = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let secondConnection = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!
+ let firstAdapter = RedisAdapter()
+ let secondAdapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: firstConnection,
+ databaseName: "db0"
+ )
+
+ state.openRedisKeyDetail(key: "session:42")
+ let firstConnectionTabID = try XCTUnwrap(state.activeTabId)
+ let firstConnectionContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == firstConnectionTabID })?.redisContext
+ )
+ XCTAssertEqual(firstConnectionContext.connectionID, firstConnection)
+ XCTAssertEqual(firstConnectionContext.databaseName, "db0")
+ XCTAssertTrue(state.activeRedisAdapter(for: firstConnectionContext) === firstAdapter)
+
+ state.activeConnectionId = secondConnection
+ state.activeAdapter = secondAdapter
+ state.openRedisKeyDetail(key: "session:42")
+ let secondConnectionTabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 2)
+ XCTAssertNotEqual(secondConnectionTabID, firstConnectionTabID)
+ let secondConnectionContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == secondConnectionTabID })?.redisContext
+ )
+ XCTAssertEqual(secondConnectionContext.connectionID, secondConnection)
+ XCTAssertEqual(secondConnectionContext.databaseName, "db0")
+ XCTAssertTrue(state.activeRedisAdapter(for: secondConnectionContext) === secondAdapter)
+
+ state.activeConnectionId = firstConnection
+ state.activeAdapter = firstAdapter
+ XCTAssertNil(state.activeRedisAdapter(for: firstConnectionContext))
+ state.openRedisKeyDetail(key: "session:42")
+ let reacceptedFirstConnectionTabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 3)
+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, firstConnectionTabID)
+ XCTAssertNotEqual(reacceptedFirstConnectionTabID, secondConnectionTabID)
+ }
+
+ func test_activeRedisAdapterForTabContext_rejectsConnectionAndDatabaseChanges() throws {
+ let firstConnection = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let secondConnection = UUID(uuidString: "22222222-2222-2222-2222-222222222222")!
+ let adapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: adapter,
+ connectionID: firstConnection,
+ databaseName: "db0"
+ )
+ state.openRedisKeyDetail(key: "session:42")
+ let tabID = try XCTUnwrap(state.activeTabId)
+ let capturedContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == tabID })?.redisContext
+ )
+
+ XCTAssertTrue(state.activeRedisAdapter(for: capturedContext) === adapter)
+
+ state.activeConnectionId = secondConnection
+ XCTAssertNil(state.activeRedisAdapter(for: capturedContext))
+
+ state.activeConnectionId = firstConnection
+ state.currentDatabaseName = "db1"
+ XCTAssertNil(state.activeRedisAdapter(for: capturedContext))
+ }
+
+ func test_replacingRedisAdapterInvalidatesSameConnectionAndDatabaseTabs() throws {
+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let firstAdapter = RedisAdapter()
+ let secondAdapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+
+ state.openRedisFlatKeyList()
+ let firstFlatTabID = try XCTUnwrap(state.activeTabId)
+ state.openRedisKeyDetail(key: "session:42")
+ let firstDetailTabID = try XCTUnwrap(state.activeTabId)
+ let firstFlatContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == firstFlatTabID })?.redisContext
+ )
+ let firstDetailContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == firstDetailTabID })?.redisContext
+ )
+
+ state.activeAdapter = secondAdapter
+
+ XCTAssertFalse(state.isRedisFlatKeyListOpen)
+ XCTAssertNil(state.activeRedisAdapter(for: firstFlatContext))
+ XCTAssertNil(state.activeRedisAdapter(for: firstDetailContext))
+
+ state.openRedisFlatKeyList()
+ let secondFlatTabID = try XCTUnwrap(state.activeTabId)
+ state.openRedisKeyDetail(key: "session:42")
+ let secondDetailTabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertEqual(state.tabs.count, 4)
+ XCTAssertNotEqual(secondFlatTabID, firstFlatTabID)
+ XCTAssertNotEqual(secondDetailTabID, firstDetailTabID)
+ let secondFlatContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == secondFlatTabID })?.redisContext
+ )
+ let secondDetailContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == secondDetailTabID })?.redisContext
+ )
+ XCTAssertEqual(secondFlatContext.connectionID, connectionID)
+ XCTAssertEqual(secondFlatContext.databaseName, "db0")
+ XCTAssertEqual(secondDetailContext.connectionID, connectionID)
+ XCTAssertEqual(secondDetailContext.databaseName, "db0")
+ XCTAssertTrue(state.activeRedisAdapter(for: secondFlatContext) === secondAdapter)
+ XCTAssertTrue(state.activeRedisAdapter(for: secondDetailContext) === secondAdapter)
+ }
+
+ func test_redisDatabaseTransitionInvalidatesOldContextBeforeAwaitingSelect() async throws {
+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let adapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: adapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+ state.openRedisFlatKeyList()
+ let flatTabID = try XCTUnwrap(state.activeTabId)
+ state.openRedisKeyDetail(key: "session:42")
+ let detailTabID = try XCTUnwrap(state.activeTabId)
+ let flatContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == flatTabID })?.redisContext
+ )
+ let detailContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == detailTabID })?.redisContext
+ )
+ var selectWasInvoked = false
+
+ try await state.performRedisDatabaseTransition(to: "db1") {
+ selectWasInvoked = true
+ XCTAssertFalse(state.isRedisFlatKeyListOpen)
+ XCTAssertNil(state.activeRedisAdapter(for: flatContext))
+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))
+
+ await Task.yield()
+
+ XCTAssertNil(state.activeRedisAdapter(for: flatContext))
+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))
+ }
+
+ XCTAssertTrue(selectWasInvoked)
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ XCTAssertNil(state.activeRedisAdapter(for: flatContext))
+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))
+ }
+
+ func test_overlappingRedisTransitions_newerSuccessOutranksOlderSuccess() async {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let olderGate = AsyncTestGate()
+ let newerGate = AsyncTestGate()
+
+ let olderTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await olderGate.enterAndWait()
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db2") {
+ await newerGate.enterAndWait()
+ }
+ }
+
+ await olderGate.release()
+ await olderTransition.value
+
+ await newerGate.waitUntilEntered()
+ await newerGate.release()
+ await newerTransition.value
+
+ XCTAssertEqual(state.currentDatabaseName, "db2")
+ }
+
+ func test_overlappingRedisTransitions_olderFailureCannotRestoreOverNewerSuccess() async {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let olderGate = AsyncTestGate()
+ let newerGate = AsyncTestGate()
+
+ let olderTransition = Task { @MainActor in
+ do {
+ try await state.performRedisDatabaseTransition(to: "db1") {
+ await olderGate.enterAndWait()
+ throw ExpectedTransitionError.selectFailed
+ }
+ return false
+ } catch ExpectedTransitionError.selectFailed {
+ return true
+ } catch {
+ return false
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db2") {
+ await newerGate.enterAndWait()
+ }
+ }
+
+ await olderGate.release()
+ let olderFailedAsExpected = await olderTransition.value
+
+ await newerGate.waitUntilEntered()
+ await newerGate.release()
+ await newerTransition.value
+
+ XCTAssertEqual(state.currentDatabaseName, "db2")
+ XCTAssertTrue(olderFailedAsExpected)
+ XCTAssertEqual(state.currentDatabaseName, "db2")
+ }
+
+ func test_overlappingRedisTransitions_newerFailureKeepsOlderSuccessfulDatabase() async {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let olderGate = AsyncTestGate()
+ let newerGate = AsyncTestGate()
+
+ let olderTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await olderGate.enterAndWait()
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerTransition = Task { @MainActor in
+ do {
+ try await state.performRedisDatabaseTransition(to: "db2") {
+ await newerGate.enterAndWait()
+ throw ExpectedTransitionError.selectFailed
+ }
+ return false
+ } catch ExpectedTransitionError.selectFailed {
+ return true
+ } catch {
+ return false
+ }
+ }
+
+ await olderGate.release()
+ await olderTransition.value
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+
+ await newerGate.waitUntilEntered()
+ await newerGate.release()
+ let newerFailedAsExpected = await newerTransition.value
+
+ XCTAssertTrue(newerFailedAsExpected)
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ }
+
+ func test_overlappingRedisTransitions_twoFailuresKeepOriginalDatabase() async {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let olderGate = AsyncTestGate()
+ let newerGate = AsyncTestGate()
+
+ let olderTransition = Task { @MainActor in
+ do {
+ try await state.performRedisDatabaseTransition(to: "db1") {
+ await olderGate.enterAndWait()
+ throw ExpectedTransitionError.selectFailed
+ }
+ return false
+ } catch ExpectedTransitionError.selectFailed {
+ return true
+ } catch {
+ return false
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerTransition = Task { @MainActor in
+ do {
+ try await state.performRedisDatabaseTransition(to: "db2") {
+ await newerGate.enterAndWait()
+ throw ExpectedTransitionError.selectFailed
+ }
+ return false
+ } catch ExpectedTransitionError.selectFailed {
+ return true
+ } catch {
+ return false
+ }
+ }
+
+ await olderGate.release()
+ let olderFailedAsExpected = await olderTransition.value
+ XCTAssertTrue(olderFailedAsExpected)
+ XCTAssertEqual(state.currentDatabaseName, "db0")
+
+ await newerGate.waitUntilEntered()
+ await newerGate.release()
+ let newerFailedAsExpected = await newerTransition.value
+
+ XCTAssertTrue(newerFailedAsExpected)
+ XCTAssertEqual(state.currentDatabaseName, "db0")
+ }
+
+ func test_overlappingRedisTransitions_serializeActualSelectClosuresInRevisionOrder() async {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let olderGate = AsyncTestGate()
+ let newerGate = AsyncTestGate()
+ let events = AsyncTestEventRecorder()
+
+ let olderTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await events.record("db1:start")
+ await olderGate.enterAndWait()
+ await events.record("db1:end")
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let newerTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db2") {
+ await events.record("db2:start")
+ await newerGate.enterAndWait()
+ await events.record("db2:end")
+ }
+ }
+ while state.redisDatabaseRevision < 2 {
+ await Task.yield()
+ }
+
+ let newerEnteredBeforeOlderFinished = await newerGate.enteredSnapshot()
+ XCTAssertFalse(newerEnteredBeforeOlderFinished)
+
+ await olderGate.release()
+ await olderTransition.value
+ await newerGate.waitUntilEntered()
+ await newerGate.release()
+ await newerTransition.value
+
+ let recordedEvents = await events.snapshot()
+ XCTAssertEqual(
+ recordedEvents,
+ ["db1:start", "db1:end", "db2:start", "db2:end"]
+ )
+ XCTAssertEqual(state.currentDatabaseName, "db2")
+ }
+
+ func test_redisOperation_serializesWithTransitionAndDiscardsStaleResult() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let context = try XCTUnwrap(state.currentRedisContext)
+ let operationGate = AsyncTestGate()
+ let selectGate = AsyncTestGate()
+ let events = AsyncTestEventRecorder()
+
+ let operation = Task { @MainActor in
+ await state.performRedisOperation(for: context) { _ in
+ await events.record("operation:start")
+ await operationGate.enterAndWait()
+ await events.record("operation:end")
+ return "db0-value"
+ }
+ }
+ await operationGate.waitUntilEntered()
+
+ let transition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await events.record("select:start")
+ await selectGate.enterAndWait()
+ await events.record("select:end")
+ }
+ }
+ while state.redisDatabaseRevision < 1 {
+ await Task.yield()
+ }
+
+ let selectEnteredBeforeOperationFinished = await selectGate.enteredSnapshot()
+ XCTAssertFalse(selectEnteredBeforeOperationFinished)
+
+ await operationGate.release()
+ let result = await operation.value
+ await selectGate.waitUntilEntered()
+ await selectGate.release()
+ await transition.value
+
+ XCTAssertNil(result)
+ let recordedEvents = await events.snapshot()
+ XCTAssertEqual(
+ recordedEvents,
+ ["operation:start", "operation:end", "select:start", "select:end"]
+ )
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ }
+
+ func test_nestedRedisOperationInSameTask_completesWithoutSelfDeadlock() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let context = try XCTUnwrap(state.currentRedisContext)
+ let completed = expectation(description: "nested Redis operation completed")
+ var nestedOperationSucceeded = false
+
+ let operation = Task { @MainActor in
+ let outerResult = await state.performRedisOperation(for: context) { _ in
+ await state.performRedisOperation(for: context) { _ in
+ "nested-value"
+ }
+ }
+ if case .success(let innerResult)? = outerResult,
+ case .success("nested-value")? = innerResult {
+ nestedOperationSucceeded = true
+ }
+ completed.fulfill()
+ }
+ defer { operation.cancel() }
+
+ await fulfillment(of: [completed], timeout: 1.0)
+
+ XCTAssertTrue(nestedOperationSucceeded)
+ }
+
+ func test_cancelledQueuedRedisTransition_completesAndRestoresContextBeforeLeaseRelease() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let context = try XCTUnwrap(state.currentRedisContext)
+ let holderGate = AsyncTestGate()
+ let holder = Task { @MainActor in
+ await state.performRedisOperation(for: context) { _ in
+ await holderGate.enterAndWait()
+ }
+ }
+ await holderGate.waitUntilEntered()
+
+ let transitionCompleted = expectation(description: "cancelled queued transition completed")
+ var didCompleteTransition = false
+ var didInvokeSelect = false
+ let transition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ didInvokeSelect = true
+ }
+ didCompleteTransition = true
+ transitionCompleted.fulfill()
+ }
+ while state.redisDatabaseRevision < 1 {
+ await Task.yield()
+ }
+
+ transition.cancel()
+ await fulfillment(of: [transitionCompleted], timeout: 1.0)
+ let databaseNameBeforeHolderRelease = state.currentDatabaseName
+ let completedBeforeHolderRelease = didCompleteTransition
+
+ await holderGate.release()
+ _ = await holder.value
+ _ = await transition.value
+
+ XCTAssertTrue(completedBeforeHolderRelease)
+ XCTAssertEqual(databaseNameBeforeHolderRelease, "db0")
+ XCTAssertFalse(didInvokeSelect)
+ XCTAssertEqual(state.currentDatabaseName, "db0")
+ }
+
+ func test_redisConnectionMetadataLoad_serializesWithTransitionAndDiscardsStaleRevision() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ state.availableDatabases = ["sentinel"]
+ state.redisDBSize = 7
+ let token = try XCTUnwrap(state.currentRedisSessionRevisionToken)
+ let metadataGate = AsyncTestGate()
+ let selectGate = AsyncTestGate()
+ let events = AsyncTestEventRecorder()
+
+ let metadataLoad = Task { @MainActor in
+ await state.loadRedisConnectionMetadata(for: token) { _ in
+ await events.record("metadata:start")
+ await metadataGate.enterAndWait()
+ await events.record("metadata:end")
+ return AppState.RedisConnectionMetadataSnapshot(
+ databaseName: "db0",
+ availableDatabases: ["stale"],
+ databaseSize: 999
+ )
+ }
+ }
+ await metadataGate.waitUntilEntered()
+
+ let transition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await events.record("select:start")
+ await selectGate.enterAndWait()
+ await events.record("select:end")
+ }
+ }
+ while state.redisDatabaseRevision < 1 {
+ await Task.yield()
+ }
+
+ let selectEnteredBeforeMetadataFinished = await selectGate.enteredSnapshot()
+ XCTAssertFalse(selectEnteredBeforeMetadataFinished)
+
+ await metadataGate.release()
+ let published = await metadataLoad.value
+ await selectGate.waitUntilEntered()
+ await selectGate.release()
+ await transition.value
+
+ XCTAssertFalse(published)
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ XCTAssertNotEqual(state.availableDatabases, ["stale"])
+ XCTAssertNotEqual(state.redisDBSize, 999)
+ let recordedEvents = await events.snapshot()
+ XCTAssertEqual(
+ recordedEvents,
+ ["metadata:start", "metadata:end", "select:start", "select:end"]
+ )
+ }
+
+ func test_redisConnectionMetadataLoad_rejectsSameAdapterSessionABA() async throws {
+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let firstAdapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+ state.availableDatabases = ["sentinel"]
+ state.redisDBSize = 7
+ let token = try XCTUnwrap(state.currentRedisSessionRevisionToken)
+ let metadataGate = AsyncTestGate()
+
+ let metadataLoad = Task { @MainActor in
+ await state.loadRedisConnectionMetadata(for: token) { _ in
+ await metadataGate.enterAndWait()
+ return AppState.RedisConnectionMetadataSnapshot(
+ databaseName: "db0",
+ availableDatabases: ["stale"],
+ databaseSize: 999
+ )
+ }
+ }
+ await metadataGate.waitUntilEntered()
+
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+
+ await metadataGate.release()
+ let published = await metadataLoad.value
+
+ XCTAssertFalse(published)
+ XCTAssertEqual(state.currentDatabaseName, "db0")
+ XCTAssertEqual(state.availableDatabases, ["sentinel"])
+ XCTAssertEqual(state.redisDBSize, 7)
+ }
+
+ func test_reacceptingSameRedisAdapterInvalidatesCapturedTabContexts() throws {
+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let adapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: adapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+ state.openRedisFlatKeyList()
+ let flatTabID = try XCTUnwrap(state.activeTabId)
+ state.openRedisKeyDetail(key: "session:42")
+ let detailTabID = try XCTUnwrap(state.activeTabId)
+ let flatContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == flatTabID })?.redisContext
+ )
+ let detailContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == detailTabID })?.redisContext
+ )
+
+ state.activeAdapter = nil
+ state.activeConnectionId = nil
+ state.currentDatabaseName = nil
+ establishRedisContext(
+ on: state,
+ adapter: adapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+
+ XCTAssertNil(state.activeRedisAdapter(for: flatContext))
+ XCTAssertNil(state.activeRedisAdapter(for: detailContext))
+ XCTAssertFalse(state.isRedisFlatKeyListOpen)
+ }
+
+ func test_redisSessionABA_doesNotReauthorizeFirstAdapterContexts() throws {
+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ let firstAdapter = RedisAdapter()
+ let interveningAdapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+ state.openRedisKeyDetail(key: "session:42")
+ let firstTabID = try XCTUnwrap(state.activeTabId)
+ let firstContext = try XCTUnwrap(
+ state.tabs.first(where: { $0.id == firstTabID })?.redisContext
+ )
+
+ establishRedisContext(
+ on: state,
+ adapter: interveningAdapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+ XCTAssertNil(state.activeRedisAdapter(for: firstContext))
+
+ establishRedisContext(
+ on: state,
+ adapter: firstAdapter,
+ connectionID: connectionID,
+ databaseName: "db0"
+ )
+
+ XCTAssertNil(state.activeRedisAdapter(for: firstContext))
+ }
+
+ func test_openRedisTabsRefuseIncompleteContext() {
+ let connectionID = UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+
+ let missingEverything = AppState()
+ missingEverything.openRedisFlatKeyList()
+ missingEverything.openRedisKeyDetail(key: "session:42")
+ XCTAssertTrue(missingEverything.tabs.isEmpty)
+ XCTAssertNil(missingEverything.activeTabId)
+ XCTAssertFalse(missingEverything.isRedisFlatKeyListOpen)
+
+ let missingAdapter = AppState()
+ missingAdapter.activeConnectionId = connectionID
+ missingAdapter.currentDatabaseName = "db0"
+ missingAdapter.openRedisFlatKeyList()
+ missingAdapter.openRedisKeyDetail(key: "session:42")
+ XCTAssertTrue(missingAdapter.tabs.isEmpty)
+
+ let missingConnection = AppState()
+ missingConnection.activeAdapter = RedisAdapter()
+ missingConnection.currentDatabaseName = "db0"
+ missingConnection.openRedisFlatKeyList()
+ missingConnection.openRedisKeyDetail(key: "session:42")
+ XCTAssertTrue(missingConnection.tabs.isEmpty)
+
+ let missingDatabase = AppState()
+ missingDatabase.activeAdapter = RedisAdapter()
+ missingDatabase.activeConnectionId = connectionID
+ missingDatabase.openRedisFlatKeyList()
+ missingDatabase.openRedisKeyDetail(key: "session:42")
+ XCTAssertTrue(missingDatabase.tabs.isEmpty)
+ }
+
+ func test_flatKeyListOpenStateBecomesFalseAfterCloseAndCanReopen() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db3"
+ )
+
+ XCTAssertFalse(state.isRedisFlatKeyListOpen)
+ state.openRedisFlatKeyList()
+ let closedTabID = try XCTUnwrap(state.activeTabId)
+ XCTAssertTrue(state.isRedisFlatKeyListOpen)
+
+ state.closeTab(id: closedTabID)
+
+ XCTAssertFalse(state.isRedisFlatKeyListOpen)
+
+ state.openRedisFlatKeyList()
+ let reopenedTabID = try XCTUnwrap(state.activeTabId)
+
+ XCTAssertTrue(state.isRedisFlatKeyListOpen)
+ XCTAssertNotEqual(reopenedTabID, closedTabID)
+ XCTAssertEqual(state.tabs.first(where: { $0.id == reopenedTabID })?.databaseName, "db3")
+ }
+
+ func test_redisCLISelectPublishesOwnedDatabaseContextAndInvalidatesOldRevision() async throws {
+ let adapter = RedisAdapter()
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: adapter,
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let oldContext = try XCTUnwrap(state.currentRedisContext)
+ var receivedStatement: String?
+ var usedActiveAdapter = false
+
+ let result = await state.performRedisCLIStatement(" select 5 ") { receivedAdapter, statement in
+ receivedStatement = statement
+ usedActiveAdapter = receivedAdapter === adapter
+ return self.redisCLIResult(value: "OK")
+ }
+
+ guard case .success(let queryResult)? = result else {
+ return XCTFail("Expected the owned SELECT result to remain current")
+ }
+ XCTAssertEqual(queryResult.rows, [[.string("OK")]])
+ XCTAssertEqual(receivedStatement, "select 5")
+ XCTAssertTrue(usedActiveAdapter)
+ XCTAssertEqual(state.currentDatabaseName, "db5")
+ XCTAssertEqual(state.redisDatabaseRevision, oldContext.databaseRevision + 1)
+ XCTAssertNil(state.activeRedisAdapter(for: oldContext))
+ }
+
+ func test_redisCLISelectServerErrorKeepsThePreviouslySelectedDatabase() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+
+ let result = await state.performRedisCLIStatement("SELECT 999") { _, _ in
+ QueryResult(
+ columns: [ColumnHeader(name: "error", dataType: "string")],
+ rows: [[.string("ERR DB index is out of range")]],
+ rowsAffected: 0,
+ executionTime: 0.01,
+ queryType: .select
+ )
+ }
+
+ guard case .success(let queryResult)? = result else {
+ return XCTFail("Expected the Redis error response to remain displayable")
+ }
+ XCTAssertEqual(queryResult.columns.first?.name, "error")
+ XCTAssertEqual(state.currentDatabaseName, "db0")
+ XCTAssertEqual(state.currentRedisContext?.databaseName, "db0")
+ }
+
+ func test_redisCLIQuotedSelectPublishesTheAdapterTokenizedDatabase() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let oldRevision = try XCTUnwrap(state.currentRedisContext).databaseRevision
+ var receivedStatement: String?
+
+ let result = await state.performRedisCLIStatement("SELECT \"4\"") { _, statement in
+ receivedStatement = statement
+ return self.redisCLIResult(value: "OK")
+ }
+
+ guard case .success? = result else {
+ return XCTFail("Expected quoted SELECT to complete as an owned transition")
+ }
+ XCTAssertEqual(receivedStatement, "SELECT \"4\"")
+ XCTAssertEqual(state.currentDatabaseName, "db4")
+ XCTAssertEqual(state.redisDatabaseRevision, oldRevision + 1)
+ }
+
+ func test_redisCLINonSelectSerializesWithTransitionAndDiscardsStaleResult() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let commandGate = AsyncTestGate()
+ let selectGate = AsyncTestGate()
+ let events = AsyncTestEventRecorder()
+
+ let command = Task { @MainActor in
+ await state.performRedisCLIStatement("GET session:42") { _, _ in
+ await events.record("command:start")
+ await commandGate.enterAndWait()
+ await events.record("command:end")
+ return self.redisCLIResult(value: "value")
+ }
+ }
+ await commandGate.waitUntilEntered()
+
+ let transition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await events.record("select:start")
+ await selectGate.enterAndWait()
+ await events.record("select:end")
+ }
+ }
+ while state.redisDatabaseRevision < 1 {
+ await Task.yield()
+ }
+
+ let selectEnteredBeforeCommandFinished = await selectGate.enteredSnapshot()
+ XCTAssertFalse(selectEnteredBeforeCommandFinished)
+
+ await commandGate.release()
+ let commandResult = await command.value
+ await selectGate.waitUntilEntered()
+ await selectGate.release()
+ await transition.value
+
+ XCTAssertNil(commandResult)
+ let recordedEvents = await events.snapshot()
+ XCTAssertEqual(
+ recordedEvents,
+ ["command:start", "command:end", "select:start", "select:end"]
+ )
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ }
+
+ func test_redisCLISelectParserAcceptsOnlyOneNonnegativeDatabaseIndex() {
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SELECT 5"), "db5")
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: " select 005 "), "db5")
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SELECT \"6\""), "db6")
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "'SELECT' 7"), "db7")
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SEL\"ECT\" 8"), "db8")
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "SELECT '9"), "db9")
+ XCTAssertEqual(AppState.redisDatabaseNameSelected(by: "\u{017F}elect 10"), "db10")
+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT"))
+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT -1"))
+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT five"))
+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT 1 extra"))
+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "GET SELECT 1"))
+ XCTAssertNil(AppState.redisDatabaseNameSelected(by: "SELECT\t1"))
+ }
+
+ func test_redisQueryTabsCaptureTheirExactDatabaseContext() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+
+ state.openNewQueryTab()
+ let db0Tab = try XCTUnwrap(state.tabs.last)
+
+ state.currentDatabaseName = "db1"
+ state.openNewQueryTab()
+ let db1Tab = try XCTUnwrap(state.tabs.last)
+
+ XCTAssertEqual(db0Tab.redisContext?.databaseName, "db0")
+ XCTAssertEqual(db1Tab.redisContext?.databaseName, "db1")
+ XCTAssertNotEqual(db0Tab.redisContext, db1Tab.redisContext)
+ }
+
+ func test_openRedisQueryTabRefusesAContextWhileDatabaseSelectionIsPending() {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ state.currentDatabaseName = nil
+
+ state.openNewQueryTab()
+
+ XCTAssertTrue(state.tabs.isEmpty)
+ }
+
+ func test_rebindRedisQueryTabAdoptsTheLatestRevisionAfterSelectFailure() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ state.openNewQueryTab()
+ let tabID = try XCTUnwrap(state.tabs.last?.id)
+ let oldContext = try XCTUnwrap(state.tabs.last?.redisContext)
+
+ _ = await state.performRedisCLIStatement("SELECT 999") { _, _ in
+ QueryResult(
+ columns: [ColumnHeader(name: "error", dataType: "string")],
+ rows: [[.string("ERR DB index is out of range")]],
+ rowsAffected: 0,
+ executionTime: 0.01,
+ queryType: .select
+ )
+ }
+ let currentContext = try XCTUnwrap(state.currentRedisContext)
+
+ state.rebindRedisQueryTab(id: tabID, to: currentContext)
+
+ XCTAssertNotEqual(currentContext.databaseRevision, oldContext.databaseRevision)
+ XCTAssertEqual(state.tabs.last?.redisContext, currentContext)
+ XCTAssertEqual(state.tabs.last?.databaseName, "db0")
+ }
+
+ func test_redisCLINonSelectingSequenceKeepsOneLeaseUntilAllCommandsFinish() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let context = try XCTUnwrap(state.currentRedisContext)
+ let firstCommandGate = AsyncTestGate()
+ let secondCommandGate = AsyncTestGate()
+ let selectGate = AsyncTestGate()
+ let events = AsyncTestEventRecorder()
+
+ let sequence = Task { @MainActor in
+ await state.performRedisCLIStatements(
+ ["GET first", "GET second"],
+ from: context
+ ) { _, statement in
+ await events.record("\(statement):start")
+ if statement == "GET first" {
+ await firstCommandGate.enterAndWait()
+ } else {
+ await secondCommandGate.enterAndWait()
+ }
+ await events.record("\(statement):end")
+ return self.redisCLIResult(value: statement)
+ }
+ }
+ await firstCommandGate.waitUntilEntered()
+
+ let transition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await events.record("select:start")
+ await selectGate.enterAndWait()
+ await events.record("select:end")
+ }
+ }
+ while state.redisDatabaseRevision < 1 {
+ await Task.yield()
+ }
+
+ await firstCommandGate.release()
+ await secondCommandGate.waitUntilEntered()
+ let selectEnteredBeforeSequenceFinished = await selectGate.enteredSnapshot()
+ XCTAssertFalse(selectEnteredBeforeSequenceFinished)
+ await secondCommandGate.release()
+
+ let sequenceResult = await sequence.value
+ XCTAssertNil(sequenceResult)
+ await selectGate.waitUntilEntered()
+ await selectGate.release()
+ await transition.value
+
+ let recordedEvents = await events.snapshot()
+ XCTAssertEqual(
+ recordedEvents,
+ [
+ "GET first:start",
+ "GET first:end",
+ "GET second:start",
+ "GET second:end",
+ "select:start",
+ "select:end",
+ ]
+ )
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ }
+
+ func test_redisCLISequenceCapturesTheDatabaseOwnedByEachStatement() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let context = try XCTUnwrap(state.currentRedisContext)
+
+ let result = await state.performRedisCLIStatements(
+ ["GET before", "SELECT 2", "GET after"],
+ from: context
+ ) { _, statement in
+ self.redisCLIResult(value: statement.uppercased().hasPrefix("SELECT") ? "OK" : "value")
+ }
+ let executions = try XCTUnwrap(result)
+
+ XCTAssertEqual(executions.map(\.databaseName), ["db0", "db2", "db2"])
+ XCTAssertEqual(state.currentDatabaseName, "db2")
+ }
+
+ func test_redisCLISelectCannotLeapfrogAPendingExternalTransition() async throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+ let oldContext = try XCTUnwrap(state.currentRedisContext)
+ let externalSelectGate = AsyncTestGate()
+ var cliSelectExecuted = false
+
+ let externalTransition = Task { @MainActor in
+ await state.performRedisDatabaseTransition(to: "db1") {
+ await externalSelectGate.enterAndWait()
+ }
+ }
+ await externalSelectGate.waitUntilEntered()
+
+ let cliBatch = Task { @MainActor in
+ await state.performRedisCLIStatements(
+ ["SELECT 5"],
+ from: oldContext
+ ) { _, _ in
+ cliSelectExecuted = true
+ return self.redisCLIResult(value: "OK")
+ }
+ }
+
+ await Task.yield()
+ XCTAssertFalse(cliSelectExecuted)
+ await externalSelectGate.release()
+ await externalTransition.value
+ let result = await cliBatch.value
+ XCTAssertNil(result)
+ XCTAssertFalse(cliSelectExecuted)
+ XCTAssertEqual(state.currentDatabaseName, "db1")
+ }
+
+ func test_redisOperationalTabsAreScopedToExactDatabaseContext() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db0"
+ )
+
+ state.openRedisServerInfo()
+ let db0Info = try XCTUnwrap(state.tabs.last)
+ state.openRedisSlowLog()
+ let db0SlowLog = try XCTUnwrap(state.tabs.last)
+
+ state.currentDatabaseName = "db1"
+ state.openRedisServerInfo()
+ let db1Info = try XCTUnwrap(state.tabs.last)
+ state.openRedisSlowLog()
+ let db1SlowLog = try XCTUnwrap(state.tabs.last)
+
+ XCTAssertEqual(db0Info.redisContext?.databaseName, "db0")
+ XCTAssertEqual(db0SlowLog.redisContext?.databaseName, "db0")
+ XCTAssertEqual(db1Info.redisContext?.databaseName, "db1")
+ XCTAssertEqual(db1SlowLog.redisContext?.databaseName, "db1")
+ XCTAssertNotEqual(db0Info.id, db1Info.id)
+ XCTAssertNotEqual(db0SlowLog.id, db1SlowLog.id)
+ XCTAssertEqual(state.tabs.count, 4)
+ }
+
+ func test_redisMutationPromptsCaptureAndClearExactContext() throws {
+ let state = AppState()
+ establishRedisContext(
+ on: state,
+ adapter: RedisAdapter(),
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: "db3"
+ )
+ let expected = try XCTUnwrap(state.currentRedisContext)
+
+ state.presentRedisAddKey()
+ state.presentRedisFlushConfirmation()
+
+ XCTAssertTrue(state.showRedisAddKey)
+ XCTAssertTrue(state.showFlushDBConfirm)
+ XCTAssertEqual(state.redisAddKeyContext, expected)
+ XCTAssertEqual(state.redisFlushContext, expected)
+
+ state.dismissRedisAddKey()
+ state.dismissRedisFlushConfirmation()
+
+ XCTAssertFalse(state.showRedisAddKey)
+ XCTAssertFalse(state.showFlushDBConfirm)
+ XCTAssertNil(state.redisAddKeyContext)
+ XCTAssertNil(state.redisFlushContext)
+ }
+
+ private func establishRedisContext(
+ on state: AppState,
+ adapter: RedisAdapter,
+ connectionID: UUID,
+ databaseName: String
+ ) {
+ state.activeAdapter = adapter
+ state.activeConnectionId = connectionID
+ state.currentDatabaseName = databaseName
+ }
+
+ private func redisConfig() -> ConnectionConfig {
+ ConnectionConfig(name: "Redis", databaseType: .redis)
+ }
+
+ private func redisCLIResult(value: String) -> QueryResult {
+ QueryResult(
+ columns: [ColumnHeader(name: "result", dataType: "string")],
+ rows: [[.string(value)]],
+ rowsAffected: 0,
+ executionTime: 0.01,
+ queryType: .select
+ )
+ }
+}
+
+private enum ExpectedTransitionError: Error {
+ case selectFailed
+}
+
+private actor AsyncTestGate {
+ private var hasEntered = false
+ private var hasBeenReleased = false
+ private var entryWaiters: [CheckedContinuation<Void, Never>] = []
+ private var releaseWaiter: CheckedContinuation<Void, Never>?
+
+ func waitUntilEntered() async {
+ guard !hasEntered else { return }
+ await withCheckedContinuation { continuation in
+ entryWaiters.append(continuation)
+ }
+ }
+
+ func enteredSnapshot() -> Bool {
+ hasEntered
+ }
+
+ func enterAndWait() async {
+ hasEntered = true
+ let waiters = entryWaiters
+ entryWaiters.removeAll()
+ waiters.forEach { $0.resume() }
+
+ guard !hasBeenReleased else { return }
+ await withCheckedContinuation { continuation in
+ releaseWaiter = continuation
+ }
+ }
+
+ func release() {
+ hasBeenReleased = true
+ releaseWaiter?.resume()
+ releaseWaiter = nil
+ }
+}
+
+private actor AsyncTestEventRecorder {
+ private var events: [String] = []
+
+ func record(_ event: String) {
+ events.append(event)
+ }
+
+ func snapshot() -> [String] {
+ events
+ }
+}
diff --cc macos/Tests/GridexTests/RedisDataGridLifecycleTests.swift
index c948356,0000000..c75a83a
mode 100644,000000..100644
--- a/macos/Tests/GridexTests/RedisDataGridLifecycleTests.swift
+++ b/macos/Tests/GridexTests/RedisDataGridLifecycleTests.swift
@@@ -1,344 -1,0 +1,367 @@@
+// RedisDataGridLifecycleTests.swift
+// Gridex
+
+import XCTest
+@testable import Gridex
+
+@MainActor
+final class RedisDataGridLifecycleTests: XCTestCase {
+
+ func test_openRedisFlatKeyListBindsExactTabContextToCachedGridBeforeDisplay() throws {
+ let appState = AppState()
+ establishRedisContext(on: appState, databaseName: "db0")
+ let expectedContext = try XCTUnwrap(appState.currentRedisContext)
+
+ appState.openRedisFlatKeyList()
+
+ let tab = try XCTUnwrap(appState.tabs.first)
+ XCTAssertEqual(tab.redisContext, expectedContext)
+ XCTAssertEqual(
+ appState.cachedDataGridState(for: tab.id).redisContext,
+ expectedContext
+ )
+ }
+
+ func test_openRedisFlatKeyListClearsStaleGlobalRowCountBeforeDisplay() {
+ let appState = AppState()
+ establishRedisContext(on: appState, databaseName: "db0")
+ appState.statusRowCount = 42
+
+ appState.openRedisFlatKeyList()
+
+ XCTAssertNil(appState.statusRowCount)
+ }
+
+ func test_rebindingSameRedisContextClearsStaleDetailEditorState() {
+ let appState = AppState()
+ let state = DataGridViewState()
+ let context = redisContext(databaseName: "db0", revision: 1)
+ state.appState = appState
+ state.bindRedisContext(context)
+
+ appState.selectedRowDetails = [(column: "name", value: "obsolete")]
+ appState.onDetailFieldEdit = { _, _ in }
+
+ state.bindRedisContext(context)
+
+ XCTAssertNil(appState.selectedRowDetails)
+ XCTAssertNil(appState.onDetailFieldEdit)
+ }
+
+ func test_redisContextMakesGridReadOnlyAndAllMutationEntryPointsNoOp() async {
+ let state = DataGridViewState()
+ state.bindRedisContext(redisContext(databaseName: "db0", revision: 1))
+ state.columns = [ColumnHeader(name: "key", dataType: "string")]
+ state.rows = [[.string("session:42")]]
+ state.rebuildDisplayCache()
+
+ XCTAssertFalse(state.allowsMutations)
+
+ state.commitCellEdit(rowIndex: 0, colIdx: 0, newText: "changed")
+ state.commitDateEdit(rowIndex: 0, colIdx: 0, newValue: .string("dated"))
+ state.addNewRow()
+ state.commitNewRowEdit(rowIndex: 0, colIdx: 0, newText: "inserted")
+ state.selectedRows = [0]
+ state.deleteSelectedRows()
+ state.prepareCommit()
+ await state.executeCommit()
+
+ XCTAssertEqual(state.rows, [[.string("session:42")]])
+ XCTAssertEqual(state.totalRows, 0)
+ XCTAssertTrue(state.insertedRowIndices.isEmpty)
+ XCTAssertFalse(state.hasPendingChanges)
+ XCTAssertTrue(state.commitSQL.isEmpty)
+ XCTAssertFalse(state.showCommitPreview)
+
+ XCTAssertTrue(DataGridViewState().allowsMutations)
+ }
+
+ func test_liveRedisLoadUsesOneOperationOnlyForTheExactBoundContext() async throws {
+ DataGridViewState.clearMetadataCache()
+ let appState = AppState()
+ let adapter = establishRedisContext(on: appState, databaseName: "db0")
+ let staleContext = try XCTUnwrap(appState.currentRedisContext)
+ var fetchCount = 0
+ var fetchedWithActiveAdapter = false
+ let state = DataGridViewState { receivedAdapter, _ in
+ fetchCount += 1
+ fetchedWithActiveAdapter = receivedAdapter === adapter
+ return self.queryResult(key: "current:key")
+ }
+ state.appState = appState
+ state.bindRedisContext(staleContext)
+
+ appState.currentDatabaseName = "db1"
+ await state.load(tableName: "Keys", schema: nil, adapter: adapter)
+
+ XCTAssertEqual(fetchCount, 0)
+ XCTAssertTrue(state.rows.isEmpty)
+ XCTAssertFalse(state.isLoading)
+
+ let currentContext = try XCTUnwrap(appState.currentRedisContext)
+ state.bindRedisContext(currentContext)
+ await state.load(tableName: "Keys", schema: nil, adapter: adapter)
+
+ XCTAssertEqual(fetchCount, 1)
+ XCTAssertTrue(fetchedWithActiveAdapter)
+ XCTAssertEqual(state.redisContext, currentContext)
+ XCTAssertEqual(state.rows, [[.string("current:key")]])
+ XCTAssertFalse(state.isLoading)
+ }
+
++ func test_reloadAfterStructureChangeForRedisReloadsOwnedPageZero() async throws {
++ DataGridViewState.clearMetadataCache()
++ let appState = AppState()
++ let adapter = establishRedisContext(on: appState, databaseName: "db0")
++ let context = try XCTUnwrap(appState.currentRedisContext)
++ var fetchedOffsets: [Int] = []
++ let state = DataGridViewState { receivedAdapter, request in
++ XCTAssertTrue(receivedAdapter === adapter)
++ fetchedOffsets.append(request.offset)
++ return self.queryResult(key: "publication-\(fetchedOffsets.count)")
++ }
++ state.appState = appState
++ state.bindRedisContext(context)
++
++ await state.load(tableName: "Keys", schema: nil, adapter: adapter)
++ await state.reloadAfterStructureChange()
++
++ XCTAssertEqual(fetchedOffsets, [0, 0])
++ XCTAssertEqual(state.currentPage, 0)
++ XCTAssertEqual(state.rows, [[.string("publication-2")]])
++ XCTAssertFalse(state.isLoading)
++ }
++
+ func test_fullAndPageLoadsShareLatestOwnershipWhenOlderFailureCompletesFirst() async {
+ let state = DataGridViewState()
+ let context = redisContext(databaseName: "db0", revision: 1)
+ let olderGate = RedisOwnershipTestGate()
+ let newerGate = RedisOwnershipTestGate()
+ state.bindRedisContext(context)
+
+ await state.performRedisLoad(in: context) {
+ Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "retained:key"))
+ )
+ }
+
+ let fullLoad = Task { @MainActor in
+ await state.performRedisLoad(in: context) {
+ await olderGate.enterAndWait()
+ return Optional<Result<QueryResult, Error>>.some(
+ .failure(ExpectedRedisDataGridError.obsolete)
+ )
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ let pageLoad = Task { @MainActor in
+ await state.performRedisLoad(in: context) {
+ await newerGate.enterAndWait()
+ return Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "page:key"))
+ )
+ }
+ }
+ await newerGate.waitUntilEntered()
+
+ await olderGate.release()
+ await fullLoad.value
+
+ XCTAssertTrue(state.isLoading)
+ XCTAssertEqual(state.rows, [[.string("retained:key")]])
+ XCTAssertNil(state.errorMessage)
+
+ await newerGate.release()
+ await pageLoad.value
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertEqual(state.rows, [[.string("page:key")]])
+ XCTAssertNil(state.errorMessage)
+ }
+
+ func test_olderFullLoadCompletingLastCannotReplaceNewerPageFailure() async {
+ let state = DataGridViewState()
+ let context = redisContext(databaseName: "db0", revision: 1)
+ let olderGate = RedisOwnershipTestGate()
+ state.bindRedisContext(context)
+
+ await state.performRedisLoad(in: context) {
+ Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "retained:key"))
+ )
+ }
+
+ let fullLoad = Task { @MainActor in
+ await state.performRedisLoad(in: context) {
+ await olderGate.enterAndWait()
+ return Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "obsolete:key"))
+ )
+ }
+ }
+ await olderGate.waitUntilEntered()
+
+ await state.performRedisLoad(in: context) {
+ Optional<Result<QueryResult, Error>>.some(
+ .failure(ExpectedRedisDataGridError.current)
+ )
+ }
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertEqual(state.rows, [[.string("retained:key")]])
+ XCTAssertEqual(state.errorMessage, "current page failed")
+
+ await olderGate.release()
+ await fullLoad.value
+
+ XCTAssertFalse(state.isLoading)
+ XCTAssertEqual(state.rows, [[.string("retained:key")]])
+ XCTAssertEqual(state.errorMessage, "current page failed")
+ }
+
+ func test_oldDb0LoadCannotPublishAfterDb1ThenNewDb0Context() async {
+ let state = DataGridViewState()
+ let oldDB0 = redisContext(databaseName: "db0", revision: 1)
+ let db1 = redisContext(databaseName: "db1", revision: 2)
+ let newDB0 = redisContext(databaseName: "db0", revision: 3)
+ let oldGate = RedisOwnershipTestGate()
+ state.bindRedisContext(oldDB0)
+
+ let oldLoad = Task { @MainActor in
+ await state.performRedisLoad(in: oldDB0) {
+ await oldGate.enterAndWait()
+ return Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "old-db0:key"))
+ )
+ }
+ }
+ await oldGate.waitUntilEntered()
+
+ state.bindRedisContext(db1)
+ XCTAssertTrue(state.rows.isEmpty)
+ await state.performRedisLoad(in: db1) {
+ Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "db1:key"))
+ )
+ }
+ state.bindRedisContext(newDB0)
+ XCTAssertTrue(state.rows.isEmpty)
+ await state.performRedisLoad(in: newDB0) {
+ Optional<Result<QueryResult, Error>>.some(
+ .success(self.queryResult(key: "new-db0:key"))
+ )
+ }
+
+ await oldGate.release()
+ await oldLoad.value
+
+ XCTAssertEqual(state.redisContext, newDB0)
+ XCTAssertEqual(state.rows, [[.string("new-db0:key")]])
+ XCTAssertNil(state.errorMessage)
+ XCTAssertFalse(state.isLoading)
+ }
+
+ func test_filteredRedisLoadsKeepTotalUnknownAndNeverReusePageCount() async throws {
+ DataGridViewState.clearMetadataCache()
+ let appState = AppState()
+ let adapter = establishRedisContext(on: appState, databaseName: "db0")
+ let db0 = try XCTUnwrap(appState.currentRedisContext)
+ var fetchCount = 0
+
+ let makeState: () -> DataGridViewState = {
+ let state = DataGridViewState { _, _ in
+ fetchCount += 1
+ return self.queryResult(key: "result-\(fetchCount)")
+ }
+ state.appState = appState
+ state.activeFilter = FilterExpression(
+ conditions: [
+ FilterCondition(
+ column: "key",
+ op: .like,
+ value: .string("session:*")
+ )
+ ],
+ combinator: .and
+ )
+ return state
+ }
+
+ let firstState = makeState()
+ firstState.bindRedisContext(db0)
+ await firstState.load(tableName: "Keys", schema: nil, adapter: adapter)
+
+ XCTAssertEqual(fetchCount, 1)
+ XCTAssertEqual(firstState.totalRows, 0)
+ XCTAssertNil(firstState.statusRowCount)
+
+ firstState.totalRows = 9_999
+ await firstState.loadPage(1)
+
+ XCTAssertEqual(fetchCount, 2)
+ XCTAssertEqual(firstState.rows, [[.string("result-2")]])
+ XCTAssertEqual(firstState.totalRows, 0)
+ XCTAssertNil(firstState.statusRowCount)
+
+ appState.currentDatabaseName = "db1"
+ let db1 = try XCTUnwrap(appState.currentRedisContext)
+ let secondState = makeState()
+ secondState.bindRedisContext(db1)
+ await secondState.load(tableName: "Keys", schema: nil, adapter: adapter)
+
+ XCTAssertEqual(fetchCount, 3)
+ XCTAssertEqual(secondState.rows, [[.string("result-3")]])
+ XCTAssertEqual(secondState.totalRows, 0)
+ XCTAssertNil(secondState.statusRowCount)
+ }
+
+ @discardableResult
+ private func establishRedisContext(
+ on state: AppState,
+ databaseName: String
+ ) -> RedisAdapter {
+ let adapter = RedisAdapter()
+ state.activeConnectionId =
+ UUID(uuidString: "11111111-1111-1111-1111-111111111111")!
+ state.activeAdapter = adapter
+ state.currentDatabaseName = databaseName
+ return adapter
+ }
+
+ private func redisContext(
+ databaseName: String,
+ revision: UInt64
+ ) -> AppState.RedisTabContext {
+ AppState.RedisTabContext(
+ connectionID: UUID(uuidString: "11111111-1111-1111-1111-111111111111")!,
+ databaseName: databaseName,
+ sessionID: UUID(uuidString: "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA")!,
+ databaseRevision: revision
+ )
+ }
+
+ private func queryResult(key: String) -> QueryResult {
+ QueryResult(
+ columns: [ColumnHeader(name: "key", dataType: "string")],
+ rows: [[.string(key)]],
+ rowsAffected: 0,
+ executionTime: 0.01,
+ queryType: .select
+ )
+ }
+}
+
+private enum ExpectedRedisDataGridError: LocalizedError {
+ case current
+ case obsolete
+
+ var errorDescription: String? {
+ switch self {
+ case .current:
+ "current page failed"
+ case .obsolete:
+ "obsolete full load failed"
+ }
+ }
+}