Remove old name graphql-core-next from docs

Author: Cito

docs/usage/extension.rst

@@ -1,7 +1,7 @@
 Extending a Schema
 ------------------
 
-With GraphQL-core-next you can also extend a given schema using type extensions. For
+With GraphQL-core 3 you can also extend a given schema using type extensions. For
 example, we might want to add a ``lastName`` property to our ``Human`` data type to
 retrieve only the last name of the person.
 

docs/usage/index.rst

@@ -1,8 +1,8 @@
 Usage
 =====
 
-GraphQL-core-next provides two important capabilities: building a type schema, and
-serving queries against that type schema.
+GraphQL-core provides two important capabilities: building a type schema, and serving
+queries against that type schema.
 
 .. toctree::
    :maxdepth: 2

docs/usage/introspection.rst

@@ -3,7 +3,7 @@ Using an Introspection Query
 
 A third way of building a schema is using an introspection query on an existing server.
 This is what GraphiQL uses to get information about the schema on the remote server. You
-can create an introspection query using GraphQL-core-next with::
+can create an introspection query using GraphQL-core 3 with::
 
     from graphql import get_introspection_query
 
@@ -41,15 +41,15 @@ This result contains all the information that is available in the SDL descriptio
 schema, i.e. it does not contain the resolve functions and information on the
 server-side values of the enum types.
 
-You can convert the introspection result into ``GraphQLSchema`` with GraphQL-core-next
-by using the :func:`graphql.utilities.build_client_schema` function::
+You can convert the introspection result into ``GraphQLSchema`` with GraphQL-core 3 by
+using the :func:`graphql.utilities.build_client_schema` function::
 
     from graphql import build_client_schema
 
     client_schema = build_client_schema(introspection_query_result.data)
 
 
-It is also possible to convert the result to SDL with GraphQL-core-next by using the
+It is also possible to convert the result to SDL with GraphQL-core 3 by using the
 :func:`graphql.utilities.print_schema` function::
 
     from graphql import print_schema
@@ -60,4 +60,4 @@ It is also possible to convert the result to SDL with GraphQL-core-next by using
 This prints the SDL representation of the schema that we started with.
 
 As you see, it is easy to convert between the three forms of representing a GraphQL
-schema in GraphQL-core-next.
+schema in GraphQL-core 3.

docs/usage/other.rst

@@ -4,7 +4,7 @@ Subscriptions
 .. currentmodule:: graphql.subscription
 
 Sometimes you need to not only query data from a server, but you also want to push data
-from the server to the client. GraphQL-core-next has you also covered here, because it
+from the server to the client. GraphQL-core 3 has you also covered here, because it
 implements the "Subscribe" algorithm described in the GraphQL spec. To execute a GraphQL
 subscription, you must use the :func:`subscribe` method from the
 :mod:`graphql.subscription` module. Instead of a single ``ExecutionResult``, this
@@ -16,7 +16,7 @@ to the client (often realized via WebSockets) to push these results back.
 Other Usages
 ------------
 
-GraphQL-core-next provides many more low-level functions that can be used to work with
+GraphQL-core 3 provides many more low-level functions that can be used to work with
 GraphQL schemas and queries. We encourage you to explore the contents of the various
 :ref:`sub-packages`, particularly :mod:`graphql.utilities`, and to look into the source
 code and tests of `GraphQL-core 3`_ in order to find all the functionality that is

docs/usage/parser.rst

@@ -4,7 +4,7 @@ Parsing GraphQL Queries and Schema Notation
 .. currentmodule:: graphql.language
 
 When executing GraphQL queries, the first step that happens under the hood is parsing
-the query. But GraphQL-core-next also exposes the parser for direct usage via the
+the query. But GraphQL-core 3 also exposes the parser for direct usage via the
 :func:`graphql.language.parse` function. When you pass this function a GraphQL source
 code, it will be parsed and returned as a Document, i.e. an abstract syntax tree (AST)
 of :class:`graphql.language.Node` objects. The root node will be a

docs/usage/queries.rst

@@ -7,7 +7,7 @@ Now that we have defined the schema and breathed life into it with our resolver
 functions, we can execute arbitrary query against the schema.
 
 The :mod:`graphql` package provides the :func:`graphql.graphql` function to execute
-queries. This is the main feature of GraphQL-core-next.
+queries. This is the main feature of GraphQL-core.
 
 Note however that this function is actually a coroutine intended to be used in
 asynchronous code running in an event loop.

docs/usage/schema.rst

@@ -42,7 +42,7 @@ heroes from the Star Wars trilogy::
 
 We have been using the so called GraphQL schema definition language (SDL) here to
 describe the schema. While it is also possible to build a schema directly from this
-notation using GraphQL-core-next, let's first create that schema manually by assembling
+notation using GraphQL-core 3, let's first create that schema manually by assembling
 the types defined here using Python classes, adding resolver functions written in Python
 for querying the data.
 
@@ -109,8 +109,8 @@ Our schema also contains a ``Character`` interface. Here is how we build it::
 Note that we did not pass the dictionary of fields to the ``GraphQLInterfaceType``
 directly, but using a lambda function (a so-called "thunk"). This is necessary because
 the fields are referring back to the character interface that we are just defining.
-Whenever you have such recursive definitions in GraphQL-core-next, you need to use
-thunks. Otherwise, you can pass everything directly.
+Whenever you have such recursive definitions in GraphQL-core, you need to use thunks.
+Otherwise, you can pass everything directly.
 
 Characters in the Star Wars trilogy are either humans or droids. So we define a
 ``Human`` and a ``Droid`` type, which both implement the ``Character`` interface::

docs/usage/sdl.rst

@@ -4,7 +4,7 @@ Using the Schema Definition Language
 Above we defined the GraphQL schema as Python code, using the ``GraphQLSchema`` class
 and other classes representing the various GraphQL types.
 
-GraphQL-core-next also provides a language-agnostic way of defining a GraphQL schema
+GraphQL-core 3 also provides a language-agnostic way of defining a GraphQL schema
 using the GraphQL schema definition language (SDL) which is also part of the GraphQL
 specification. To do this, we simply feed the SDL as a string to the
 :func:`graphql.utilities.build_schema` function::