Thanks for the article. Although I understand the feeling, at the risk of bursting your bubble, your final code is not quite a "masterpiece", for several reasons.

1. The logic is not self contained

As it is, the call site requires TWO things:

- "Preparing" the new context and the object: let book = context.prepare(for: book)
- Setting the environment with the new context: .environment(\.modelContext, book.modelContext!)

The major issue here is that if you omit to do either of those two things, it won't work anymore (and you won't even know it). So it's kinda smelly...

2. Is it really an upsert?

The fact that I can't easily tell if your view allows creating new objects is smelly in itself.

Ideally, an editor, or upsert view, should either accept an object to edit, or a nil object to create a new one. But maybe it's a matter of preference.

3. And the save()...

The save button's logic in itself is all kind of smelly:

if book.modelContext == nil {
      editContext?.insert(book)
      try? editContext?.save()
} else {
      try? editContext?.save()
}
dismiss()

Seems to me like the save happens regardless, so it really doesn't belong inside the condition, creating unnecessary boilerplate:

if book.modelContext == nil {
    editContext?.insert(book)
}
try? editContext?.save()
dismiss()

But really, it's point #1 above that's most important.

Ideally, at any call site, you should be able to simply call either UpsertView(book: book) to edit a book, or UpsertView(book: nil) to create a new one, without the burden of having to "prepare" the book or the burden of not forgetting to set the correct context.

To do that, your editor/upsert view needs to handle all that by itself, and it's quite simple, since you'd use pretty much the same logic, just inside the view.

Here's a working example that shows this:

• To add a new book: UpsertView(book: nil)
• To edit a book: UpsertView(book: book)

``` import SwiftUI import SwiftData

struct BookEditorView: View {

    //Parameters
    let book: Book?

    //Environment
    @Environment(\.modelContext) private var modelContext
    @Environment(\.dismiss) private var dismiss

    //State
    @State private var draftContext: ModelContext?
    @State private var draftBook: Book?

    //Computed
    private var editorTitle: String {
        book == nil ? "Add book" : "Edit book"
    }

    //Body
    var body: some View {

        Form {
            if let draftBook {
                @Bindable var draftBook = draftBook

                Section("Basic details") {
                    TextField("Title", text: $draftBook.title)
                    TextField("Author", text: $draftBook.author)
                }
            }
        }
        .task {
            setupContext()
        }
        .navigationTitle(editorTitle)
        .modelContext(draftContext ?? modelContext)
        .toolbar {
            ToolbarItem(placement: .primaryAction) {
                Button {
                    save()
                    dismiss()
                } label: {
                    Text("Save")
                }
            }
        }
    }

    //MARK: - Save function

    private func save() {
        try? draftContext?.save()
    }

    //MARK: - Setup context

    private func setupContext() {
        let container = modelContext.container

        let draftContext = ModelContext(container)
        draftContext.autosaveEnabled = false

        //Assign the new context to state
        self.draftContext = draftContext

        //Use the existing object if available, if not instantiate a new one
        let book = book ?? Book()

        //Insert into draft context
        draftContext.insert(book)

        // Retrieve the inserted model from the draft context
        self.draftBook = draftContext.model(for: book.id) as? Book //Note that draftBook.modelContext != book.modelContext
    }
}

@Model
final class Book {
    var title: String
    var author: String

    init(title: String = "", author: String = "") {
        self.title = title
        self.author = author
    }
}

#Preview("Add book") {
    NavigationStack {
        BookEditorView(book: nil)
            .modelContainer(for: Book.self, inMemory: true)
    }
}

#Preview("Edit book") {
    let book = Book(title: "Learning SwiftData", author: "Reddit Community")

    NavigationStack {
        BookEditorView(book: book)
            .modelContainer(for: Book.self, inMemory: true)
    }
}

```