Merge branch 'feature/common_fixes' into 'master'

Feature/common fixes



See merge request !1

Author: Roman Kyrylenko

DBClient/Core/DBClient.swift

@@ -76,6 +76,13 @@ public protocol DBClient {
 }
 
 public extension DBClient {
+    
+  /// Fetch all entities from database
+  ///
+  /// - Returns: Task with array of objects
+  func fetchAll<T: Stored>() -> Task<[T]> {
+    return execute(FetchRequest())
+  }
 
   /**
     Finds first element with given value as primary.

DBClient/CoreData/CoreDataDBClient.swift

@@ -86,7 +86,7 @@ public class CoreDataDBClient {
 
       dict[NSUnderlyingErrorKey] = error as NSError
       let wrappedError = NSError(domain: "com.Yalantis.DBClient", code: 9999, userInfo: dict)
-      NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
+      print("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
       abort()
     }
 
@@ -105,6 +105,7 @@ public class CoreDataDBClient {
     context.parent = managedObjectContext
     context.perform {
       closure(context)
+      try? self.managedObjectContext.save()
     }
   }
 

DBClient/CoreData/CoreDataObservable.swift

@@ -30,6 +30,9 @@ class CoreDataObservable<T: Stored, U: NSManagedObject>: RequestObservable<T> {
       }
       if let sortDescriptor = request.sortDescriptor {
         fetchRequest.sortDescriptors = [sortDescriptor]
+      } else {
+        let defaultSortDescriptor = NSSortDescriptor(key: coreDataModelType.primaryKey, ascending: true)
+        fetchRequest.sortDescriptors = [defaultSortDescriptor]
       }
       fetchRequest.fetchLimit = request.fetchLimit
       fetchRequest.fetchOffset = request.fetchOffset
@@ -63,7 +66,7 @@ class CoreDataObservable<T: Stored, U: NSManagedObject>: RequestObservable<T> {
       closure(.initial(mapped))
       observer = closure
 
-      fetchedResultsControllerDelegate.observer = { change in
+      fetchedResultsControllerDelegate.observer = { [unowned self] change in
         if case .update(deletions: let deletions, insertions: let insertions, modifications: let modifications) = change {
           let mappedInsertions = insertions.map { ($0, coreDataModelType.from($1) as! T) }
           let mappedModifications = modifications.map { ($0, coreDataModelType.from($1) as! T) }
@@ -91,11 +94,11 @@ private class FetchedResultsControllerDelegate<T: NSManagedObject>: NSObject, NS
 
     switch type {
     case .delete:
-      batchChanges.append(.delete(indexPath![0], object))
+      batchChanges.append(.delete(indexPath!.row, object))
     case .insert:
-      batchChanges.append(.insert(newIndexPath![0], object))
+      batchChanges.append(.insert(newIndexPath!.row, object))
     case .update:
-      batchChanges.append(.update(indexPath![0], object))
+      batchChanges.append(.update(indexPath!.row, object))
     default: break
     }
   }

DBClient/Realm/RealmDBClient.swift

@@ -117,8 +117,7 @@ extension RealmDBClient: DBClient {
   }
 
   public func observable<T: Stored>(for request: FetchRequest<T>) -> RequestObservable<T>{
-//    return RealmObservable(request: request, realm: realm)
-    return RequestObservable(request: request)
+    return RealmObservable(request: request, realm: realm)
   }
 
 }
@@ -147,4 +146,5 @@ extension Results {
 
     return l
   }
+  
 }

DBClient/Realm/RealmObservable.swift

@@ -11,7 +11,7 @@ import RealmSwift
 
 extension Object: Stored {}
 
-public class RealmObservable<T: Object>: RequestObservable<T> {
+public class RealmObservable<T: Stored>: RequestObservable<T> {
 
   internal let realm: Realm
   internal var notificationToken: NotificationToken?
@@ -24,37 +24,38 @@ public class RealmObservable<T: Object>: RequestObservable<T> {
   open override func observe(_ closure: @escaping (ObservableChange<T>) -> Void) {
     precondition(notificationToken == nil, "Observable can be observed only once")
 
-    var realmObjects = realm.objects(T.self)
+    guard let realmModelType = T.self as? RealmModelConvertible.Type else  {
+      fatalError("RealmDBClient can manage only types which conform to RealmModelConvertible")
+    }
+    
+    var realmObjects = realm.objects(realmModelType.realmClass())
     if let predicate = request.predicate {
       realmObjects = realmObjects.filter(predicate)
     }
     if let sortDescriptor = request.sortDescriptor, let key = sortDescriptor.key {
       realmObjects = realmObjects.sorted(byProperty: key, ascending: sortDescriptor.ascending)
     }
 
-    notificationToken = realmObjects.addNotificationBlock { [unowned self] changes in
-      closure(self.map(changes))
+    notificationToken = realmObjects.addNotificationBlock { changes in
+      switch changes {
+      case .initial(let initial):
+        let mapped = initial.map { realmModelType.from($0) as! T }
+        closure(.initial(Array(mapped)))
+      
+      case .update(let objects, let deletions, let insertions, let modifications):
+        let mappedObjects = objects.map { realmModelType.from($0) as! T }
+        let insertions = insertions.map { (index: $0, element: mappedObjects[$0]) }
+        let modifications = modifications.map { (index: $0, element: mappedObjects[$0]) }
+        closure(.update(deletions: deletions, insertions: insertions, modifications: modifications))
+        
+      case .error(let error):
+        closure(.error(error))
+      }
     }
   }
 
   public func stopObserving() {
     notificationToken = nil
   }
 
-  fileprivate func map(_ realmChange: RealmCollectionChange<Results<T>>) -> ObservableChange<T> {
-    switch realmChange {
-    case .initial(let initial):
-      return .initial(Array(initial))
-      
-    case .update(let objects, let deletions, let insertions, let modifications):
-      let deletions = deletions.map { $0 }
-      let insertions = insertions.map { (index: $0, element: objects[$0]) }
-      let modifications = modifications.map { (index: $0, element: objects[$0]) }
-      return .update(deletions: deletions, insertions: insertions, modifications: modifications)
-      
-    case .error(let error):
-      return .error(error)
-    }
-  }
-  
 }