Stop reporting a prefetched relation as a batching fallback (v0.19.3).

The batcher writes a path off when the resolver hands back something other
than a query, and v0.19.1 started reporting those through the lazy-resolution
diagnostic. A prefetched relation hands back the rows it already holds, which
takes that same branch, so a perfectly optimized read was reported as falling
back to one query per parent.

Measured: a depth-two selection under a connection with a scoped leaf runs
three statements and now reports nothing, where it previously warned. Genuine
fallbacks, where a resolver ran its own query, are unaffected.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: jamietdavidson

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "strawberry-orm"
-version = "0.19.2"
+version = "0.19.3"
 description = "Unified, backend-agnostic ORM abstraction for Strawberry GraphQL"
 readme = "README.md"
 license = "MIT"

src/strawberry_orm/batching.py

@@ -90,6 +90,36 @@ def stash_parents(execution_context: Any, info: Any, rows: Any) -> None:
     store[path_key(info)] = rows
 
 
+def _already_loaded(root: Any, info: Any) -> bool:
+    """True when this field's rows were loaded with the parent.
+
+    A prefetched relation hands back the rows it already holds, which is not a
+    query object and so looks to the rewrite like a resolver that ran its own.
+    Nothing ran, and nothing is owed a report.
+    """
+    from strawberry_orm.lazy_resolution import (
+        _django_relation_prefetched,
+        _sqlalchemy_relation_prefetched,
+        _tortoise_relation_prefetched,
+    )
+
+    name = getattr(info, "python_name", None) or _path_field_names(info)[-1:]
+    field_name = name if isinstance(name, str) else (name[0] if name else None)
+    if field_name is None:
+        return False
+    for probe in (
+        _sqlalchemy_relation_prefetched,
+        _django_relation_prefetched,
+        _tortoise_relation_prefetched,
+    ):
+        try:
+            if probe(root, field_name) is True:
+                return True
+        except Exception:  # pragma: no cover - probes are best effort
+            continue
+    return False
+
+
 def record_bail(execution_context: Any, path: str, reason: str) -> None:
     """Note that *path* fell back to one query per parent, and why.
 
@@ -168,14 +198,15 @@ def resolve(
         first = _next(root, info, *args, **kwargs)
         if isawaitable(first) or not backend.is_query_object(first):
             results[key] = _UNBATCHABLE
-            record_bail(
-                execution_context,
-                key,
-                "the resolver answers asynchronously, so there is no query to "
-                "rewrite before it runs"
-                if isawaitable(first)
-                else "the resolver ran its own query, leaving nothing to rewrite",
-            )
+            if not _already_loaded(root, info):
+                record_bail(
+                    execution_context,
+                    key,
+                    "the resolver answers asynchronously, so there is no query "
+                    "to rewrite before it runs"
+                    if isawaitable(first)
+                    else "the resolver ran its own query, leaving nothing to rewrite",
+                )
             return first
 
         try:

tests/test_relation_connection_internals.py

@@ -13,6 +13,7 @@
     _CONNECTION_KEY,
     _UNBATCHABLE,
     RelationConnectionExtension,
+    _already_loaded,
     _Bail,
     extensions_include_relation_connections,
     page_attr,
@@ -186,3 +187,9 @@ def test_the_pass_is_installed_only_once():
 
 def test_the_page_is_left_where_the_resolver_looks_for_it():
     assert page_attr("posts").endswith("posts")
+
+
+def test_a_field_with_no_discoverable_name_is_not_treated_as_loaded():
+    """Without a name there is nothing to probe, so nothing is assumed."""
+    nameless = types.SimpleNamespace(path=None, python_name=None)
+    assert _already_loaded(object(), nameless) is False