bundle analysis: add a paginated option to retrieve assets (#798)

Author: JerrySentry

graphql_api/tests/test_commit.py

@@ -71,6 +71,14 @@ type BundleReport {
     filters: BundleAnalysisMeasurementsSetFilters
   ): [BundleAnalysisMeasurements!]
   isCached: Boolean!
+  assetsPaginated(
+    ordering: AssetOrdering
+    orderingDirection: OrderingDirection
+    first: Int
+    after: String
+    last: Int
+    before: String
+  ): AssetConnection
 }
 
 type BundleAnalysisMeasurements{
@@ -79,4 +87,15 @@ type BundleAnalysisMeasurements{
     size: BundleData
     change: BundleData
     measurements: [Measurement!]
+}
+
+type AssetConnection {
+  edges: [AssetEdge]!
+  totalCount: Int!
+  pageInfo: PageInfo!
+}
+
+type AssetEdge {
+  cursor: String!
+  node: BundleAsset!
 }

graphql_api/types/bundle_analysis/base.graphql

@@ -1,11 +1,12 @@
 from datetime import datetime
-from typing import List, Mapping, Optional
+from typing import Dict, List, Mapping, Optional, Union
 
 from ariadne import ObjectType, convert_kwargs_to_snake_case
 from graphql import GraphQLResolveInfo
 
+from codecov.commands.exceptions import ValidationError
 from codecov.db import sync_to_async
-from graphql_api.types.enums import OrderingDirection
+from graphql_api.types.enums import AssetOrdering, OrderingDirection
 from services.bundle_analysis import (
     AssetReport,
     BundleAnalysisMeasurementData,
@@ -25,6 +26,16 @@
 bundle_report_bindable = ObjectType("BundleReport")
 
 
+def _find_index_by_cursor(assets: List, cursor: str) -> int:
+    try:
+        for i, asset in enumerate(assets):
+            if asset.id == int(cursor):
+                return i
+    except ValueError:
+        pass
+    return -1
+
+
 # ============= Bundle Data Bindable =============
 
 
@@ -135,6 +146,70 @@ def resolve_assets(
     return list(bundle_report.assets())
 
 
+@bundle_report_bindable.field("assetsPaginated")
+def resolve_assets_paginated(
+    bundle_report: BundleReport,
+    info: GraphQLResolveInfo,
+    ordering: AssetOrdering = AssetOrdering.SIZE,
+    ordering_direction: OrderingDirection = OrderingDirection.DESC,
+    first: Optional[int] = None,
+    after: Optional[str] = None,
+    last: Optional[int] = None,
+    before: Optional[str] = None,
+) -> Union[Dict[str, object], ValidationError]:
+    if first is not None and last is not None:
+        return ValidationError("First and last can not be used at the same time")
+    if after is not None and before is not None:
+        return ValidationError("After and before can not be used at the same time")
+
+    # All filtered assets before pagination
+    assets = list(
+        bundle_report.assets(
+            ordering=ordering.value,
+            ordering_desc=ordering_direction.value == OrderingDirection.DESC.value,
+        )
+    )
+
+    total_count, has_next_page, has_previous_page = len(assets), False, False
+    start_cursor, end_cursor = None, None
+
+    # Apply cursors to edges
+    if after is not None:
+        after_edge = _find_index_by_cursor(assets, after)
+        if after_edge > -1:
+            assets = assets[after_edge + 1 :]
+
+    if before is not None:
+        before_edge = _find_index_by_cursor(assets, before)
+        if before_edge > -1:
+            assets = assets[:before_edge]
+
+    # Slice edges by return size
+    if first is not None and first >= 0:
+        if len(assets) > first:
+            assets = assets[:first]
+            has_next_page = True
+
+    if last is not None and last >= 0:
+        if len(assets) > last:
+            assets = assets[len(assets) - last :]
+            has_previous_page = True
+
+    if assets:
+        start_cursor, end_cursor = assets[0].id, assets[-1].id
+
+    return {
+        "edges": [{"cursor": asset.id, "node": asset} for asset in assets],
+        "total_count": total_count,
+        "page_info": {
+            "has_next_page": has_next_page,
+            "has_previous_page": has_previous_page,
+            "start_cursor": start_cursor,
+            "end_cursor": end_cursor,
+        },
+    }
+
+
 @bundle_report_bindable.field("asset")
 def resolve_asset(
     bundle_report: BundleReport, info: GraphQLResolveInfo, name: str

graphql_api/types/bundle_analysis/base.py

@@ -1,4 +1,5 @@
 from .enums import (
+    AssetOrdering,
     BundleLoadTypes,
     CommitErrorCode,
     CommitErrorGeneralType,
@@ -20,6 +21,7 @@
 )
 
 __all__ = [
+    "AssetOrdering",
     "BundleLoadTypes",
     "CommitErrorCode",
     "CommitErrorGeneralType",

graphql_api/types/enums/__init__.py

@@ -0,0 +1,5 @@
+enum AssetOrdering {
+  NAME
+  SIZE
+  TYPE
+}

graphql_api/types/enums/asset_ordering.graphql

@@ -11,6 +11,7 @@
 from timeseries.models import MeasurementName
 
 from .enums import (
+    AssetOrdering,
     BundleLoadTypes,
     CoverageLine,
     GoalOnboarding,
@@ -52,4 +53,5 @@
     EnumType("YamlStates", YamlStates),
     EnumType("BundleLoadTypes", BundleLoadTypes),
     EnumType("TestResultsOrderingParameter", TestResultsOrderingParameter),
+    EnumType("AssetOrdering", AssetOrdering),
 ]

graphql_api/types/enums/enum_types.py

@@ -130,3 +130,9 @@ class BundleLoadTypes(enum.Enum):
     ENTRY = "ENTRY"
     INITIAL = "INITIAL"
     LAZY = "LAZY"
+
+
+class AssetOrdering(enum.Enum):
+    NAME = "name"
+    SIZE = "size"
+    TYPE = "asset_type"

graphql_api/types/enums/enums.py

@@ -206,6 +206,10 @@ def __init__(self, asset: SharedAssetReport):
         self.asset = asset
         self.all_modules = None
 
+    @cached_property
+    def id(self) -> int:
+        return self.asset.id
+
     @cached_property
     def name(self) -> str:
         return self.asset.hashed_name
@@ -249,9 +253,17 @@ def name(self) -> str:
     def all_assets(self) -> List[AssetReport]:
         return [AssetReport(asset) for asset in self.report.asset_reports()]
 
-    def assets(self) -> List[AssetReport]:
+    def assets(
+        self, ordering: Optional[str] = None, ordering_desc: Optional[bool] = None
+    ) -> List[AssetReport]:
+        ordering_dict: Dict[str, Any] = {}
+        if ordering:
+            ordering_dict["ordering_column"] = ordering
+        if ordering_desc is not None:
+            ordering_dict["ordering_desc"] = ordering_desc
         return [
-            AssetReport(asset) for asset in self.report.asset_reports(**self.filters)
+            AssetReport(asset)
+            for asset in self.report.asset_reports(**{**ordering_dict, **self.filters})
         ]
 
     def asset(self, name: str) -> Optional[AssetReport]: