Swift-Combine-CoreData-Fetched-Results-Publisher

FetchedResultsPublisher.swift

import Combine
import CoreData

public final class FetchedResultsPublisher<ResultType>: Publisher where ResultType: NSFetchRequestResult {
  
  public init(request: NSFetchRequest<ResultType>, context: NSManagedObjectContext) {
    self.request = request
    self.context = context
  }
  
  let request: NSFetchRequest<ResultType>
  let context: NSManagedObjectContext
  
  // MARK: - Publisher
  
  public typealias Output = [ResultType]
  public typealias Failure = NSError
  
  public func receive<S>(subscriber: S) where S: Subscriber, S.Failure == Failure, S.Input == Output {
    subscriber.receive(subscription: FetchedResultsSubscription(
      subscriber: subscriber,
      request: request,
      context: context
    ))
  }
  
}

final class FetchedResultsSubscription<SubscriberType, ResultType>: NSObject, Subscription, NSFetchedResultsControllerDelegate where SubscriberType: Subscriber, SubscriberType.Input == [ResultType], SubscriberType.Failure == NSError, ResultType: NSFetchRequestResult {
  
  init(subscriber: SubscriberType, request: NSFetchRequest<ResultType>, context: NSManagedObjectContext) {
    self.subscriber = subscriber
    self.request = request
    self.context = context
  }
  
  private(set) var subscriber: SubscriberType?
  private(set) var request: NSFetchRequest<ResultType>?
  private(set) var context: NSManagedObjectContext?
  private(set) var controller: NSFetchedResultsController<ResultType>?
  
  // MARK: - Subscription
  
  func request(_ demand: Subscribers.Demand) {
    guard demand > 0,
          let subscriber = subscriber,
          let request = request,
          let context = context else { return }
    
    controller = NSFetchedResultsController(
      fetchRequest: request,
      managedObjectContext: context,
      sectionNameKeyPath: nil,
      cacheName: nil
    )
    controller?.delegate = self
    
    do {
      try controller?.performFetch()
      if let fetchedObjects = controller?.fetchedObjects {
        _ = subscriber.receive(fetchedObjects)
      }
    } catch {
      subscriber.receive(completion: .failure(error as NSError))
    }
  }
  
  // MARK: - Cancellable
  
  func cancel() {
    subscriber = nil
    controller = nil
    request = nil
    context = nil
  }
  
  // MARK: - NSFetchedResultsControllerDelegate
  
  func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
    guard let subscriber = subscriber,
          controller == self.controller else { return }
    
    if let fetchedObjects = self.controller?.fetchedObjects {
      _ = subscriber.receive(fetchedObjects)
    }
  }
  
}