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++
20.7 KB
Raw Blame
// RedisKeyDetailView.swift
// Gridex
//
// Detailed view for a single Redis key — shows hash fields, list items, set members, etc.

import SwiftUI

@MainActor
final class RedisKeyDetailViewLifecycle: ObservableObject {
    private var generation: UInt64 = 0
    private var isActive = false

    func activate() {
        generation &+= 1
        isActive = true
    }

    func deactivate() {
        generation &+= 1
        isActive = false
    }

    @discardableResult
    func task(
        _ operation: @escaping @MainActor () async -> Void
    ) -> Task<Void, Never>? {
        guard isActive else { return nil }
        let capturedGeneration = generation

        return Task { @MainActor [weak self] in
            guard let self,
                  self.isActive,
                  self.generation == capturedGeneration else { return }
            await operation()
        }
    }
}

@MainActor
final class RedisKeyDetailViewState: ObservableObject {
    @Published private(set) var detail: RedisKeyDetail?
    @Published private(set) var isLoading = false
    @Published private(set) var isMutating = false
    @Published private(set) var errorMessage: String?

    private var activeContext: AppState.RedisTabContext?
    private let loadCoordinator = RedisRequestCoordinator()
    private let mutationCoordinator = RedisRequestCoordinator()

    func load(
        in context: AppState.RedisTabContext,
        execute: () async -> Result<RedisKeyDetail, Error>?
    ) async {
        transitionIfNeeded(to: context)
        isLoading = true
        errorMessage = nil

        let completion = await loadCoordinator.perform(
            for: context,
            execute: execute
        )

        switch completion {
        case .current(.success(let detail)):
            self.detail = detail
            errorMessage = nil
            isLoading = false
        case .current(.failure(let error)):
            errorMessage = error.localizedDescription
            isLoading = false
        case .stale:
            isLoading = false
        case .superseded:
            break
        }
    }

    @discardableResult
    func mutate(
        in context: AppState.RedisTabContext,
        execute: () async -> Result<RedisKeyDetail?, Error>?,
        onCurrentSuccess: () -> Void
    ) async -> Bool {
        transitionIfNeeded(to: context)
        isMutating = true
        errorMessage = nil

        let completion = await mutationCoordinator.perform(
            for: context,
            execute: execute
        )

        switch completion {
        case .current(.success(let detail)):
            if let detail {
                self.detail = detail
            }
            errorMessage = nil
            isMutating = false
            onCurrentSuccess()
            return true
        case .current(.failure(let error)):
            errorMessage = error.localizedDescription
            isMutating = false
            return false
        case .stale:
            isMutating = false
            return false
        case .superseded:
            return false
        }
    }

    func deactivate() {
        transitionIfNeeded(to: nil)
    }

    private func transitionIfNeeded(to context: AppState.RedisTabContext?) {
        guard activeContext != context else { return }
        activeContext = context
        loadCoordinator.invalidate()
        mutationCoordinator.invalidate()
        detail = nil
        errorMessage = nil
        isLoading = false
        isMutating = false
    }
}

struct RedisKeyDetailView: View {
    let keyName: String
    let redisContext: AppState.RedisTabContext?
    @EnvironmentObject private var appState: AppState
    @StateObject private var viewState = RedisKeyDetailViewState()
    @StateObject private var lifecycle = RedisKeyDetailViewLifecycle()

    // Editing
    @State private var showRename = false
    @State private var newKeyName = ""
    @State private var showTTLInput = false
    @State private var ttlInput = ""
    @State private var newFieldName = ""
    @State private var newFieldValue = ""

    private struct LoadRequest: Hashable {
        let keyName: String
        let context: AppState.RedisTabContext?
        let isActive: Bool
    }

    var body: some View {
        let loadRequest = LoadRequest(
            keyName: keyName,
            context: redisContext,
            isActive: isCapturedContextActive
        )

        return VStack(spacing: 0) {
            // Header
            headerBar
            Divider()

            if !isCapturedContextActive {
                contextMismatchView
            } else if viewState.isLoading {
                ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
            } else if let err = viewState.errorMessage {
                Text(err).foregroundStyle(.red).padding()
            } else if let detail = viewState.detail {
                detailContent(detail)
            }
        }
        .task(id: loadRequest) {
            guard !Task.isCancelled else { return }
            guard loadRequest.isActive,
                  let context = loadRequest.context else {
                lifecycle.deactivate()
                viewState.deactivate()
                return
            }
            lifecycle.activate()
            await loadDetail(in: context)
        }
        .onDisappear {
            lifecycle.deactivate()
            viewState.deactivate()
        }
    }

    // MARK: - Header

    private var headerBar: some View {
        HStack(spacing: 8) {
            Image(systemName: "key.fill")
                .foregroundStyle(.secondary)
            Text(keyName)
                .font(.system(size: 13, weight: .semibold, design: .monospaced))

            if let detail = viewState.detail {
                Text(detail.type.rawValue.uppercased())
                    .font(.system(size: 10, weight: .bold))
                    .padding(.horizontal, 6)
                    .padding(.vertical, 2)
                    .background(Color.accentColor.opacity(0.15))
                    .clipShape(RoundedRectangle(cornerRadius: 3))

                if let ttl = detail.ttl {
                    Text("TTL: \(ttl)s")
                        .font(.system(size: 11, design: .monospaced))
                        .foregroundStyle(.secondary)
                }

                if let mem = detail.memoryBytes {
                    Text(formatBytes(mem))
                        .font(.system(size: 11, design: .monospaced))
                        .foregroundStyle(.secondary)
                }
            }

            Spacer()

            Button("Set TTL") { showTTLInput = true }
                .font(.system(size: 11))
                .disabled(!isCapturedContextActive)
            Button("Rename") {
                newKeyName = keyName
                showRename = true
            }
            .font(.system(size: 11))
            .disabled(!isCapturedContextActive)
            Button {
                guard let context = redisContext else { return }
                startPresentedTask { await loadDetail(in: context) }
            } label: {
                Image(systemName: "arrow.clockwise").font(.system(size: 11))
            }
            .disabled(!isCapturedContextActive)
        }
        .padding(.horizontal, 12)
        .padding(.vertical, 8)
        .alert("Rename Key", isPresented: $showRename) {
            TextField("New name", text: $newKeyName)
            Button("Cancel", role: .cancel) {}
            Button("Rename") {
                guard let context = redisContext, !newKeyName.isEmpty else { return }
                let replacementName = newKeyName
                startPresentedTask {
                    await renameKey(
                        to: replacementName,
                        in: context
                    )
                }
            }
        }
        .alert("Set TTL", isPresented: $showTTLInput) {
            TextField("Seconds (0 = remove)", text: $ttlInput)
            Button("Cancel", role: .cancel) {}
            Button("Set") {
                guard let context = redisContext else { return }
                let seconds = Int(ttlInput) ?? 0
                startPresentedTask { await setTTL(seconds, in: context) }
            }
        }
    }

    // MARK: - Detail Content

    @ViewBuilder
    private func detailContent(_ d: RedisKeyDetail) -> some View {
        switch d.data {
        case .string(let value):
            stringView(value)
        case .hash(let fields):
            hashView(fields)
        case .list(let items):
            listView(items)
        case .set(let members):
            setView(members)
        case .zset(let members):
            zsetView(members)
        }
    }

    private func stringView(_ value: String) -> some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("Value").font(.system(size: 11, weight: .semibold)).foregroundStyle(.secondary)
            ScrollView {
                Text(value)
                    .font(.system(size: 12, design: .monospaced))
                    .textSelection(.enabled)
                    .frame(maxWidth: .infinity, alignment: .leading)
                    .padding(8)
            }
        }
        .padding()
    }

    private func hashView(_ fields: [(field: String, value: String)]) -> some View {
        VStack(spacing: 0) {
            HStack {
                Text("\(fields.count) fields").font(.system(size: 11)).foregroundStyle(.secondary)
                Spacer()
                HStack(spacing: 4) {
                    TextField("field", text: $newFieldName).frame(width: 100).textFieldStyle(.roundedBorder).font(.system(size: 11))
                    TextField("value", text: $newFieldValue).frame(width: 120).textFieldStyle(.roundedBorder).font(.system(size: 11))
                    Button("Add") {
                        guard let context = redisContext, !newFieldName.isEmpty else { return }
                        let field = newFieldName
                        let value = newFieldValue
                        startPresentedTask {
                            await mutateAndReload(in: context, operation: { redis in
                                try await redis.updateHashField(
                                    key: keyName,
                                    field: field,
                                    value: value
                                )
                            }, onCurrentSuccess: {
                                newFieldName = ""
                                newFieldValue = ""
                            })
                        }
                    }.font(.system(size: 11))
                }
            }
            .padding(.horizontal, 12).padding(.vertical, 6)

            tableGrid(headers: ["Field", "Value"], rows: fields.map { [$0.field, $0.value] }) { row in
                if let field = row.first {
                    Button("Delete Field") {
                        guard let context = redisContext else { return }
                        startPresentedTask {
                            await mutateAndReload(in: context) { redis in
                                try await redis.deleteHashField(
                                    key: keyName,
                                    field: field
                                )
                            }
                        }
                    }
                }
            }
        }
    }

    private func listView(_ items: [String]) -> some View {
        VStack(spacing: 0) {
            HStack {
                Text("\(items.count) items").font(.system(size: 11)).foregroundStyle(.secondary)
                Spacer()
            }.padding(.horizontal, 12).padding(.vertical, 6)

            tableGrid(headers: ["Index", "Value"], rows: items.enumerated().map { [String($0.offset), $0.element] })
        }
    }

    private func setView(_ members: [String]) -> some View {
        VStack(spacing: 0) {
            HStack {
                Text("\(members.count) members").font(.system(size: 11)).foregroundStyle(.secondary)
                Spacer()
                HStack(spacing: 4) {
                    TextField("member", text: $newFieldName).frame(width: 140).textFieldStyle(.roundedBorder).font(.system(size: 11))
                    Button("Add") {
                        guard let context = redisContext, !newFieldName.isEmpty else { return }
                        let member = newFieldName
                        startPresentedTask {
                            await mutateAndReload(in: context, operation: { redis in
                                try await redis.addSetMember(
                                    key: keyName,
                                    member: member
                                )
                            }, onCurrentSuccess: {
                                newFieldName = ""
                            })
                        }
                    }.font(.system(size: 11))
                }
            }.padding(.horizontal, 12).padding(.vertical, 6)

            tableGrid(headers: ["Member"], rows: members.map { [$0] }) { row in
                if let member = row.first {
                    Button("Remove") {
                        guard let context = redisContext else { return }
                        startPresentedTask {
                            await mutateAndReload(in: context) { redis in
                                try await redis.removeSetMember(
                                    key: keyName,
                                    member: member
                                )
                            }
                        }
                    }
                }
            }
        }
    }

    private func zsetView(_ members: [(member: String, score: Double)]) -> some View {
        VStack(spacing: 0) {
            HStack {
                Text("\(members.count) members").font(.system(size: 11)).foregroundStyle(.secondary)
                Spacer()
                HStack(spacing: 4) {
                    TextField("member", text: $newFieldName).frame(width: 100).textFieldStyle(.roundedBorder).font(.system(size: 11))
                    TextField("score", text: $newFieldValue).frame(width: 60).textFieldStyle(.roundedBorder).font(.system(size: 11))
                    Button("Add") {
                        guard let context = redisContext, !newFieldName.isEmpty else { return }
                        let member = newFieldName
                        let score = Double(newFieldValue) ?? 0
                        startPresentedTask {
                            await mutateAndReload(in: context, operation: { redis in
                                try await redis.addZSetMember(
                                    key: keyName,
                                    member: member,
                                    score: score
                                )
                            }, onCurrentSuccess: {
                                newFieldName = ""
                                newFieldValue = ""
                            })
                        }
                    }.font(.system(size: 11))
                }
            }.padding(.horizontal, 12).padding(.vertical, 6)

            tableGrid(headers: ["Member", "Score"], rows: members.map { [$0.member, String($0.score)] }) { row in
                if let member = row.first {
                    Button("Remove") {
                        guard let context = redisContext else { return }
                        startPresentedTask {
                            await mutateAndReload(in: context) { redis in
                                try await redis.removeZSetMember(
                                    key: keyName,
                                    member: member
                                )
                            }
                        }
                    }
                }
            }
        }
    }

    // MARK: - Reusable Table Grid

    private func tableGrid(headers: [String], rows: [[String]], @ViewBuilder contextMenuBuilder: @escaping ([String]) -> some View = { _ in EmptyView() }) -> some View {
        ScrollView {
            LazyVStack(spacing: 0) {
                HStack(spacing: 0) {
                    ForEach(headers, id: \.self) { h in
                        Text(h)
                            .font(.system(size: 11, weight: .semibold))
                            .foregroundStyle(.secondary)
                            .frame(maxWidth: .infinity, alignment: .leading)
                            .padding(.horizontal, 8)
                            .padding(.vertical, 4)
                    }
                }
                .background(Color(nsColor: .controlBackgroundColor))
                Divider()

                ForEach(Array(rows.enumerated()), id: \.offset) { _, row in
                    HStack(spacing: 0) {
                        ForEach(Array(row.enumerated()), id: \.offset) { _, cell in
                            Text(cell)
                                .font(.system(size: 12, design: .monospaced))
                                .lineLimit(3)
                                .textSelection(.enabled)
                                .frame(maxWidth: .infinity, alignment: .leading)
                                .padding(.horizontal, 8)
                                .padding(.vertical, 3)
                        }
                    }
                    .contextMenu {
                        contextMenuBuilder(row)
                        Button("Copy") {
                            NSPasteboard.general.clearContents()
                            NSPasteboard.general.setString(row.joined(separator: "\t"), forType: .string)
                        }
                    }
                    Divider()
                }
            }
        }
    }

    // MARK: - Actions

    private var isCapturedContextActive: Bool {
        guard let redisContext else { return false }
        return appState.activeRedisAdapter(for: redisContext) != nil
    }

    private var contextMismatchView: some View {
        VStack(spacing: 8) {
            Image(systemName: "exclamationmark.triangle")
                .foregroundStyle(.orange)
            Text("This key belongs to another Redis connection or database.")
                .font(.system(size: 12, weight: .medium))
            Text("Reopen it from the current Redis key browser to continue.")
                .font(.system(size: 11))
                .foregroundStyle(.secondary)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }

    private func startPresentedTask(
        _ operation: @escaping @MainActor () async -> Void
    ) {
        lifecycle.task(operation)
    }

    private func loadDetail(in context: AppState.RedisTabContext) async {
        await viewState.load(in: context) {
            await appState.performRedisOperation(for: context) { redis in
                try await redis.fetchKeyDetail(key: keyName)
            }
        }
    }

    private func renameKey(
        to replacementName: String,
        in context: AppState.RedisTabContext
    ) async {
        await viewState.mutate(
            in: context,
            execute: {
                await appState.performRedisOperation(for: context) { redis -> RedisKeyDetail? in
                    try await redis.renameKey(
                        oldName: keyName,
                        newName: replacementName
                    )
                    return nil
                }
            },
            onCurrentSuccess: {
                newKeyName = ""
                NotificationCenter.default.post(name: .reloadData, object: nil)
            }
        )
    }

    private func setTTL(
        _ seconds: Int,
        in context: AppState.RedisTabContext
    ) async {
        await mutateAndReload(in: context, operation: { redis in
            if seconds <= 0 {
                try await redis.removeTTL(key: keyName)
            } else {
                try await redis.setTTL(key: keyName, seconds: seconds)
            }
        }, onCurrentSuccess: {
            ttlInput = ""
        })
    }

    private func mutateAndReload(
        in context: AppState.RedisTabContext,
        operation: (RedisAdapter) async throws -> Void,
        onCurrentSuccess: () -> Void = {}
    ) async {
        await viewState.mutate(
            in: context,
            execute: {
                await appState.performRedisOperation(for: context) { redis -> RedisKeyDetail? in
                    try await operation(redis)
                    return try await redis.fetchKeyDetail(key: keyName)
                }
            },
            onCurrentSuccess: onCurrentSuccess
        )
    }

    private func formatBytes(_ bytes: Int) -> String {
        if bytes < 1024 { return "\(bytes) B" }
        if bytes < 1024 * 1024 { return String(format: "%.1f KB", Double(bytes) / 1024) }
        return String(format: "%.1f MB", Double(bytes) / 1024 / 1024)
    }
}