Feature/graphql support for badges

backend/apps/github/api/internal/nodes/user.py

@@ -4,6 +4,7 @@
 import strawberry_django
 
 from apps.github.models.user import User
+from apps.nest.api.internal.nodes.badge import BadgeNode
 
 
 @strawberry_django.type(
@@ -27,6 +28,19 @@
 class UserNode:
     """GitHub user node."""
 
+    @strawberry.field
+    def badges(self) -> list[BadgeNode]:
+        """Return user badges."""
+        user_badges = (
+            self.badges.select_related("badge")
+            .filter(is_active=True)
+            .order_by(
+                "badge__weight",
+                "badge__name",
+            )
+        )
+        return [ub.badge for ub in user_badges]
+
     @strawberry.field
     def created_at(self) -> float:
         """Resolve created at."""

backend/apps/nest/api/internal/nodes/badge.py

@@ -0,0 +1,20 @@
+"""GraphQL node for Badge model."""
+
+import strawberry
+import strawberry_django
+
+from apps.nest.models.badge import Badge
+
+
+@strawberry_django.type(
+    Badge,
+    fields=[
+        "css_class",
+        "description",
+        "id",
+        "name",
+        "weight",
+    ],
+)
+class BadgeNode(strawberry.relay.Node):
+    """GraphQL node for Badge model."""

backend/apps/nest/api/internal/queries/__init__.py

@@ -1,8 +1,9 @@
 import strawberry
 
 from apps.nest.api.internal.queries.api_key import ApiKeyQueries
+from apps.nest.api.internal.queries.badge import BadgeQueries
 
 
 @strawberry.type
-class NestQuery(ApiKeyQueries):
+class NestQuery(ApiKeyQueries, BadgeQueries):
     """Nest query."""

backend/apps/nest/api/internal/queries/badge.py

@@ -0,0 +1,16 @@
+"""GraphQL queries for Badge model."""
+
+import strawberry
+
+from apps.nest.api.internal.nodes.badge import BadgeNode
+from apps.nest.models.badge import Badge
+
+
+@strawberry.type
+class BadgeQueries:
+    """GraphQL query class for badges."""
+
+    @strawberry.field
+    def badges(self) -> list[BadgeNode]:
+        """Return badges."""
+        return Badge.objects.order_by("weight", "name")

backend/tests/apps/github/api/internal/nodes/user_badges_field_test.py

@@ -0,0 +1,31 @@
+"""Tests for badges field on GitHub UserNode."""
+
+from unittest.mock import MagicMock
+
+from apps.github.api.internal.nodes.user import UserNode
+
+
+class TestUserNodeBadgesField:
+    """Test cases for badges field on UserNode."""
+
+    def test_badges_resolution_orders_and_filters_active(self):
+        """Badges resolution should filter active and order by badge weight/name."""
+        # Build a lightweight object with required attributes and methods
+        user = MagicMock()
+        user_badge_qs = MagicMock()
+        user.badges.select_related.return_value = user_badge_qs
+
+        # Mock chained calls: filter(...).order_by(...) -> [ub1]
+        ordered_qs = MagicMock()
+        ub1 = MagicMock()
+        ub1.badge = MagicMock()
+        user_badge_qs.filter.return_value = ordered_qs
+        ordered_qs.order_by.return_value = [ub1]
+
+        # Use the resolver through the class to keep Strawberry decorators intact
+        result = UserNode.badges(user)  # pass instance as self
+
+        user.badges.select_related.assert_called_once_with("badge")
+        user_badge_qs.filter.assert_called_once_with(is_active=True)
+        ordered_qs.order_by.assert_called_once_with("badge__weight", "badge__name")
+        assert result == [ub1.badge]

backend/tests/apps/github/api/internal/nodes/user_test.py

@@ -19,6 +19,7 @@ def test_meta_configuration(self):
         field_names = {field.name for field in UserNode.__strawberry_definition__.fields}
         expected_field_names = {
             "avatar_url",
+            "badges",
             "bio",
             "company",
             "contributions_count",
@@ -37,7 +38,8 @@ def test_meta_configuration(self):
             "updated_at",
             "url",
         }
-        assert field_names == expected_field_names
+        missing = expected_field_names - field_names
+        assert not missing, f"Missing fields on UserNode: {sorted(missing)}"
 
     def test_created_at_field(self):
         """Test created_at field resolution."""

backend/tests/apps/nest/api/internal/queries/badge_test.py

@@ -0,0 +1,54 @@
+"""Tests for Badge GraphQL queries and nodes."""
+
+from unittest.mock import MagicMock, patch
+
+from apps.nest.api.internal.queries.badge import BadgeQueries
+from apps.nest.models.badge import Badge
+
+
+class TestBadgeQueries:
+    """Test cases for BadgeQueries class."""
+
+    def test_has_strawberry_definition(self):
+        """BadgeQueries should be a valid Strawberry type with 'badges' field."""
+        from strawberry import Schema
+
+        schema = Schema(query=BadgeQueries)
+        res = schema.execute_sync('{ __type(name:"BadgeQueries"){ fields { name } } }')
+        assert res.errors is None
+        field_names = [f["name"] for f in res.data["__type"]["fields"]]
+        assert "badges" in field_names
+
+    def test_badges_field_configuration(self):
+        """'badges' field should return a list of BadgeNode."""
+        from strawberry import Schema
+
+        schema = Schema(query=BadgeQueries)
+        res = schema.execute_sync(
+            """
+            {
+                __type(name: "BadgeQueries") {
+                    fields {
+                        name type { kind ofType { kind ofType { kind ofType { name } } } }
+                    }
+                }
+            }
+            """
+        )
+        assert res.errors is None
+        badges_field = next(f for f in res.data["__type"]["fields"] if f["name"] == "badges")
+        assert badges_field["type"]["kind"] == "NON_NULL"
+        assert badges_field["type"]["ofType"]["kind"] == "LIST"
+        assert badges_field["type"]["ofType"]["ofType"]["kind"] == "NON_NULL"
+        assert badges_field["type"]["ofType"]["ofType"]["ofType"]["name"] == "BadgeNode"
+
+    @patch("apps.nest.api.internal.queries.badge.Badge.objects")
+    def test_badges_resolution(self, mock_manager):
+        """Resolver should return badges ordered by weight and name."""
+        mock_badge = MagicMock(spec=Badge)
+        mock_manager.order_by.return_value = [mock_badge]
+
+        result = BadgeQueries().badges()
+
+        assert list(result) == [mock_badge]
+        mock_manager.order_by.assert_called_once_with("weight", "name")