fix: nested node caching by implementing path based key generation

Author: rudransh-shrivastava

backend/apps/common/extensions.py

@@ -1,11 +1,13 @@
 """Strawberry extensions."""
 
 import json
+from typing import Any
 
 from django.conf import settings
 from django.core.cache import cache
 from django.core.serializers.json import DjangoJSONEncoder
 from strawberry.extensions.field_extension import FieldExtension
+from strawberry.types.info import Info
 
 
 class CacheFieldExtension(FieldExtension):
@@ -22,24 +24,38 @@ def __init__(self, cache_timeout: int | None = None, prefix: str | None = None):
         self.cache_timeout = cache_timeout or settings.GRAPHQL_RESOLVER_CACHE_TIME_SECONDS
         self.prefix = prefix or settings.GRAPHQL_RESOLVER_CACHE_PREFIX
 
-    def generate_key(self, info, kwargs: dict) -> str:
+    def _convert_path_to_str(self, path: Any) -> str:
+        """Convert the Strawberry path linked list to a string."""
+        parts = []
+        current = path
+        while current:
+            parts.append(str(current.key))
+            current = getattr(current, "prev", None)
+        return ".".join(reversed(parts))
+
+    def generate_key(self, source: Any | None, info: Info, kwargs: dict) -> str:
         """Generate a unique cache key for a field.
 
         Args:
+            source (Any | None): The source/parent object.
             info (Info): The Strawberry execution info.
             kwargs (dict): The resolver's arguments.
 
         Returns:
             str: The unique cache key.
 
         """
-        args_str = json.dumps(kwargs, sort_keys=True, cls=DjangoJSONEncoder)
+        key_kwargs = kwargs.copy()
+        if source and (source_id := getattr(source, "id", None)) is not None:
+            key_kwargs["__source_id__"] = str(source_id)
+
+        args_str = json.dumps(key_kwargs, sort_keys=True, cls=DjangoJSONEncoder)
 
-        return f"{self.prefix}:{info.path.typename}:{info.path.key}:{args_str}"
+        return f"{self.prefix}:{self._convert_path_to_str(info.path)}:{args_str}"
 
-    def resolve(self, next_, source, info, **kwargs):
+    def resolve(self, next_: Any, source: Any, info: Info, **kwargs: Any) -> Any:
         """Wrap the resolver to provide caching."""
-        cache_key = self.generate_key(info, kwargs)
+        cache_key = self.generate_key(source, info, kwargs)
 
         return cache.get_or_set(
             cache_key,

backend/tests/apps/common/extensions_test.py

@@ -6,41 +6,93 @@
 from apps.common.extensions import CacheFieldExtension
 
 
+class MockPath:
+    def __init__(self, key, typename, prev=None):
+        self.key = key
+        self.prev = prev
+        self.typename = typename
+
+
+class MockSource:
+    def __init__(self, id=None):  # noqa: A002
+        self.id = id
+
+
 @pytest.mark.parametrize(
-    ("typename", "key", "kwargs", "prefix", "expected_key"),
+    ("source", "path", "kwargs", "prefix", "expected_key"),
     [
-        ("UserNode", "name", {}, "p1", "p1:UserNode:name:{}"),
         (
-            "RepositoryNode",
-            "issues",
-            {"limit": 10},
+            None,
+            MockPath(key="repository", typename="Query"),
+            {"organization_key": "OWASP", "repository_key": "nest"},
+            "p1",
+            'p1:repository:{"organization_key": "OWASP", "repository_key": "nest"}',
+        ),
+        (
+            MockSource(id=123),
+            MockPath(
+                key="organization",
+                typename="RepositoryNode",
+                prev=MockPath(key="repository", typename="Query"),
+            ),
+            {},
             "p2",
-            """p2:RepositoryNode:issues:{"limit": 10}""",
+            'p2:repository.organization:{"__source_id__": "123"}',
         ),
         (
-            "RepositoryNode",
-            "issues",
-            {"limit": 10, "state": "open"},
+            MockSource(id=0),
+            MockPath(
+                key="organization",
+                typename="RepositoryNode",
+                prev=MockPath(key="repository", typename="Query"),
+            ),
+            {},
             "p3",
-            """p3:RepositoryNode:issues:{"limit": 10, "state": "open"}""",
+            'p3:repository.organization:{"__source_id__": "0"}',
         ),
         (
-            "RepositoryNode",
-            "issues",
-            {"state": "open", "limit": 10},
+            MockSource(),
+            MockPath(
+                key="organization",
+                typename="RepositoryNode",
+                prev=MockPath(key="repository", typename="Query"),
+            ),
+            {},
             "p4",
-            """p4:RepositoryNode:issues:{"limit": 10, "state": "open"}""",
+            "p4:repository.organization:{}",
+        ),
+        (
+            None,
+            MockPath(
+                key="badgeCount",
+                typename="UserNode",
+                prev=MockPath(
+                    key="author",
+                    typename="IssueNode",
+                    prev=MockPath(
+                        key=0,
+                        typename=None,
+                        prev=MockPath(
+                            key="issues",
+                            typename="RepositoryNode",
+                            prev=MockPath(key="repository", typename="Query"),
+                        ),
+                    ),
+                ),
+            ),
+            {},
+            "graphql-resolver",
+            "graphql-resolver:repository.issues.0.author.badgeCount:{}",
         ),
     ],
 )
-def test_generate_key(typename, key, kwargs, prefix, expected_key):
+def test_generate_key(source, path, kwargs, prefix, expected_key):
     """Test cases for the generate_key method."""
     mock_info = MagicMock(spec=Info)
-    mock_info.path.typename = typename
-    mock_info.path.key = key
+    mock_info.path = path
 
     extension = CacheFieldExtension(prefix=prefix)
-    assert extension.generate_key(mock_info, kwargs) == expected_key
+    assert extension.generate_key(source, mock_info, kwargs) == expected_key
 
 
 class TestCacheFieldExtensionResolve:
@@ -50,8 +102,7 @@ class TestCacheFieldExtensionResolve:
     def mock_info(self):
         """Return a mock Strawberry Info object."""
         mock_info = MagicMock(spec=Info)
-        mock_info.path.typename = "TestType"
-        mock_info.path.key = "testField"
+        mock_info.path = MockPath(key="testField", typename="TestType", prev=None)
         return mock_info
 
     @patch("apps.common.extensions.cache")