"'StateObject' requires that ' conform to 'ObservableObject'" when creating a dual entry (add/edit) form for Core Data without needing a ViewModel

Question

How do I create a dual entry (add/edit) form for Core Data without needing a ViewModel? If I have a Core Data entity named Scenario and am building a detail view to add or edit where I have a:

@StateObject var scenario: Scenario

but want it to support a nil value, so I can use it for an add as well as an update, but when I change it to:

@StateObject var scenario: Scenario?

I get this error:

Generic struct 'StateObject' requires that 'Scenario?' conform to 'ObservableObject'

I've watched this video by Paul Hudson, but it is just a simple read detail. Also this one is close as well, by Swift Arcade, but it's an edit and not an edit/add. I think for most demos, simple screens which have one attribute, such as "name", seem to be dominate.

In this core data video, Stewart Lynch has a dual form for add/edit, but he's using a ViewModel. I've seen a lot of content regarding not using View Models including this one, which seemed to make sense. Paul Hudson covers the MVVM topic as well.

My form is complex, with relationship records, so I don't want to create two separate forms, one for adding and one for editing.

I'm trying to keep it simple. Any help would be appreciated.

Answer 1

I'm doing editing like below, using a child context as a "scratch pad" for editing, to prevent edits that are cancelled from affecting the main context:

I'm using a child context like this:

    struct ItemEditorConfig: Identifiable {
        let id = UUID()
        let context: NSManagedObjectContext
        let item: Item
        
        init(viewContext: NSManagedObjectContext, objectID: NSManagedObjectID) {
            // create the scratch pad context
            context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)
            context.parent = viewContext
            // load the item into the scratch pad
            item = context.object(with: objectID) as! Item
        }
    }
    
    struct ItemEditor: View {
        @ObservedObject var item: Item // this is the scratch pad item
        @Environment(\.managedObjectContext) private var context
        @Environment(\.dismiss) private var dismiss // causes body to run
        let onSave: () -> Void
        @State var errorMessage: String?
        
        var body: some View {
            NavigationView {
                Form {
                    Text(item.timestamp!, formatter: itemFormatter)
                    if let errorMessage = errorMessage {
                        Text(errorMessage)
                    }
                    Button("Update Time") {
                        item.timestamp = Date()
                    }
                }
                .toolbar {
                    ToolbarItem(placement: .navigationBarLeading) {
                        Button("Cancel") {
                            dismiss()
                        }
                    }
                    ToolbarItem(placement: .navigationBarTrailing) {
                        Button("Save") {
                            // first save the scratch pad context then call the handler which will save the view context.
                            do {
                                try context.save()
                                errorMessage = nil
                                onSave()
                            } catch {
                                let nsError = error as NSError
                                errorMessage  = "Unresolved error \(nsError), \(nsError.userInfo)"
                            }
                        }
                    }
                }
            }
        }
    }

    struct EditItemButton: View {
        let itemObjectID: NSManagedObjectID
        @Environment(\.managedObjectContext) private var viewContext
        @State var itemEditorConfig: ItemEditorConfig?
        
        var body: some View {
            Button(action: edit) {
                Text("Edit")
            }
            .sheet(item: $itemEditorConfig, onDismiss: didDismiss) { config in
                ItemEditor(item: config.item) {
                    do {
                        try viewContext.save()
                    } catch {
                        // Replace this implementation with code to handle the error appropriately.
                        // fatalError() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
                        let nsError = error as NSError
                        fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
                    }
                    itemEditorConfig = nil // dismiss the sheet
                }
                .environment(\.managedObjectContext, config.context)
            }
        }
        
        func edit() {
            itemEditorConfig = ItemEditorConfig(viewContext: viewContext, objectID: itemObjectID)
        }
        
        func didDismiss() {
            // Handle the dismissing action.
        }
    }
    
    struct DetailView: View {
        @ObservedObject var item: Item
        
        var body: some View {
            Text("Item at \(item.timestamp!, formatter: itemFormatter)")
                .toolbar {
                    ToolbarItem(placement: .navigationBarTrailing) {
                        EditItemButton(itemObjectID: item.objectID)
                    }
                }
        }
    }

Answer 2

I followed the pattern in a post @loremipsum recommended, but adapted it so I would not have to incorporate a view model, which is a design decision (lots of debate on this but SwiftUI + Core Data can suffice for this example).

I added an object to the view:

@State var newScenario: Scenario? = nil

Added a sheet to view the new item:

        .sheet(item: $newScenario, onDismiss: {
            moc.rollback()
        }, content: { newItem in
            NavigationView{
                ScenarioDetailView(scenario: newItem)
            }
        })

A button to create it:

        .toolbar {
            ToolbarItemGroup (placement: .navigationBarTrailing) {
                Button {
                    createNewScenario()
                } label: {
                    
                    Image(systemName: "plus")
                }
                .padding()
            }
        }

and a function to create the new Scenario causing the sheet to display:

func createNewScenario() {
    var scenario = Scenario(context: moc)
    scenario.name = "New Scenario"
    newScenario = scenario
}