done with changes suggested by coderabbit with all checks passing

Author: Piyushrathoree

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

@@ -56,7 +56,7 @@ def url(self) -> str:
     @strawberry.field
     def badges(self) -> list[BadgeNode]:
         """Return active badges for the user, ordered by badge weight and name."""
-        # related_name on UserBadge is "badges"; prefetch badge and filter active
+        # related_name on UserBadge is "badges"; join badge via select_related and filter active
         user_badges = (
             self.badges.select_related("badge")
             .filter(is_active=True)

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

@@ -13,4 +13,4 @@ class BadgeQueries:
     @strawberry.field
     def badges(self) -> list[BadgeNode]:
         """Return all badges ordered by weight and name."""
-        return list(Badge.objects.all().order_by("weight", "name"))
+        return Badge.objects.all().order_by("weight", "name")

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

@@ -17,12 +17,11 @@ def test_badges_resolution_orders_and_filters_active(self):
 
         # Mock chained calls: filter(...).order_by(...) -> [ub1]
         ordered_qs = MagicMock()
-        ordered_qs.__iter__.return_value = iter([])
         ub1 = MagicMock()
         ub1.badge = MagicMock()
         ordered_qs.__iter__.return_value = iter([ub1])
         user_badge_qs.filter.return_value = ordered_qs
-        ordered_qs.order_by.return_value = [ub1]
+        ordered_qs.order_by.return_value = ordered_qs
 
         # Use the resolver through the class to keep Strawberry decorators intact
         result = UserNode.badges(user)  # pass instance as self

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

@@ -38,7 +38,7 @@ def test_meta_configuration(self):
             "updated_at",
             "url",
         }
-        assert field_names == expected_field_names
+        assert expected_field_names.issubset(field_names)
 
     def test_created_at_field(self):
         """Test created_at field resolution."""

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

@@ -2,7 +2,6 @@
 
 from unittest.mock import MagicMock, patch
 
-from apps.nest.api.internal.nodes.badge import BadgeNode
 from apps.nest.api.internal.queries.badge import BadgeQueries
 from apps.nest.models.badge import Badge
 
@@ -12,27 +11,47 @@ class TestBadgeQueries:
 
     def test_has_strawberry_definition(self):
         """BadgeQueries should be a valid Strawberry type with 'badges' field."""
-        assert hasattr(BadgeQueries, "__strawberry_definition__")
-        field_names = [f.name for f in BadgeQueries.__strawberry_definition__.fields]
+        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."""
-        field = next(
-            f for f in BadgeQueries.__strawberry_definition__.fields if f.name == "badges"
+        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 field.type.of_type is BadgeNode or field.type is BadgeNode
-
-    @patch("apps.nest.models.badge.Badge.objects.all")
-    def test_badges_resolution(self, mock_all):
+        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_qs = MagicMock()
+        mock_manager.all.return_value = mock_qs
         mock_qs.order_by.return_value = [mock_badge]
-        mock_all.return_value = mock_qs
 
         result = BadgeQueries().badges()
 
-        assert result == [mock_badge]
-        mock_all.assert_called_once()
+        assert list(result) == [mock_badge]
+        mock_manager.all.assert_called_once_with()
         mock_qs.order_by.assert_called_once_with("weight", "name")