IFC-1886: Paginated branch graphql query

backend/infrahub/core/branch/models.py

@@ -165,6 +165,18 @@ async def get_list(
 
         return branches
 
+    @classmethod
+    async def get_list_and_count(
+        cls,
+        db: InfrahubDatabase,
+        limit: int = 1000,
+        ids: list[str] | None = None,
+        name: str | None = None,
+        **kwargs: Any,
+    ) -> tuple[list[Self], int]:
+        kwargs["raw_filter"] = f"n.status <> '{BranchStatus.DELETING.value}'"
+        return await super().get_list_and_count(db=db, limit=limit, ids=ids, name=name, **kwargs)
+
     @classmethod
     def isinstance(cls, obj: Any) -> bool:
         return isinstance(obj, cls)

backend/infrahub/core/node/standard.py

@@ -227,3 +227,19 @@ async def get_list(
         await query.execute(db=db)
 
         return [cls.from_db(result.get("n")) for result in query.get_results()]
+
+    @classmethod
+    async def get_list_and_count(
+        cls,
+        db: InfrahubDatabase,
+        limit: int = 1000,
+        ids: list[str] | None = None,
+        name: str | None = None,
+        **kwargs: dict[str, Any],
+    ) -> tuple[list[Self], int]:
+        query: Query = await StandardNodeGetListQuery.init(
+            db=db, node_class=cls, ids=ids, node_name=name, limit=limit, **kwargs
+        )
+        await query.execute(db=db)
+
+        return [cls.from_db(result.get("n")) for result in query.get_results()], await query.count(db=db)

backend/infrahub/core/query/__init__.py

@@ -352,6 +352,7 @@ def __init__(
         offset: int | None = None,
         order_by: list[str] | None = None,
         branch_agnostic: bool = False,
+        **kwargs: Any,
     ):
         if branch:
             self.branch = branch
@@ -378,6 +379,7 @@ def __init__(
         self.has_errors: bool = False
 
         self.stats: QueryStats = QueryStats()
+        self.kwargs = kwargs
 
     def update_return_labels(self, value: str | list[str]) -> None:
         if isinstance(value, str) and value not in self.return_labels:

backend/infrahub/core/query/standard_node.py

@@ -150,6 +150,8 @@ async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa
         if self.node_name:
             filters.append("n.name = $name")
             self.params["name"] = self.node_name
+        if raw_filter := self.kwargs.get("raw_filter"):
+            filters.append(raw_filter)
 
         where = ""
         if filters:

backend/infrahub/graphql/queries/__init__.py

@@ -1,5 +1,5 @@
 from .account import AccountPermissions, AccountToken
-from .branch import BranchQueryList
+from .branch import BranchQueryList, InfrahubBranchQueryList
 from .internal import InfrahubInfo
 from .ipam import (
     DeprecatedIPAddressGetNextAvailable,
@@ -20,6 +20,7 @@
     "BranchQueryList",
     "DeprecatedIPAddressGetNextAvailable",
     "DeprecatedIPPrefixGetNextAvailable",
+    "InfrahubBranchQueryList",
     "InfrahubIPAddressGetNextAvailable",
     "InfrahubIPPrefixGetNextAvailable",
     "InfrahubInfo",

backend/infrahub/graphql/queries/branch.py

@@ -2,10 +2,10 @@
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import ID, Field, List, NonNull, String
+from graphene import ID, Field, Int, List, NonNull, String
 
 from infrahub.graphql.field_extractor import extract_graphql_fields
-from infrahub.graphql.types import BranchType
+from infrahub.graphql.types import BranchType, InfrahubBranchType
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -28,3 +28,33 @@ async def branch_resolver(
     resolver=branch_resolver,
     required=True,
 )
+
+
+async def infrahub_branch_resolver(
+    root: dict,  # noqa: ARG001
+    info: GraphQLResolveInfo,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    limit = kwargs.pop("limit", 100)
+    offset = kwargs.pop("offset", 0)
+    fields = extract_graphql_fields(info)
+    branches, count = await InfrahubBranchType.get_list_and_count(
+        fields=fields.get("edges", {}).get("node", {}),
+        graphql_context=info.context,
+        limit=limit,
+        offset=offset,
+        **kwargs,
+    )
+    return {"count": count, "edges": {"node": branches}}
+
+
+InfrahubBranchQueryList = Field(
+    InfrahubBranchType,
+    ids=List(ID),
+    name=String(),
+    offset=Int(default_value=0),
+    limit=Int(default_value=100),
+    description="Retrieve paginated information about active branches.",
+    resolver=infrahub_branch_resolver,
+    required=True,
+)

backend/infrahub/graphql/schema.py

@@ -39,6 +39,7 @@
     BranchQueryList,
     DeprecatedIPAddressGetNextAvailable,
     DeprecatedIPPrefixGetNextAvailable,
+    InfrahubBranchQueryList,
     InfrahubInfo,
     InfrahubIPAddressGetNextAvailable,
     InfrahubIPPrefixGetNextAvailable,
@@ -65,6 +66,7 @@ class InfrahubBaseQuery(ObjectType):
 
     Relationship = Relationship
 
+    InfrahubBranch = InfrahubBranchQueryList
     InfrahubInfo = InfrahubInfo
     InfrahubStatus = InfrahubStatus
 

backend/infrahub/graphql/types/__init__.py

@@ -21,7 +21,7 @@
     StrAttributeType,
     TextAttributeType,
 )
-from .branch import BranchType
+from .branch import BranchType, InfrahubBranchType
 from .interface import InfrahubInterface
 from .node import InfrahubObject
 from .permission import PaginatedObjectPermission
@@ -41,6 +41,7 @@
     "DropdownType",
     "IPHostType",
     "IPNetworkType",
+    "InfrahubBranchType",
     "InfrahubInterface",
     "InfrahubObject",
     "InfrahubObjectType",

backend/infrahub/graphql/types/branch.py

@@ -2,7 +2,7 @@
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, Field, String
+from graphene import Boolean, Field, Int, List, NonNull, String
 
 from infrahub.core.branch import Branch
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
@@ -44,3 +44,27 @@ async def get_list(
                 return []
 
             return [await obj.to_graphql(fields=fields) for obj in objs if obj.name != GLOBAL_BRANCH_NAME]
+
+
+class InfrahubBranchEdge(InfrahubObjectType):
+    node = Field(List(of_type=NonNull(BranchType), required=True), required=True)
+
+
+class InfrahubBranchType(InfrahubObjectType):
+    count = Field(Int, required=True)
+    edges = Field(InfrahubBranchEdge, required=True)
+
+    @classmethod
+    async def get_list_and_count(
+        cls,
+        fields: dict,
+        graphql_context: GraphqlContext,
+        **kwargs: Any,
+    ) -> tuple[list[dict[str, Any]], int]:
+        async with graphql_context.db.start_session(read_only=True) as db:
+            objs, count = await Branch.get_list_and_count(db=db, **kwargs)
+
+            if not objs:
+                return [], 0
+
+            return [await obj.to_graphql(fields=fields) for obj in objs if obj.name != GLOBAL_BRANCH_NAME], count

backend/tests/unit/graphql/queries/test_branch.py

@@ -148,3 +148,93 @@ async def test_branch_query(
         assert id_response.data
         assert id_response.data["Branch"][0]["name"] == "branch3"
         assert len(id_response.data["Branch"]) == 1
+
+    async def test_paginated_branch_query(
+        self,
+        db: InfrahubDatabase,
+        default_branch: Branch,
+        register_core_models_schema,
+        session_admin,
+        client,
+        service,
+    ):
+        for i in range(10):
+            create_branch_query = """
+            mutation {
+                BranchCreate(data: { name: "%s", description: "%s" }) {
+                    ok
+                    object {
+                        id
+                        name
+                    }
+                }
+            }
+            """ % (
+                f"sample-branch-{i}",
+                f"sample description {i}",
+            )
+
+            gql_params = await prepare_graphql_params(
+                db=db,
+                include_subscription=False,
+                branch=default_branch,
+                account_session=session_admin,
+                service=service,
+            )
+            branch_result = await graphql(
+                schema=gql_params.schema,
+                source=create_branch_query,
+                context_value=gql_params.context,
+                root_value=None,
+                variable_values={},
+            )
+            assert branch_result.errors is None
+            assert branch_result.data
+
+        query = """
+            query {
+                InfrahubBranch(offset: 2, limit: 5) {
+                    count
+                    edges {
+                        node {
+                            name
+                            description
+                        }
+                    }
+                }
+            }
+        """
+        gql_params = await prepare_graphql_params(
+            db=db, include_subscription=False, branch=default_branch, service=service
+        )
+        all_branches = await graphql(
+            schema=gql_params.schema,
+            source=query,
+            context_value=gql_params.context,
+            root_value=None,
+            variable_values={},
+        )
+        assert all_branches.errors is None
+        assert all_branches.data
+        assert all_branches.data["InfrahubBranch"]["count"] == 13
+
+        expected_branches = [
+            {
+                "description": "Default Branch",
+                "name": "main",
+            },
+            {
+                "description": "my description",
+                "name": "branch3",
+            },
+            *[
+                {
+                    "description": f"sample description {i}",
+                    "name": f"sample-branch-{i}",
+                }
+                for i in range(10)
+            ],
+        ]
+        assert all_branches.data["InfrahubBranch"]["edges"]["node"].sort(
+            key=operator.itemgetter("name")
+        ) == expected_branches.sort(key=operator.itemgetter("name"))