方向分页

GraphQLQueryPager支持双向分页，即正方向和反方向的分页。

正向分页

正向分页是最常见的分页形式。它用于获取列表中的下一n项。根据我们的需求有许多选择 —— 无论我们使用一个查询还是两个，我们是否想使用一个游标或者偏移，我们是否想转换结果，等等 - 我们将检查使用单个查询中的游标。

1
let initialQuery = MyQuery(first: 10, after: nil)
2
let pager = GraphQLQueryPager(
3
    client: client,
4
    initialQuery: initialQuery,
5
    extractPageInfo: { data in
6
        CursorBasedPagination.Forward(
7
            hasNext: data.values.pageInfo.hasNextPage ?? false,
8
            endCursor: data.values.pageInfo.endCursor
9
        )
10
    },
11
    pageResolver: { page, paginationDirection in
12
        // As we only want to support forward pagination, we can return `nil` for reverse pagination
13
        switch paginationDirection {
14
        case .next:
15
            return MyQuery(first: 10, after: page.endCursor ?? .none)
16
        case .previous:
17
            return nil
18
        }
19
    }
20
)

反向分页

反向分页用于获取列表中的前 n 项。虽然根据需求我们有很多选择——是使用一个还是两个查询，是希望使用游标还是偏移量，是否想要转换结果等——但我们将探讨使用单个查询与游标结合的方法。

1
let initialQuery = MyQuery(first: 10, after: nil)
2
let pager = GraphQLQueryPager(
3
    client: client,
4
    initialQuery: initialQuery,
5
    extractPageInfo: { data in
6
        CursorBasedPagination.Reverse(
7
            hasNext: data.values.pageInfo.hasPrevious ?? false,
8
            endCursor: data.values.pageInfo.startCursor
9
        )
10
    },
11
    pageResolver: { page, paginationDirection in
12
        // As we only want to support reverse pagination, we can return `nil` for forward pagination
13
        switch paginationDirection {
14
        case .next:
15
            return nil
16
        case .previous:
17
            return MyQuery(first: 10, before: page.startCursor ?? .none)
18
        }
19
    }
20
)

双向分页

双向分页用于获取列表中下一个 n 项以及前 n 项。考虑到我们可以双向获取，这意味着最初的查询结果既不在列表的头部也不在尾部。在这个例子中，我们将探讨使用单个查询与游标结合的方法。

1
let pager = GraphQLQueryPager(
2
    client: client,
3
    initialQuery: MyQuery(first: 10, after: nil),
4
    extractPageInfo: { data in
5
        CursorBasedPagination.Bidirectional(
6
            hasNext: data.values.pageInfo.hasNextPage ?? false,
7
            endCursor: data.values.pageInfo.endCursor,
8
            hasPrevious: data.values.pageInfo.hasPreviousPage ?? false,
9
            startCursor: data.values.pageInfo.startCursor
10
        )
11
    },
12
    pageResolver: { page, direction in
13
        switch direction {
14
        case .next:
15
            return MyQuery(first: 10, after: page?.endCursor ?? .none)
16
        case .previous:
17
            return MyQuery(first: 10, before: page?.startCursor ?? .none)
18
        }
19
    }
20
)

通常，建议使用便利初始化器来创建配置好的 GraphQLQueryPager。然而，如果您需要自定义配置，可以直接使用 init 方法。如果您的应用程序只使用特定类型的分页，您可以声明一个可通用于整个应用的自定义 GraphQLQueryPager 便利初始化器。这允许您轻松地实例化分页器，无需担心应用程序不支持的情况。如果您的分页方案只支持向前分页和偏移量，您可以声明一个只支持向前分页和偏移量的自定义 GraphQLQueryPager 便利初始化器。在这个例子中，我们声明了两个正向偏移量分页的初始化器——一个是带有 transform 的，另一个不带：

1
extension GraphQLQueryPager {
2
  static func makeForwardOffsetQueryPager<InitialQuery: GraphQLQuery>(
3
    client: ApolloClientProtocol,
4
    watcherDispatchQueue: DispatchQueue = .main,
5
    queryProvider: @escaping (OffsetPagination.Forward?) -> InitialQuery,
6
    extractPageInfo: @escaping (InitialQuery.Data) -> OffsetPagination.Forward
7
  ) -> GraphQLQueryPager where Model == PaginationOutput<InitialQuery, InitialQuery> {
8
    GraphQLQueryPager.init(
9
      client: client,
10
      initialQuery: queryProvider(nil),
11
      watcherDispatchQueue: watcherDispatchQueue,
12
      extractPageInfo: pageExtraction(transform: extractPageInfo),
13
      pageResolver: { page, direction in
14
        guard direction == .next else { return nil }
15
        return queryProvider(page)
16
      }
17
    )
18
  }
19

20
  static func makeForwardOffsetQueryPager<InitialQuery: GraphQLQuery, T>(
21
    client: ApolloClientProtocol,
22
    watcherDispatchQueue: DispatchQueue = .main,
23
    queryProvider: @escaping (OffsetPagination.Forward?) -> InitialQuery,
24
    extractPageInfo: @escaping (InitialQuery.Data) -> OffsetPagination.Forward,
25
    transform: @escaping (InitialQuery.Data) throws -> Model
26
  ) -> GraphQLQueryPager where Model: RangeReplaceableCollection, T == Model.Element {
27
    GraphQLQueryPager.init(
28
      client: client,
29
      initialQuery: queryProvider(nil),
30
      watcherDispatchQueue: watcherDispatchQueue,
31
      extractPageInfo: pageExtraction(transform: extractPageInfo),
32
      pageResolver: { page, direction in
33
        guard direction == .next else { return nil }
34
        return queryProvider(page)
35
      },
36
      initialTransform: transform,
37
      pageTransform: transform
38
    )
39
  }
40
}
41

42
private func pageExtraction<InitialQuery: GraphQLQuery, P: PaginationInfo, T>(
43
  transform: @escaping (InitialQuery.Data) -> P
44
) -> (PageExtractionData<InitialQuery, InitialQuery, T>) -> P {
45
  { extractionData in
46
    switch extractionData {
47
    case .initial(let value, _), .paginated(let value, _):
48
      return transform(value)
49
    }
50
  }
51
}
52

53
private func pageExtraction<InitialQuery: GraphQLQuery, PaginatedQuery: GraphQLQuery, P: PaginationInfo, T>(
54
  initialTransform: @escaping (InitialQuery.Data) -> P,
55
  paginatedTransform: @escaping (PaginatedQuery.Data) -> P
56
) -> (PageExtractionData<InitialQuery, PaginatedQuery, T>) -> P {
57
  { extractionData in
58
    switch extractionData {
59
    case .initial(let value, _):
60
      return initialTransfom(value)
61
    case .paginated(let value, _):
62
      return paginatedTransform(value)
63
    }
64
  }
65
}