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

strawberry/django/views.py

@@ -2,12 +2,17 @@ from __future__ import annotations
 
 import asyncio
 import json
-import warnings
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Mapping,
+    Optional,
+    Union,
+    cast,
+)
 
-from django.core.exceptions import BadRequest, SuspiciousOperation
-from django.core.serializers.json import DjangoJSONEncoder
-from django.http import Http404, HttpResponseNotAllowed, JsonResponse
+from django.http import HttpRequest, HttpResponseNotAllowed, JsonResponse
 from django.http.response import HttpResponse
 from django.template import RequestContext, Template
 from django.template.exceptions import TemplateDoesNotExist
@@ -17,30 +22,27 @@ from django.utils.decorators import classonlymethod, method_decorator
 from django.views.decorators.csrf import csrf_exempt
 from django.views.generic import View
 
-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.sync_base_view import SyncBaseHTTPView, SyncHTTPRequestAdapter
+from strawberry.http.types import FormData, HTTPMethod, QueryParams
+from strawberry.http.typevars import (
+    Context,
+    RootValue,
 )
-from strawberry.schema.exceptions import InvalidOperationTypeError
-from strawberry.types.graphql import OperationType
 from strawberry.utils.graphiql import get_graphiql_html
 
 from .context import StrawberryDjangoContext
 
 if TYPE_CHECKING:
-    from django.http import HttpRequest
-
-    from strawberry.http import GraphQLHTTPResponse, GraphQLRequestData
-    from strawberry.types import ExecutionResult
+    from strawberry.http import GraphQLHTTPResponse
 
     from ..schema import BaseSchema
 
 
+# TODO: remove this and unify temporal responses
 class TemporalHttpResponse(JsonResponse):
-    status_code = None
+    status_code: Optional[int] = None  # pyright: ignore
 
     def __init__(self) -> None:
         super().__init__({})
@@ -49,101 +51,99 @@ class TemporalHttpResponse(JsonResponse):
         """Adopted from Django to handle `status_code=None`."""
         if self.status_code is not None:
             return super().__repr__()
+
         return "<{cls} status_code={status_code}{content_type}>".format(
             cls=self.__class__.__name__,
             status_code=self.status_code,
-            content_type=self._content_type_for_repr,
+            content_type=self._content_type_for_repr,  # pyright: ignore
         )
 
 
-class BaseView(View):
-    subscriptions_enabled = False
-    graphiql = True
-    allow_queries_via_get = True
-    schema: Optional[BaseSchema] = None
-    json_encoder: Optional[Type[json.JSONEncoder]] = None
-    json_dumps_params: Optional[Dict[str, Any]] = None
+class DjangoHTTPRequestAdapter(SyncHTTPRequestAdapter):
+    def __init__(self, request: HttpRequest):
+        self.request = request
 
-    def __init__(
-        self,
-        schema: BaseSchema,
-        graphiql: bool = True,
-        allow_queries_via_get: bool = True,
-        subscriptions_enabled: bool = False,
-        **kwargs: Any,
-    ):
-        self.schema = schema
-        self.graphiql = graphiql
-        self.allow_queries_via_get = allow_queries_via_get
-        self.subscriptions_enabled = subscriptions_enabled
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.GET.dict()
 
-        super().__init__(**kwargs)
+    @property
+    def body(self) -> Union[str, bytes]:
+        return self.request.body.decode()
 
-        self.json_dumps_params = kwargs.pop("json_dumps_params", self.json_dumps_params)
+    @property
+    def method(self) -> HTTPMethod:
+        assert self.request.method is not None
 
-        if self.json_dumps_params:
-            warnings.warn(
-                "json_dumps_params is deprecated, override encode_json instead",
-                DeprecationWarning,
-                stacklevel=2,
-            )
+        return cast(HTTPMethod, self.request.method.upper())
 
-            self.json_encoder = DjangoJSONEncoder
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
 
-        self.json_encoder = kwargs.pop("json_encoder", self.json_encoder)
+    @property
+    def post_data(self) -> Mapping[str, Union[str, bytes]]:
+        return self.request.POST
 
-        if self.json_encoder is not None:
-            warnings.warn(
-                "json_encoder is deprecated, override encode_json instead",
-                DeprecationWarning,
-                stacklevel=2,
-            )
+    @property
+    def files(self) -> Mapping[str, Any]:
+        return self.request.FILES
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
 
-    def parse_body(self, request: HttpRequest) -> 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"):
-            data = json.loads(request.POST.get("operations", "{}"))
-            files_map = json.loads(request.POST.get("map", "{}"))
+class AsyncDjangoHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: HttpRequest):
+        self.request = request
 
-            data = replace_placeholders_with_files(data, files_map, request.FILES)
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.GET.dict()
 
-            return data
-        elif request.method.lower() == "get" and request.META.get("QUERY_STRING"):
-            return parse_query_params(request.GET.copy())
+    @property
+    def method(self) -> HTTPMethod:
+        assert self.request.method is not None
 
-        return json.loads(request.body)
+        return cast(HTTPMethod, self.request.method.upper())
 
-    def is_request_allowed(self, request: HttpRequest) -> bool:
-        return request.method.lower() in ("get", "post")
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
 
-    def should_render_graphiql(self, request: HttpRequest) -> bool:
-        if request.method.lower() != "get":
-            return False
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
 
-        if self.allow_queries_via_get and request.META.get("QUERY_STRING"):
-            return False
+    async def get_body(self) -> str:
+        return self.request.body.decode()
 
-        return any(
-            supported_header in request.META.get("HTTP_ACCEPT", "")
-            for supported_header in ("text/html", "*/*")
+    async def get_form_data(self) -> FormData:
+        return FormData(
+            files=self.request.FILES,
+            form=self.request.POST,
         )
 
-    def get_request_data(self, request: HttpRequest) -> GraphQLRequestData:
-        try:
-            data = self.parse_body(request)
-        except json.decoder.JSONDecodeError:
-            raise SuspiciousOperation("Unable to parse request body as JSON")
-        except KeyError:
-            raise BadRequest("File(s) missing in form data")
 
-        return parse_request_data(data)
+class BaseView:
+    def __init__(
+        self,
+        schema: BaseSchema,
+        graphiql: bool = True,
+        allow_queries_via_get: bool = True,
+        subscriptions_enabled: bool = False,
+        **kwargs: Any,
+    ):
+        self.schema = schema
+        self.graphiql = graphiql
+        self.allow_queries_via_get = allow_queries_via_get
+        self.subscriptions_enabled = subscriptions_enabled
+
+        super().__init__(**kwargs)
 
-    def _render_graphiql(self, request: HttpRequest, context=None) -> TemplateResponse:
-        if not self.graphiql:
-            raise Http404()
+    def render_graphiql(self, request: HttpRequest) -> HttpResponse:
+        context = None  # TODO?
 
         try:
             template = Template(render_to_string("graphql/graphiql.html"))
@@ -158,10 +158,10 @@ class BaseView(View):
 
         return response
 
-    def _create_response(
+    def create_response(
         self, response_data: GraphQLHTTPResponse, sub_response: HttpResponse
     ) -> HttpResponse:
-        data = self.encode_json(response_data)
+        data = self.encode_json(response_data)  # type: ignore
 
         response = HttpResponse(
             data,
@@ -171,7 +171,7 @@ class BaseView(View):
         for name, value in sub_response.items():
             response[name] = value
 
-        if sub_response.status_code is not None:
+        if sub_response.status_code:
             response.status_code = sub_response.status_code
 
         for name, value in sub_response.cookies.items():
@@ -179,82 +179,57 @@ class BaseView(View):
 
         return response
 
-    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)
 
+class GraphQLView(
+    BaseView,
+    SyncBaseHTTPView[
+        HttpRequest, HttpResponse, TemporalHttpResponse, Context, RootValue
+    ],
+    View,
+):
+    subscriptions_enabled = False
+    graphiql = True
+    allow_queries_via_get = True
+    schema: BaseSchema = None  # type: ignore
+    request_adapter_class = DjangoHTTPRequestAdapter
 
-class GraphQLView(BaseView):
-    def get_root_value(self, request: HttpRequest) -> Any:
+    def get_root_value(self, request: HttpRequest) -> Optional[RootValue]:
         return None
 
     def get_context(self, request: HttpRequest, response: HttpResponse) -> Any:
         return StrawberryDjangoContext(request=request, response=response)
 
-    def process_result(
-        self, request: HttpRequest, result: ExecutionResult
-    ) -> GraphQLHTTPResponse:
-        return process_result(result)
+    def get_sub_response(self, request: HttpRequest) -> TemporalHttpResponse:
+        return TemporalHttpResponse()
 
     @method_decorator(csrf_exempt)
     def dispatch(
-        self, request, *args, **kwargs
+        self, request: HttpRequest, *args: Any, **kwargs: Any
     ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
-        if not self.is_request_allowed(request):
-            return HttpResponseNotAllowed(
-                ["GET", "POST"], "GraphQL only supports GET and POST requests."
-            )
-
-        if self.should_render_graphiql(request):
-            return self._render_graphiql(request)
-
-        request_data = self.get_request_data(request)
-
-        sub_response = TemporalHttpResponse()
-        context = self.get_context(request, response=sub_response)
-        root_value = self.get_root_value(request)
-
-        method = request.method
-        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}
-
-        assert self.schema
-
         try:
-            result = 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,
+            return self.run(request=request)
+        except HTTPException as e:
+            return HttpResponse(
+                content=e.reason,
+                status=e.status_code,
             )
-        except InvalidOperationTypeError as e:
-            raise BadRequest(e.as_http_error_reason(method)) from e
-        except MissingQueryError:
-            raise SuspiciousOperation("No GraphQL query found in the request")
 
-        response_data = self.process_result(request=request, result=result)
-
-        return self._create_response(
-            response_data=response_data, sub_response=sub_response
-        )
 
+class AsyncGraphQLView(
+    BaseView,
+    AsyncBaseHTTPView[
+        HttpRequest, HttpResponse, TemporalHttpResponse, Context, RootValue
+    ],
+    View,
+):
+    subscriptions_enabled = False
+    graphiql = True
+    allow_queries_via_get = True
+    schema: BaseSchema = None  # type: ignore
+    request_adapter_class = AsyncDjangoHTTPRequestAdapter
 
-class AsyncGraphQLView(BaseView):
     @classonlymethod
-    def as_view(cls, **initkwargs) -> Callable[..., HttpResponse]:
+    def as_view(cls, **initkwargs: Any) -> Callable[..., HttpResponse]:
         # This code tells django that this view is async, see docs here:
         # https://docs.djangoproject.com/en/3.1/topics/async/#async-views
 
@@ -262,60 +237,23 @@ class AsyncGraphQLView(BaseView):
         view._is_coroutine = asyncio.coroutines._is_coroutine  # type: ignore[attr-defined] # noqa: E501
         return view
 
-    @method_decorator(csrf_exempt)
-    async def dispatch(
-        self, request, *args, **kwargs
-    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
-        if not self.is_request_allowed(request):
-            return HttpResponseNotAllowed(
-                ["GET", "POST"], "GraphQL only supports GET and POST requests."
-            )
-
-        if self.should_render_graphiql(request):
-            return self._render_graphiql(request)
-
-        request_data = self.get_request_data(request)
-
-        sub_response = TemporalHttpResponse()
-        context = await self.get_context(request, response=sub_response)
-        root_value = await self.get_root_value(request)
-
-        method = request.method
-
-        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}
-
-        assert self.schema
-
-        try:
-            result = await self.schema.execute(
-                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,
-            )
-        except InvalidOperationTypeError as e:
-            raise BadRequest(e.as_http_error_reason(method)) from e
-        except MissingQueryError:
-            raise SuspiciousOperation("No GraphQL query found in the request")
-
-        response_data = await self.process_result(request=request, result=result)
-
-        return self._create_response(
-            response_data=response_data, sub_response=sub_response
-        )
-
     async def get_root_value(self, request: HttpRequest) -> Any:
         return None
 
     async def get_context(self, request: HttpRequest, response: HttpResponse) -> Any:
         return StrawberryDjangoContext(request=request, response=response)
 
-    async def process_result(
-        self, request: HttpRequest, result: ExecutionResult
-    ) -> GraphQLHTTPResponse:
-        return process_result(result)
+    async def get_sub_response(self, request: HttpRequest) -> TemporalHttpResponse:
+        return TemporalHttpResponse()
+
+    @method_decorator(csrf_exempt)
+    async def dispatch(  # pyright: ignore
+        self, request: HttpRequest, *args: Any, **kwargs: Any
+    ) -> Union[HttpResponseNotAllowed, TemplateResponse, HttpResponse]:
+        try:
+            return await self.run(request=request)
+        except HTTPException as e:
+            return HttpResponse(
+                content=e.reason,
+                status=e.status_code,
+            )