Refactored code using graphql_server

Author: syrusakbary

flask_graphql/graphqlview.py

@@ -1,34 +1,14 @@
 import json
-from promise import Promise
-from collections import namedtuple
 
-import six
 from flask import Response, request
 from flask.views import View
 
-from graphql import Source, execute, parse, validate
-from graphql.error import format_error as format_graphql_error
-from graphql.error import GraphQLError
-from graphql.execution import ExecutionResult
 from graphql.type.schema import GraphQLSchema
-from graphql.utils.get_operation_ast import get_operation_ast
+from graphql_server import run_http_query, HttpQueryError, default_format_error, load_json_body
 
 from .render_graphiql import render_graphiql
 
 
-GraphQLParams = namedtuple('GraphQLParams', 'query,variables,operation_name,id')
-GraphQLResponse = namedtuple('GraphQLResponse', 'result,status_code')
-
-
-class HttpQueryError(Exception):
-    def __init__(self, status_code, message=None, is_graphql_error=False, headers=None):
-        self.status_code = status_code
-        self.message = message
-        self.is_graphql_error = is_graphql_error
-        self.headers = headers
-        super(HttpQueryError, self).__init__(message)
-
-
 class GraphQLView(View):
     schema = None
     executor = None
@@ -51,22 +31,18 @@ def __init__(self, **kwargs):
 
         assert isinstance(self.schema, GraphQLSchema), 'A Schema is required to be provided to GraphQLView.'
 
-    # Flask
     # noinspection PyUnusedLocal
     def get_root_value(self):
         return self.root_value
 
-    # Flask
     def get_context(self):
         if self.context is not None:
             return self.context
         return request
 
-    # Flask
     def get_middleware(self):
         return self.middleware
 
-    # Flask
     def get_executor(self):
         return self.executor
 
@@ -82,57 +58,30 @@ def dispatch_request(self):
 
         try:
             request_method = request.method.lower()
-            if request_method not in ('get', 'post'):
-                raise HttpQueryError(
-                    405,
-                    'GraphQL only supports GET and POST requests.',
-                    headers={
-                        'Allow': ['GET, POST']
-                    }
-                )
-
             data = self.parse_body()
-            is_batch = isinstance(data, list)
+            if isinstance(data, dict):
+                data = dict(data, **request.args.to_dict())
 
-            show_graphiql = not is_batch and self.should_display_graphiql(data)
+            show_graphiql = request_method == 'get' and self.should_display_graphiql()
             catch = HttpQueryError if show_graphiql else None
-            only_allow_query = request_method == 'get'
-
-            if not is_batch:
-                if not isinstance(data, dict):
-                    raise HttpQueryError(
-                        400,
-                        'GraphQL params should be a dict. Received {}.'.format(data)
-                    )
-                data = dict(data, **request.args.to_dict())
-                data = [data]
-            elif not self.batch:
-                raise HttpQueryError(
-                    400,
-                    'Batch GraphQL requests are not enabled.'
-                )
 
-            all_params = [self.get_graphql_params(entry) for entry in data]
+            pretty = self.pretty or show_graphiql or request.args.get('pretty')
 
-            responses = [self.get_response(
+            result, status_code, all_params = run_http_query(
                 self.schema,
-                params,
-                catch,
-                only_allow_query,
+                request_method,
+                data,
+                batch_enabled=self.batch,
+                catch=catch,
+
+                # Execute options
                 root_value=self.get_root_value(),
                 context_value=self.get_context(),
                 middleware=self.get_middleware(),
                 executor=self.get_executor(),
-            ) for params in all_params]
-
-            response, status_codes = zip(*responses)
-            status_code = max(status_codes)
-
-            if not is_batch:
-                response = response[0]
+            )
 
-            pretty = self.pretty or show_graphiql or request.args.get('pretty')
-            result = self.json_encode(response, pretty)
+            result = self.json_encode(result, pretty)
 
             if show_graphiql:
                 return self.render_graphiql(
@@ -149,49 +98,13 @@ def dispatch_request(self):
         except HttpQueryError as e:
             return Response(
                 self.json_encode({
-                    'errors': [self.format_error(e)]
+                    'errors': [default_format_error(e)]
                 }),
                 status=e.status_code,
                 headers=e.headers,
                 content_type='application/json'
             )
 
-    def get_response(self, schema, params, catch=None, only_allow_query=False, **kwargs):
-        try:
-            execution_result = self.execute_graphql_request(
-                schema,
-                params,
-                only_allow_query,
-                **kwargs
-            )
-        except catch:
-            return GraphQLResponse(None, 400)
-        
-        return self.format_execution_result(execution_result, params.id, self.format_error)
-
-    @staticmethod
-    def format_execution_result(execution_result, id, format_error):
-        status_code = 200
-        if execution_result:
-            response = {}
-
-            if execution_result.errors:
-                response['errors'] = [format_error(e) for e in execution_result.errors]
-
-            if execution_result.invalid:
-                status_code = 400
-            else:
-                status_code = 200
-                response['data'] = execution_result.data
-
-            if id:
-                response['id'] = id
-
-        else:
-            response = None
-
-        return GraphQLResponse(response, status_code)
-
     # Flask
     # noinspection PyBroadException
     def parse_body(self):
@@ -202,61 +115,14 @@ def parse_body(self):
             return {'query': request.data.decode()}
 
         elif content_type == 'application/json':
-            try:
-                return json.loads(request.data.decode('utf8'))
-            except:
-                raise HttpQueryError(
-                    400,
-                    'POST body sent invalid JSON.'
-                )
-
-        elif content_type == 'application/x-www-form-urlencoded':
-            return request.form.to_dict()
+            return load_json_body(request.data.decode('utf8'))
 
-        elif content_type == 'multipart/form-data':
+        elif content_type == 'application/x-www-form-urlencoded' \
+          or content_type == 'multipart/form-data':
             return request.form.to_dict()
 
         return {}
 
-    @staticmethod
-    def execute_graphql_request(schema, params, only_allow_query=False, **kwargs):
-        if not params.query:
-            raise HttpQueryError(400, 'Must provide query string.')
-
-        try:
-            source = Source(params.query, name='GraphQL request')
-            ast = parse(source)
-            validation_errors = validate(schema, ast)
-            if validation_errors:
-                return ExecutionResult(
-                    errors=validation_errors,
-                    invalid=True,
-                )
-        except Exception as e:
-            return ExecutionResult(errors=[e], invalid=True)
-
-        if only_allow_query:
-            operation_ast = get_operation_ast(ast, params.operation_name)
-            if operation_ast and operation_ast.operation != 'query':
-                raise HttpQueryError(
-                    405,
-                    'Can only perform a {} operation from a POST request.'.format(operation_ast.operation),
-                    headers={
-                        'Allow': ['POST'],
-                    }
-                )
-
-        try:
-            return execute(
-                schema,
-                ast,
-                operation_name=params.operation_name,
-                variable_values=params.variables,
-                **kwargs
-            )
-        except Exception as e:
-            return ExecutionResult(errors=[e], invalid=True)
-
     @staticmethod
     def json_encode(data, pretty=False):
         if not pretty:
@@ -268,42 +134,15 @@ def json_encode(data, pretty=False):
             separators=(',', ': ')
         )
 
-    # Flask
-    def should_display_graphiql(self, data):
-        if not self.graphiql or 'raw' in data:
+    def should_display_graphiql(self):
+        if not self.graphiql or 'raw' in request.args:
             return False
 
         return self.request_wants_html()
 
-    # Flask
     def request_wants_html(self):
         best = request.accept_mimetypes \
             .best_match(['application/json', 'text/html'])
         return best == 'text/html' and \
             request.accept_mimetypes[best] > \
             request.accept_mimetypes['application/json']
-
-    @staticmethod
-    def get_variables(variables):
-        if variables and isinstance(variables, six.text_type):
-            try:
-                return json.loads(variables)
-            except:
-                raise HttpQueryError(400, 'Variables are invalid JSON.')
-        return variables
-
-    @classmethod
-    def get_graphql_params(cls, data):
-        query = data.get('query')
-        variables = cls.get_variables(data.get('variables'))
-        id = data.get('id')
-        operation_name = data.get('operationName')
-
-        return GraphQLParams(query, variables, operation_name, id)
-
-    @staticmethod
-    def format_error(error):
-        if isinstance(error, GraphQLError):
-            return format_graphql_error(error)
-
-        return {'message': six.text_type(error)}

tests/app.py

@@ -1,6 +1,6 @@
 from flask import Flask
 from flask_graphql import GraphQLView
-from .schema import Schema
+from schema import Schema
 
 
 def create_app(path='/graphql', **kwargs):