A Generic fetch request protocol that uses an Associated Type to send fetch requests through an Enum

FetchRequestGenerator.swift

import CoreData

let context = NSManagedObjectContext(concurrencyType: .mainQueueConcurrencyType)

class Book: NSManagedObject {
    var title: String?
    var author: Author?
    var date: Date?
}

class Author: NSManagedObject {
    var firstName: String?
    var lastName: String?
}


protocol FetchRequestGenerator {
    associatedtype fetchType: FetchRequestFromEnum
}

protocol FetchRequestFromEnum {
    func fetchRequest<T: NSManagedObject>() -> [T]
}

extension FetchRequestGenerator where Self: NSManagedObject {
    
    typealias T = Self.Type
    
    static func fetch<T: NSManagedObject>(_ fetchType: fetchType) -> [T] {
        return fetchType.fetchRequest()
    }
    
}


extension Book: FetchRequestGenerator {
    
    typealias fetchType = FetchType
    
    enum FetchType: FetchRequestFromEnum {
        
        case all
        case first
        case last
        case title(title: String)
        case byAuthor(Author)
        case fromInterval(DateInterval)
        case sortedAlphabetically
        
        func fetchRequest<T: NSManagedObject>() -> [T] {
            
            guard let request = T.fetchRequest() as? NSFetchRequest<T> else { return [] }
            
            ///default sort descriptor
            request.sortDescriptors = [NSSortDescriptor(key: "date", ascending: true)]
            
            switch self {
                
            case .all:
                break
                
            case .first:
                request.fetchLimit = 1
                request.sortDescriptors = [NSSortDescriptor(key: "date", ascending: false)]
                
            case .last:
                request.fetchLimit = 1
                
            case .title(let title):
                request.predicate = NSPredicate(format: "title = %@", title)
                
            case .byAuthor(let author):
                request.predicate = NSPredicate(format: "author = %@", author)
                
            case .fromInterval(let interval):
                request.predicate = NSPredicate(format: "date >= %@ && date <= %@",
                                        interval.start as CVarArg, interval.end as CVarArg)
                
            case .sortedAlphabetically:
                request.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
                
            }
            
            let result = try? context.fetch(request)
            return result!
            
        }
        
    }
    
}