PR feedback

Author: johnclayton

README.md

@@ -166,15 +166,10 @@ Person[0..<5]
 When you know you'll need related objects, you can prefetch relationships to reduce trips to the persistent store:
 
 ```swift
-// Prefetch a single relationship
-let ordersWithCustomers = Order
-    .include(#Predicate { $0.status == .active })
-    .prefetchRelationship(\.customer)
-
 // Prefetch multiple relationships
 let ordersWithDetails = Order
-    .prefetchRelationship(\.customer)
-    .prefetchRelationship(\.items)
+    .include(#Predicate { $0.status == .active })
+    .prefetchRelationships(\.customer, \.items)
 ```
 
 #### Fetching specific properties

Sources/SwiftQuery/FetchWrappers/FetchAll.swift

@@ -2,9 +2,6 @@ import Foundation
 import CoreData
 import Dependencies
 import SwiftData
-#if canImport(SwiftUI)
-import SwiftUI
-#endif
 
 @MainActor
 @propertyWrapper
@@ -57,7 +54,3 @@ public final class FetchAll<Model: PersistentModel>: Observable {
         init() {}
     }
 }
-
-#if canImport(SwiftUI)
-extension FetchAll: DynamicProperty {}
-#endif

Sources/SwiftQuery/FetchWrappers/FetchResults.swift

@@ -2,9 +2,6 @@ import Foundation
 import CoreData
 import Dependencies
 import SwiftData
-#if canImport(SwiftUI)
-import SwiftUI
-#endif
 
 @MainActor
 @propertyWrapper
@@ -58,7 +55,3 @@ public final class FetchResults<Model: PersistentModel> {
         init() {}
     }
 }
-
-#if canImport(SwiftUI)
-extension FetchResults: DynamicProperty {}
-#endif

Sources/SwiftQuery/PersistentModel+Query.swift

@@ -68,9 +68,9 @@ public extension PersistentModel {
 }
 
 public extension PersistentModel {
-    /// Constructs an empty query over this model type and invokes ``Query/prefetchRelationship(_:)`` on that query.
-    static func prefetchRelationship(_ keyPath: PartialKeyPath<Self>) -> Query<Self> {
-        query().prefetchRelationship(keyPath)
+    /// Constructs an empty query over this model type and invokes ``Query/prefetchRelationships(_:)`` on that query.
+    static func prefetchRelationships(_ keyPaths: PartialKeyPath<Self>...) -> Query<Self> {
+        query().prefetchRelationships(keyPaths)
     }
 
     /// Constructs an empty query over this model type and invokes ``Query/fetchKeyPaths(_:)`` on that query.

Sources/SwiftQuery/Query.swift

@@ -37,9 +37,11 @@ public struct Query<T: PersistentModel> {
 
     /// A range representing the number of results to skip before returning matches and maximum number of results to fetch. When `nil`, the query will return all matching results.
     public var range: Range<Int>?
-
+    
+    /// Key paths representing related models to fetch as part of this query.
     public var relationshipKeyPaths: [PartialKeyPath<T>] = []
-
+    
+    /// The subset of attributes to fetch for this entity
     public var propertiesToFetch: [PartialKeyPath<T>] = []
 
     /// SwiftData compatible sort descriptors generated from the query's sort configuration.
@@ -298,36 +300,41 @@ public extension Query {
 }
 
 public extension Query {
-    /// Returns a new query that prefetches the specified relationship when executing the fetch.
+    /// Returns a new query that prefetches the specified relationships when executing the fetch.
     ///
     /// Prefetching relationships can improve performance by reducing the number of database
-    /// trips needed when accessing related objects. Multiple relationships can be prefetched
-    /// by chaining multiple calls to this method.
-    ///
-    /// - Parameter keyPath: Key path to the relationship property to prefetch
-    /// - Returns: A new query with the additional relationship marked for prefetching
-    ///
-    /// ## Example
-    /// ```swift
-    /// // Prefetch single relationship
-    /// let ordersWithCustomers = Order
-    ///     .include(#Predicate { $0.status == .active })
-    ///     .prefetchRelationship(\.customer)
+    /// trips needed when accessing related objects.
     ///
-    /// // Prefetch multiple relationships
-    /// let ordersWithDetails = Order
-    ///     .prefetchRelationship(\.customer)
-    ///     .prefetchRelationship(\.items)
-    /// ```
-    func prefetchRelationship(_ keyPath: PartialKeyPath<T>) -> Self {
+    /// - Parameter keyPaths: Array of key paths to the relationships to prefetch
+    /// - Returns: A new query with the additional relationships marked for prefetching
+    func prefetchRelationships(_ keyPaths: [PartialKeyPath<T>]) -> Self {
         Query(
             predicate: predicate,
             sortBy: sortBy,
             range: range,
-            prefetchRelationships: relationshipKeyPaths + [keyPath],
+            prefetchRelationships: relationshipKeyPaths + keyPaths,
             propertiesToFetch: propertiesToFetch
         )
     }
+    
+    /// Returns a new query that prefetches the specified relationships when executing the fetch.
+    ///
+    /// Prefetching relationships can improve performance by reducing the number of database
+    /// trips needed when accessing related objects.
+    ///
+    /// - Parameter keyPaths: Key paths to the relationships to prefetch
+    /// - Returns: A new query with the additional relationships marked for prefetching
+    ///
+    /// ## Example
+    /// ```swift
+    /// // Prefetch multiple relationships
+    /// let ordersWithDetails = Order
+    ///     .include(#Predicate { $0.status == .active })
+    ///     .prefetchRelationships(\.customer, \.items)
+    /// ```
+    func prefetchRelationships(_ keyPaths: PartialKeyPath<T>...) -> Self {
+        prefetchRelationships(keyPaths)
+    }
 
     /// Returns a new query that fetches only the specified key paths when executing the fetch.
     ///

Tests/SwiftQueryTests/PersistentModelQueryTests.swift

@@ -61,9 +61,9 @@ struct PersistentModelQueryTests {
         #expect(modelQuery.sortDescriptors.first?.order == directQuery.sortDescriptors.first?.order)
     }
 
-    @Test func prefetchRelationship() async throws {
-        let modelQuery = Person.prefetchRelationship(\.name)
-        let directQuery = Query<Person>().prefetchRelationship(\.name)
+    @Test func prefetchRelationships() async throws {
+        let modelQuery = Person.prefetchRelationships(\.name)
+        let directQuery = Query<Person>().prefetchRelationships(\.name)
 
         #expect(modelQuery.relationshipKeyPaths.count == directQuery.relationshipKeyPaths.count)
         #expect(modelQuery.relationshipKeyPaths.contains(\Person.name) == directQuery.relationshipKeyPaths.contains(\Person.name))

Tests/SwiftQueryTests/QueryTests.swift

@@ -269,29 +269,28 @@ struct QueryTests {
         }
     }
 
-    @Test func prefetchRelationship_single() async throws {
+    @Test func prefetchRelationships_single() async throws {
         let query = Query<Person>()
-            .prefetchRelationship(\.name)
+            .prefetchRelationships(\.name)
 
         #expect(query.relationshipKeyPaths.count == 1)
         #expect(query.relationshipKeyPaths.contains(\Person.name))
     }
 
-    @Test func prefetchRelationship_multiple() async throws {
+    @Test func prefetchRelationships_multiple() async throws {
         let query = Query<Person>()
-            .prefetchRelationship(\.name)
-            .prefetchRelationship(\.age)
+            .prefetchRelationships(\.name, \.age)
 
         #expect(query.relationshipKeyPaths.count == 2)
         #expect(query.relationshipKeyPaths.contains(\Person.name))
         #expect(query.relationshipKeyPaths.contains(\Person.age))
     }
 
-    @Test func prefetchRelationship_withOtherModifiers() async throws {
+    @Test func prefetchRelationships_withOtherModifiers() async throws {
         let predicate = #Predicate<Person> { $0.age >= 18 }
         let query = Person.include(predicate)
             .sortBy(\.name)
-            .prefetchRelationship(\.age)
+            .prefetchRelationships(\.age)
 
         #expect(query.predicate != nil)
         #expect(query.sortBy.count == 1)