First version graphql-flask package

Author: syrusakbary

.gitignore

@@ -0,0 +1,7 @@
+*.pyc
+.idea
+.cache
+.tox
+*.egg
+*.egg-info
+.coverage

.travis.yml

@@ -0,0 +1,27 @@
+language: python
+sudo: false
+matrix:
+  include:
+    - python: "pypy"
+      env: TOX_ENV=pypy
+    - python: "2.7"
+      env: TOX_ENV=py27
+    - python: "3.3"
+      env: TOX_ENV=py33
+    - python: "3.4"
+      env: TOX_ENV=py34
+    - python: "3.5"
+      env: TOX_ENV=py35,import-order,flake8
+
+cache:
+  directories:
+    - $HOME/.cache/pip
+    - $TRAVIS_BUILD_DIR/.tox
+
+install:
+- pip install tox coveralls
+
+script:
+- tox -e $TOX_ENV -- --cov=graphql_flask
+after_success:
+- coveralls

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Syrus Akbary
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,32 @@
+# `graphql-flask`
+
+[![Build Status](https://travis-ci.org/graphql-python/graphql-graphql-flask.svg?branch=master)](https://travis-ci.org/graphql-python/graphql-flask) [![Coverage Status](https://coveralls.io/repos/graphql-python/graphql-flask/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql-python/graphql-flask?branch=master) [![PyPI version](https://badge.fury.io/py/graphql-flask.svg)](https://badge.fury.io/py/graphql-flask)
+
+A `Flask` package that provides two main views for operate with `GraphQL`:
+* `GraphQLView`: endpoint for expose the GraphQL schema
+* `GraphiQLView`: Graphical Interface for operate with GraphQL easily
+
+## Usage
+Use it like you would any other Flask View.
+
+```python
+from flask_graphql import GraphQLView, GraphiQLView
+
+app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema))
+```
+
+### Supported options
+ * `schema`: The `GraphQLSchema` object that you want the view to execute when it gets a valid request.
+ * `pretty`: Whether or not you want the response to be pretty printed JSON.
+ * `executor`: The `Executor` that you want to use to execute queries.
+ * `root_value`: The `root_value` you want to provide to `executor.execute`.
+
+You can also subclass `GraphQLView` and overwrite `get_root_value(self, request)` to have a dynamic root value
+per request.
+
+```python
+class UserRootValue(GraphQLView):
+    def get_root_value(self, request):
+        return request.user
+
+```

graphql_flask/__init__.py

@@ -0,0 +1,5 @@
+from .blueprint import GraphQL
+from .graphqlview import GraphQLView
+from .graphiqlview import GraphiQLView
+
+__all__ = ['GraphQL', 'GraphQLView', 'GraphiQLView']

graphql_flask/blueprint.py

@@ -0,0 +1,16 @@
+from flask import Blueprint
+from .graphqlview import GraphQLView
+from .graphiqlview import GraphiQLView
+
+
+class GraphQL(object):
+    def __init__(self, app, schema, **options):
+        self.app = app
+        self.blueprint = Blueprint('graphql', __name__,
+                                   template_folder='templates',
+                                   static_folder='./static/')
+
+        app.add_url_rule('/graphql', view_func=GraphQLView.as_view('graphql', schema=schema, **options))
+        app.add_url_rule('/graphiql', view_func=GraphiQLView.as_view('graphiql'))
+
+        self.app.register_blueprint(self.blueprint)

graphql_flask/graphiqlview.py

@@ -0,0 +1,16 @@
+from flask import render_template
+from flask.views import View
+
+
+class GraphiQLView(View):
+    template_name = 'graphiql/index.html'
+    methods = ['GET']
+
+    def __init__(self, **kwargs):
+        super(GraphiQLView, self).__init__()
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+    def dispatch_request(self):
+        return render_template(self.template_name)

graphql_flask/graphqlview.py

@@ -0,0 +1,164 @@
+import json
+from werkzeug.exceptions import BadRequest, MethodNotAllowed
+from flask import Response, request
+from flask.views import View
+from graphql.core import Source, parse
+from graphql.core.error import GraphQLError, format_error as format_graphql_error
+from graphql.core.execution import ExecutionResult, get_default_executor
+from graphql.core.type.schema import GraphQLSchema
+from graphql.core.utils.get_operation_ast import get_operation_ast
+import six
+
+
+class HttpError(Exception):
+    def __init__(self, response, message=None, *args, **kwargs):
+        self.response = response
+        self.message = message = message or response.description.decode()
+        super(HttpError, self).__init__(message, *args, **kwargs)
+
+
+class GraphQLView(View):
+    schema = None
+    executor = None
+    root_value = None
+    pretty = False
+
+    methods = ['GET', 'POST', 'PUT', 'DELETE']
+
+    def __init__(self, **kwargs):
+        super(GraphQLView, self).__init__()
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+        if not self.executor:
+            self.executor = get_default_executor()
+
+        assert isinstance(self.schema, GraphQLSchema), 'A Schema is required to be provided to GraphQLView.'
+
+    # noinspection PyUnusedLocal
+    def get_root_value(self, request):
+        return self.root_value
+
+    def get_request_context(self, request):
+        return request
+
+    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.'))
+
+            execution_result = self.execute_graphql_request(request)
+            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
+
+            return Response(
+                status=status_code,
+                response=self.json_encode(request, response),
+                content_type='application/json'
+            )
+
+        except HttpError as e:
+            return Response(
+                self.json_encode(request, {
+                    'errors': [self.format_error(e)]
+                }),
+                status=e.response.code,
+                headers={'Allow': ['GET, POST']},
+                content_type='application/json'
+            )
+
+    def json_encode(self, request, d):
+        if not self.pretty and not request.args.get('pretty'):
+            return json.dumps(d, separators=(',', ':'))
+
+        return json.dumps(d, sort_keys=True,
+                          indent=2, separators=(',', ': '))
+
+    # noinspection PyBroadException
+    def parse_body(self, request):
+        content_type = self.get_content_type(request)
+
+        if content_type == 'application/graphql':
+            return {'query': request.data.decode()}
+
+        elif content_type == 'application/json':
+            try:
+                request_json = json.loads(request.data.decode())
+                assert isinstance(request_json, dict)
+                return request_json
+            except:
+                raise HttpError(BadRequest('POST body sent invalid JSON.'))
+
+        elif content_type == 'application/x-www-form-urlencoded':
+            return request.form
+
+        return {}
+
+    def execute(self, *args, **kwargs):
+        return self.executor.execute(self.schema, *args, **kwargs)
+
+    def execute_graphql_request(self, request):
+        query, variables, operation_name = self.get_graphql_params(request, self.parse_body(request))
+
+        if not query:
+            raise HttpError(BadRequest('Must provide query string.'))
+
+        source = Source(query, name='GraphQL request')
+
+        try:
+            document_ast = parse(source)
+        except Exception as e:
+            return ExecutionResult(errors=[e], invalid=True)
+
+        if request.method.lower() == 'get':
+            operation_ast = get_operation_ast(document_ast, operation_name)
+            if operation_ast and operation_ast.operation != 'query':
+                raise HttpError(MethodNotAllowed(
+                    ['POST'], 'Can only perform a {} operation from a POST request.'.format(operation_ast.operation)
+                ))
+
+        try:
+            return self.execute(
+                document_ast,
+                self.get_root_value(request),
+                variables,
+                operation_name=operation_name,
+                request_context=self.get_request_context(request)
+            )
+        except Exception as e:
+            return ExecutionResult(errors=[e], invalid=True)
+
+    @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')
+
+        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
+
+    @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):
+        return request.content_type