SwiftData, ModelContext, and working in a Reducer

[sbeitzel]

I'm trying to wrap my head around using SwiftData in an app (macOS) where I'm using SwiftData to persist all my models. For the most part, I've had no trouble, since querying for data is something that can be triggered inside a SwiftUI View, and there's no mutating side effect I need to worry about. However, I do want to control the creation of new model objects inside a Reducer's body method, and I've run into a problem I'm not sure how to handle.

• model objects need to be inserted into the ModelContext before they can be associated with one another
• a ModelContext is not @Sendable
• access (read/write) to a ModelContext has to happen on the main actor

So, I have a behavior, "generate a bunch of model objects that will be children of this other model object," and I want to run it in a reducer:

…
            case .generateAssignments:
                // clear any existing assignments
                state.selectedExchange.exchanges.removeAll()
                // try doing the generation
                let context = state.modelContext
                do {
                    let people = try people(in: context)
                    let assignments = try generateAssignments(for: state.selectedExchange,
                                            population: people,
                                            rules: state.exchangeRuleParams.rules,
                                            context: context)
                    // if successful, put the tuples into the exchange
                    state.selectedExchange.exchanges.append(contentsOf: assignments)
                    state.errorMessage = nil
                } catch ExchangeError.couldNotGenerate {
                    state.errorMessage = "Could not generate assignments after two tries."
                } catch ExchangeError.noCandidates {
                    state.errorMessage = "At least one person couldn't be matched on this go around."
                } catch {
                    state.errorMessage = "Error generating assignments: \(error.localizedDescription)"
                }
                return .none
…

So, this implementation won't compile, because my function people(in:) is marked as @MainActor because it runs a query to fetch all the Person model objects out of the ModelContext. Xcode points this out: Call to main actor-isolated global function 'people(in:)' in a synchronous nonisolated context.

I tried writing this as a .run Effect, but immediately ran into the problem that a ModelContext isn't @Sendable.

What's the right way to do this? Any ideas?

[bradhowes]

My own demo project works pretty much as you described. It creates a modelContext in the App as a dependency and then the rest of the code pretty much does like you have, with nothing special done to handle inserting a new record from inside a Reducer due to a button tap:

      case .addButtonTapped:
        let movieModel = db.add()
        return fetchMovies(movieModel.valueType, state: &state)

The db.add() resolves to a schema-specific function that does the dirty work:

  @discardableResult
  static func makeMock(context: ModelContext, entry: (title: String, cast: [String])) -> MovieModel {
    let movie = MovieModel(title: entry.0)
    context.insert(movie)

    let actors = entry.cast.map { fetchOrMakeActor(context, name: $0) }
    movie.actors = actors
    for actor in actors {
      actor.movies.append(movie)
    }

    try? context.save()

    return movie
  }

The fetchMovies call for updates the array of items so that it includes the new one:

  private func fetchMovies(_ movie: Movie?, state: inout State) -> Effect<Action> {
    @Dependency(\.database) var db
    state.movies = .init(uncheckedUniqueElements: db.fetchMovies(state.fetchDescriptor).map(\.valueType))
    if let movie {
      state.scrollTo = movie
    }
    return .none
  }

(this view is not using @Query in the view hence the need to update the collection, but another view in the app does use @Query)
I'm still learning how to integrate TCA and SwiftData but I'm now evaluating GRDB -- the demo app above has a 'grdb' branch which works pretty well with TCA. There is no @Model macro but the GRDB record definition comes close and so far has fewer surprises.