return ExecutionResult from Schema.execute/execute_async

Author: m.kindritskiy

docs/changelog/changes_07.rst

@@ -90,7 +90,6 @@ Changes in 0.7
   - Added support for extensions :ref:`Check extensions documentation <extensions-doc>`
 
     - Added ``QueryParseCache`` extension - cache parsed graphql queries ast.
-    - Added ``QueryTransformCache`` extension - cache transformed graphql ast into query Node.
     - Added ``QueryValidationCache`` extension - cache query validation.
     - Added ``QueryDepthValidator`` extension - validate query depth
     - Added ``PrometheusMetrics`` extension - wrapper around ``GraphMetrics`` visitor

docs/changelog/changes_08.rst

@@ -16,6 +16,9 @@ Changes in 0.8
   - Drop `hiku.federation.endpoint` - use `hiku.endpoint` instead
   - Merge `tests.test_federation.test_endpoint` and `tests.test_federation.test_engine` into `tests.test_federation.test_schema`
   - Change `QueryDepthValidator` hook to `on_validate`
+  - Change `GraphQLResponse` type - it now has both `data` and `errors` fields
+  - Rename `on_dispatch` hook to `on_operation`
+  - Remove old `on_operation` hook
 
 Backward-incompatible changes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/extensions.rst

@@ -13,17 +13,15 @@ graph processing.
 Here are all the methods that can be implemented:
 
 - :meth:`~hiku.extensions.Extension.on_graph` - when endpoint is created and transformations applied to graph
-- :meth:`~hiku.extensions.Extension.on_dispatch` - when query is dispatched to the endpoint
-- :meth:`~hiku.extensions.Extension.on_parse` - when query string is parsed into ast
-- :meth:`~hiku.extensions.Extension.on_operation` - when query ast parsed into query Node
+- :meth:`~hiku.extensions.Extension.on_operation` - when query is executed by the schema
+- :meth:`~hiku.extensions.Extension.on_parse` - when query string is parsed into ast and the into query Node
 - :meth:`~hiku.extensions.Extension.on_validate` - when query is validated
 - :meth:`~hiku.extensions.Extension.on_execute` - when query is executed by engine
 
 Built-in extensions
 ~~~~~~~~~~~~~~~~~~~
 
 - ``QueryParseCache`` - cache parsed graphql queries ast.
-- ``QueryTransformCache`` - cache transformed graphql ast into query Node.
 - ``QueryValidationCache`` - cache query validation.
 - ``QueryDepthValidator`` - validate query depth
 - ``PrometheusMetrics`` - wrapper around ``GraphMetrics`` visitor

hiku/endpoint/graphql.py

@@ -1,26 +1,37 @@
-import typing as t
+from typing import Any, Optional, List, Dict, Union, overload
+from typing_extensions import TypedDict
 
 from abc import ABC
 from asyncio import gather
 
 
-from hiku.schema import GraphQLError, GraphQLRequest, GraphQLResponse, Schema
-from ..graph import Graph
+from hiku.schema import ExecutionResult, GraphQLError, Schema
 
 
-BatchedRequest = t.List[GraphQLRequest]
-BatchedResponse = t.List[GraphQLResponse]
+class GraphQLErrorObject(TypedDict):
+    message: str
 
-SingleOrBatchedRequest = t.Union[GraphQLRequest, BatchedRequest]
-SingleOrBatchedResponse = t.Union[GraphQLResponse, BatchedResponse]
 
+class GraphQLRequest(TypedDict, total=False):
+    query: str
+    variables: Optional[Dict[Any, Any]]
+    operationName: Optional[str]
 
-# TODO: do we need it ?
-G = t.TypeVar("G", bound=Graph)
-C = t.TypeVar("C")
 
+class GraphQLResponse(TypedDict, total=False):
+    data: Optional[Dict[str, object]]
+    errors: Optional[List[object]]
+    extensions: Optional[Dict[str, object]]
 
-class BaseGraphQLEndpoint(ABC, t.Generic[C]):
+
+BatchedRequest = List[GraphQLRequest]
+BatchedResponse = List[GraphQLResponse]
+
+SingleOrBatchedRequest = Union[GraphQLRequest, BatchedRequest]
+SingleOrBatchedResponse = Union[GraphQLResponse, BatchedResponse]
+
+
+class BaseGraphQLEndpoint(ABC):
     """TODO: add doc explaining the purpose of this class over plain schema"""
 
     schema: Schema
@@ -33,10 +44,18 @@ def __init__(
         self.schema = schema
         self.batching = batching
 
+    def process_result(self, result: ExecutionResult) -> GraphQLResponse:
+        data: GraphQLResponse = {"data": result.data}
+
+        if result.error:
+            data["errors"] = [{"message": e} for e in result.error.errors]
+
+        return data
+
 
 class BaseSyncGraphQLEndpoint(BaseGraphQLEndpoint):
     def dispatch(
-        self, data: GraphQLRequest, context: t.Optional[t.Dict] = None
+        self, data: GraphQLRequest, context: Optional[Dict] = None
     ) -> GraphQLResponse:
         """
         Dispatch graphql request to graph
@@ -46,32 +65,45 @@ def dispatch(
 
         Returns: graphql response: data or errors
         """
-        return self.schema.execute_sync(data, context)
+        assert "query" in data, "query is required"
+        result = self.schema.execute_sync(
+            query=data["query"],
+            variables=data.get("variables"),
+            operation_name=data.get("operationName"),
+            context=context,
+        )
+        return self.process_result(result)
 
 
 class BaseAsyncGraphQLEndpoint(BaseGraphQLEndpoint):
     async def dispatch(
-        self, data: GraphQLRequest, context: t.Optional[t.Dict] = None
+        self, data: GraphQLRequest, context: Optional[Dict] = None
     ) -> GraphQLResponse:
-        # TODO: what it we want to override exception handling?
-        return await self.schema.execute(data, context)
+        assert "query" in data, "query is required"
+        result = await self.schema.execute(
+            query=data["query"],
+            variables=data.get("variables"),
+            operation_name=data.get("operationName"),
+            context=context,
+        )
+        return self.process_result(result)
 
 
 class GraphQLEndpoint(BaseSyncGraphQLEndpoint):
-    @t.overload
+    @overload
     def dispatch(
-        self, data: GraphQLRequest, context: t.Optional[t.Dict] = None
+        self, data: GraphQLRequest, context: Optional[Dict] = None
     ) -> GraphQLResponse:
         ...
 
-    @t.overload
+    @overload
     def dispatch(
-        self, data: BatchedRequest, context: t.Optional[t.Dict] = None
+        self, data: BatchedRequest, context: Optional[Dict] = None
     ) -> BatchedResponse:
         ...
 
     def dispatch(
-        self, data: SingleOrBatchedRequest, context: t.Optional[t.Dict] = None
+        self, data: SingleOrBatchedRequest, context: Optional[Dict] = None
     ) -> SingleOrBatchedResponse:
         if isinstance(data, list):
             if not self.batching:
@@ -88,26 +120,26 @@ def dispatch(
 class BatchGraphQLEndpoint(GraphQLEndpoint):
     """For backward compatibility"""
 
-    def __init__(self, *args: t.Any, **kwargs: t.Any):
+    def __init__(self, *args: Any, **kwargs: Any):
         kwargs["batching"] = True
         super().__init__(*args, **kwargs)
 
 
 class AsyncGraphQLEndpoint(BaseAsyncGraphQLEndpoint):
-    @t.overload
+    @overload
     async def dispatch(
-        self, data: GraphQLRequest, context: t.Optional[t.Dict] = None
+        self, data: GraphQLRequest, context: Optional[Dict] = None
     ) -> GraphQLResponse:
         ...
 
-    @t.overload
+    @overload
     async def dispatch(
-        self, data: BatchedRequest, context: t.Optional[t.Dict] = None
+        self, data: BatchedRequest, context: Optional[Dict] = None
     ) -> BatchedResponse:
         ...
 
     async def dispatch(
-        self, data: SingleOrBatchedRequest, context: t.Optional[t.Dict] = None
+        self, data: SingleOrBatchedRequest, context: Optional[Dict] = None
     ) -> SingleOrBatchedResponse:
         if isinstance(data, list):
             return list(
@@ -129,6 +161,6 @@ async def dispatch(
 class AsyncBatchGraphQLEndpoint(AsyncGraphQLEndpoint):
     """For backward compatibility"""
 
-    def __init__(self, *args: t.Any, **kwargs: t.Any):
+    def __init__(self, *args: Any, **kwargs: Any):
         kwargs["batching"] = True
         super().__init__(*args, **kwargs)

hiku/extensions/base_extension.py

@@ -46,35 +46,21 @@ def on_graph(
         """
         yield None
 
-    def on_dispatch(
+    def on_operation(
         self, execution_context: ExecutionContext
     ) -> AsyncIteratorOrIterator[None]:
-        """Called before and after the dispatch step.
+        """Called before and after the operation step.
 
-        Dispatch step is a step where the query is dispatched by to the endpoint
-        to be parsed, validated and executed.
+        Operation step is a step where the query is executed by schema.
 
         At this step the:
-        - execution_context.query_src is set to the query string
-            from request
+        - execution_context.query_src (if type str) is set to the query string
+        - execution_context.query (if type Noe) is set to the query Node
         - execution_context.variables is set to the query variables
-            from request
         - execution_context.operation_name is set to the query operation name
-            from request
         - execution_context.query_graph is set to the query graph
         - execution_context.mutation_graph is set to the mutation graph
-        - execution_context.context is set to the context from dispatch argument
-        """
-        yield None
-
-    def on_operation(
-        self, execution_context: ExecutionContext
-    ) -> AsyncIteratorOrIterator[None]:
-        """Called before and after the operation step.
-
-        Operation step is a step where the graphql ast is transformed into
-        hiku's query ast and Operation type is created and assigned to the
-        execution_context.operation.
+        - execution_context.context is set to the context from execute argument
         """
         yield None
 
@@ -83,8 +69,12 @@ def on_parse(
     ) -> AsyncIteratorOrIterator[None]:
         """Called before and after the parsing step.
 
-        Parse step is when query string is parsed into graphql ast
-        and will be assigned to the execution_context.graphql_document.
+        Parse step is when query string is:
+        - parsed into graphql ast and will be assigned to the
+          execution_context.graphql_document
+        - graphql ast is transformed into
+          hiku's query ast and Operation type is created and assigned to the
+          execution_context.operation.
         """
         yield None
 
@@ -142,9 +132,9 @@ def graph(self) -> "ExtensionContextManagerBase":
             Extension.on_graph.__name__, self.extensions, self.execution_context
         )
 
-    def dispatch(self) -> "ExtensionContextManagerBase":
+    def operation(self) -> "ExtensionContextManagerBase":
         return ExtensionContextManagerBase(
-            Extension.on_dispatch.__name__,
+            Extension.on_operation.__name__,
             self.extensions,
             self.execution_context,
         )
@@ -154,13 +144,6 @@ def parsing(self) -> "ExtensionContextManagerBase":
             Extension.on_parse.__name__, self.extensions, self.execution_context
         )
 
-    def operation(self) -> "ExtensionContextManagerBase":
-        return ExtensionContextManagerBase(
-            Extension.on_operation.__name__,
-            self.extensions,
-            self.execution_context,
-        )
-
     def validation(self) -> "ExtensionContextManagerBase":
         return ExtensionContextManagerBase(
             Extension.on_validate.__name__,

hiku/extensions/query_transform_cache.py

@@ -21,7 +21,7 @@ def get_resource_name(self, execution_context: ExecutionContext) -> str:
     def _hash_query(self, query: str) -> str:
         return hashlib.md5(query.encode("utf-8")).hexdigest()
 
-    def on_dispatch(
+    def on_operation(
         self, execution_context: ExecutionContext
     ) -> Iterator[None]:
         self._operation_name = execution_context.operation_name