One solution could be to actually call save() and then have a manual rollback function that when called would delete the object with a given id. That way you could hopefully avoid creating strong dependencies between your services (actors). Of course if there are cases that are more complicated than the one in your code that returns a single id a solution like this could easily become quite complex so it depends on your use case if this is doable.

Use an Array instead of a Set in your model, use Date instead of DateComponents as the element type. If using an array gives you warnings in the console similar to CoreData: fault: Could not materialize Objective-C class named "Array" from declared attribute value type "Array" of attribute named ... then you can wrap the Date property in a Codable structure and use that as a type struct ToDoDate: Codable { let date: Date } In model: var dates: [ToDoDate] = []

My guess is that this is because SQLite only support 64 bit integers so it won't work "out of the box" but require some extra work to store this type

But if you don’t like a movie anymore should a Friend or Movie really be deleted then, isn’t it the relationship that should be deleted/removed? Think about it…

How do you know T.ModelType has a property recordName?

I am pretty sure OP meant this particular sort descriptor

It makes no sense to sort against handlers.first (or at all against a to-many relationship) so I would remove this requirement

This seems like expected behavior to me and not a bug.

It could be an issue with how you handle ModelContainer in your code or possibly how you handle your ModelContext object(s)

It would help if you provided a more complete code sample. For instance what is in that where condition?

There's a lot I don't understand about your question like what Reporter really is, how the ModelActor comes into play and what you mean with the last paragraph about the fetchAll method (did you write a "not" to much?) but one issue I see in your code is that you are passing PersistentModel objects from the detached Task to the UI which means you are passing them across actor boundaries and that is something you should not do since they are not conforming to Sendable. (Which swift version are you using and do you have any concurrency checking set?) This makes the whole solution look flawed and I would suggest that you instead fetch your objects on the MainActor using a @Query instead.

Why don't you use the @ModelActor macro instead? @ModelActor actor ConcurrentDatabase { private func save() { if self.modelContext.hasChanges { do { try self.modelContext.save() } catch { ... } } } }

Is this for a released app or only local in Xcode?

A migration is probably the best solution but if you don't want to do that you could use a custom decoding for the enum extension Kind { init(from decoder: any Decoder) throws { let container = try decoder.singleValueContainer() let rawValue = try container.decode(String.self) if let kind = Kind(rawValue: rawValue) { self = kind } else { let oldValue = rawValue.capitalized // <-- You might need to adjust this depending on how the rest of the enum looks. guard let kind = Kind(rawValue: oldValue) else { throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "Unknow kind: \(oldValue)")) } self = kind } } } Note that this will fix the value when read from storage but to actually store the new value, "Credit", each objects will need to be saved until it's persisted.

If you create a Color.Resolved value in a playground and encodes it you see you get an array of doubles rather than a structure with RGB properties and the error clearly states that an array (keyless container) is not supported. So I guess the conclusion is that Color.Resolved isn't supported by SwiftData. My playground test code and output let color = Color.red var resolvedColor: Color.Resolved resolvedColor = color.resolve(in: EnvironmentValues()) let data = try! JSONEncoder().encode(resolvedColor) print(String(data: data, encoding: .utf8)!) [1,0.23137254,0.18823528,1]