NSFetchedResultsController wrapper for SwiftUI view models

Although SwiftUI framework contains a @FetchRequest property wrapper, it is not possible to use it outside of SwiftUI views because it relies on accessing the managed object context from the view environment. While working on an CoreData based app which uses view models a lot within SwiftUI views, I ended up creating a wrapper class for making it easier to use NSFetchedResultsController. The wrapper class is named FetchedResultList and what it does internally is creating a NSFetchedResultsController instance, handling its delegate methods, and notifying about data changes through closures. Here is an example of a view model using the wrapper.

	@MainActor final class ViewModel: ObservableObject {
	private let list: FetchedResultList<Fruit>

	init(context: NSManagedObjectContext = PersistenceController.shared.container.viewContext) {
	list = FetchedResultList(context: context,
	sortDescriptors: [
	NSSortDescriptor(keyPath: \Fruit.name, ascending: true)
	])
	list.willChange = { [weak self] in self?.objectWillChange.send() }
	}

	var fruits: [Fruit] {
	list.items
	}

	@Published var searchText: String = "" {
	didSet {
	if searchText.isEmpty {
	list.predicate = nil
	}
	else {
	list.predicate = NSPredicate(format: "name contains[cd] %@", searchText)
	}
	}
	}
	}

view raw Fruits.swift hosted with ❤ by GitHub

The view model conforms to ObservableObject protocol and FetchedResultList provides a willChange closure which gets called when NSFetchedResultsController’s will change delegate is called. Calling the objectWillChange publisher will signal the SwiftUI view about the data change and the view gets re-rendered. The wrapper also supports updating predicate or sort descriptors dynamically. Here, we can see how setting a searchableText property from the view will update the predicate of the wrapper class. The SwiftUI view which uses the view model looks like this:

	struct FruitList: View {
	@StateObject var viewModel = ViewModel()

	var body: some View {
	NavigationStack {
	List(viewModel.fruits) { item in
	NavigationLink(item.name) {
	Text(verbatim: "Detail view for \(item.name)")
	}
	}
	.navigationTitle("Fruits")
	.searchable(text: $viewModel.searchText)
	}
	}
	}

view raw Fruits.swift hosted with ❤ by GitHub

Let’s take a look at how the wrapper class is implemented. The core logic around the wrapper is creating an instance of NSFetchedResultsController, allowing to reconfigure it dynamically, handling its delegate, and notifying changes through closures. Using closures instead of conforming to ObservableObject is a conscious choice since the main use case is using the wrapper class in view models or in other controllers, and it means that propagating the data change to a SwiftUI view needs to be done manually. It is shorter to call view model’s objectWillChange in a closure than republishing wrapper’s objectWillChange to view model’s objectWillChange. Moreover, it would make more sense to use SwiftUI provided property wrapper instead of this wrapper if we would want to handle CoreData fetching in the SwiftUI view’s implementation.

	@MainActor final class FetchedResultList<Result: NSManagedObject> {
	private let fetchedResultsController: NSFetchedResultsController<Result>
	private let observer: FetchedResultsObserver<Result>

	init(context: NSManagedObjectContext, filter: NSPredicate? = nil, sortDescriptors: [NSSortDescriptor]) {
	let request = NSFetchRequest<Result>(entityName: Result.entity().name ?? "<not set>")
	request.predicate = filter
	request.sortDescriptors = sortDescriptors.isEmpty ? nil : sortDescriptors
	fetchedResultsController = NSFetchedResultsController(fetchRequest: request, managedObjectContext: context, sectionNameKeyPath: nil, cacheName: nil)
	observer = FetchedResultsObserver(controller: fetchedResultsController)
	observer.willChange = { [unowned self] in self.willChange?() }
	observer.didChange = { [unowned self] in self.didChange?() }
	refresh()
	}

	private func refresh() {
	do {
	try fetchedResultsController.performFetch()
	}
	catch {
	Logger().error("Failed to load results")
	}
	}

	var items: [Result] {
	fetchedResultsController.fetchedObjects ?? []
	}

	var predicate: NSPredicate? {
	get {
	fetchedResultsController.fetchRequest.predicate
	}
	set {
	fetchedResultsController.fetchRequest.predicate = newValue
	refresh()
	}
	}

	var sortDescriptors: [NSSortDescriptor] {
	get {
	fetchedResultsController.fetchRequest.sortDescriptors ?? []
	}
	set {
	fetchedResultsController.fetchRequest.sortDescriptors = newValue.isEmpty ? nil : newValue
	refresh()
	}
	}

	var willChange: (() -> Void)?
	var didChange: (() -> Void)?
	}

view raw FetchedResultList.swift hosted with ❤ by GitHub

The wrapper class uses private FetchedResultsObserver class which must derive from NSObject because it implements NSFetchedResultsControllerDelegate methods. This approach allows keeping the FetchedResultList class a pure Swift class and not a NSObject subclass which I like to avoid in SwiftUI apps (just a personal preference).

	private final class FetchedResultsObserver<Result: NSManagedObject>: NSObject, NSFetchedResultsControllerDelegate {
	var willChange: () -> Void = {}
	var didChange: () -> Void = {}

	init(controller: NSFetchedResultsController<Result>) {
	super.init()
	controller.delegate = self
	}

	func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
	willChange()
	}

	func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
	didChange()
	}
	}