Add UnmanagedReadOnly protocol for read and fetch

add-unmanaged-read-only-model-protocol

Author: roanutil

Sources/CoreDataRepository/Internal/FetchSubscription.swift

@@ -10,7 +10,7 @@ import CoreData
 import Foundation
 
 /// Subscription provider that sends updates when a fetch request changes
-final class FetchSubscription<Model: UnmanagedModel>: Subscription<
+final class FetchSubscription<Model: UnmanagedReadOnlyModel>: Subscription<
     [Model],
     Model.ManagedModel,
     Model.ManagedModel

Sources/CoreDataRepository/Internal/FetchThrowingSubscription.swift

@@ -10,7 +10,7 @@ import CoreData
 import Foundation
 
 /// Subscription provider that sends updates when a fetch request changes
-final class FetchThrowingSubscription<Model: UnmanagedModel>: ThrowingSubscription<
+final class FetchThrowingSubscription<Model: UnmanagedReadOnlyModel>: ThrowingSubscription<
     [Model],
     Model.ManagedModel,
     Model.ManagedModel

Sources/CoreDataRepository/Internal/ReadSubscription.swift

@@ -11,7 +11,7 @@ import CoreData
 import Foundation
 
 /// Subscription provider that sends updates when a single ``NSManagedObject`` changes
-final class ReadSubscription<Model: UnmanagedModel> {
+final class ReadSubscription<Model: UnmanagedReadOnlyModel> {
     private let objectId: NSManagedObjectID
     private let context: NSManagedObjectContext
     private var cancellables: Set<AnyCancellable>

Sources/CoreDataRepository/Internal/ReadThrowingSubscription.swift

@@ -10,7 +10,7 @@ import Combine
 import CoreData
 import Foundation
 
-final class ReadThrowingSubscription<Model: UnmanagedModel> {
+final class ReadThrowingSubscription<Model: UnmanagedReadOnlyModel> {
     private let objectId: NSManagedObjectID
     private let context: NSManagedObjectContext
     private var cancellables: Set<AnyCancellable>

Sources/CoreDataRepository/UnmanagedModel.swift

@@ -9,11 +9,8 @@
 import CoreData
 import Foundation
 
-/// A protocol for a value type that corresponds to a ``NSManagedObject`` subclass
-public protocol UnmanagedModel: Equatable {
-    /// The ``NSManagedObject`` subclass `Self` corresponds to
-    associatedtype ManagedModel: NSManagedObject
-
+/// Protocol for a value type that corresponds to a ``NSManagedObject`` subclass
+public protocol UnmanagedModel: UnmanagedReadOnlyModel {
     /// URL representation of the ``ManagedModel``'s ``NSManagedObjectID``
     ///
     /// A `nil` value should mean that this instance has not been saved in the repository
@@ -24,19 +21,4 @@ public protocol UnmanagedModel: Equatable {
 
     /// Update the properties of the ``ManagedModel`` instance from `self`
     func updating(managed: ManagedModel) throws
-
-    /// Initialize of new instance of `Self` from an instance of ``ManagedModel``
-    init(managed: ManagedModel) throws
-
-    /// ``NSFetchRequest`` for ``ManagedModel`` with a strongly typed ``NSFetchRequest.ResultType``
-    static func managedFetchRequest() -> NSFetchRequest<ManagedModel>
-}
-
-extension UnmanagedModel {
-    public static func managedFetchRequest() -> NSFetchRequest<ManagedModel> {
-        NSFetchRequest<ManagedModel>(
-            entityName: ManagedModel.entity().name ?? ManagedModel.entity()
-                .managedObjectClassName
-        )
-    }
 }

Sources/CoreDataRepository/UnmanagedReadOnlyModel.swift

@@ -0,0 +1,90 @@
+// UnmanagedReadOnlyModel.swift
+// CoreDataRepository
+//
+//
+// MIT License
+//
+// Copyright © 2024 Andrew Roan
+
+import CoreData
+import Foundation
+
+/// Protocol for a value type for reading and fetchiing a ``NSManagedObject`` subclass
+///
+/// There are times where a single ``NSManagedObject``subclass may be accessed via multiple value types.
+/// ``UnmanagedReadOnlyModel`` provides a minimal interface for reading and fetching values from CoreData
+/// without needing to implement the full ``UnmanagedModel`` protocol.
+///
+/// For example, for `ManagedMovie`, there are two unmanaged models, `Movie` and `MoviePlaceholder`.
+/// `MoviePlaceholder` will never create, update, or delete a corresponding instance of `ManagedMovie`. It is read only.
+/// `Movie` supports all operations against a corresponding instacnce of `ManagedMovie`.
+///
+/// ```swift
+/// @objc(ManagedMovie)
+/// final class ManagedMovie: NSManagedObject {
+///     @NSManaged var id: UUID?
+///     @NSManaged var title: String?
+/// }
+///
+/// struct Movie: Hashable, UnmanagedModel {
+///     let id: UUID
+///     var title: String = ""
+///     var url: URL?
+///
+///     init(managed: ManagedMovie) throws {
+///         self.init(
+///             id: managed.id!,
+///             title: managed.title!,
+///             url: managed.objectID.uriRepresentation()
+///         )
+///     }
+///
+///     var managedIdUrl: URL? {
+///         get {
+///             url
+///         }
+///         set(newValue) {
+///             url = newValue
+///         }
+///     }
+///
+///     func asManagedModel(in context: NSManagedObjectContext) throws -> ManagedMovie {
+///         let object = ManagedMovie(context: context)
+///         object.id = id
+///         object.title = title
+///         return object
+///     }
+///
+///     func updating(managed: ManagedMovie) throws {
+///         managed.id = id
+///         managed.title = title
+///     }
+/// }
+///
+/// struct MoviePlaceholder: UnmanagedReadOnlyModel {
+///     let id: UUID
+///
+///     init(managed: ManagedMovie) throws {
+///         self.init(id: managed.id!)
+///     }
+/// }
+/// ```
+public protocol UnmanagedReadOnlyModel: Equatable {
+    /// The ``NSManagedObject`` subclass `Self` corresponds to
+    associatedtype ManagedModel: NSManagedObject
+
+    /// Initialize of new instance of `Self` from an instance of ``ManagedModel``
+    init(managed: ManagedModel) throws
+
+    /// ``NSFetchRequest`` for ``ManagedModel`` with a strongly typed ``NSFetchRequest.ResultType``
+    static func managedFetchRequest() -> NSFetchRequest<ManagedModel>
+}
+
+extension UnmanagedReadOnlyModel {
+    public static func managedFetchRequest() -> NSFetchRequest<ManagedModel> {
+        NSFetchRequest<ManagedModel>(
+            entityName: ManagedModel.entity().name ?? ManagedModel.entity()
+                .managedObjectClassName
+        )
+    }
+}