graphql-api 1.6.9__tar.gz → 1.7.0__tar.gz

{graphql_api-1.6.9 → graphql_api-1.7.0}/.github/workflows/python-package.yml

@@ -17,7 +17,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.12"] # graphql-api requires Python 3.11+
+        python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] # graphql-api requires Python 3.11+
 
     steps:
     - name: Checkout repository

{graphql_api-1.6.9 → graphql_api-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.9
+Version: 1.7.0
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT
@@ -10,12 +10,17 @@ Keywords: GraphQL,GraphQL-API,GraphQLAPI,Server
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.13,>=3.11
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphql-core
+Requires-Dist: graphql-core<3.3
 Requires-Dist: requests
 Requires-Dist: typing-inspect
 Requires-Dist: aiohttp

graphql_api-1.7.0/VERSION

@@ -0,0 +1 @@
+1.7.0

{graphql_api-1.6.9 → graphql_api-1.7.0}/graphql_api/executor.py

@@ -68,10 +68,21 @@ class ErrorProtectionExecutionContext(ExecutionContext):
         self,
         error: GraphQLError,
         return_type: GraphQLOutputType,
+        *args: Any,
+        **kwargs: Any,
     ) -> None:
         """
         Intercept field errors to decide whether to raise or suppress them based on the
         'error_protection' attribute, either on the error or its original error.
+
+        Anything after ``return_type`` is forwarded to graphql-core untouched.
+        graphql-core added a ``path`` argument to this method in 3.2.8, and an
+        override with a fixed arity turns every field error into a TypeError
+        raised from inside the executor — so the resolver's real error never
+        reaches the caller and a validation failure reads as a crash. Since
+        this class exists precisely to sit in the error path, it must not be
+        the thing that breaks it: accepting whatever the installed version
+        passes keeps it working across both signatures.
         """
         error_protection = self.default_error_protection
         original_error = error.original_error
@@ -86,8 +97,9 @@ class ErrorProtectionExecutionContext(ExecutionContext):
         if not error_protection:
             raise error.original_error if error.original_error is not None else error
 
-        # Otherwise, call the default error handler
-        return super().handle_field_error(error=error, return_type=return_type)
+        # Otherwise, call the default error handler. Positionally, because the
+        # trailing arguments differ by version and only the caller knows them.
+        return super().handle_field_error(error, return_type, *args, **kwargs)
 
 
 class NoErrorProtectionExecutionContext(ErrorProtectionExecutionContext):

{graphql_api-1.6.9 → graphql_api-1.7.0}/graphql_api/remote.py

@@ -157,6 +157,14 @@ class GraphQLRemoteExecutor(GraphQLBaseExecutor, GraphQLObjectType):
     A GraphQL executor that forwards all operations to a remote GraphQL service.
     """
 
+    def __new__(cls, url, name="Remote", *args, **kwargs):
+        # graphql-core >= 3.2.7 gives GraphQLNamedType a __new__(cls, name, ...)
+        # that checks for reserved type names. Our first argument is the URL, so
+        # pass the type name explicitly (older versions have no such __new__).
+        if GraphQLNamedType.__new__ is object.__new__:
+            return super().__new__(cls)
+        return super().__new__(cls, name)
+
     def __init__(
         self,
         url,

{graphql_api-1.6.9 → graphql_api-1.7.0}/graphql_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.9
+Version: 1.7.0
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT
@@ -10,12 +10,17 @@ Keywords: GraphQL,GraphQL-API,GraphQLAPI,Server
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.13,>=3.11
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphql-core
+Requires-Dist: graphql-core<3.3
 Requires-Dist: requests
 Requires-Dist: typing-inspect
 Requires-Dist: aiohttp

{graphql_api-1.6.9 → graphql_api-1.7.0}/graphql_api.egg-info/SOURCES.txt

@@ -89,6 +89,7 @@ tests/test_docs_getting_started.py
 tests/test_docs_relay.py
 tests/test_docstrings.py
 tests/test_error.py
+tests/test_executor_signature.py
 tests/test_federation.py
 tests/test_federation_example.graphql
 tests/test_federation_example.py

{graphql_api-1.6.9 → graphql_api-1.7.0}/graphql_api.egg-info/requires.txt

@@ -1,4 +1,4 @@
-graphql-core
+graphql-core<3.3
 requests
 typing-inspect
 aiohttp

{graphql_api-1.6.9 → graphql_api-1.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ dynamic = ["version"]
 description = "A framework for building Python GraphQL APIs."
 readme = "README.md"
 license = {text = "MIT"}
-requires-python = ">=3.11,<3.13"
+requires-python = ">=3.11"
 authors = [
     {name = "Robert Parker", email = "rob@parob.com"}
 ]
@@ -13,11 +13,16 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "graphql-core",
+    "graphql-core<3.3",
     "requests",
     "typing-inspect",
     "aiohttp",

graphql_api-1.7.0/tests/test_executor_signature.py

@@ -0,0 +1,116 @@
+"""The error path must survive graphql-core changing under us.
+
+`ErrorProtectionExecutionContext` overrides `handle_field_error`, which
+graphql-core calls positionally from inside the executor. graphql-core added a
+`path` argument to it in 3.2.8; the override kept its three-argument shape, and
+the result was that **every** field error became a `TypeError` raised from
+inside the executor. A resolver raising `ValueError("title is required")` came
+back to the caller as a crash with no message — the one thing an error path
+must never do.
+
+It went unnoticed because this library's own environment resolves an older
+graphql-core than its consumers do, so the existing error tests all pass here
+and fail there. Asserting against a pinned signature would repeat that mistake,
+so these tests ask the *installed* graphql-core what it expects and check the
+override against that.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+from graphql import GraphQLError, GraphQLInt
+from graphql.execution.execute import ExecutionContext
+from graphql.pyutils import Path
+
+from graphql_api.api import GraphQLAPI
+from graphql_api.executor import (
+    ErrorProtectionExecutionContext,
+    NoErrorProtectionExecutionContext,
+)
+
+
+def _accepted_arity(func) -> int:
+    """How many positional arguments this method takes, `self` excluded."""
+    parameters = [
+        p for name, p in inspect.signature(func).parameters.items()
+        if name != "self"
+    ]
+    return sum(
+        1 for p in parameters
+        if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+    )
+
+
+class TestHandleFieldErrorSignature:
+    def test_override_accepts_everything_graphql_core_passes(self) -> None:
+        """The override must be callable however the installed version calls it."""
+        expected = _accepted_arity(ExecutionContext.handle_field_error)
+        override = inspect.signature(
+            ErrorProtectionExecutionContext.handle_field_error
+        )
+        # Either the arities match, or the override absorbs the difference.
+        absorbs = any(
+            p.kind is p.VAR_POSITIONAL for p in override.parameters.values()
+        )
+        assert absorbs or _accepted_arity(
+            ErrorProtectionExecutionContext.handle_field_error
+        ) == expected, (
+            f"graphql-core passes {expected} positional argument(s) to "
+            f"handle_field_error; the override does not accept them"
+        )
+
+    def test_survives_being_called_the_way_the_executor_calls_it(self) -> None:
+        """A direct call with graphql-core's own argument list.
+
+        This is the exact call that was raising TypeError in production.
+        """
+        context = ErrorProtectionExecutionContext.__new__(
+            ErrorProtectionExecutionContext
+        )
+        error = GraphQLError("boom", original_error=ValueError("boom"))
+        args = [error, GraphQLInt]
+        if _accepted_arity(ExecutionContext.handle_field_error) > 2:
+            # graphql-core >= 3.2.8 also passes the field's path.
+            args.append(Path(None, "field", None))
+
+        # Nullable return type, so the error is collected rather than re-raised;
+        # the point is only that the call itself is well-formed.
+        context.errors = []
+        try:
+            context.handle_field_error(*args)
+        except TypeError as exc:  # pragma: no cover - this is the regression
+            raise AssertionError(
+                f"handle_field_error rejected graphql-core's own call: {exc}"
+            ) from exc
+        except Exception:
+            # Any GraphQL-level outcome is fine; a TypeError is not.
+            pass
+
+    def test_the_no_protection_variant_inherits_the_same_shape(self) -> None:
+        assert (
+            NoErrorProtectionExecutionContext.handle_field_error
+            is ErrorProtectionExecutionContext.handle_field_error
+        )
+
+
+class TestResolverErrorsReachTheCaller:
+    def test_a_raising_resolver_produces_a_graphql_error_not_a_crash(self) -> None:
+        """End to end: the shape every consumer actually depends on.
+
+        A validating resolver — "status must be one of …" — has to come back as
+        a GraphQL error carrying its message, or callers cannot tell a bad
+        argument from a broken server.
+        """
+        api = GraphQLAPI()
+
+        @api.type(is_root_type=True)
+        class Root:
+            @api.field
+            def set_status(self, status: str) -> bool:
+                raise ValueError(f"status must be one of ['open', 'closed'], got {status!r}")
+
+        result = api.execute('query { setStatus(status: "banana") }')
+
+        assert result.errors, "the resolver's error never reached the caller"
+        assert "status must be one of" in str(result.errors[0])

{graphql_api-1.6.9 → graphql_api-1.7.0}/tests/test_performance.py

@@ -601,23 +601,29 @@ class TestSchemaRebuilding:
                 return []
 
         times = []
-        for i in range(10):
+        for i in range(14):
             start_time = time.perf_counter()
             api = GraphQLAPI(root_type=API)
             schema, _ = api.build()
             end_time = time.perf_counter()
             times.append((end_time - start_time) * 1000)
 
-        print("\n10 repeated schema builds:")
+        # Drop warm-up iterations (imports, first-touch caches), then compare
+        # the medians of the early and late halves. Comparing two single
+        # sub-millisecond samples is scheduler noise on shared CI runners and
+        # produced false failures.
+        warm = times[2:]
+        half = len(warm) // 2
+        early = sorted(warm[:half])[half // 2]
+        late = sorted(warm[half:])[half // 2]
+
+        print(f"\n{len(times)} repeated schema builds:")
         print(f"  Times: {[f'{t:.2f}' for t in times]}")
-        print(f"  Average: {sum(times) / len(times):.2f}ms")
-
-        # Later builds should not be significantly slower than first
-        # Allow 50% variance
-        first_build = times[0]
-        last_build = times[-1]
-        assert last_build < first_build * 1.5, \
-            f"Performance degradation: first={first_build:.2f}ms, last={last_build:.2f}ms"
+        print(f"  Early median: {early:.2f}ms, late median: {late:.2f}ms")
+
+        # Later builds should not degrade relative to earlier ones.
+        assert late < early * 2 + 1.0, \
+            f"Performance degradation: early median={early:.2f}ms, late median={late:.2f}ms"
 
 
 class TestDataclassNesting:

{graphql_api-1.6.9 → graphql_api-1.7.0}/tests/test_remote.py

@@ -1098,3 +1098,15 @@ class TestGraphQLRemote:
         roll.fetch()  # type: ignore[reportIncompatibleMethodOverride]
 
         assert roll.students() == ["alice", "bob"]
+
+    def test_remote_executor_construction(self) -> None:
+        # graphql-core >= 3.2.7 routes the first constructor argument to
+        # GraphQLNamedType.__new__ as the type name; the URL must not end up
+        # there, and keyword-only construction must work. Fields are resolved
+        # lazily, so no request is made here.
+        by_keyword = GraphQLRemoteExecutor(url="http://localhost:1/graphql")
+        positional = GraphQLRemoteExecutor("http://localhost:1/graphql", "Upstream")
+
+        assert by_keyword.name == "Remote"
+        assert positional.name == "Upstream"
+        assert positional.url == "http://localhost:1/graphql"