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++
16.0 KB
Raw Blame
// RedisKeyBrowserView.swift
// Gridex
//
// Redis-specific sidebar browser backed by a names-only SCAN.

import SwiftUI

enum RedisKeyBrowserBehavior {
    static func effectiveDelimiter(for delimiter: String) -> String {
        delimiter.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
            ? ":"
            : delimiter
    }

    static func shouldPublish(
        capturedNonce: Int,
        currentNonce: Int,
        isCancelled: Bool
    ) -> Bool {
        !isCancelled && capturedNonce == currentNonce
    }

    static func openKeyAccessibilityLabel(for key: String) -> String {
        "Open key \(key)"
    }
}

typealias RedisKeyBrowserContext = AppState.RedisTabContext

@MainActor
final class RedisRequestCoordinator {
    enum Completion<Value> {
        case current(Result<Value, Error>)
        case stale
        case superseded
    }

    private var generation: UInt64 = 0

    func perform<Value>(
        for context: RedisKeyBrowserContext,
        execute: () async -> Result<Value, Error>?
    ) async -> Completion<Value> {
        _ = context
        generation &+= 1
        let requestGeneration = generation
        let result = await execute()

        guard requestGeneration == generation else {
            return .superseded
        }
        guard let result else {
            return .stale
        }
        return .current(result)
    }

    func invalidate() {
        generation &+= 1
    }
}

struct RedisKeyBrowserContentState {
    private var context: RedisKeyBrowserContext?
    private var lastSuccessfulResult: RedisKeyScanResult?
    private var errorMessage: String?

    init() {}

    mutating func beginLoading(in context: RedisKeyBrowserContext) {
        if self.context != context {
            lastSuccessfulResult = nil
        }
        self.context = context
        errorMessage = nil
    }

    mutating func publishSuccess(
        _ result: RedisKeyScanResult,
        in context: RedisKeyBrowserContext
    ) {
        guard self.context == context else { return }
        lastSuccessfulResult = result
        errorMessage = nil
    }

    mutating func publishFailure(
        _ message: String,
        in context: RedisKeyBrowserContext
    ) {
        guard self.context == context else { return }
        errorMessage = message
    }

    func visibleResult(in context: RedisKeyBrowserContext) -> RedisKeyScanResult? {
        self.context == context ? lastSuccessfulResult : nil
    }

    func visibleErrorMessage(in context: RedisKeyBrowserContext) -> String? {
        self.context == context ? errorMessage : nil
    }
}

@MainActor
final class RedisKeyBrowserViewState: ObservableObject {
    @Published private(set) var isLoading = false

    private var contentState = RedisKeyBrowserContentState()
    private let coordinator = RedisRequestCoordinator()

    func scan(
        in context: RedisKeyBrowserContext,
        isCurrent: () -> Bool = { true },
        execute: () async -> Result<RedisKeyScanResult, Error>?
    ) async {
        contentState.beginLoading(in: context)
        isLoading = true

        let completion = await coordinator.perform(for: context) {
            let result = await execute()
            return isCurrent() ? result : nil
        }

        switch completion {
        case .current(.success(let result)):
            contentState.publishSuccess(result, in: context)
            isLoading = false
        case .current(.failure(let error)):
            contentState.publishFailure(error.localizedDescription, in: context)
            isLoading = false
        case .stale:
            isLoading = false
        case .superseded:
            break
        }
    }

    func deactivate() {
        coordinator.invalidate()
        isLoading = false
    }

    func visibleResult(in context: RedisKeyBrowserContext) -> RedisKeyScanResult? {
        contentState.visibleResult(in: context)
    }

    func visibleErrorMessage(in context: RedisKeyBrowserContext) -> String? {
        contentState.visibleErrorMessage(in: context)
    }
}

enum RedisKeyBrowserMode: String, CaseIterable, Identifiable {
    case tree, flat

    var id: String { rawValue }
}

struct RedisKeyBrowserView: View {
    @EnvironmentObject private var appState: AppState
    @AppStorage("redis.keyBrowser.delimiter") private var delimiter = ":"
    @State private var mode: RedisKeyBrowserMode = .tree
    @StateObject private var viewState = RedisKeyBrowserViewState()

    private struct LoadRequest: Hashable {
        let context: RedisKeyBrowserContext?
        let refreshNonce: Int
    }

    private var activeContext: RedisKeyBrowserContext? {
        appState.currentRedisContext
    }

    private var visibleResult: RedisKeyScanResult? {
        guard let activeContext else { return nil }
        return viewState.visibleResult(in: activeContext)
    }

    private var visibleErrorMessage: String? {
        guard let activeContext else { return nil }
        return viewState.visibleErrorMessage(in: activeContext)
    }

    private var effectiveDelimiter: String {
        RedisKeyBrowserBehavior.effectiveDelimiter(for: delimiter)
    }

    private var namespaceNodes: [RedisKeyNamespaceNode] {
        RedisKeyNamespaceTree.build(
            keys: visibleResult?.keys ?? [],
            delimiter: effectiveDelimiter
        )
    }

    var body: some View {
        let loadRequest = LoadRequest(
            context: activeContext,
            refreshNonce: appState.redisKeyBrowserRefreshNonce
        )

        return VStack(spacing: 0) {
            toolbar
            Divider()

            if mode == .flat {
                flatContent
            } else {
                treeContent
            }
        }
        .onChange(of: mode) { _, newMode in
            if newMode == .flat {
                appState.openRedisFlatKeyList()
            }
        }
        .onReceive(NotificationCenter.default.publisher(for: .reloadData)) { _ in
            appState.requestRedisKeyBrowserRefresh()
        }
        .task(id: loadRequest) {
            guard let context = loadRequest.context else {
                viewState.deactivate()
                return
            }
            await scanKeys(
                capturedNonce: loadRequest.refreshNonce,
                context: context
            )
        }
        .onDisappear { viewState.deactivate() }
    }

    private var toolbar: some View {
        VStack(alignment: .leading, spacing: 5) {
            HStack(spacing: 6) {
                Picker("Mode", selection: $mode) {
                    ForEach(RedisKeyBrowserMode.allCases) { mode in
                        Text(mode.rawValue.capitalized).tag(mode)
                    }
                }
                .labelsHidden()
                .pickerStyle(.segmented)
                .frame(width: 118)

                Spacer()

                Menu {
                    Button("Add Key…") {
                        appState.presentRedisAddKey()
                    }
                    Divider()
                    Button("Server Info") {
                        appState.openRedisServerInfo()
                    }
                    Button("Slow Log") {
                        appState.openRedisSlowLog()
                    }
                    Divider()
                    Button("Flush Database…", role: .destructive) {
                        appState.presentRedisFlushConfirmation()
                    }
                } label: {
                    Image(systemName: "ellipsis.circle")
                        .font(.system(size: 11))
                }
                .menuStyle(.borderlessButton)
                .fixedSize()
                .accessibilityLabel("Redis actions")
                .help("Redis actions")

                Button {
                    appState.requestRedisKeyBrowserRefresh()
                } label: {
                    HStack(spacing: 4) {
                        if viewState.isLoading {
                            ProgressView()
                                .controlSize(.small)
                                .frame(width: 12, height: 12)
                        } else {
                            Image(systemName: "arrow.clockwise")
                                .font(.system(size: 10))
                                .frame(width: 12, height: 12)
                        }
                        Text("Refresh")
                            .font(.system(size: 11))
                    }
                }
                .buttonStyle(.plain)
                .help("Refresh Redis keys")
            }

            Text("Delimiter: \(effectiveDelimiter)")
                .font(.system(size: 10, design: .monospaced))
                .foregroundStyle(.secondary)
                .lineLimit(1)
        }
        .padding(.horizontal, 8)
        .padding(.vertical, 6)
    }

    @ViewBuilder
    private var treeContent: some View {
        if let result = visibleResult {
            VStack(spacing: 0) {
                if let errorMessage = visibleErrorMessage {
                    errorBanner(errorMessage)
                    Divider()
                }

                if result.keys.isEmpty {
                    Text("No keys found")
                        .font(.system(size: 12))
                        .foregroundStyle(.secondary)
                        .frame(maxWidth: .infinity, maxHeight: .infinity)
                } else {
                    ScrollView {
                        LazyVStack(alignment: .leading, spacing: 1) {
                            ForEach(namespaceNodes) { node in
                                RedisKeyNamespaceNodeView(node: node) { key in
                                    appState.openRedisKeyDetail(key: key)
                                }
                            }
                        }
                        .padding(.horizontal, 7)
                        .padding(.vertical, 5)
                    }
                }

                if result.isTruncated {
                    Divider()
                    Text("Showing the first 10,000 keys. Use Flat mode to filter with SCAN.")
                        .font(.system(size: 10))
                        .foregroundStyle(.secondary)
                        .fixedSize(horizontal: false, vertical: true)
                        .padding(8)
                }
            }
        } else if let errorMessage = visibleErrorMessage {
            errorView(errorMessage)
                .frame(maxWidth: .infinity, maxHeight: .infinity)
        } else {
            ProgressView()
                .frame(maxWidth: .infinity, maxHeight: .infinity)
        }
    }

    private var flatContent: some View {
        VStack(spacing: 8) {
            Spacer()
            Image(systemName: "list.bullet.rectangle")
                .font(.system(size: 24))
                .foregroundStyle(.secondary)
            Text(appState.isRedisFlatKeyListOpen
                 ? "The existing Keys tab is open."
                 : "The Keys tab is closed.")
                .font(.system(size: 12, weight: .medium))
            Text(appState.isRedisFlatKeyListOpen
                 ? "Use its SCAN filter to narrow the flat key list."
                 : "Open it to use the SCAN filter for the flat key list.")
                .font(.system(size: 11))
                .foregroundStyle(.secondary)
                .multilineTextAlignment(.center)
            Button(appState.isRedisFlatKeyListOpen ? "Show Keys Tab" : "Open Keys Tab") {
                appState.openRedisFlatKeyList()
            }
            .controlSize(.small)
            Button("Show Tree") { mode = .tree }
                .controlSize(.small)
            Spacer()
        }
        .padding()
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }

    private func errorView(_ message: String) -> some View {
        VStack(spacing: 8) {
            Image(systemName: "exclamationmark.triangle")
                .foregroundStyle(.orange)
            Text(message)
                .font(.system(size: 11))
                .foregroundStyle(.secondary)
                .multilineTextAlignment(.center)
                .textSelection(.enabled)
            Button("Retry") { appState.requestRedisKeyBrowserRefresh() }
                .controlSize(.small)
        }
        .padding()
    }

    private func errorBanner(_ message: String) -> some View {
        HStack(spacing: 6) {
            Image(systemName: "exclamationmark.triangle.fill")
                .foregroundStyle(.orange)
            Text(message)
                .font(.system(size: 10))
                .foregroundStyle(.secondary)
                .lineLimit(2)
            Spacer()
            Button("Retry") { appState.requestRedisKeyBrowserRefresh() }
                .controlSize(.mini)
        }
        .padding(.horizontal, 8)
        .padding(.vertical, 5)
    }

    @MainActor
    private func scanKeys(
        capturedNonce: Int,
        context: RedisKeyBrowserContext
    ) async {
        await viewState.scan(
            in: context,
            isCurrent: {
                RedisKeyBrowserBehavior.shouldPublish(
                    capturedNonce: capturedNonce,
                    currentNonce: appState.redisKeyBrowserRefreshNonce,
                    isCancelled: Task.isCancelled
                ) && activeContext == context
            }
        ) {
            await appState.performRedisOperation(for: context) { redis in
                try await redis.scanKeyNames()
            }
        }
    }
}

private struct RedisKeyNamespaceNodeView: View {
    let node: RedisKeyNamespaceNode
    let openKey: (String) -> Void

    var body: some View {
        if node.children.isEmpty {
            leafRow
        } else {
            DisclosureGroup {
                ForEach(node.children) { child in
                    RedisKeyNamespaceNodeView(node: child, openKey: openKey)
                }
            } label: {
                namespaceRow
            }
        }
    }

    private var namespaceRow: some View {
        HStack(spacing: 5) {
            Image(systemName: "folder")
                .font(.system(size: 11))
                .foregroundStyle(.secondary)
            Text(RedisKeyNamespaceTree.displayLabel(for: node.segment))
                .font(.system(size: 12, design: .monospaced))
                .lineLimit(1)
            Spacer(minLength: 4)
            Text("\(node.descendantKeyCount)")
                .font(.system(size: 9, design: .monospaced))
                .foregroundStyle(.tertiary)
            if let concreteKey = node.concreteKey {
                Button {
                    openKey(concreteKey)
                } label: {
                    Image(systemName: "key.fill")
                        .font(.system(size: 9))
                        .frame(width: 18, height: 18)
                }
                .buttonStyle(.plain)
                .accessibilityLabel(Text(
                    RedisKeyBrowserBehavior.openKeyAccessibilityLabel(for: concreteKey)
                ))
                .help("Open key \(concreteKey)")
            }
        }
        .padding(.vertical, 2)
    }

    @ViewBuilder
    private var leafRow: some View {
        if let concreteKey = node.concreteKey {
            Button {
                openKey(concreteKey)
            } label: {
                HStack(spacing: 5) {
                    Image(systemName: "key")
                        .font(.system(size: 10))
                        .foregroundStyle(.secondary)
                    Text(RedisKeyNamespaceTree.displayLabel(for: node.segment))
                        .font(.system(size: 12, design: .monospaced))
                        .lineLimit(1)
                    Spacer()
                }
                .padding(.vertical, 3)
                .contentShape(Rectangle())
            }
            .buttonStyle(.plain)
            .accessibilityLabel(Text(
                RedisKeyBrowserBehavior.openKeyAccessibilityLabel(for: concreteKey)
            ))
            .help("Open key \(concreteKey)")
        } else {
            Text(RedisKeyNamespaceTree.displayLabel(for: node.segment))
                .font(.system(size: 12, design: .monospaced))
                .padding(.vertical, 3)
        }
    }
}