- );
- }
-}
-
-Template.contextTypes = {
- router: React.PropTypes.func
-};
-
-module.exports = Template;
diff --git a/docs/pages/docs/basic-types.md b/docs/pages/docs/basic-types.md
deleted file mode 100644
index f8e251cd..00000000
--- a/docs/pages/docs/basic-types.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-title: Basic Types
-description: Walkthrough Basic Types
----
-
-# Basic Types
-
-Graphene define the following base Scalar Types:
-- `graphene.String`
-- `graphene.Int`
-- `graphene.Float`
-- `graphene.Boolean`
-- `graphene.ID`
-
-Also the following Types are available:
-- `graphene.List`
-- `graphene.NonNull`
-
-Graphene also provides custom scalars for Dates and JSON:
-- `graphene.core.types.custom_scalars.DateTime`
-- `graphene.core.types.custom_scalars.JSONString`
-
-## Shortcuts
-
-There are some shortcuts for building schemas more easily.
-The following are equivalent
-
-```python
-# A list of strings
-string_list = graphene.List(graphene.String())
-string_list = graphene.String().List
-
-# A non-null string
-string_non_null = graphene.String().NonNull
-string_non_null = graphene.NonNull(graphene.String())
-```
-
-
-## Custom scalars
-
-You can also create a custom scalar for your schema.
-If you want to create a DateTime Scalar Type just type:
-
-```python
-import datetime
-from graphene.core.classtypes import Scalar
-from graphql.core.language import ast
-
-class DateTime(Scalar):
- '''DateTime'''
- @staticmethod
- def serialize(dt):
- return dt.isoformat()
-
- @staticmethod
- def parse_literal(node):
- if isinstance(node, ast.StringValue):
- return datetime.datetime.strptime(
- node.value, "%Y-%m-%dT%H:%M:%S.%f")
-
- @staticmethod
- def parse_value(value):
- return datetime.datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
-```
-
-## Mounting in ClassTypes
-
-This types if are mounted in a `ObjectType`, `Interface` or `Mutation`,
- would act as `Field`s.
-
-```python
-class Person(graphene.ObjectType):
- name = graphene.String()
-
-# Is equivalent to:
-class Person(graphene.ObjectType):
- name = graphene.Field(graphene.String())
-```
-
-## Mounting in Fields
-
-If the types are mounted in a `Field`, would act as `Argument`s.
-
-```python
-graphene.Field(graphene.String(), to=graphene.String())
-
-# Is equivalent to:
-graphene.Field(graphene.String(), to=graphene.Argument(graphene.String()))
-```
-
-
-## Using custom object types as argument
-
-To use a custom object type as an argument, you need to inherit `graphene.InputObjectType`, not `graphene.ObjectType`.
-
-```python
-class CustomArgumentObjectType(graphene.InputObjectType):
- field1 = graphene.String()
- field2 = graphene.String()
-
-```
-
-Then, when defining this in an argument, you need to wrap it in an `Argument` object.
-
-```python
-graphene.Field(graphene.String(), to=graphene.Argument(CustomArgumentObjectType))
-```
diff --git a/docs/pages/docs/django/debug.md b/docs/pages/docs/django/debug.md
deleted file mode 100644
index 63afea6c..00000000
--- a/docs/pages/docs/django/debug.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-title: Django Debug Middleware
-description: How to debug Django queries and requests using Graphene
----
-
-# Django Debug Middleware
-
-You can debug your GraphQL queries in a similar way to [django-debug-toolbar](https://django-debug-toolbar.readthedocs.org/),
-but outputing in the results in GraphQL response as fields, instead of the graphical HTML interface.
-
-
-For that, you will need to add the plugin in your graphene schema.
-
-## Installation
-
-For use the Django Debug plugin in Graphene:
-* Import `DjangoDebugMiddleware` and add it to the `middlewares` argument when you initiate the `Schema`.
-* Add the `debug` field into the schema root `Query` with the value `graphene.Field(DjangoDebug, name='__debug')`.
-
-
-```python
-from graphene.contrib.django.debug import DjangoDebugMiddleware, DjangoDebug
-
-class Query(graphene.ObjectType):
- # ...
- debug = graphene.Field(DjangoDebug, name='__debug')
-
-schema = graphene.Schema(query=Query, middlewares=[DjangoDebugMiddleware()])
-```
-
-
-## Querying
-
-You can query it for outputing all the sql transactions that happened in the GraphQL request, like:
-
-```graphql
-{
- # A example that will use the ORM for interact with the DB
- allIngredients {
- edges {
- node {
- id,
- name
- }
- }
- }
- # Here is the debug field that will output the SQL queries
- __debug {
- sql {
- rawSql
- }
- }
-}
-```
-Note that the `__debug` field must be the last field in your query.
diff --git a/docs/pages/docs/django/filtering.md b/docs/pages/docs/django/filtering.md
deleted file mode 100644
index 8f15f6ea..00000000
--- a/docs/pages/docs/django/filtering.md
+++ /dev/null
@@ -1,159 +0,0 @@
----
-title: Filtering
-description: Details of how to perform filtering in Graphene Django
----
-
-# Filteringo
-
-Graphene integrates with [django-filter](https://django-filter.readthedocs.org)
-to provide filtering of results. See the
-[usage documentation](https://django-filter.readthedocs.org/en/latest/usage.html#the-filter)
-for details on the format for `filter_fields`.
-
-This filtering is only available when using the Django integrations
-(i.e. nodes which extend `DjangoNode`). Additionally `django-filter`
-is an optional dependency of Graphene. You will need to
-install it manually, which can be done as follows:
-
-```bash
-# You'll need to django-filter
-pip install django-filter
-```
-
-**Note: The techniques below are demoed in the
-[cookbook example app](https://github.com/graphql-python/graphene/tree/master/examples/cookbook_django).**
-
-## Filterable fields
-
-The `filter_fields` parameter is used to specify the fields which can be filtered upon.
-The value specified here is passed directly to `django-filter`, so see the
-[filtering documentation](https://django-filter.readthedocs.org/en/latest/usage.html#the-filter)
-for full details on the range of options available.
-
-For example:
-
-```python
-class AnimalNode(DjangoNode):
- class Meta:
- # Assume you have an Animal model defined with the following fields
- model = Animal
- filter_fields = ['name', 'genus', 'is_domesticated']
-
-class Query(ObjectType):
- animal = relay.NodeField(AnimalNode)
- all_animals = DjangoFilterConnectionField(AnimalNode)
-```
-
-You could then perform a query such as:
-
-```graphql
-query {
- # Note that fields names become camelcased
- allAnimals(genus: "cat", isDomesticated: true) {
- edges {
- node {
- id,
- name
- }
- }
- }
-}
-```
-
-You can also make more complex lookup types available:
-
-```python
-class AnimalNode(DjangoNode):
- class Meta:
- model = Animal
- # Provide more complex lookup types
- filter_fields = {
- 'name': ['exact', 'icontains', 'istartswith'],
- 'genus': ['exact'],
- 'is_domesticated': ['exact'],
- }
-```
-
-Which you could query as follows:
-
-```graphql
-query {
- # Note that fields names become camelcased
- allAnimals(name_Icontains: "lion") {
- edges {
- node {
- id,
- name
- }
- }
- }
-}
-```
-
-## Orderable fields
-
-Ordering can also be specified using `filter_order_by`. Like `filter_fields`,
-this value is also passed directly to `django-filter` as the `order_by` field.
-For full details see the
-[order_by documentation](https://django-filter.readthedocs.org/en/latest/usage.html#ordering-using-order-by).
-
-For example:
-
-```python
-class AnimalNode(DjangoNode):
- class Meta:
- model = Animal
- filter_fields = ['name', 'genus', 'is_domesticated']
- # Either a tuple/list of fields upon which ordering is allowed, or
- # True to allow filtering on all fields specified in filter_fields
- filter_order_by = True
-```
-
-You can then control the ordering via the `orderBy` argument:
-
-```graphql
-query {
- allAnimals(orderBy: "name") {
- edges {
- node {
- id,
- name
- }
- }
- }
-}
-```
-
-## Custom Filtersets
-
-By default Graphene provides easy access to the most commonly used
-features of `django-filter`. This is done by transparently creating a
-`django_filters.FilterSet` class for you and passing in the values for
-`filter_fields` and `filter_order_by`.
-
-However, you may find this to be insufficient. In these cases you can
-create your own `Filterset` as follows:
-
-```python
-class AnimalNode(DjangoNode):
- class Meta:
- # Assume you have an Animal model defined with the following fields
- model = Animal
- filter_fields = ['name', 'genus', 'is_domesticated']
-
-
-class AnimalFilter(django_filters.FilterSet):
- # Do case-insensitive lookups on 'name'
- name = django_filters.CharFilter(lookup_type='iexact')
-
- class Meta:
- model = Animal
- fields = ['name', 'genus', 'is_domesticated']
-
-
-class Query(ObjectType):
- animal = relay.NodeField(AnimalNode)
- # We specify our custom AnimalFilter using the filterset_class param
- all_animals = DjangoFilterConnectionField(AnimalNode,
- filterset_class=AnimalFilter)
-```
diff --git a/docs/pages/docs/django/introspection-schema.md b/docs/pages/docs/django/introspection-schema.md
deleted file mode 100644
index d7ac8f1d..00000000
--- a/docs/pages/docs/django/introspection-schema.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: Introspection Schema
-description: A guide to instrospection schema in Django
----
-
-# Introspection Schema
-
-Relay uses [Babel Relay Plugin](https://facebook.github.io/relay/docs/guides-babel-plugin.html)
-that requires you to provide your GraphQL schema data.
-
-Graphene comes with a management command for Django to dump your schema data to
-`schema.json` that is compatible with babel-relay-plugin.
-
-
-## Usage
-
-Include `graphene.contrib.django` to `INSTALLED_APPS` in you project settings:
-
-```python
-INSTALLED_APPS += ('graphene.contrib.django')
-```
-
-Assuming your Graphene schema is at `tutorial.quickstart.schema`, run the command:
-
-```bash
-./manage.py graphql_schema --schema tutorial.quickstart.schema --out schema.json
-```
-
-It dumps your full introspection schema to `schema.json` inside your project root
-directory. Point `babel-relay-plugin` to this file and you're ready to use Relay
-with Graphene GraphQL implementation.
-
-
-## Advanced Usage
-
-To simplify the command to `./manage.py graphql_schema`, you can specify the
-parameters in your settings.py:
-
-```python
-GRAPHENE_SCHEMA = 'tutorial.quickstart.schema'
-GRAPHENE_SCHEMA_OUTPUT = 'data/schema.json' # defaults to schema.json
-```
-
-Running `./manage.py graphql_schema` dumps your schema to
-`/data/schema.json`.
-
-
-## Help
-
-Run `./manage.py graphql_schema -h` for command usage.
diff --git a/docs/pages/docs/django/tutorial.md b/docs/pages/docs/django/tutorial.md
deleted file mode 100644
index a4d2f072..00000000
--- a/docs/pages/docs/django/tutorial.md
+++ /dev/null
@@ -1,312 +0,0 @@
----
-title: Quickstart
-description: A Quick guide to Graphene in Django
----
-
-# Django Tutorial
-
-Graphene has a number of additional features that are designed to make
-working with Django *really simple*.
-
-**Note: The code in this quickstart is pulled from the
-[cookbook example app](https://github.com/graphql-python/graphene/tree/master/examples/cookbook_django)**.
-
-
-## Setup the Django project
-
-We will setup the project, create the following:
-
-* A Django project called `cookbook`
-* An app within `cookbook` called `ingredients`
-
-```bash
-# Create the project directory
-mkdir cookbook
-cd cookbook
-
-# Create a virtualenv to isolate our package dependencies locally
-virtualenv env
-source env/bin/activate # On Windows use `env\Scripts\activate`
-
-# Install Django and Graphene with Django support
-pip install django
-pip install graphene[django]
-pip install django-graphiql
-
-# Set up a new project with a single application
-django-admin.py startproject cookbook . # Note the trailing '.' character
-django-admin.py startapp ingredients
-```
-
-Now sync your database for the first time:
-
-```bash
-python manage.py migrate
-```
-
-Let's create a few simple models...
-
-
-## Defining our models
-
-Let's get started with these models:
-
-```python
-# cookbook/ingredients/models.py
-from django.db import models
-
-
-class Category(models.Model):
- name = models.CharField(max_length=100)
-
- def __str__(self):
- return self.name
-
-
-class Ingredient(models.Model):
- name = models.CharField(max_length=100)
- notes = models.TextField()
- category = models.ForeignKey(Category, related_name='ingredients')
-
- def __str__(self):
- return self.name
-```
-
-## Schema
-
-GraphQL presents your objects to the world as a graph structure rather than a more
-hierarchical structure to which you may be accustomed. In order to create this
-representation, Graphene needs to know about each *type* of object which will appear in
-the graph.
-
-This graph also has a *root type* through which all access begins. This is the `Query` class below.
-In this example, we provide the ability to list all ingredients via `all_ingredients`, and the
-ability to obtain a specific ingredient via `ingredient`.
-
-Create `cookbook/ingredients/schema.py` and type the following:
-
-```python
-# cookbook/ingredients/schema.py
-from graphene import relay, ObjectType
-from graphene.contrib.django.filter import DjangoFilterConnectionField
-from graphene.contrib.django.types import DjangoNode
-
-from cookbook.ingredients.models import Category, Ingredient
-
-
-# Graphene will automatically map the Category model's fields onto the CategoryNode.
-# This is configured in the CategoryNode's Meta class (as you can see below)
-class CategoryNode(DjangoNode):
- class Meta:
- model = Category
- filter_fields = ['name', 'ingredients']
- filter_order_by = ['name']
-
-
-class IngredientNode(DjangoNode):
- class Meta:
- model = Ingredient
- # Allow for some more advanced filtering here
- filter_fields = {
- 'name': ['exact', 'icontains', 'istartswith'],
- 'notes': ['exact', 'icontains'],
- 'category': ['exact'],
- 'category__name': ['exact'],
- }
- filter_order_by = ['name', 'category__name']
-
-
-class Query(ObjectType):
- category = relay.NodeField(CategoryNode)
- all_categories = DjangoFilterConnectionField(CategoryNode)
-
- ingredient = relay.NodeField(IngredientNode)
- all_ingredients = DjangoFilterConnectionField(IngredientNode)
-
- class Meta:
- abstract = True
-```
-
-The filtering functionality is provided by
-[django-filter](https://django-filter.readthedocs.org). See the
-[usage documentation](https://django-filter.readthedocs.org/en/latest/usage.html#the-filter)
-for details on the format for `filter_fields`. While optional, this tutorial makes use of this functionality so you will need to install `django-filter` for this tutorial to work:
-
-```bash
-pip install django-filter
-```
-
-Note that the above `Query` class is marked as 'abstract'. This is because we
-will now create a project-level query which will combine all our app-level
-queries.
-
-Create the parent project-level `cookbook/schema.py`:
-
-```python
-import graphene
-
-import cookbook.ingredients.schema
-
-
-class Query(cookbook.ingredients.schema.Query):
- # This class will inherit from multiple Queries
- # as we begin to add more apps to our project
- pass
-
-schema = graphene.Schema(name='Cookbook Schema')
-schema.query = Query
-```
-
-You can think of this as being something like your top-level `urls.py`
-file (although it currently lacks any namespacing).
-
-## Update `INSTALLED_APPS`
-
-Next, install your app and GraphiQL in your Django project. GraphiQL is
-a web-based integrated development environment to assist in the writing and
-executing of GraphQL queries. It will provide us with a simple and easy way
-of testing our cookbook project.
-
-Add `ingredients`, `graphene.contrib.django` and `django_graphiql` to
-`INSTALLED_APPS` in `cookbook/settings.py`:
-
-```python
-INSTALLED_APPS = [
- ...
- 'django_graphiql',
-
- # This will also make the `graphql_schema` management command available
- 'graphene.contrib.django',
-
- # Install the ingredients app
- 'ingredients',
-]
-```
-
-
-## Creating GraphQL and GraphiQL views
-
-Unlike a RESTful API, there is only a single URL from which GraphQL is accessed.
-Requests to this URL are handled by Graphene's `GraphQLView` view.
-
-Additionally, we'll add a URL for aforementioned GraphiQL, and for the Django admin
-interface (the latter can be useful for creating test data).
-
-```python
-from django.conf.urls import url, include
-from django.contrib import admin
-from django.views.decorators.csrf import csrf_exempt
-
-from graphene.contrib.django.views import GraphQLView
-
-from cookbook.schema import schema
-
-urlpatterns = [
- url(r'^admin/', admin.site.urls),
- url(r'^graphql', csrf_exempt(GraphQLView.as_view(schema=schema))),
- url(r'^graphiql', include('django_graphiql.urls')),
-]
-```
-
-## Apply model changes to database
-
-Tell Django that we've added models and update the database schema to reflect these additions.
-
-```bash
-python manage.py makemigrations
-python manage.py migrate
-```
-
-## Load some test data
-
-Now is a good time to load up some test data. The easiest option will be to
-[download the ingredients.json](https://raw.githubusercontent.com/graphql-python/graphene/master/examples/cookbook_django/cookbook/ingredients/fixtures/ingredients.json)
-fixture and place it in
-`cookbook/ingredients/fixtures/ingredients.json`. You can then run the following:
-
-```
-$ python ./manage.py loaddata ingredients
-
-Installed 6 object(s) from 1 fixture(s)
-```
-
-Alternatively you can use the Django admin interface to create some data yourself.
-You'll need to run the development server (see below), and create a login
-for yourself too (`./manage.py createsuperuser`).
-
-## Testing our GraphQL schema
-
-We're now ready to test the API we've built. Let's fire up the server from the command line.
-
-```bash
-$ python ./manage.py runserver
-
-Performing system checks...
-Django version 1.9, using settings 'cookbook.settings'
-Starting development server at http://127.0.0.1:8000/
-Quit the server with CONTROL-C.
-```
-
-Go to [localhost:8000/graphiql](http://localhost:8000/graphiql) and type your first query!
-
-```graphql
-query {
- allIngredients {
- edges {
- node {
- id,
- name
- }
- }
- }
-}
-```
-
-The above will return the names & IDs for all ingredients. But perhaps you want
-a specific ingredient:
-
-```graphql
-query {
- # Graphene creates globally unique IDs for all objects.
- # You may need to copy this value from the results of the first query
- ingredient(id: "SW5ncmVkaWVudE5vZGU6MQ==") {
- name
- }
-}
-```
-
-You can also get each ingredient for each category:
-
-```graphql
-query {
- allCategories {
- edges {
- node {
- name,
- ingredients {
- edges {
- node {
- name
- }
- }
- }
- }
- }
- }
-}
-```
-
-Or you can get only 'meat' ingredients containing the letter 'e':
-
-```graphql
-query {
- # You can also use `category: "CATEGORY GLOBAL ID"`
- allIngredients(name_Icontains: "e", category_Name: "Meat") {
- edges {
- node {
- name
- }
- }
- }
-}
-```
diff --git a/docs/pages/docs/enums.md b/docs/pages/docs/enums.md
deleted file mode 100644
index 6878d610..00000000
--- a/docs/pages/docs/enums.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Enums
-description: Walkthrough Enums
----
-
-# Enums
-
-A `Enum` is a special `GraphQL` type that represents a set of symbolic names (members) bound to unique, constant values.
-
-## Enum definition
-
-You can create an `Enum` using classes:
-
-```python
-import graphene
-
-class Episode(graphene.Enum):
- NEWHOPE = 4
- EMPIRE = 5
- JEDI = 6
-```
-
-But also using instances of Enum:
-
-```python
-Episode = graphene.Enum('Episode', [('NEWHOPE', 4), ('EMPIRE', 5), ('JEDI', 6)])
-```
-
-## Notes
-
-Internally, `graphene.Enum` uses [`enum.Enum`](https://docs.python.org/3/library/enum.html) Python implementation if available, or a backport if not.
-
-So you can use it in the same way as you would do with Python `enum.Enum`.
diff --git a/docs/pages/docs/interfaces.md b/docs/pages/docs/interfaces.md
deleted file mode 100644
index b6e61743..00000000
--- a/docs/pages/docs/interfaces.md
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: Interfaces
-description: Walkthrough Interfaces
----
-
-# Interfaces
-
-An Interface contains the essential fields that will be shared among multiple ObjectTypes.
-
-The basics:
-- Each Interface is a Python class that inherits from `graphene.Interface`.
-- Each attribute of the Interface represents a GraphQL field.
-
-## Quick example
-
-This example model defines a Character, which has a name. `Human` and `Droid` inherit from it.
-
-```python
-import graphene
-
-# Character is an Interface
-class Character(graphene.Interface):
- name = graphene.String()
-
-# Human is an ObjectType, as inherits an interface
-class Human(Character):
- born_in = graphene.String()
-
-# Droid is an ObjectType, as inherits an interface
-class Droid(Character):
- function = graphene.String()
-
-```
-
-**name** is a field in the `Character` interface that will be in both `Human` and `Droid` ObjectTypes (as those inherit from `Character`). Each ObjectType also define extra fields at the same time.
-
-The above types would have the following representation in a schema:
-
-```graphql
-interface Character {
- name: String
-}
-
-type Droid implements Character {
- name: String
- function: String
-}
-
-type Human implements Character {
- name: String
- bornIn: String
-}
-```
diff --git a/docs/pages/docs/middleware.md b/docs/pages/docs/middleware.md
deleted file mode 100644
index 6ad6c9bb..00000000
--- a/docs/pages/docs/middleware.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: Middleware
-description: Walkthrough Middleware
----
-
-# Middleware
-
-You can use _middleware_ to affect the evaluation of fields in your schema.
-
-A middleware is any object that responds to `resolve(*args, next_middleware)`. Inside that method, it should either:
-
-* Send `resolve` to the next middleware to continue the evaluation; or
-* Return a value to end the evaluation early.
-
-Middlewares' `resolve` is invoked with several arguments:
-
-* `next` represents the execution chain. Call `next` to continue evalution.
-* `root` is the root value object passed throughout the query
-* `args` is the hash of arguments passed to the field
-* `context` is the context object passed throughout the query
-* `info` is the resolver info
-
-Add a middleware to a schema by adding to the `middlewares` list.
-
-
-### Example: Authorization
-
-This middleware only continues evaluation if the `field_name` is not `'user'`:
-
-```python
-class AuthorizationMiddleware(object):
-
- def resolve(self, next, root, args, context, info):
- if info.field_name == 'user':
- return None
- return next(root, args, context, info)
-```
-
-Then, add the middleware to your schema:
-
-```python
-schema = Schema(middlewares=[AuthorizationMiddleware()])
-```
diff --git a/docs/pages/docs/mutations.md b/docs/pages/docs/mutations.md
deleted file mode 100644
index 444c596d..00000000
--- a/docs/pages/docs/mutations.md
+++ /dev/null
@@ -1,75 +0,0 @@
----
-title: Mutations
-description: Walkthrough Mutations
----
-
-# Mutations
-
-A Mutation is a special ObjectType that also defines an Input.
-
-## Quick example
-
-This example defines a Mutation:
-
-```python
-import graphene
-
-class CreatePerson(graphene.Mutation):
- class Input:
- name = graphene.String()
-
- ok = graphene.Boolean()
- person = graphene.Field('Person')
-
- @classmethod
- def mutate(cls, instance, args, info):
- person = Person(name=args.get('name'))
- ok = True
- return CreatePerson(person=person, ok=ok)
-```
-
-**person** and **ok** are the output fields of the Mutation when is resolved.
-
-**Input** attributes are the arguments that the Mutation `CreatePerson` needs for resolving, in this case **name** will be the only argument for the mutation.
-
-**mutate** is the function that will be applied once the mutation is called.
-
-So, we can finish our schema like this:
-
-```python
-# ... the Mutation Class
-
-class Person(graphene.ObjectType):
- name = graphene.String()
-
-class MyMutations(graphene.ObjectType):
- create_person = graphene.Field(CreatePerson)
-
-schema = graphene.Schema(mutation=MyMutations)
-```
-
-## Executing the Mutation
-
-Then, if we query (`schema.execute(query_str)`) the following:
-```graphql
-mutation myFirstMutation {
- createPerson(name:"Peter") {
- person {
- name
- }
- ok
- }
-}
-```
-
-We should receive:
-
-```json
-{
- "createPerson": {
- "person" : {
- name: "Peter"
- },
- "ok": true
- }
-}
diff --git a/docs/pages/docs/objecttypes.md b/docs/pages/docs/objecttypes.md
deleted file mode 100644
index b1c59663..00000000
--- a/docs/pages/docs/objecttypes.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: ObjectTypes
-description: Walkthrough ObjectTypes
----
-
-# ObjectTypes
-
-An ObjectType is the single, definitive source of information about your data. It contains the essential fields and behaviors of the data you’re querying.
-
-The basics:
-- Each ObjectType is a Python class that inherits `graphene.ObjectType` or inherits an implemented [Interface](/docs/interfaces/).
-- Each attribute of the ObjectType represents a GraphQL field.
-
-## Quick example
-
-This example model defines a Person, which has a first_name and last_name:
-
-```python
-import graphene
-
-class Person(graphene.ObjectType):
- first_name = graphene.String()
- last_name = graphene.String()
- full_name = graphene.String()
-
- def resolve_full_name(self, args, info):
- return '{} {}'.format(self.first_name, self.last_name)
-```
-
-**first_name** and **last_name** are fields of the ObjectType. Each field is specified as a class attribute, and each attribute maps to a GraphQL field.
-
-The above `Person` ObjectType would have the following representation in a schema:
-
-```graphql
-type Person {
- firstName: String
- lastName: String
- fullName: String
-}
-```
-
-## Instances as containers
-
-Graphene `ObjectType`s could act as containers too.
-So with the previous example you could do.
-
-```python
-peter = Person(first_name='Peter', last_name='Griffin')
-```
\ No newline at end of file
diff --git a/docs/pages/docs/quickstart.md b/docs/pages/docs/quickstart.md
deleted file mode 100644
index ce56a6a7..00000000
--- a/docs/pages/docs/quickstart.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: Getting started
-description: A Quick guide to Graphene
----
-
-# Getting started
-
-Let's build a basic GraphQL schema from scratch.
-
-
-## Requirements
-
-- Python (2.7, 3.2, 3.3, 3.4, 3.5, pypy)
-- Graphene (0.10+)
-
-
-## Project setup
-
-```bash
-pip install graphene
-```
-
-## Creating a basic Schema
-
-A GraphQL schema describes your data model, and provides a GraphQL server with an associated set of resolve methods that know how to fetch data.
-
-We are going to create a very simple schema, with a `Query` with only one field: `hello`. And when we query it should return `"World"`.
-
-
-```python
-import graphene
-
-class Query(graphene.ObjectType):
- hello = graphene.String()
-
- def resolve_hello(self, args, info):
- return 'World'
-
-schema = graphene.Schema(query=Query)
-```
-
-
-## Querying
-
-Then, we can start querying our schema:
-
-```python
-result = schema.execute('{ hello }')
-print result.data['hello'] # "World"
-```
-
-Congrats! You got your first graphene schema working!
diff --git a/docs/pages/docs/relay.md b/docs/pages/docs/relay.md
deleted file mode 100644
index fd477da9..00000000
--- a/docs/pages/docs/relay.md
+++ /dev/null
@@ -1,87 +0,0 @@
----
-title: Relay
-description: A Relay implementation in Graphene
----
-
-# Relay
-
-Graphene has complete support for [Relay](https://facebook.github.io/relay/docs/graphql-relay-specification.html) and offers some utils to make integration from Python easy.
-
-## Nodes
-
-A `Node` is an Interface provided by `graphene.relay` that contains a single field `id` (which is a `ID!`). Any object that inherits from it have to implement a `get_node` method for retrieving a `Node` by an *id*.
-
-Example usage (taken from the [Starwars Relay example](https://github.com/graphql-python/graphene/blob/master/examples/starwars_relay/schema.py)):
-
-```python
-class Ship(relay.Node):
- '''A ship in the Star Wars saga'''
- name = graphene.String(description='The name of the ship.')
-
- @classmethod
- def get_node(cls, id, info):
- return get_ship(id)
-```
-
-The `id` returned by the `Ship` type when you query it will be a scalar which contains the enough info for the server for knowing it's type and it's id.
-
-For example, the instance `Ship(id=1)` will return `U2hpcDox` as the id when you query it (which is the base64 encoding of `Ship:1`), and which could be useful later if we want to query a node by its id.
-
-
-## Connection
-
-A connection is a vitaminized version of a List that provides ways of slicing and paginating through it. The way you create Connection fields in `graphene` is using `relay.ConnectionField`.
-
-You can create connection fields in any ObjectType, but the connection **must** be linked to an object which inherits from `Node` (in this case, a `Ship`).
-
-```python
-class Faction(graphene.ObjectType):
- name = graphene.String()
- ships = relay.ConnectionField(Ship)
-
- def resolve_ships(self, args, info):
- return []
-```
-
-## Node Root field
-
-As is required in the [Relay specification](https://facebook.github.io/relay/graphql/objectidentification.htm#sec-Node-root-field), the server must implement a root field called `node` that returns a `Node` Interface.
-
-For this reason, `graphene` provides the field `relay.NodeField`, which links to any type in the Schema which inherits from `Node`. Example usage:
-
-```python
-class Query(graphene.ObjectType):
- node = relay.NodeField()
-```
-
-If you encounter an error like `Cannot query field "node" on type "Query"`, you most likely forgot to add the `node` Field.
-
-## Mutations
-
-Most APIs don't just allow you to read data, they also allow you to write. In GraphQL, this is done using mutations. Just like queries, Relay puts some additional requirements on mutations, but Graphene nicely manages that for you. All you need to do is make your mutation a subclass of `relay.ClientIDMutation`.
-
-```python
-class IntroduceShip(relay.ClientIDMutation):
-
- class Input:
- ship_name = graphene.String(required=True)
- faction_id = graphene.String(required=True)
-
- ship = graphene.Field(Ship)
- faction = graphene.Field(Faction)
-
- @classmethod
- def mutate_and_get_payload(cls, input, info):
- ship_name = input.get('ship_name')
- faction_id = input.get('faction_id')
- ship = create_ship(ship_name, faction_id)
- faction = get_faction(faction_id)
- return IntroduceShip(ship=ship, faction=faction)
-```
-
-## Useful links
-
-* [Getting started with Relay](https://facebook.github.io/relay/docs/graphql-relay-specification.html)
-* [Relay Global Identification Specification](https://facebook.github.io/relay/graphql/objectidentification.htm)
-* [Relay Cursor Connection Specification](https://facebook.github.io/relay/graphql/connections.htm)
-* [Relay input Object Mutation](https://facebook.github.io/relay/graphql/mutations.htm)
diff --git a/docs/pages/docs/resolvers.md b/docs/pages/docs/resolvers.md
deleted file mode 100644
index 073fac99..00000000
--- a/docs/pages/docs/resolvers.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: Resolvers
-description: Walkthrough Resolvers
----
-
-# Resolvers
-
-A resolver is a method that resolves certain field within a `ObjectType`.
-The resolver of a field will be, if not specified otherwise, the `resolve_{field_name}` within the `ObjectType`.
-
-By default a resolver will take the `args`, and `info` arguments.
-*This is likely to be simplified in the future*.
-
-
-## Quick example
-
-This example model defines a `Query` type, which has a reverse field that reverses the given `word`
-argument using the `resolve_reverse` method in the class.
-
-```python
-import graphene
-
-class Query(graphene.ObjectType):
- reverse = graphene.String(word=graphene.String())
-
- def resolve_reverse(self, args, info):
- word = args.get('word')
- return word[::-1]
-```
-
-## Resolvers outside the class
-
-A field could also specify a custom resolver outside the class:
-
-```python
-import graphene
-
-def reverse(root, args, info):
- word = args.get('word')
- return word[::-1]
-
-class Query(graphene.ObjectType):
- reverse = graphene.String(word=graphene.String(), resolver=reverse)
-```
-
-
-## Context
-
-A query in a GraphQL schema could have some context that we can use in any resolver.
-In this case we need to decorate the resolver function with `with_context`.
-
-```python
-class Query(graphene.ObjectType):
- name = graphene.String()
-
- @with_context
- def resolve_name(self, args, context, info):
- return context['name']
-
-
-result = schema.execute(query, context_value={'name': 'Peter'})
-```
diff --git a/docs/pages/docs/sqlalchemy/tips.md b/docs/pages/docs/sqlalchemy/tips.md
deleted file mode 100644
index d27e3bcc..00000000
--- a/docs/pages/docs/sqlalchemy/tips.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: Tips
-description: Tips when SQLAlchemy in Graphene
----
-
-# Tips
-
-## Querying
-
-For make querying to the database work, there are two alternatives:
-
-* Expose the db session when you create the `graphene.Schema`:
-
-```python
-schema = graphene.Schema(session=session)
-```
-
-* Create a query for the models.
-
-```python
-Base = declarative_base()
-Base.query = db_session.query_property()
-
-class MyModel(Base):
- # ...
-```
-
-If you don't specify any, the following error will be displayed:
-
-`A query in the model Base or a session in the schema is required for querying.`
diff --git a/docs/pages/docs/sqlalchemy/tutorial.md b/docs/pages/docs/sqlalchemy/tutorial.md
deleted file mode 100644
index 3695d17c..00000000
--- a/docs/pages/docs/sqlalchemy/tutorial.md
+++ /dev/null
@@ -1,199 +0,0 @@
----
-title: Tutorial
-description: Using SQLAlchemy with Graphene
----
-
-# SQLAlchemy + Flask Tutorial
-
-Graphene comes with builtin support to SQLAlchemy, which makes quite easy to operate with your current models.
-
-**Note: The code in this tutorial is pulled from the
-[Flask SQLAlchemy example app](https://github.com/graphql-python/graphene/tree/master/examples/flask_sqlalchemy)**.
-
-
-## Setup the Project
-
-We will setup the project, execute the following:
-
-```bash
-# Create the project directory
-mkdir flask_sqlalchemy
-cd flask_sqlalchemy
-
-# Create a virtualenv to isolate our package dependencies locally
-virtualenv env
-source env/bin/activate # On Windows use `env\Scripts\activate`
-
-# SQLAlchemy and Graphene with SQLAlchemy support
-pip install SQLAlchemy
-pip install graphene[sqlalchemy]
-
-# Install Flask and GraphQL Flask for exposing the schema through HTTP
-pip install Flask
-pip install Flask-GraphQL
-```
-
-## Defining our models
-
-Let's get started with these models:
-
-```python
-# flask_sqlalchemy/models.py
-from sqlalchemy import *
-from sqlalchemy.orm import (scoped_session, sessionmaker, relationship,
- backref)
-from sqlalchemy.ext.declarative import declarative_base
-
-engine = create_engine('sqlite:///database.sqlite3', convert_unicode=True)
-db_session = scoped_session(sessionmaker(autocommit=False,
- autoflush=False,
- bind=engine))
-
-Base = declarative_base()
-# We will need this for querying
-Base.query = db_session.query_property()
-
-
-class Department(Base):
- __tablename__ = 'department'
- id = Column(Integer, primary_key=True)
- name = Column(String)
-
-
-class Employee(Base):
- __tablename__ = 'employee'
- id = Column(Integer, primary_key=True)
- name = Column(String)
- hired_on = Column(DateTime, default=func.now())
- department_id = Column(Integer, ForeignKey('department.id'))
- department = relationship(
- Department,
- backref=backref('employees',
- uselist=True,
- cascade='delete,all'))
-```
-
-## Schema
-
-GraphQL presents your objects to the world as a graph structure rather than a more
-hierarchical structure to which you may be accustomed. In order to create this
-representation, Graphene needs to know about each *type* of object which will appear in
-the graph.
-
-This graph also has a *root type* through which all access begins. This is the `Query` class below.
-In this example, we provide the ability to list all employees via `all_employees`, and the
-ability to obtain a specific node via `node`.
-
-Create `flask_sqlalchemy/schema.py` and type the following:
-
-```python
-# flask_sqlalchemy/schema.py
-import graphene
-from graphene import relay
-from graphene.contrib.sqlalchemy import SQLAlchemyNode, SQLAlchemyConnectionField
-from models import db_session, Department as DepartmentModel, Employee as EmployeeModel
-
-schema = graphene.Schema()
-
-
-@schema.register
-class Department(SQLAlchemyNode):
- class Meta:
- model = DepartmentModel
-
-
-@schema.register
-class Employee(SQLAlchemyNode):
- class Meta:
- model = EmployeeModel
-
-
-class Query(graphene.ObjectType):
- node = relay.NodeField()
- all_employees = SQLAlchemyConnectionField(Employee)
-
-schema.query = Query
-```
-
-## Creating GraphQL and GraphiQL views in Flask
-
-Unlike a RESTful API, there is only a single URL from which GraphQL is accessed.
-
-We are going to use Flask to create a server that expose the GraphQL schema under `/graphql` and a interface for querying it easily: GraphiQL under `/graphiql`.
-
-Fortunately for us, the library `Flask-GraphQL` that we previously installed makes this task quite easy.
-
-```python
-# flask_sqlalchemy/app.py
-from flask import Flask
-from flask_graphql import GraphQL
-
-from models import db_session
-from schema import schema, Department
-
-app = Flask(__name__)
-app.debug = True
-
-# This is creating the `/graphql` and `/graphiql` endpoints
-GraphQL(app, schema=schema)
-
-@app.teardown_appcontext
-def shutdown_session(exception=None):
- db_session.remove()
-
-if __name__ == '__main__':
- app.run()
-```
-
-
-## Creating some data
-
-```bash
-$ python
-
->>> from models import engine, db_session, Base, Department, Employee
->>> Base.metadata.create_all(bind=engine)
-
->>> # Fill the tables with some data
->>> engineering = Department(name='Engineering')
->>> db_session.add(engineering)
->>> hr = Department(name='Human Resources')
->>> db_session.add(hr)
-
->>> peter = Employee(name='Peter', department=engineering)
->>> db_session.add(peter)
->>> roy = Employee(name='Roy', department=engineering)
->>> db_session.add(roy)
->>> tracy = Employee(name='Tracy', department=hr)
->>> db_session.add(tracy)
->>> db_session.commit()
-```
-
-
-## Testing our GraphQL schema
-
-We're now ready to test the API we've built. Let's fire up the server from the command line.
-
-```bash
-$ python ./app.py
-
- * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
-```
-
-Go to [localhost:5000/graphiql](http://localhost:5000/graphiql) and type your first query!
-
-```graphql
-{
- allEmployees {
- edges {
- node {
- id
- name
- department {
- name
- }
- }
- }
- }
-}
-```
diff --git a/docs/pages/index.md b/docs/pages/index.md
deleted file mode 100644
index 6b54d35d..00000000
--- a/docs/pages/index.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-path: /
----
-
-
-## Meet Graphene
-
-Graphene is a Python library for building *GraphQL* schemas/types fast and easily.
-
-
-* **Easy to use**: Graphene helps you use *GraphQL* in Python easily.
-* Graphene has **builtin support for Relay**.
-* Support for **Django**, **SQLAlchemy** and **GAE**: mapping the models automatically to *GraphQL* types.
-
-
-
-#### What is GraphQL?
-*GraphQL* is a data query language and runtime designed to request and deliver data in a performant way.
-
-Advantages of using *GraphQL*:
-* Only **one API endpoint**. One roundtrip for fetch everything you need.
-* No data overfetching or underfetching.
-* Autogenerated Graphical UI and docs based in your schema.
-