Merge pull request #27 from graphql-python/features/graphql-server

Use graphql_server package for reusability

Author: syrusakbary

flask_graphql/graphqlview.py

@@ -1,27 +1,16 @@
-import json
+from functools import partial
 
-import six
 from flask import Response, request
 from flask.views import View
-from werkzeug.exceptions import BadRequest, MethodNotAllowed
 
-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 (HttpQueryError, default_format_error,
+                            encode_execution_results, json_encode,
+                            load_json_body, run_http_query)
 
 from .render_graphiql import render_graphiql
 
 
-class HttpError(Exception):
-    def __init__(self, response, message=None, *args, **kwargs):
-        self.response = response
-        self.message = message = message or response.description
-        super(HttpError, self).__init__(message, *args, **kwargs)
-
-
 class GraphQLView(View):
     schema = None
     executor = None
@@ -42,52 +31,68 @@ def __init__(self, **kwargs):
             if hasattr(self, key):
                 setattr(self, key, value)
 
-        assert not all((self.graphiql, self.batch)), 'Use either graphiql or batch processing'
         assert isinstance(self.schema, GraphQLSchema), 'A Schema is required to be provided to GraphQLView.'
 
     # noinspection PyUnusedLocal
-    def get_root_value(self, request):
+    def get_root_value(self):
         return self.root_value
 
-    def get_context(self, request):
+    def get_context(self):
         if self.context is not None:
             return self.context
         return request
 
-    def get_middleware(self, request):
+    def get_middleware(self):
         return self.middleware
 
-    def get_executor(self, request):
+    def get_executor(self):
         return self.executor
 
-    def render_graphiql(self, **kwargs):
+    def render_graphiql(self, params, result):
         return render_graphiql(
+            params=params,
+            result=result,
             graphiql_version=self.graphiql_version,
             graphiql_template=self.graphiql_template,
-            **kwargs
         )
 
+    format_error = staticmethod(default_format_error)
+    encode = staticmethod(json_encode)
+
     def dispatch_request(self):
         try:
-            if request.method.lower() not in ('get', 'post'):
-                raise HttpError(MethodNotAllowed(['GET', 'POST'], 'GraphQL only supports GET and POST requests.'))
-
-            data = self.parse_body(request)
-            show_graphiql = self.graphiql and self.can_display_graphiql(data)
-
-            if self.batch:
-                responses = [self.get_response(request, entry) for entry in data]
-                result = '[{}]'.format(','.join([response[0] for response in responses]))
-                status_code = max(responses, key=lambda response: response[1])[1]
-            else:
-                result, status_code = self.get_response(request, data, show_graphiql)
+            request_method = request.method.lower()
+            data = self.parse_body()
+
+            show_graphiql = request_method == 'get' and self.should_display_graphiql()
+            catch = HttpQueryError if show_graphiql else None
+
+            pretty = self.pretty or show_graphiql or request.args.get('pretty')
+
+            execution_results, all_params = run_http_query(
+                self.schema,
+                request_method,
+                data,
+                query_data=request.args,
+                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(),
+            )
+            result, status_code = encode_execution_results(
+                execution_results,
+                is_batch=isinstance(data, list),
+                format_error=self.format_error,
+                encode=partial(self.encode, pretty=pretty)
+            )
 
             if show_graphiql:
-                query, variables, operation_name, id = self.get_graphql_params(request, data)
                 return self.render_graphiql(
-                    query=query,
-                    variables=variables,
-                    operation_name=operation_name,
+                    params=all_params[0],
                     result=result
                 )
 
@@ -97,167 +102,42 @@ def dispatch_request(self):
                 content_type='application/json'
             )
 
-        except HttpError as e:
+        except HttpQueryError as e:
             return Response(
-                self.json_encode(request, {
+                self.encode({
                     'errors': [self.format_error(e)]
                 }),
-                status=e.response.code,
-                headers={'Allow': ['GET, POST']},
+                status=e.status_code,
+                headers=e.headers,
                 content_type='application/json'
             )
 
-    def get_response(self, request, data, show_graphiql=False):
-        query, variables, operation_name, id = self.get_graphql_params(request, data)
-
-        execution_result = self.execute_graphql_request(
-            data,
-            query,
-            variables,
-            operation_name,
-            show_graphiql
-        )
-
-        status_code = 200
-        if execution_result:
-            response = {}
-
-            if execution_result.errors:
-                response['errors'] = [self.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 self.batch:
-                response = {
-                    'id': id,
-                    'payload': response,
-                    'status': status_code,
-                }
-
-            result = self.json_encode(request, response, show_graphiql)
-        else:
-            result = None
-
-        return result, status_code
-
-    def json_encode(self, request, d, show_graphiql=False):
-        pretty = self.pretty or show_graphiql or request.args.get('pretty')
-        if not pretty:
-            return json.dumps(d, separators=(',', ':'))
-
-        return json.dumps(d, sort_keys=True,
-                          indent=2, separators=(',', ': '))
-
+    # Flask
     # noinspection PyBroadException
-    def parse_body(self, request):
-        content_type = self.get_content_type(request)
+    def parse_body(self):
+        # We use mimetype here since we don't need the other
+        # information provided by content_type
+        content_type = request.mimetype
         if content_type == 'application/graphql':
-            return {'query': request.data.decode()}
+            return {'query': request.data.decode('utf8')}
 
         elif content_type == 'application/json':
-            try:
-                request_json = json.loads(request.data.decode('utf8'))
-                if self.batch:
-                    assert isinstance(request_json, list)
-                else:
-                    assert isinstance(request_json, dict)
-                return request_json
-            except:
-                raise HttpError(BadRequest('POST body sent invalid JSON.'))
+            return load_json_body(request.data.decode('utf8'))
 
-        elif content_type == 'application/x-www-form-urlencoded':
-            return request.form
-
-        elif content_type == 'multipart/form-data':
+        elif content_type in ('application/x-www-form-urlencoded', 'multipart/form-data'):
             return request.form
 
         return {}
 
-    def execute(self, *args, **kwargs):
-        return execute(self.schema, *args, **kwargs)
-
-    def execute_graphql_request(self, data, query, variables, operation_name, show_graphiql=False):
-        if not query:
-            if show_graphiql:
-                return None
-            raise HttpError(BadRequest('Must provide query string.'))
-
-        try:
-            source = Source(query, name='GraphQL request')
-            ast = parse(source)
-            validation_errors = validate(self.schema, ast)
-            if validation_errors:
-                return ExecutionResult(
-                    errors=validation_errors,
-                    invalid=True,
-                )
-        except Exception as e:
-            return ExecutionResult(errors=[e], invalid=True)
-
-        if request.method.lower() == 'get':
-            operation_ast = get_operation_ast(ast, operation_name)
-            if operation_ast and operation_ast.operation != 'query':
-                if show_graphiql:
-                    return None
-                raise HttpError(MethodNotAllowed(
-                    ['POST'], 'Can only perform a {} operation from a POST request.'.format(operation_ast.operation)
-                ))
-
-        try:
-            return self.execute(
-                ast,
-                root_value=self.get_root_value(request),
-                variable_values=variables or {},
-                operation_name=operation_name,
-                context_value=self.get_context(request),
-                middleware=self.get_middleware(request),
-                executor=self.get_executor(request)
-            )
-        except Exception as e:
-            return ExecutionResult(errors=[e], invalid=True)
+    def should_display_graphiql(self):
+        if not self.graphiql or 'raw' in request.args:
+            return False
 
-    @classmethod
-    def can_display_graphiql(cls, data):
-        raw = 'raw' in request.args or 'raw' in data
-        return not raw and cls.request_wants_html(request)
+        return self.request_wants_html()
 
-    @classmethod
-    def request_wants_html(cls, request):
+    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_graphql_params(request, data):
-        query = request.args.get('query') or data.get('query')
-        variables = request.args.get('variables') or data.get('variables')
-        id = request.args.get('id') or data.get('id')
-
-        if variables and isinstance(variables, six.text_type):
-            try:
-                variables = json.loads(variables)
-            except:
-                raise HttpError(BadRequest('Variables are invalid JSON.'))
-
-        operation_name = request.args.get('operationName') or data.get('operationName')
-
-        return 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)}
-
-    @staticmethod
-    def get_content_type(request):
-        # We use mimetype here since we don't need the other
-        # information provided by content_type
-        return request.mimetype

flask_graphql/render_graphiql.py

@@ -1,6 +1,5 @@
 from flask import render_template_string
 
-
 GRAPHIQL_VERSION = '0.7.1'
 
 TEMPLATE = '''<!--
@@ -112,10 +111,10 @@
         onEditQuery: onEditQuery,
         onEditVariables: onEditVariables,
         onEditOperationName: onEditOperationName,
-        query: {{ query|tojson }},
+        query: {{ params.query|tojson }},
         response: {{ result|tojson }},
-        variables: {{ variables|tojson }},
-        operationName: {{ operation_name|tojson }},
+        variables: {{ params.variables|tojson }},
+        operationName: {{ params.operation_name|tojson }},
       }),
       document.body
     );
@@ -124,9 +123,13 @@
 </html>'''
 
 
-def render_graphiql(graphiql_version=None, graphiql_template=None, **kwargs):
+def render_graphiql(params, result, graphiql_version=None, graphiql_template=None):
     graphiql_version = graphiql_version or GRAPHIQL_VERSION
     template = graphiql_template or TEMPLATE
 
     return render_template_string(
-        template, graphiql_version=graphiql_version, **kwargs)
+        template,
+        graphiql_version=graphiql_version,
+        result=result,
+        params=params
+    )

graphql_server/__init__.py

@@ -0,0 +1,212 @@
+import json
+from collections import namedtuple
+
+import six
+from promise import Promise
+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 .error import HttpQueryError
+
+
+class SkipException(Exception):
+    pass
+
+
+GraphQLParams = namedtuple('GraphQLParams', 'query,variables,operation_name,id')
+GraphQLResponse = namedtuple('GraphQLResponse', 'result,status_code')
+
+
+def default_format_error(error):
+    if isinstance(error, GraphQLError):
+        return format_graphql_error(error)
+
+    return {'message': six.text_type(error)}
+
+
+
+def run_http_query(schema, request_method, data, query_data=None, batch_enabled=False, catch=None, **execute_options):
+        if request_method not in ('get', 'post'):
+            raise HttpQueryError(
+                405,
+                'GraphQL only supports GET and POST requests.',
+                headers={
+                    'Allow': 'GET, POST'
+                }
+            )
+
+        is_batch = isinstance(data, list)
+
+        is_get_request = request_method == 'get'
+        allow_only_query = is_get_request
+
+        if not is_batch:
+            if not isinstance(data, dict):
+                raise HttpQueryError(
+                    400,
+                    'GraphQL params should be a dict. Received {}.'.format(data)
+                )
+            data = [data]
+        elif not batch_enabled:
+            raise HttpQueryError(
+                400,
+                'Batch GraphQL requests are not enabled.'
+            )
+
+        if not data:
+            raise HttpQueryError(
+                400,
+                'Received an empty list in the batch request.'
+            )
+
+        extra_data = {}
+        # If is a batch request, we don't consume the data from the query
+        if not is_batch:
+            extra_data = query_data or {}
+
+        all_params = [get_graphql_params(entry, extra_data) for entry in data]
+
+        responses = [get_response(
+            schema,
+            params,
+            catch,
+            allow_only_query,
+            **execute_options
+        ) for params in all_params]
+
+        return responses, all_params
+
+
+def encode_execution_results(execution_results, format_error, is_batch, encode):
+    responses = [
+        format_execution_result(execution_result, format_error)
+        for execution_result in execution_results
+    ]
+    result, status_codes = zip(*responses)
+    status_code = max(status_codes)
+
+    if not is_batch:
+        result = result[0]
+
+    return encode(result), status_code
+
+
+def json_encode(data, pretty=False):
+    if not pretty:
+        return json.dumps(data, separators=(',', ':'))
+
+    return json.dumps(
+        data,
+        indent=2,
+        separators=(',', ': ')
+    )
+
+
+def load_json_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
+
+
+def get_graphql_params(data, query_data):
+    query = data.get('query') or query_data.get('query')
+    variables = data.get('variables') or query_data.get('variables')
+    id = data.get('id')
+    operation_name = data.get('operationName') or query_data.get('operationName')
+
+    return GraphQLParams(query, load_json_variables(variables), operation_name, id)
+
+
+def get_response(schema, params, catch=None, allow_only_query=False, **kwargs):
+    if catch is None:
+        catch = SkipException
+    try:
+        execution_result = execute_graphql_request(
+            schema,
+            params,
+            allow_only_query,
+            **kwargs
+        )
+    except catch:
+        return None
+
+    return execution_result
+
+
+def format_execution_result(execution_result, 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
+
+    else:
+        response = None
+
+    return GraphQLResponse(response, status_code)
+
+
+def execute_graphql_request(schema, params, allow_only_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 allow_only_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)
+
+
+def load_json_body(data):
+    try:
+        return json.loads(data)
+    except:
+        raise HttpQueryError(
+            400,
+            'POST body sent invalid JSON.'
+        )

graphql_server/error.py

@@ -0,0 +1,7 @@
+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)

tests/test_graphqlview.py

@@ -376,12 +376,12 @@ def test_handles_errors_caused_by_a_lack_of_query(client):
     }
 
 
-def test_handles_invalid_json_bodies(client):
+def test_handles_batch_correctly_if_is_disabled(client):
     response = client.post(url_string(), data='[]', content_type='application/json')
 
     assert response.status_code == 400
     assert response_json(response) == {
-        'errors': [{'message': 'POST body sent invalid JSON.'}]
+        'errors': [{'message': 'Batch GraphQL requests are not enabled.'}]
     }
 
 
@@ -470,15 +470,17 @@ def test_post_multipart_data(client):
 def test_batch_allows_post_with_json_encoding(client):
     response = client.post(
         url_string(),
-        data=jl(id=1, query='{test}'),
+        data=jl(
+            # id=1,
+            query='{test}'
+        ),
         content_type='application/json'
     )
 
     assert response.status_code == 200
     assert response_json(response) == [{
-        'id': 1,
-        'payload': { 'data': {'test': "Hello World"} },
-        'status': 200,
+        # 'id': 1,
+        'data': {'test': "Hello World"}
     }]
 
 
@@ -487,7 +489,7 @@ def test_batch_supports_post_json_query_with_json_variables(client):
     response = client.post(
         url_string(),
         data=jl(
-            id=1,
+            # id=1,
             query='query helloWho($who: String){ test(who: $who) }',
             variables={'who': "Dolly"}
         ),
@@ -496,9 +498,8 @@ def test_batch_supports_post_json_query_with_json_variables(client):
 
     assert response.status_code == 200
     assert response_json(response) == [{
-        'id': 1,
-        'payload': { 'data': {'test': "Hello Dolly"} },
-        'status': 200,
+        # 'id': 1,
+        'data': {'test': "Hello Dolly"}
     }]
 
 
@@ -507,7 +508,7 @@ def test_batch_allows_post_with_operation_name(client):
     response = client.post(
         url_string(),
         data=jl(
-            id=1,
+            # id=1,
             query='''
             query helloYou { test(who: "You"), ...shared }
             query helloWorld { test(who: "World"), ...shared }
@@ -523,12 +524,9 @@ def test_batch_allows_post_with_operation_name(client):
 
     assert response.status_code == 200
     assert response_json(response) == [{
-        'id': 1,
-        'payload': {
-            'data': {
-                'test': 'Hello World',
-                'shared': 'Hello Everyone'
-            }
-        },
-        'status': 200,
+        # 'id': 1,
+        'data': {
+            'test': 'Hello World',
+            'shared': 'Hello Everyone'
+        }
     }]