strawberry-graphql 0.168.2__py3-none-any.whl → 0.170.0__py3-none-any.whl

strawberry/http/sync_base_view.py

@@ -0,0 +1,210 @@
+import abc
+import json
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Mapping,
+    Optional,
+    Union,
+)
+
+from strawberry import UNSET
+from strawberry.exceptions import MissingQueryError
+from strawberry.file_uploads.utils import replace_placeholders_with_files
+from strawberry.http import GraphQLHTTPResponse, GraphQLRequestData, process_result
+from strawberry.schema import BaseSchema
+from strawberry.schema.exceptions import InvalidOperationTypeError
+from strawberry.types import ExecutionResult
+from strawberry.types.graphql import OperationType
+
+from .base import BaseView
+from .exceptions import HTTPException
+from .types import HTTPMethod, QueryParams
+from .typevars import Context, Request, Response, RootValue, SubResponse
+
+
+class SyncHTTPRequestAdapter(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def query_params(self) -> QueryParams:
+        ...
+
+    @property
+    @abc.abstractmethod
+    def body(self) -> Union[str, bytes]:
+        ...
+
+    @property
+    @abc.abstractmethod
+    def method(self) -> HTTPMethod:
+        ...
+
+    @property
+    @abc.abstractmethod
+    def headers(self) -> Mapping[str, str]:
+        ...
+
+    @property
+    @abc.abstractmethod
+    def content_type(self) -> Optional[str]:
+        ...
+
+    @property
+    @abc.abstractmethod
+    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+        ...
+
+    @property
+    @abc.abstractmethod
+    def files(self) -> Mapping[str, Any]:
+        ...
+
+
+class SyncBaseHTTPView(
+    abc.ABC,
+    BaseView[Request],
+    Generic[Request, Response, SubResponse, Context, RootValue],
+):
+    schema: BaseSchema
+    graphiql: bool
+    request_adapter_class: Callable[[Request], SyncHTTPRequestAdapter]
+
+    # Methods that need to be implemented by individual frameworks
+
+    @property
+    @abc.abstractmethod
+    def allow_queries_via_get(self) -> bool:
+        ...
+
+    @abc.abstractmethod
+    def get_sub_response(self, request: Request) -> SubResponse:
+        ...
+
+    @abc.abstractmethod
+    def get_context(self, request: Request, response: SubResponse) -> Context:
+        ...
+
+    @abc.abstractmethod
+    def get_root_value(self, request: Request) -> Optional[RootValue]:
+        ...
+
+    @abc.abstractmethod
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: SubResponse
+    ) -> Response:
+        ...
+
+    @abc.abstractmethod
+    def render_graphiql(self, request: Request) -> Response:
+        # TODO: this could be non abstract
+        # maybe add a get template function?
+        ...
+
+    def execute_operation(
+        self, request: Request, context: Context, root_value: Optional[RootValue]
+    ) -> ExecutionResult:
+        request_adapter = self.request_adapter_class(request)
+
+        try:
+            request_data = self.parse_http_body(request_adapter)
+        except json.decoder.JSONDecodeError as e:
+            raise HTTPException(400, "Unable to parse request body as JSON") from e
+            # DO this only when doing files
+        except KeyError as e:
+            raise HTTPException(400, "File(s) missing in form data") from e
+
+        allowed_operation_types = OperationType.from_http(request_adapter.method)
+
+        if not self.allow_queries_via_get and request_adapter.method == "GET":
+            allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
+
+        assert self.schema
+
+        return self.schema.execute_sync(
+            request_data.query,
+            root_value=root_value,
+            variable_values=request_data.variables,
+            context_value=context,
+            operation_name=request_data.operation_name,
+            allowed_operation_types=allowed_operation_types,
+        )
+
+    def parse_multipart(self, request: SyncHTTPRequestAdapter) -> Dict[str, str]:
+        operations = self.parse_json(request.post_data.get("operations", "{}"))
+        files_map = self.parse_json(request.post_data.get("map", "{}"))
+
+        try:
+            return replace_placeholders_with_files(operations, files_map, request.files)
+        except KeyError as e:
+            raise HTTPException(400, "File(s) missing in form data") from e
+
+    def parse_http_body(self, request: SyncHTTPRequestAdapter) -> GraphQLRequestData:
+        content_type = request.content_type or ""
+
+        if "application/json" in content_type:
+            data = self.parse_json(request.body)
+        elif content_type.startswith("multipart/form-data"):
+            data = self.parse_multipart(request)
+        elif request.method == "GET":
+            data = self.parse_query_params(request.query_params)
+        else:
+            raise HTTPException(400, "Unsupported content type")
+
+        return GraphQLRequestData(
+            query=data.get("query"),
+            variables=data.get("variables"),  # type: ignore
+            operation_name=data.get("operationName"),
+        )
+
+    def run(
+        self,
+        request: Request,
+        context: Optional[Context] = UNSET,
+        root_value: Optional[RootValue] = UNSET,
+    ) -> Response:
+        request_adapter = self.request_adapter_class(request)
+
+        if not self.is_request_allowed(request_adapter):
+            raise HTTPException(405, "GraphQL only supports GET and POST requests.")
+
+        if self.should_render_graphiql(request_adapter):
+            if self.graphiql:
+                return self.render_graphiql(request)
+            else:
+                raise HTTPException(404, "Not Found")
+
+        sub_response = self.get_sub_response(request)
+        context = (
+            self.get_context(request, response=sub_response)
+            if context is UNSET
+            else context
+        )
+        root_value = self.get_root_value(request) if root_value is UNSET else root_value
+
+        assert context
+
+        try:
+            result = self.execute_operation(
+                request=request,
+                context=context,
+                root_value=root_value,
+            )
+        except InvalidOperationTypeError as e:
+            raise HTTPException(
+                400, e.as_http_error_reason(request_adapter.method)
+            ) from e
+        except MissingQueryError as e:
+            raise HTTPException(400, "No GraphQL query found in the request") from e
+
+        response_data = self.process_result(request=request, result=result)
+
+        return self.create_response(
+            response_data=response_data, sub_response=sub_response
+        )
+
+    def process_result(
+        self, request: Request, result: ExecutionResult
+    ) -> GraphQLHTTPResponse:
+        return process_result(result)

strawberry/http/temporal_response.py

@@ -1,6 +1,8 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Dict
 
 
 @dataclass
 class TemporalResponse:
     status_code: int = 200
+    headers: Dict[str, str] = field(default_factory=dict)

strawberry/http/types.py

@@ -0,0 +1,13 @@
+from typing import Any, List, Mapping, Optional, Union
+from typing_extensions import Literal, TypedDict
+
+HTTPMethod = Literal[
+    "GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "TRACE"
+]
+
+QueryParams = Mapping[str, Optional[Union[str, List[str]]]]
+
+
+class FormData(TypedDict):
+    files: Mapping[str, Any]
+    form: Mapping[str, Any]

strawberry/http/typevars.py

@@ -0,0 +1,7 @@
+from typing import TypeVar
+
+Request = TypeVar("Request", contravariant=True)
+Response = TypeVar("Response")
+SubResponse = TypeVar("SubResponse")
+Context = TypeVar("Context")
+RootValue = TypeVar("RootValue")

strawberry/sanic/utils.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from io import BytesIO
-from typing import TYPE_CHECKING, Any, Dict, List, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
+
+from sanic.request import File
 
 if TYPE_CHECKING:
     from sanic.request import Request
@@ -23,11 +25,16 @@ def convert_request_to_files_dict(request: Request) -> Dict[str, Any]:
 
     Note that the dictionary entries are lists.
     """
-    request_files = request.files
+    request_files = cast(Optional[Dict[str, List[File]]], request.files)
+
+    if not request_files:
+        return {}
+
     files_dict: Dict[str, Union[BytesIO, List[BytesIO]]] = {}
 
     for field_name, file_list in request_files.items():
         assert len(file_list) == 1
+
         files_dict[field_name] = BytesIO(file_list[0].body)
 
     return files_dict

strawberry/sanic/views.py

@@ -2,37 +2,82 @@ from __future__ import annotations
 
 import json
 import warnings
-from typing import TYPE_CHECKING, Any, Dict, Optional, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Type,
+    cast,
+)
 
-from sanic.exceptions import NotFound, SanicException, ServerError
+from sanic.request import Request
 from sanic.response import HTTPResponse, html
 from sanic.views import HTTPMethodView
-from strawberry.exceptions import MissingQueryError
-from strawberry.file_uploads.utils import replace_placeholders_with_files
-from strawberry.http import (
-    parse_query_params,
-    parse_request_data,
-    process_result,
-)
+from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncHTTPRequestAdapter
+from strawberry.http.exceptions import HTTPException
 from strawberry.http.temporal_response import TemporalResponse
-from strawberry.sanic.graphiql import should_render_graphiql
+from strawberry.http.types import FormData, HTTPMethod, QueryParams
+from strawberry.http.typevars import (
+    Context,
+    RootValue,
+)
 from strawberry.sanic.utils import convert_request_to_files_dict
-from strawberry.schema.exceptions import InvalidOperationTypeError
-from strawberry.types.graphql import OperationType
 from strawberry.utils.graphiql import get_graphiql_html
 
 if TYPE_CHECKING:
-    from typing_extensions import Literal
-
-    from sanic.request import Request
-    from strawberry.http import GraphQLHTTPResponse, GraphQLRequestData
+    from strawberry.http import GraphQLHTTPResponse
     from strawberry.schema import BaseSchema
-    from strawberry.types import ExecutionResult
 
-    from .context import StrawberrySanicContext
 
+class SanicHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request):
+        self.request = request
+
+    @property
+    def query_params(self) -> QueryParams:
+        # Just a heads up, Sanic's request.args uses urllib.parse.parse_qs
+        # to parse query string parameters. This returns a dictionary where
+        # the keys are the unique variable names and the values are lists
+        # of values for each variable name. To ensure consistency, we're
+        # enforcing the use of the first value in each list.
+
+        args = cast(
+            Dict[str, Optional[List[str]]],
+            self.request.get_args(keep_blank_values=True),
+        )
+
+        return {k: args.get(k, None) for k in args}
+
+    @property
+    def method(self) -> HTTPMethod:
+        return cast(HTTPMethod, self.request.method.upper())
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
 
-class GraphQLView(HTTPMethodView):
+    async def get_body(self) -> str:
+        return self.request.body.decode()
+
+    async def get_form_data(self) -> FormData:
+        assert self.request.form is not None
+
+        files = convert_request_to_files_dict(self.request)
+
+        return FormData(form=self.request.form, files=files)
+
+
+class GraphQLView(
+    AsyncBaseHTTPView[Request, HTTPResponse, TemporalResponse, Context, RootValue],
+    HTTPMethodView,
+):
     """
     Class based view to handle GraphQL HTTP Requests
 
@@ -51,6 +96,9 @@ class GraphQLView(HTTPMethodView):
         )
     """
 
+    allow_queries_via_get = True
+    request_adapter_class = SanicHTTPRequestAdapter
+
     def __init__(
         self,
         schema: BaseSchema,
@@ -81,57 +129,26 @@ class GraphQLView(HTTPMethodView):
 
             self.json_encoder = json.JSONEncoder
 
-    def get_root_value(self) -> Any:
+    async def get_root_value(self, request: Request) -> Optional[RootValue]:
         return None
 
     async def get_context(
         self, request: Request, response: TemporalResponse
-    ) -> StrawberrySanicContext:
-        return {"request": request, "response": response}
-
-    def render_template(self, template: str) -> HTTPResponse:
-        return html(template)
+    ) -> Context:
+        return {"request": request, "response": response}  # type: ignore
 
-    async def process_result(
-        self, request: Request, result: ExecutionResult
-    ) -> GraphQLHTTPResponse:
-        return process_result(result)
+    def render_graphiql(self, request: Request) -> HTTPResponse:
+        template = get_graphiql_html()
 
-    async def get(self, request: Request) -> HTTPResponse:
-        if request.args:
-            # Sanic request.args uses urllib.parse.parse_qs
-            # returns a dictionary where the keys are the unique variable names
-            # and the values are a list of values for each variable name
-            # Enforcing using the first value
-            query_data = {
-                variable_name: value[0] for variable_name, value in request.args.items()
-            }
-            try:
-                data = parse_query_params(query_data)
-            except json.JSONDecodeError:
-                raise ServerError(
-                    "Unable to parse request body as JSON", status_code=400
-                )
-
-            request_data = parse_request_data(data)
-
-            return await self.execute_request(
-                request=request, request_data=request_data, method="GET"
-            )
-
-        elif should_render_graphiql(self.graphiql, request):
-            template = get_graphiql_html(False)
-            return self.render_template(template=template)
+        return html(template)
 
-        raise NotFound()
+    async def get_sub_response(self, request: Request) -> TemporalResponse:
+        return TemporalResponse()
 
-    async def get_response(
-        self, response_data: GraphQLHTTPResponse, context: StrawberrySanicContext
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: TemporalResponse
     ) -> HTTPResponse:
-        status_code = 200
-
-        if "response" in context and context["response"]:
-            status_code = context["response"].status_code
+        status_code = sub_response.status_code
 
         data = self.encode_json(response_data)
 
@@ -139,84 +156,17 @@ class GraphQLView(HTTPMethodView):
             data,
             status=status_code,
             content_type="application/json",
+            headers=sub_response.headers,
         )
 
-    def encode_json(self, response_data: GraphQLHTTPResponse) -> str:
-        if self.json_dumps_params:
-            assert self.json_encoder
-
-            return json.dumps(
-                response_data, cls=self.json_encoder, **self.json_dumps_params
-            )
-
-        if self.json_encoder:
-            return json.dumps(response_data, cls=self.json_encoder)
-
-        return json.dumps(response_data)
-
     async def post(self, request: Request) -> HTTPResponse:
-        request_data = self.get_request_data(request)
-
-        return await self.execute_request(
-            request=request, request_data=request_data, method="POST"
-        )
-
-    async def execute_request(
-        self,
-        request: Request,
-        request_data: GraphQLRequestData,
-        method: Union[Literal["GET"], Literal["POST"]],
-    ) -> HTTPResponse:
-        context = await self.get_context(request, TemporalResponse())
-        root_value = self.get_root_value()
-
-        allowed_operation_types = OperationType.from_http(method)
-
-        if not self.allow_queries_via_get and method == "GET":
-            allowed_operation_types = allowed_operation_types - {OperationType.QUERY}
-
         try:
-            result = await self.schema.execute(
-                query=request_data.query,
-                variable_values=request_data.variables,
-                context_value=context,
-                root_value=root_value,
-                operation_name=request_data.operation_name,
-                allowed_operation_types=allowed_operation_types,
-            )
-        except InvalidOperationTypeError as e:
-            raise ServerError(
-                e.as_http_error_reason(method=method), status_code=400
-            ) from e
-        except MissingQueryError:
-            raise ServerError("No GraphQL query found in the request", status_code=400)
-
-        response_data = await self.process_result(request, result)
+            return await self.run(request)
+        except HTTPException as e:
+            return HTTPResponse(e.reason, status=e.status_code)
 
-        return await self.get_response(response_data, context)
-
-    def get_request_data(self, request: Request) -> GraphQLRequestData:
+    async def get(self, request: Request) -> HTTPResponse:
         try:
-            data = self.parse_request(request)
-        except json.JSONDecodeError:
-            raise ServerError("Unable to parse request body as JSON", status_code=400)
-
-        return parse_request_data(data)
-
-    def parse_request(self, request: Request) -> Dict[str, Any]:
-        content_type = request.content_type or ""
-
-        if "application/json" in content_type:
-            return json.loads(request.body)
-        elif content_type.startswith("multipart/form-data"):
-            files = convert_request_to_files_dict(request)
-            operations = json.loads(request.form.get("operations", "{}"))
-            files_map = json.loads(request.form.get("map", "{}"))
-            try:
-                return replace_placeholders_with_files(operations, files_map, files)
-            except KeyError:
-                raise SanicException(
-                    status_code=400, message="File(s) missing in form data"
-                )
-
-        raise ServerError("Unsupported Media Type", status_code=415)
+            return await self.run(request)
+        except HTTPException as e:
+            return HTTPResponse(e.reason, status=e.status_code)

strawberry/schema/name_converter.py

@@ -5,7 +5,7 @@ from typing_extensions import Protocol
 
 from strawberry.custom_scalar import ScalarDefinition
 from strawberry.directive import StrawberryDirective
-from strawberry.enum import EnumDefinition
+from strawberry.enum import EnumDefinition, EnumValue
 from strawberry.lazy_type import LazyType
 from strawberry.schema_directive import StrawberrySchemaDirective
 from strawberry.type import StrawberryList, StrawberryOptional
@@ -76,6 +76,9 @@ class NameConverter:
     def from_enum(self, enum: EnumDefinition) -> str:
         return enum.name
 
+    def from_enum_value(self, enum: EnumDefinition, enum_value: EnumValue) -> str:
+        return enum_value.name
+
     def from_directive(
         self, directive: Union[StrawberryDirective, StrawberrySchemaDirective]
     ) -> str:

strawberry/schema/schema_converter.py

@@ -150,7 +150,12 @@ class GraphQLCoreConverter:
         graphql_enum = CustomGraphQLEnumType(
             enum=enum,
             name=enum_name,
-            values={item.name: self.from_enum_value(item) for item in enum.values},
+            values={
+                self.config.name_converter.from_enum_value(
+                    enum, item
+                ): self.from_enum_value(item)
+                for item in enum.values
+            },
             description=enum.description,
             extensions={
                 GraphQLCoreConverter.DEFINITION_BACKREF: enum,