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

strawberry/flask/views.py

@@ -1,33 +1,59 @@
 from __future__ import annotations
 
-import json
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Union, cast
 
-from flask import Response, render_template_string, request
+from flask import Request, Response, render_template_string, request
+from flask.views import View
+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.utils.graphiql import get_graphiql_html
 
 if TYPE_CHECKING:
     from flask.typing import ResponseReturnValue
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.schema.base import BaseSchema
-    from strawberry.types import ExecutionResult
 
-from flask.views import View
-from strawberry.exceptions import MissingQueryError
-from strawberry.file_uploads.utils import replace_placeholders_with_files
-from strawberry.flask.graphiql import should_render_graphiql
-from strawberry.http import (
-    parse_query_params,
-    parse_request_data,
-    process_result,
-)
-from strawberry.schema.exceptions import InvalidOperationTypeError
-from strawberry.types.graphql import OperationType
-from strawberry.utils.graphiql import get_graphiql_html
 
+class FlaskHTTPRequestAdapter(SyncHTTPRequestAdapter):
+    def __init__(self, request: Request):
+        self.request = request
 
-class BaseGraphQLView(View):
-    methods = ["GET", "POST"]
+    @property
+    def query_params(self) -> Mapping[str, Union[str, Optional[List[str]]]]:
+        return self.request.args.to_dict()
+
+    @property
+    def body(self) -> Union[str, bytes]:
+        return self.request.data.decode()
+
+    @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 post_data(self) -> Mapping[str, Union[str, bytes]]:
+        return self.request.form
+
+    @property
+    def files(self) -> Mapping[str, Any]:
+        return self.request.files
+
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
+
+
+class BaseGraphQLView:
     def __init__(
         self,
         schema: BaseSchema,
@@ -38,187 +64,100 @@ class BaseGraphQLView(View):
         self.graphiql = graphiql
         self.allow_queries_via_get = allow_queries_via_get
 
-    def render_template(self, template: str) -> str:
-        return render_template_string(template)
+    def render_graphiql(self, request: Request) -> Response:
+        template = get_graphiql_html(False)
 
-    def encode_json(self, response_data: GraphQLHTTPResponse) -> str:
-        return json.dumps(response_data)
+        return render_template_string(template)  # type: ignore
 
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: Response
+    ) -> Response:
+        sub_response.set_data(self.encode_json(response_data))  # type: ignore
 
-class GraphQLView(BaseGraphQLView):
-    def get_root_value(self) -> object:
-        return None
+        return sub_response
 
-    def get_context(self, response: Response) -> Dict[str, object]:
-        return {"request": request, "response": response}
 
-    def process_result(self, result: ExecutionResult) -> GraphQLHTTPResponse:
-        return process_result(result)
+class GraphQLView(
+    BaseGraphQLView,
+    SyncBaseHTTPView[Request, Response, Response, Context, RootValue],
+    View,
+):
+    methods = ["GET", "POST"]
+    allow_queries_via_get: bool = True
+    request_adapter_class = FlaskHTTPRequestAdapter
 
-    def dispatch_request(self) -> ResponseReturnValue:
-        method = request.method
-        content_type = request.content_type or ""
+    def get_context(self, request: Request, response: Response) -> Context:
+        return {"request": request, "response": response}  # type: ignore
 
-        if request.method not in {"POST", "GET"}:
-            return Response(
-                "Unsupported method, must be of request type POST or GET", 405
-            )
+    def get_root_value(self, request: Request) -> Optional[RootValue]:
+        return None
 
-        if "application/json" in content_type:
-            try:
-                data = json.loads(request.data)
-            except json.JSONDecodeError:
-                return Response(
-                    status=400, response="Unable to parse request body as JSON"
-                )
-        elif content_type.startswith("multipart/form-data"):
-            try:
-                operations = json.loads(request.form.get("operations", "{}"))
-                files_map = json.loads(request.form.get("map", "{}"))
-            except json.JSONDecodeError:
-                return Response(
-                    status=400, response="Unable to parse request body as JSON"
-                )
-
-            try:
-                data = replace_placeholders_with_files(
-                    operations, files_map, request.files
-                )
-            except KeyError:
-                return Response(status=400, response="File(s) missing in form data")
-        elif method == "GET" and request.args:
-            try:
-                data = parse_query_params(request.args.to_dict())
-            except json.JSONDecodeError:
-                return Response(
-                    status=400, response="Unable to parse request body as JSON"
-                )
-        elif method == "GET" and should_render_graphiql(self.graphiql, request):
-            template = get_graphiql_html(False)
-
-            return self.render_template(template=template)
-        elif method == "GET":
-            return Response(status=404)
-        else:
-            return Response("Unsupported Media Type", 415)
-
-        request_data = parse_request_data(data)
-
-        response = Response(status=200, content_type="application/json")
-        context = self.get_context(response)
-
-        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}
+    def get_sub_response(self, request: Request) -> Response:
+        return Response(status=200, content_type="application/json")
 
+    def dispatch_request(self) -> ResponseReturnValue:
         try:
-            result = self.schema.execute_sync(
-                request_data.query,
-                variable_values=request_data.variables,
-                context_value=context,
-                operation_name=request_data.operation_name,
-                root_value=self.get_root_value(),
-                allowed_operation_types=allowed_operation_types,
+            return self.run(request=request)
+        except HTTPException as e:
+            return Response(
+                response=e.reason,
+                status=e.status_code,
             )
-        except InvalidOperationTypeError as e:
-            return Response(e.as_http_error_reason(method), 400)
-        except MissingQueryError:
-            return Response("No GraphQL query found in the request", 400)
 
-        response_data = self.process_result(result)
-        response.set_data(self.encode_json(response_data))
 
-        return response
+class AsyncFlaskHTTPRequestAdapter(AsyncHTTPRequestAdapter):
+    def __init__(self, request: Request):
+        self.request = request
 
+    @property
+    def query_params(self) -> QueryParams:
+        return self.request.args.to_dict()
 
-class AsyncGraphQLView(BaseGraphQLView):
-    methods = ["GET", "POST"]
+    @property
+    def method(self) -> HTTPMethod:
+        return cast(HTTPMethod, self.request.method.upper())
 
-    async def get_root_value(self) -> object:
-        return None
+    @property
+    def content_type(self) -> Optional[str]:
+        return self.request.content_type
 
-    async def get_context(self, response: Response) -> Dict[str, object]:
-        return {"request": request, "response": response}
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.request.headers
 
-    async def process_result(self, result: ExecutionResult) -> GraphQLHTTPResponse:
-        return process_result(result)
+    async def get_body(self) -> str:
+        return self.request.data.decode()
 
-    async def dispatch_request(self) -> ResponseReturnValue:  # type: ignore[override]
-        method = request.method
-        content_type = request.content_type or ""
+    async def get_form_data(self) -> FormData:
+        return FormData(
+            files=self.request.files,
+            form=self.request.form,
+        )
 
-        if request.method not in {"POST", "GET"}:
-            return Response(
-                "Unsupported method, must be of request type POST or GET", 405
-            )
 
-        if "application/json" in content_type:
-            try:
-                data = json.loads(request.data)
-            except json.JSONDecodeError:
-                return Response(
-                    status=400, response="Unable to parse request body as JSON"
-                )
-        elif content_type.startswith("multipart/form-data"):
-            try:
-                operations = json.loads(request.form.get("operations", "{}"))
-                files_map = json.loads(request.form.get("map", "{}"))
-            except json.JSONDecodeError:
-                return Response(
-                    status=400, response="Unable to parse request body as JSON"
-                )
-
-            try:
-                data = replace_placeholders_with_files(
-                    operations, files_map, request.files
-                )
-            except KeyError:
-                return Response(status=400, response="File(s) missing in form data")
-        elif method == "GET" and request.args:
-            try:
-                data = parse_query_params(request.args.to_dict())
-            except json.JSONDecodeError:
-                return Response(
-                    status=400, response="Unable to parse request body as JSON"
-                )
-
-        elif method == "GET" and should_render_graphiql(self.graphiql, request):
-            template = get_graphiql_html(False)
-
-            return self.render_template(template=template)
-        elif method == "GET":
-            return Response(status=404)
-        else:
-            return Response("Unsupported Media Type", 415)
-
-        request_data = parse_request_data(data)
-
-        response = Response(status=200, content_type="application/json")
-        context = await self.get_context(response)
-
-        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}
-
-        root_value = await self.get_root_value()
+class AsyncGraphQLView(
+    BaseGraphQLView,
+    AsyncBaseHTTPView[Request, Response, Response, Context, RootValue],
+    View,
+):
+    methods = ["GET", "POST"]
+    allow_queries_via_get: bool = True
+    request_adapter_class = AsyncFlaskHTTPRequestAdapter
 
-        try:
-            result = await self.schema.execute(
-                request_data.query,
-                variable_values=request_data.variables,
-                context_value=context,
-                operation_name=request_data.operation_name,
-                root_value=root_value,
-                allowed_operation_types=allowed_operation_types,
-            )
-        except InvalidOperationTypeError as e:
-            return Response(e.as_http_error_reason(method), 400)
-        except MissingQueryError:
-            return Response("No GraphQL query found in the request", 400)
+    async def get_context(self, request: Request, response: Response) -> Context:
+        return {"request": request, "response": response}  # type: ignore
+
+    async def get_root_value(self, request: Request) -> Optional[RootValue]:
+        return None
 
-        response_data = await self.process_result(result)
-        response.set_data(self.encode_json(response_data))
+    async def get_sub_response(self, request: Request) -> Response:
+        return Response(status=200, content_type="application/json")
 
-        return response
+    async def dispatch_request(self) -> ResponseReturnValue:  # type: ignore
+        try:
+            return await self.run(request=request)
+        except HTTPException as e:
+            return Response(
+                response=e.reason,
+                status=e.status_code,
+            )

strawberry/http/async_base_view.py

@@ -0,0 +1,215 @@
+import abc
+import json
+from typing import (
+    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.base 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 FormData, HTTPMethod, QueryParams
+from .typevars import Context, Request, Response, RootValue, SubResponse
+
+
+class AsyncHTTPRequestAdapter(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def query_params(self) -> QueryParams:
+        ...
+
+    @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]:
+        ...
+
+    @abc.abstractmethod
+    async def get_body(self) -> Union[str, bytes]:
+        ...
+
+    @abc.abstractmethod
+    async def get_form_data(self) -> FormData:
+        ...
+
+
+class AsyncBaseHTTPView(
+    abc.ABC,
+    BaseView[Request],
+    Generic[Request, Response, SubResponse, Context, RootValue],
+):
+    schema: BaseSchema
+    graphiql: bool
+    request_adapter_class: Callable[[Request], AsyncHTTPRequestAdapter]
+
+    @property
+    @abc.abstractmethod
+    def allow_queries_via_get(self) -> bool:
+        ...
+
+    @abc.abstractmethod
+    async def get_sub_response(self, request: Request) -> SubResponse:
+        ...
+
+    @abc.abstractmethod
+    async def get_context(self, request: Request, response: SubResponse) -> Context:
+        ...
+
+    @abc.abstractmethod
+    async def get_root_value(self, request: Request) -> Optional[RootValue]:
+        ...
+
+    @abc.abstractmethod
+    def render_graphiql(self, request: Request) -> Response:
+        # TODO: this could be non abstract
+        # maybe add a get template function?
+        ...
+
+    @abc.abstractmethod
+    def create_response(
+        self, response_data: GraphQLHTTPResponse, sub_response: SubResponse
+    ) -> Response:
+        ...
+
+    async def execute_operation(
+        self, request: Request, context: Context, root_value: Optional[RootValue]
+    ) -> ExecutionResult:
+        request_adapter = self.request_adapter_class(request)
+
+        try:
+            request_data = await 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 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,
+        )
+
+    async def parse_multipart(self, request: AsyncHTTPRequestAdapter) -> Dict[str, str]:
+        try:
+            form_data = await request.get_form_data()
+        except ValueError as e:
+            raise HTTPException(400, "Unable to parse the multipart body") from e
+
+        operations = form_data["form"].get("operations", "{}")
+        files_map = form_data["form"].get("map", "{}")
+
+        if isinstance(operations, (bytes, str)):
+            operations = self.parse_json(operations)
+
+        if isinstance(files_map, (bytes, str)):
+            files_map = self.parse_json(files_map)
+
+        try:
+            return replace_placeholders_with_files(
+                operations, files_map, form_data["files"]
+            )
+        except KeyError as e:
+            raise HTTPException(400, "File(s) missing in form data") from e
+
+    async 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 = await self.get_sub_response(request)
+        context = (
+            await self.get_context(request, response=sub_response)
+            if context is UNSET
+            else context
+        )
+        root_value = (
+            await self.get_root_value(request) if root_value is UNSET else root_value
+        )
+
+        assert context
+
+        try:
+            result = await 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 = await self.process_result(request=request, result=result)
+
+        return self.create_response(
+            response_data=response_data, sub_response=sub_response
+        )
+
+    async def parse_http_body(
+        self, request: AsyncHTTPRequestAdapter
+    ) -> GraphQLRequestData:
+        content_type = request.content_type or ""
+
+        if "application/json" in content_type:
+            data = self.parse_json(await request.get_body())
+        elif content_type.startswith("multipart/form-data"):
+            data = await 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"),
+        )
+
+    async def process_result(
+        self, request: Request, result: ExecutionResult
+    ) -> GraphQLHTTPResponse:
+        return process_result(result)

strawberry/http/base.py

@@ -0,0 +1,63 @@
+import json
+from typing import Any, Dict, Generic, List, Mapping, Optional, Union
+from typing_extensions import Protocol
+
+from strawberry.http import GraphQLHTTPResponse
+from strawberry.http.types import HTTPMethod
+
+from .exceptions import HTTPException
+from .typevars import Request
+
+
+class BaseRequestProtocol(Protocol):
+    @property
+    def query_params(self) -> Mapping[str, Optional[Union[str, List[str]]]]:
+        ...
+
+    @property
+    def method(self) -> HTTPMethod:
+        ...
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        ...
+
+
+class BaseView(Generic[Request]):
+    def should_render_graphiql(self, request: BaseRequestProtocol) -> bool:
+        return (
+            request.method == "GET"
+            and request.query_params.get("query") is None
+            and any(
+                supported_header in request.headers.get("accept", "")
+                for supported_header in ("text/html", "*/*")
+            )
+        )
+
+    def is_request_allowed(self, request: BaseRequestProtocol) -> bool:
+        return request.method in ("GET", "POST")
+
+    def parse_json(self, data: Union[str, bytes]) -> Dict[str, str]:
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError as e:
+            raise HTTPException(400, "Unable to parse request body as JSON") from e
+
+    def encode_json(self, response_data: GraphQLHTTPResponse) -> str:
+        return json.dumps(response_data)
+
+    def parse_query_params(
+        self, params: Mapping[str, Optional[Union[str, List[str]]]]
+    ) -> Dict[str, Any]:
+        params = dict(params)
+
+        if "variables" in params:
+            variables = params["variables"]
+
+            if isinstance(variables, list):
+                variables = variables[0]
+
+            if variables:
+                params["variables"] = json.loads(variables)
+
+        return params

strawberry/http/exceptions.py

@@ -0,0 +1,4 @@
+class HTTPException(Exception):
+    def __init__(self, status_code: int, reason: str):
+        self.status_code = status_code
+        self.reason = reason