CoreData Update Fetched Entity

[m-housh]

Forgive my ignorance with CoreData in general, but I'm playing around with the _CoreDataDependency and trying to determine how to update a Fetched item. I have tried several approaches, mainly the following...

struct TodoFeature: Reducer {
  struct State: Equatable {
     var todos: Todo.FetchedResults = .empty
  }

  Action: Equatable {
    ...
    case toggleComplete(todo: Fetched<Todo>)
  }

  @Dependency(\.persistentContainer) var persistentContainer;

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
       ...
       case .toggleComplete(todo: let todo):
          todo.withManagedObject { update in 
            update.complete.toggle()
            try! update.managedObjectContext!.save()
          }
         return .none
      }
      
    }
  }
}

This does not update the view / state, however if I shut the app down and restart it, the complete value is toggled. So I'm not sure if I need to invalidate the cached items that have been fetched, but calling my task that initially loads the todo's does not seem to update the todo's state either. Once again, forgive my ignorance in working with core data in general as it seems like there's something basic that I'm missing.

Here's the repository for more complete example.

https://github.com/m-housh/CoreData_Test

[tgrapperon]

Hey @m-housh! Thanks for reaching out. It looks like a bug to me. The fetched item should update its internal token and this should be spotted as an update. I'll check what's going on.

As an aside, persistentContainer.withContext{…} was more thought as a way to perform setup operation when the context is built. You should probably use the async withViewContext and withNewBackgroundContext instead, or directly fish the context out of the fetched item when possible:

case let .toggleComplete(todo: todo):
  return .run { _ in
    await todo.withManagedObject { update in
      update.complete.toggle()
      try! update.managedObjectContext?.save()
    }
  }

case .addTodoButtonTapped:
  return .run { _ in
    await persistentContainer.withNewBackgroundContext {
      let newTodo = Todo(context: $0)
      newTodo.title = "Finish CoreData"
      newTodo.id = uuid()
      try! $0.save()
    }
  }

[m-housh]

Thanks for the reply. The token property on a Fetched item is always nil in my scenario when I use the _printChanges on my reducer, it does seem to notice there was a change and call my didLoad(todos:_) method, but the states are the same. If that's helpful.

[tgrapperon]

Thanks! I need to have a look at what's going on. Likely the change is not observed or something like this or CoreData's side. There is a little "magic" involved because the objects are reference types, and they won't change when you update one of their value, so I'm setting a random token value that should mark the Fetched value as different. Or the object is captured at some point, making the observation unnoticed by SwiftUI.
I'll try to have a look as soon as possible.

[acosmicflamingo]

Ah, wish I saw this thread earlier lol

@tgrapperon it appears that although you have code that exists that sets a random token value, there's nothing that ever utilizes this functionality (in fact, every single mention of editor and fetched exists within the code block below), which is why token is always nil:

extension Fetched {
    //  public var view: View {
    //    get { .init(fetched: self) }
    //    set { self = newValue.fetched }
    //  }
    //
    //  @dynamicMemberLookup
    //  public struct View {
    //    var fetched: Fetched
    //
    //    public var editor: Editor {
    //      get { .init(fetched: self.fetched) }
    //      set { self.fetched = newValue.fetched }
    //    }
    //
    //    var context: NSManagedObjectContext { fetched.viewContext }
    //
    //    @MainActor
    //    public subscript<Value>(dynamicMember keyPath: WritableKeyPath<ManagedObject, Value>) -> Value {
    //      get { (self.fetched.viewContext.object(with: self.fetched.id) as! ManagedObject)[keyPath: keyPath] }
    //      set { }
    //    }
    //  }

    public var editor: Editor {
      get { .init(fetched: self) }
      set { self = newValue.fetched }
    }

    @dynamicMemberLookup
    public struct Editor {
      var fetched: Fetched

      var context: NSManagedObjectContext { fetched.viewContext }
      @MainActor
      public subscript<Value>(dynamicMember keyPath: WritableKeyPath<ManagedObject, Value>) -> Value
      {
        get {
          (self.fetched.viewContext.object(with: self.fetched.id) as! ManagedObject)[
            keyPath: keyPath]
        }
        set {
          var object = (self.fetched.viewContext.object(with: self.fetched.id) as! ManagedObject)
          object[keyPath: keyPath] = newValue
          self.fetched.token = .init()
          self.fetched.viewContext.processPendingChanges()
        }
      }
    }
  }

I was looking to see where token could be updated (the withManagedObject methods looked like candidates), but adding a mutating keyword to get this to work resulted in more compiler issues than I had hoped for. It also doesn't seem like I can touch token within the perform closure because this is where the state is mutated and not the value wrapper Fetched, so I don't even have access to the token property.

Was there in fact a place where the editor property was supposed to be used?