CloudKit in SwiftUI

import CloudKit

// Theoretical example of creating a record
let noteRecord = CKRecord(recordType: "Note")
noteRecord["title"] = "My first note"
noteRecord["content"] = "Learning CloudKit in SwiftUI"

import Foundation
import CloudKit

// Data model for our app
struct Note: Identifiable {
    let id: String
    let title: String
    let content: String
    let record: CKRecord // We keep the original reference to update/delete it later
}

@MainActor
class CloudKitManager: ObservableObject {
    @Published var notes: [Note] = []
    @Published var isLoading: Bool = false
    @Published var errorMessage: String? = nil
    
    // Access the user's PRIVATE database in our container
    private let database = CKContainer(identifier: "iCloud.com.yourcompany.yourapp").privateCloudDatabase
    
    // MARK: - Fetch Data
    func fetchNotes() async {
        isLoading = true
        errorMessage = nil
        
        // Create a query that returns all records of type "Note"
        let query = CKQuery(recordType: "Note", predicate: NSPredicate(value: true))
        
        // Sort by creation date (newest to oldest)
        query.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
        
        do {
            // Perform the asynchronous request to CloudKit
            let (matchResults, _) = try await database.records(matching: query)
            
            var fetchedNotes: [Note] = []
            
            for (_, recordResult) in matchResults {
                switch recordResult {
                case .success(let record):
                    if let title = record["title"] as? String,
                       let content = record["content"] as? String {
                        
                        let note = Note(id: record.recordID.recordName, title: title, content: content, record: record)
                        fetchedNotes.append(note)
                    }
                case .failure(let error):
                    print("Error reading a specific record: \(error)")
                }
            }
            
            self.notes = fetchedNotes
            
        } catch {
            self.errorMessage = "iCloud connection error: \(error.localizedDescription)"
        }
        
        isLoading = false
    }
    
    // MARK: - Save Data
    func addNote(title: String, content: String) async {
        let newRecord = CKRecord(recordType: "Note")
        newRecord["title"] = title
        newRecord["content"] = content
        
        do {
            let savedRecord = try await database.save(newRecord)
            let newNote = Note(id: savedRecord.recordID.recordName, title: title, content: content, record: savedRecord)
            
            // Update the UI by adding the note to the top of the list
            self.notes.insert(newNote, at: 0)
            
        } catch {
            self.errorMessage = "Could not save the note to iCloud."
        }
    }
    
    // MARK: - Delete Data
    func deleteNote(at offsets: IndexSet) async {
        for index in offsets {
            let noteToDelete = notes[index]
            do {
                try await database.deleteRecord(withID: noteToDelete.record.recordID)
                self.notes.remove(at: index)
            } catch {
                self.errorMessage = "Error deleting the note."
            }
        }
    }
}

import SwiftUI

struct ContentView: View {
    @StateObject private var cloudKitManager = CloudKitManager()
    @State private var showingAddNote = false
    
    var body: some View {
        NavigationView {
            ZStack {
                // Notes List
                List {
                    ForEach(cloudKitManager.notes) { note in
                        VStack(alignment: .leading, spacing: 4) {
                            Text(note.title)
                                .font(.headline)
                            Text(note.content)
                                .font(.subheadline)
                                .foregroundColor(.secondary)
                                .lineLimit(2)
                        }
                        .padding(.vertical, 4)
                    }
                    .onDelete { indexSet in
                        Task {
                            await cloudKitManager.deleteNote(at: indexSet)
                        }
                    }
                }
                .listStyle(InsetGroupedListStyle())
                
                // Error Message
                if let errorMessage = cloudKitManager.errorMessage {
                    VStack {
                        Text("⚠️")
                            .font(.largeTitle)
                        Text(errorMessage)
                            .multilineTextAlignment(.center)
                            .padding()
                    }
                    .background(Color(.systemBackground).opacity(0.9))
                    .cornerRadius(10)
                    .padding()
                }
                
                // Loading Indicator
                if cloudKitManager.isLoading {
                    ProgressView("Syncing with iCloud...")
                        .padding()
                        .background(Color(.systemBackground))
                        .cornerRadius(10)
                        .shadow(radius: 10)
                }
            }
            .navigationTitle("My Cloud Notes")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showingAddNote = true }) {
                        Image(systemName: "plus")
                    }
                }
                ToolbarItem(placement: .navigationBarLeading) {
                    Button(action: {
                        Task {
                            await cloudKitManager.fetchNotes()
                        }
                    }) {
                        Image(systemName: "arrow.clockwise")
                    }
                }
            }
            .sheet(isPresented: $showingAddNote) {
                AddNoteView(cloudKitManager: cloudKitManager)
            }
            .task {
                // Automatically fetch notes when opening the app
                await cloudKitManager.fetchNotes()
            }
        }
    }
}

// Sub-view to add a new note
struct AddNoteView: View {
    @Environment(\.presentationMode) var presentationMode
    @ObservedObject var cloudKitManager: CloudKitManager
    
    @State private var title = ""
    @State private var content = ""
    @State private var isSaving = false
    
    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("Note details")) {
                    TextField("Title", text: $title)
                    TextEditor(text: $content)
                        .frame(height: 150)
                }
            }
            .navigationTitle("New Note")
            .navigationBarItems(
                leading: Button("Cancel") {
                    presentationMode.wrappedValue.dismiss()
                },
                trailing: Button("Save") {
                    Task {
                        isSaving = true
                        await cloudKitManager.addNote(title: title, content: content)
                        isSaving = false
                        presentationMode.wrappedValue.dismiss()
                    }
                }
                .disabled(title.isEmpty || isSaving)
            )
            .overlay(
                isSaving ? ProgressView().scaleEffect(1.5) : nil
            )
        }
    }
}