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++
6.5 KB
Raw Blame
// RedisAddKeySheet.swift
// Gridex
//
// Sheet for creating a new Redis key with type selection.

import SwiftUI

struct RedisAddKeySheet: View {
    @EnvironmentObject private var appState: AppState
    @Environment(\.dismiss) private var dismiss

    let redisContext: AppState.RedisTabContext

    @State private var keyName = ""
    @State private var keyType: RedisKeyType = .string
    @State private var ttlString = ""
    @State private var errorMessage: String?
    @State private var isCreating = false

    // String
    @State private var stringValue = ""
    // Hash
    @State private var hashFields: [(field: String, value: String)] = [("", "")]
    // List
    @State private var listItems: [String] = [""]
    // Set
    @State private var setMembers: [String] = [""]
    // ZSet
    @State private var zsetMembers: [(member: String, score: String)] = [("", "0")]

    var body: some View {
        VStack(spacing: 0) {
            Text("Add Key")
                .font(.system(size: 14, weight: .semibold))
                .padding(.top, 16)

            Form {
                TextField("Key", text: $keyName)

                Picker("Type", selection: $keyType) {
                    ForEach(RedisKeyType.allCases, id: \.self) { t in
                        Text(t.rawValue.uppercased()).tag(t)
                    }
                }

                switch keyType {
                case .string:
                    TextField("Value", text: $stringValue)
                case .hash:
                    hashFieldsEditor
                case .list:
                    listItemsEditor
                case .set:
                    setMembersEditor
                case .zset:
                    zsetMembersEditor
                }

                TextField("TTL (seconds, optional)", text: $ttlString)
            }
            .formStyle(.grouped)
            .scrollContentBackground(.hidden)

            if let err = errorMessage {
                Text(err).foregroundStyle(.red).font(.system(size: 11)).padding(.horizontal)
            }

            HStack {
                Button("Cancel") { dismiss() }
                    .keyboardShortcut(.cancelAction)
                Spacer()
                Button("Create") { createKey() }
                    .keyboardShortcut(.defaultAction)
                    .disabled(keyName.isEmpty || isCreating)
            }
            .padding()
        }
        .frame(width: 420)
    }

    // MARK: - Editors

    private var hashFieldsEditor: some View {
        Section("Fields") {
            ForEach(hashFields.indices, id: \.self) { i in
                HStack {
                    TextField("field", text: Binding(get: { hashFields[i].field }, set: { hashFields[i].field = $0 }))
                    TextField("value", text: Binding(get: { hashFields[i].value }, set: { hashFields[i].value = $0 }))
                    removeButton { hashFields.remove(at: i) }
                }
            }
            addButton { hashFields.append(("", "")) }
        }
    }

    private var listItemsEditor: some View {
        Section("Items") {
            ForEach(listItems.indices, id: \.self) { i in
                HStack {
                    TextField("item \(i)", text: Binding(get: { listItems[i] }, set: { listItems[i] = $0 }))
                    removeButton { listItems.remove(at: i) }
                }
            }
            addButton { listItems.append("") }
        }
    }

    private var setMembersEditor: some View {
        Section("Members") {
            ForEach(setMembers.indices, id: \.self) { i in
                HStack {
                    TextField("member", text: Binding(get: { setMembers[i] }, set: { setMembers[i] = $0 }))
                    removeButton { setMembers.remove(at: i) }
                }
            }
            addButton { setMembers.append("") }
        }
    }

    private var zsetMembersEditor: some View {
        Section("Members") {
            ForEach(zsetMembers.indices, id: \.self) { i in
                HStack {
                    TextField("member", text: Binding(get: { zsetMembers[i].member }, set: { zsetMembers[i].member = $0 }))
                    TextField("score", text: Binding(get: { zsetMembers[i].score }, set: { zsetMembers[i].score = $0 }))
                        .frame(width: 80)
                    removeButton { zsetMembers.remove(at: i) }
                }
            }
            addButton { zsetMembers.append(("", "0")) }
        }
    }

    private func addButton(action: @escaping () -> Void) -> some View {
        Button(action: action) {
            Label("Add", systemImage: "plus.circle")
                .font(.system(size: 12))
        }.buttonStyle(.plain)
    }

    private func removeButton(action: @escaping () -> Void) -> some View {
        Button(action: action) {
            Image(systemName: "minus.circle").foregroundStyle(.red)
        }.buttonStyle(.plain)
    }

    // MARK: - Create

    private func createKey() {
        isCreating = true
        errorMessage = nil

        let capturedKeyName = keyName
        let capturedKeyType = keyType
        let data: RedisKeyData
        switch capturedKeyType {
        case .string: data = .string(value: stringValue)
        case .hash: data = .hash(fields: hashFields.filter { !$0.field.isEmpty })
        case .list: data = .list(items: listItems.filter { !$0.isEmpty })
        case .set: data = .set(members: setMembers.filter { !$0.isEmpty })
        case .zset: data = .zset(members: zsetMembers.compactMap {
            guard !$0.member.isEmpty else { return nil }
            return (member: $0.member, score: Double($0.score) ?? 0)
        })
        }

        let ttl = Int(ttlString)
        Task {
            let result = await appState.performRedisOperation(for: redisContext) { redis in
                try await redis.redisInsertTyped(
                    key: capturedKeyName,
                    type: capturedKeyType,
                    data: data,
                    ttl: ttl
                )
            }
            switch result {
            case .success?:
                appState.requestRedisKeyBrowserRefresh()
                dismiss()
                NotificationCenter.default.post(name: .reloadData, object: nil)
            case .failure(let error)?:
                errorMessage = error.localizedDescription
                isCreating = false
            case nil:
                errorMessage = "The Redis connection or database changed. Reopen Add Key and try again."
                isCreating = false
            }
        }
    }
}