feat/rustberry integration v2

pyproject.toml

@@ -62,6 +62,7 @@ libcst = {version = ">=0.4.7", optional = true}
 rich = {version = ">=12.0.0", optional = true}
 pyinstrument = {version = ">=4.0.0", optional = true}
 graphlib_backport = {version = "*", python = "<3.9", optional = true}
+rustberry = {version = "^0.0.10", python= ">=3.11"}
 
 [tool.poetry.group.dev.dependencies]
 asgiref = "^3.2"

strawberry/schema/execute.py

@@ -17,9 +17,8 @@
     cast,
 )
 
-from graphql import GraphQLError, parse
+from graphql import GraphQLError, parse, validate
 from graphql import execute as original_execute
-from graphql.validation import validate
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.extensions.runner import SchemaExtensionsRunner
@@ -38,6 +37,7 @@
 
     from strawberry.extensions import SchemaExtension
     from strawberry.types import ExecutionContext
+    from strawberry.types.execution import Executor, ParseOptions
     from strawberry.types.graphql import OperationType
 
 
@@ -82,6 +82,7 @@ async def execute(
     execution_context: ExecutionContext,
     execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
     process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
+    executor: Executor,
 ) -> ExecutionResult:
     extensions_runner = SchemaExtensionsRunner(
         execution_context=execution_context,
@@ -95,30 +96,28 @@ async def execute(
             if not execution_context.query:
                 raise MissingQueryError()
 
-            async with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
+        async with extensions_runner.parsing():
+            try:
+                if not execution_context.graphql_document:
+                    executor.parse(execution_context)
 
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=await extensions_runner.get_extensions_results(),
-                    )
+            except GraphQLError as exc:
+                execution_context.errors = [exc]
+                process_errors([exc], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[exc],
+                    extensions=await extensions_runner.get_extensions_results(),
+                )
 
             if execution_context.operation_type not in allowed_operation_types:
                 raise InvalidOperationTypeError(execution_context.operation_type)
 
-            async with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
+        async with extensions_runner.validation():
+            executor.validate(execution_context)
+            if execution_context.errors:
+                process_errors(execution_context.errors, execution_context)
+                return ExecutionResult(data=None, errors=execution_context.errors)
 
             async with extensions_runner.executing():
                 if not execution_context.result:
@@ -180,6 +179,7 @@ def execute_sync(
     execution_context: ExecutionContext,
     execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
     process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
+    executor: Executor,
 ) -> ExecutionResult:
     extensions_runner = SchemaExtensionsRunner(
         execution_context=execution_context,
@@ -193,30 +193,28 @@ def execute_sync(
             if not execution_context.query:
                 raise MissingQueryError()
 
-            with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
+        with extensions_runner.parsing():
+            try:
+                if not execution_context.graphql_document:
+                    executor.parse(execution_context)
 
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=extensions_runner.get_extensions_results_sync(),
-                    )
+            except GraphQLError as exc:
+                execution_context.errors = [exc]
+                process_errors([exc], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[exc],
+                    extensions=extensions_runner.get_extensions_results_sync(),
+                )
 
             if execution_context.operation_type not in allowed_operation_types:
                 raise InvalidOperationTypeError(execution_context.operation_type)
 
-            with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
+        with extensions_runner.validation():
+            executor.validate(execution_context)
+            if execution_context.errors:
+                process_errors(execution_context.errors, execution_context)
+                return ExecutionResult(data=None, errors=execution_context.errors)
 
             with extensions_runner.executing():
                 if not execution_context.result:

strawberry/schema/executors.py

@@ -0,0 +1,35 @@
+from typing import TYPE_CHECKING
+
+from graphql import GraphQLError
+from rustberry import QueryCompiler
+
+from strawberry import Schema
+from strawberry.types.execution import ExecutionContext, Executor
+
+if TYPE_CHECKING:
+    from rustberry._rustberry import Document
+
+RUSTBERRY_DOCUMENT_FIELD = "__rustberry_document"
+
+
+class RustberryExecutor(Executor):
+    def __init__(self, schema: Schema) -> None:
+        super().__init__(schema)
+        self.compiler = QueryCompiler(schema.as_str())
+
+    def parse(self, execution_context: ExecutionContext) -> None:
+        document = self.compiler.parse(execution_context.query)
+        setattr(execution_context, RUSTBERRY_DOCUMENT_FIELD, document)
+        execution_context.graphql_document = self.compiler.gql_core_ast_mirror(document)
+
+    def validate(
+        self,
+        execution_context: ExecutionContext,
+    ) -> None:
+        assert execution_context.graphql_document
+        document: Document = getattr(execution_context, RUSTBERRY_DOCUMENT_FIELD, None)
+        assert document, "Document not set - Required for Rustberry use"
+        validation_successful = self.compiler.validate(document)
+        if not validation_successful:
+            execution_context.errors = execution_context.errors or []
+            execution_context.errors.append(GraphQLError("Validation failed"))

strawberry/schema/schema.py

@@ -40,6 +40,7 @@
 from strawberry.types.types import StrawberryObjectDefinition
 
 from ..printer import print_schema
+from ..types.execution import Executor, GraphQlCoreExecutor
 from . import compat
 from .base import BaseSchema
 from .config import StrawberryConfig
@@ -82,6 +83,7 @@ def __init__(
             Dict[object, Union[Type, ScalarWrapper, ScalarDefinition]]
         ] = None,
         schema_directives: Iterable[object] = (),
+        executor_class: Optional[Type[Executor]] = None,
     ) -> None:
         self.query = query
         self.mutation = mutation
@@ -176,6 +178,11 @@ def __init__(
             formatted_errors = "\n\n".join(f"❌ {error.message}" for error in errors)
             raise ValueError(f"Invalid Schema. Errors:\n\n{formatted_errors}")
 
+        if executor_class:
+            self.executor = executor_class(self)
+        else:
+            self.executor = GraphQlCoreExecutor(self)
+
     def get_extensions(
         self, sync: bool = False
     ) -> List[Union[Type[SchemaExtension], SchemaExtension]]:
@@ -267,6 +274,7 @@ async def execute(
             execution_context=execution_context,
             allowed_operation_types=allowed_operation_types,
             process_errors=self.process_errors,
+            executor=self.executor,
         )
 
         return result
@@ -299,6 +307,7 @@ def execute_sync(
             execution_context=execution_context,
             allowed_operation_types=allowed_operation_types,
             process_errors=self.process_errors,
+            executor=self.executor,
         )
 
         return result

strawberry/types/execution.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import abc
 import dataclasses
 from typing import (
     TYPE_CHECKING,
@@ -12,7 +13,7 @@
 )
 from typing_extensions import TypedDict
 
-from graphql import specified_rules
+from graphql import parse, specified_rules, validate
 
 from strawberry.utils.operation import get_first_operation, get_operation_type
 
@@ -29,6 +30,45 @@
     from .graphql import OperationType
 
 
+class Executor(abc.ABC):
+    def __init__(self, schema: Schema) -> None:
+        self.schema = schema
+
+    @abc.abstractmethod
+    def parse(self, execution_context: ExecutionContext) -> None: ...
+
+    @abc.abstractmethod
+    def validate(
+        self,
+        execution_context: ExecutionContext,
+    ) -> None: ...
+
+
+class GraphQlCoreExecutor(Executor):
+    def __init__(self, schema: Schema) -> None:
+        super().__init__(schema)
+
+    def parse(self, execution_context: ExecutionContext) -> None:
+        execution_context.graphql_document = parse(
+            execution_context.query, **execution_context.parse_options
+        )
+
+    def validate(
+        self,
+        execution_context: ExecutionContext,
+    ) -> None:
+        if (
+            len(execution_context.validation_rules) > 0
+            and execution_context.errors is None
+        ):
+            assert execution_context.graphql_document
+            execution_context.errors = validate(
+                execution_context.schema._schema,
+                execution_context.graphql_document,
+                execution_context.validation_rules,
+            )
+
+
 @dataclasses.dataclass
 class ExecutionContext:
     query: Optional[str]

tests/benchmarks/api.py

@@ -2,6 +2,7 @@
 
 import strawberry
 from strawberry.directive import DirectiveLocation
+from strawberry.schema.executors import RustberryExecutor
 
 
 @strawberry.type
@@ -79,7 +80,9 @@ def uppercase(value: str) -> str:
     return value.upper()
 
 
-schema = strawberry.Schema(query=Query, subscription=Subscription)
+schema = strawberry.Schema(
+    query=Query, subscription=Subscription, executor_class=RustberryExecutor
+)
 schema_with_directives = strawberry.Schema(
     query=Query, directives=[uppercase], subscription=Subscription
 )

tests/benchmarks/test_execute_sync.py

@@ -28,16 +28,13 @@ def test_execute_with_many_fields_and_directives(benchmark: BenchmarkFixture):
     benchmark(schema_with_directives.execute_sync, many_fields_query_directives)
 
 
-@pytest.mark.benchmark
-def test_execute_with_10_items(benchmark: BenchmarkFixture):
-    benchmark(schema.execute_sync, items_query, variable_values={"count": 10})
-
-
-@pytest.mark.benchmark
-def test_execute_with_100_items(benchmark: BenchmarkFixture):
-    benchmark(schema.execute_sync, items_query, variable_values={"count": 100})
-
-
-@pytest.mark.benchmark
-def test_execute_with_1000_items(benchmark: BenchmarkFixture):
-    benchmark(schema.execute_sync, items_query, variable_values={"count": 1000})
+# @pytest.mark.benchmark
+# def test_execute_with_10_items(benchmark: BenchmarkFixture):
+#
+#
+# @pytest.mark.benchmark
+# def test_execute_with_100_items(benchmark: BenchmarkFixture):
+#
+#
+# @pytest.mark.benchmark
+# def test_execute_with_1000_items(benchmark: BenchmarkFixture):