Squashed 'apollo-ios-pagination/' changes from 017a468c..b591b09c

b591b09c [ApolloPagination] Update `PaginationOutput` to operate over `GraphQLResult`s (#428)

git-subtree-dir: apollo-ios-pagination
git-subtree-split: b591b09cc9891e16d699925be4fb706b37ff2714

Author: gh-action-runner

Package.swift

@@ -8,7 +8,7 @@ let package = Package(
     .iOS(.v13),
     .macOS(.v10_15),
     .tvOS(.v13),
-    .watchOS(.v6)
+    .watchOS(.v6),
   ],
   products: [
     .library(name: "ApolloPagination", targets: ["ApolloPagination"]),

Sources/ApolloPagination/AsyncGraphQLQueryPager.swift

@@ -6,7 +6,7 @@ import Foundation
 /// Type-erases a query pager, transforming data from a generic type to a specific type, often a view model or array of view models.
 public class AsyncGraphQLQueryPager<Model>: Publisher {
   public typealias Failure = Never
-  public typealias Output = Result<(Model, UpdateSource), any Error>
+  public typealias Output = Result<Model, any Error>
   let _subject: CurrentValueSubject<Output?, Never> = .init(nil)
   var publisher: AnyPublisher<Output, Never> { _subject.compactMap({ $0 }).eraseToAnyPublisher() }
   @Atomic public var cancellables: Set<AnyCancellable> = []
@@ -17,7 +17,7 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
 
   init<Pager: AsyncGraphQLQueryPagerCoordinator<InitialQuery, PaginatedQuery>, InitialQuery, PaginatedQuery>(
     pager: Pager,
-    transform: @escaping ([PaginatedQuery.Data], InitialQuery.Data, [PaginatedQuery.Data]) throws -> Model
+    transform: @escaping (PaginationOutput<InitialQuery, PaginatedQuery>) throws -> Model
   ) {
     self.pager = pager
     Task {
@@ -26,10 +26,10 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
         let returnValue: Output
 
         switch result {
-        case let .success((output, source)):
+        case let .success(output):
           do {
-            let transformedModels = try transform(output.previousPages, output.initialPage, output.nextPages)
-            returnValue = .success((transformedModels, source))
+            let transformedModels = try transform(output)
+            returnValue = .success(transformedModels)
           } catch {
             returnValue = .failure(error)
           }
@@ -50,89 +50,19 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
     Task {
       let cancellable = await pager.subscribe { [weak self] result in
         guard let self else { return }
-        let returnValue: Output
-
-        switch result {
-        case let .success((output, source)):
-          returnValue = .success((output, source))
-        case let .failure(error):
-          returnValue = .failure(error)
-        }
-
-        _subject.send(returnValue)
+        _subject.send(result)
       }
       _ = $cancellables.mutate { $0.insert(cancellable) }
     }
   }
 
-  convenience init<
-    Pager: AsyncGraphQLQueryPagerCoordinator<InitialQuery, PaginatedQuery>,
-    InitialQuery,
-    PaginatedQuery,
-    Element
-  >(
-    pager: Pager,
-    initialTransform: @escaping (InitialQuery.Data) throws -> Model,
-    pageTransform: @escaping (PaginatedQuery.Data) throws -> Model
-  ) where Model: RangeReplaceableCollection, Model.Element == Element {
-    self.init(
-      pager: pager,
-      transform: { previousData, initialData, nextData in
-        let previous = try previousData.flatMap { try pageTransform($0) }
-        let initial = try initialTransform(initialData)
-        let next = try nextData.flatMap { try pageTransform($0) }
-        return previous + initial + next
-      }
-    )
-  }
-
-  public convenience init<
-    P: PaginationInfo,
-    InitialQuery: GraphQLQuery,
-    PaginatedQuery: GraphQLQuery,
-    Element
-  >(
-    client: any ApolloClientProtocol,
-    initialQuery: InitialQuery,
-    watcherDispatchQueue: DispatchQueue = .main,
-    extractPageInfo: @escaping (PageExtractionData<InitialQuery, PaginatedQuery, Model?>) -> P,
-    pageResolver: ((P, PaginationDirection) -> PaginatedQuery?)?,
-    initialTransform: @escaping (InitialQuery.Data) throws -> Model,
-    pageTransform: @escaping (PaginatedQuery.Data) throws -> Model
-  ) where Model: RangeReplaceableCollection, Model.Element == Element {
-    let pager = AsyncGraphQLQueryPagerCoordinator(
-      client: client,
-      initialQuery: initialQuery,
-      watcherDispatchQueue: watcherDispatchQueue,
-      extractPageInfo: { data in
-        switch data {
-        case .initial(let data, let output):
-          return extractPageInfo(.initial(data, convertOutput(result: output)))
-        case .paginated(let data, let output):
-          return extractPageInfo(.paginated(data, convertOutput(result: output)))
-        }
-      },
-      pageResolver: pageResolver
-    )
-    self.init(
-      pager: pager,
-      initialTransform: initialTransform,
-      pageTransform: pageTransform
-    )
-
-    func convertOutput(result: PaginationOutput<InitialQuery, PaginatedQuery>?) -> Model? {
-      guard let result else { return nil }
-
-      let transform: ([PaginatedQuery.Data], InitialQuery.Data, [PaginatedQuery.Data]) throws -> Model = { previousData, initialData, nextData in
-        let previous = try previousData.flatMap { try pageTransform($0) }
-        let initial = try initialTransform(initialData)
-        let next = try nextData.flatMap { try pageTransform($0) }
-        return previous + initial + next
-      }
-      return try? transform(result.previousPages, result.initialPage, result.nextPages)
-    }
-  }
-
+  /// Initialize an `AsyncGraphQLQueryPager` that outputs a `PaginationOutput<InitialQuery, PaginatedQuery>`.
+  /// - Parameters:
+  ///   - client: Apollo client type
+  ///   - initialQuery: The query to call for the first page of pagination. May be a separate type of query than the pagination query.
+  ///   - watcherDispatchQueue: The queue that the underlying `GraphQLQueryWatcher`s respond on. Defaults to `main`.
+  ///   - extractPageInfo: A user-input closure that instructs the pager on how to extract `P`, a `PaginationInfo` type, from the `Data` of either the `InitialQuery` or `PaginatedQuery`.
+  ///   - pageResolver: A user-input closure that instructs the pager on how to create a new `PaginatedQuery` given a `PaginationInfo` and a `PaginationDirection`.
   public convenience init<
     P: PaginationInfo,
     InitialQuery: GraphQLQuery,
@@ -151,11 +81,17 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
       extractPageInfo: extractPageInfo,
       pageResolver: pageResolver
     )
-    self.init(
-      pager: pager
-    )
+    self.init(pager: pager)
   }
 
+  /// Initialize an `AsyncGraphQLQueryPager` that outputs a user-defined `Model`, the result of the `transform` argument.
+  /// - Parameters:
+  ///   - client: Apollo client type
+  ///   - initialQuery: The query to call for the first page of pagination. May be a separate type of query than the pagination query.
+  ///   - watcherDispatchQueue: The queue that the underlying `GraphQLQueryWatcher`s respond on. Defaults to `main`.
+  ///   - extractPageInfo: A user-input closure that instructs the pager on how to extract `P`, a `PaginationInfo` type, from the `Data` of either the `InitialQuery` or `PaginatedQuery`.
+  ///   - pageResolver: A user-input closure that instructs the pager on how to create a new `PaginatedQuery` given a `PaginationInfo` and a `PaginationDirection`.
+  ///   - transform: Transforms the `PaginationOutput` into a `Model` type.
   public convenience init<
     P: PaginationInfo,
     InitialQuery: GraphQLQuery,
@@ -164,38 +100,23 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
     client: any ApolloClientProtocol,
     initialQuery: InitialQuery,
     watcherDispatchQueue: DispatchQueue = .main,
-    extractPageInfo: @escaping (PageExtractionData<InitialQuery, PaginatedQuery, Model?>) -> P,
+    extractPageInfo: @escaping (PageExtractionData<InitialQuery, PaginatedQuery, PaginationOutput<InitialQuery, PaginatedQuery>?>) -> P,
     pageResolver: ((P, PaginationDirection) -> PaginatedQuery?)?,
-    transform: @escaping ([PaginatedQuery.Data], InitialQuery.Data, [PaginatedQuery.Data]) throws -> Model
+    transform: @escaping (PaginationOutput<InitialQuery, PaginatedQuery>) throws -> Model
   ) {
     let pager = AsyncGraphQLQueryPagerCoordinator(
       client: client,
       initialQuery: initialQuery,
       watcherDispatchQueue: watcherDispatchQueue,
-      extractPageInfo: { data in
-        switch data {
-        case .initial(let data, let output):
-          return extractPageInfo(.initial(data, convertOutput(result: output)))
-        case .paginated(let data, let output):
-          return extractPageInfo(.paginated(data, convertOutput(result: output)))
-        }
-      },
+      extractPageInfo: extractPageInfo,
       pageResolver: pageResolver
     )
-    self.init(
-      pager: pager,
-      transform: transform
-    )
-
-    func convertOutput(result: PaginationOutput<InitialQuery, PaginatedQuery>?) -> Model? {
-      guard let result else { return nil }
-      return try? transform(result.previousPages, result.initialPage, result.nextPages)
-    }
+    self.init(pager: pager, transform: transform)
   }
 
-
   /// Subscribe to the results of the pager, with the management of the subscriber being stored internally to the `AnyGraphQLQueryPager`.
   /// - Parameter completion: The closure to trigger when new values come in.
+  @available(*, deprecated, message: "Will be removed in a future version of ApolloPagination. Use the `Combine` publishers instead. If you need to dispatch to the main thread, make sure to use a `.receive(on: RunLoop.main)` as part of your `Combine` operation.")
   public func subscribe(completion: @MainActor @escaping (Output) -> Void) {
     let cancellable = publisher.sink { result in
       Task { await completion(result) }
@@ -221,7 +142,7 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
     try await pager.loadPrevious(cachePolicy: cachePolicy)
   }
 
-  /// Loads all pages.
+  /// Loads all pages. Does not output a value until all pages have loaded.
   /// - Parameters:
   ///   - fetchFromInitialPage: Pass true to begin loading from the initial page; otherwise pass false.  Defaults to `true`.  **NOTE**: Loading all pages with this value set to `false` requires that the initial page has already been loaded previously.
   public func loadAll(
@@ -243,30 +164,12 @@ public class AsyncGraphQLQueryPager<Model>: Publisher {
 
   /// Resets pagination state and cancels in-flight updates from the pager.
   public func reset() async {
-    await pager.reset()    
+    await pager.reset()
   }
 
   public func receive<S>(
     subscriber: S
-  ) where S: Subscriber, Never == S.Failure, Result<(Model, UpdateSource), any Error> == S.Input {
+  ) where S: Subscriber, Never == S.Failure, Result<Model, any Error> == S.Input {
     publisher.subscribe(subscriber)
   }
 }
-
-extension AsyncGraphQLQueryPager: Equatable where Model: Equatable {
-  public static func == (lhs: AsyncGraphQLQueryPager<Model>, rhs: AsyncGraphQLQueryPager<Model>) -> Bool {
-    let left = lhs._subject.value
-    let right = rhs._subject.value
-
-    switch (left, right) {
-    case (.success((let leftValue, let leftSource)), .success((let rightValue, let rightSource))):
-      return leftValue == rightValue && leftSource == rightSource
-    case (.failure(let leftError), .failure(let rightError)):
-      return leftError.localizedDescription == rightError.localizedDescription
-    case (.none, .none):
-      return true
-    default:
-      return false
-    }
-  }
-}