crossmate

RecordEditorView.swift (8866B)

---

 import CloudKit
 import SwiftUI
 
 /// In-app substitute for CloudKit Console for accounts that lack developer
 /// console access. Fetches a record by `(scope, zone, owner, recordName)`,
 /// displays its fields, allows editing String fields and adding new String
 /// fields, and saves back via the CKDatabase API. Non-String fields are shown
 /// read-only — extend the type dispatch below if a future migration needs to
 /// edit numbers, dates, etc.
 struct RecordEditorView: View {
     @Environment(\.syncEngine) private var syncEngine
 
     @State private var scope: CKDatabase.Scope = .private
     @State private var zoneName: String = ""
     @State private var ownerName: String = ""
     @State private var recordName: String = ""
 
     @State private var record: CKRecord?
     @State private var stringEdits: [String: String] = [:]
     @State private var newFieldName: String = ""
     @State private var newFieldValue: String = ""
 
     @State private var status: String = ""
     @State private var isWorking: Bool = false
 
     var body: some View {
         Form {
             Section("Lookup") {
                 Picker("Scope", selection: $scope) {
                     Text("Private").tag(CKDatabase.Scope.private)
                     Text("Shared").tag(CKDatabase.Scope.shared)
                 }
                 .pickerStyle(.segmented)
                 plainField("Zone name", text: $zoneName)
                 plainField("Owner (blank = self)", text: $ownerName)
                 plainField("Record name", text: $recordName)
                 Button {
                     Task { await fetch() }
                 } label: {
                     HStack {
                         Text("Fetch")
                         if isWorking {
                             Spacer()
                             ProgressView()
                         }
                     }
                 }
                 .disabled(isWorking || zoneName.isEmpty || recordName.isEmpty)
             }
 
             if let record {
                 Section("Fields") {
                     let keys = record.allKeys().sorted()
                     if keys.isEmpty {
                         Text("(no fields)").foregroundStyle(.secondary)
                     } else {
                         ForEach(keys, id: \.self) { key in
                             FieldRow(
                                 key: key,
                                 value: record[key],
                                 stringBinding: stringBinding(for: key, in: record)
                             )
                         }
                     }
                 }
 
                 Section("Add string field") {
                     plainField("Name", text: $newFieldName)
                     plainField("Value", text: $newFieldValue)
                 }
 
                 Section("Metadata") {
                     metaRow("Type", record.recordType)
                     metaRow("Zone", record.recordID.zoneID.zoneName)
                     metaRow("Owner", record.recordID.zoneID.ownerName)
                     if let mod = record.modificationDate {
                         metaRow("Modified", ISO8601DateFormatter().string(from: mod))
                     }
                     if let tag = record.recordChangeTag {
                         metaRow("ChangeTag", tag)
                     }
                 }
 
                 Section {
                     Button("Save changes") {
                         Task { await save() }
                     }
                     .disabled(isWorking || !hasPendingEdits)
                 }
             }
 
             if !status.isEmpty {
                 Section("Status") {
                     Text(status)
                         .font(.body.monospaced())
                         .textSelection(.enabled)
                 }
             }
         }
         .navigationTitle("Record Editor")
         .navigationBarTitleDisplayMode(.inline)
     }
 
     // MARK: - Subviews
 
     @ViewBuilder
     private func plainField(_ placeholder: String, text: Binding<String>) -> some View {
         TextField(placeholder, text: text)
             .textInputAutocapitalization(.never)
             .autocorrectionDisabled()
             .font(.body.monospaced())
     }
 
     @ViewBuilder
     private func metaRow(_ title: String, _ value: String) -> some View {
         VStack(alignment: .leading, spacing: 2) {
             Text(title).font(.caption).foregroundStyle(.secondary)
             Text(value).font(.caption.monospaced()).textSelection(.enabled)
         }
     }
 
     // MARK: - Bindings / state
 
     private var hasPendingEdits: Bool {
         !stringEdits.isEmpty || !newFieldName.isEmpty
     }
 
     private func stringBinding(for key: String, in record: CKRecord) -> Binding<String>? {
         guard record[key] is String else { return nil }
         return Binding(
             get: { stringEdits[key] ?? (record[key] as? String) ?? "" },
             set: { stringEdits[key] = $0 }
         )
     }
 
     // MARK: - Actions
 
     private func fetch() async {
         guard let syncEngine else { return }
         isWorking = true
         defer { isWorking = false }
         status = "Fetching…"
         do {
             let owner = ownerName.isEmpty ? CKCurrentUserDefaultName : ownerName
             let zoneID = CKRecordZone.ID(zoneName: zoneName, ownerName: owner)
             let recordID = CKRecord.ID(recordName: recordName, zoneID: zoneID)
             let fetched = try await syncEngine.fetchRecordForEdit(
                 scope: scope,
                 recordID: recordID
             )
             record = fetched
             stringEdits = [:]
             newFieldName = ""
             newFieldValue = ""
             status = "Fetched."
         } catch {
             record = nil
             status = describe(error)
         }
     }
 
     private func save() async {
         guard let syncEngine, let record else { return }
         isWorking = true
         defer { isWorking = false }
         status = "Saving…"
 
         for (key, value) in stringEdits {
             record[key] = value.isEmpty ? nil : (value as CKRecordValue)
         }
         let trimmedNewName = newFieldName.trimmingCharacters(in: .whitespaces)
         if !trimmedNewName.isEmpty {
             record[trimmedNewName] = newFieldValue.isEmpty
                 ? nil
                 : (newFieldValue as CKRecordValue)
         }
 
         do {
             let saved = try await syncEngine.saveRecordForEdit(scope: scope, record: record)
             self.record = saved
             stringEdits = [:]
             newFieldName = ""
             newFieldValue = ""
             status = "Saved."
         } catch {
             status = describe(error)
         }
     }
 
     private func describe(_ error: Error) -> String {
         let nsError = error as NSError
         return "Error: domain=\(nsError.domain) code=\(nsError.code) — \(nsError.localizedDescription)"
     }
 }
 
 private struct FieldRow: View {
     let key: String
     let value: CKRecordValue?
     let stringBinding: Binding<String>?
 
     var body: some View {
         VStack(alignment: .leading, spacing: 4) {
             HStack {
                 Text(key).font(.caption.bold())
                 Spacer()
                 Text(typeName).font(.caption2).foregroundStyle(.secondary)
             }
             if let stringBinding {
                 TextField("", text: stringBinding, axis: .vertical)
                     .font(.body.monospaced())
                     .textInputAutocapitalization(.never)
                     .autocorrectionDisabled()
             } else {
                 Text(displayValue)
                     .font(.body.monospaced())
                     .textSelection(.enabled)
                     .foregroundStyle(.secondary)
             }
         }
     }
 
     private var typeName: String {
         guard let value else { return "nil" }
         if value is String { return "String" }
         if value is Date { return "Date" }
         if value is Data { return "Data" }
         if value is CKAsset { return "Asset" }
         if value is CKRecord.Reference { return "Reference" }
         if value is [Any] { return "Array" }
         if value is NSNumber { return "Number" }
         return String(describing: type(of: value))
     }
 
     private var displayValue: String {
         guard let value else { return "(nil)" }
         if let s = value as? String { return s }
         if let d = value as? Date { return ISO8601DateFormatter().string(from: d) }
         if let data = value as? Data { return "\(data.count) bytes" }
         if let asset = value as? CKAsset {
             return "asset(\(asset.fileURL?.lastPathComponent ?? "?"))"
         }
         if let ref = value as? CKRecord.Reference {
             return "ref(\(ref.recordID.recordName))"
         }
         if let arr = value as? [Any] { return "[\(arr.count) items]" }
         return "\(value)"
     }
 }