,
- returnType: GraphQLOutputType,
- parentType: GraphQLCompositeType,
- schema: GraphQLSchema,
- fragments: { [fragmentName: string]: FragmentDefinition },
- rootValue: any,
- operation: OperationDefinition,
- variableValues: { [variableName: string]: any },
-}
-
-type GraphQLFieldConfig = {
- type: GraphQLOutputType;
- args?: GraphQLFieldConfigArgumentMap;
- resolve?: GraphQLFieldResolveFn;
- deprecationReason?: string;
- description?: string;
-}
-
-type GraphQLFieldConfigArgumentMap = {
- [argName: string]: GraphQLArgumentConfig;
-};
-
-type GraphQLArgumentConfig = {
- type: GraphQLInputType;
- defaultValue?: any;
- description?: string;
-}
-
-type GraphQLFieldConfigMap = {
- [fieldName: string]: GraphQLFieldConfig;
-};
-```
-
-Almost all of the GraphQL types you define will be object types. Object types
-have a name, but most importantly describe their fields.
-
-When two types need to refer to each other, or a type needs to refer to
-itself in a field, you can use a function expression (aka a closure or a
-thunk) to supply the fields lazily.
-
-Note that resolver functions are provided the `source` object as the first parameter.
-However, if a resolver function is not provided, then the default resolver is
-used, which looks for a method on `source` of the same name as the field. If found,
-the method is called with `(args, context, info)`. Since it is a method on `source`,
-that value can always be referenced with `this`.
-
-#### Examples
-
-```js
-var AddressType = new GraphQLObjectType({
- name: "Address",
- fields: {
- street: { type: GraphQLString },
- number: { type: GraphQLInt },
- formatted: {
- type: GraphQLString,
- resolve(obj) {
- return obj.number + " " + obj.street
- }
- }
- }
-})
-
-var PersonType = new GraphQLObjectType({
- name: "Person",
- fields: () => ({
- name: { type: GraphQLString },
- bestFriend: { type: PersonType }
- })
-})
-```
-
-### GraphQLInterfaceType
-
-```ts
-class GraphQLInterfaceType {
- constructor(config: GraphQLInterfaceTypeConfig)
-}
-
-type GraphQLInterfaceTypeConfig = {
- name: string,
- fields: GraphQLFieldConfigMapThunk | GraphQLFieldConfigMap,
- resolveType?: (value: any, info?: GraphQLResolveInfo) => GraphQLObjectType,
- description?: string
-};
-```
-
-When a field can return one of a heterogeneous set of types, a Interface type
-is used to describe what types are possible, what fields are in common across
-all types, as well as a function to determine which type is actually used
-when the field is resolved.
-
-#### Example
-
-```js
-var EntityType = new GraphQLInterfaceType({
- name: "Entity",
- fields: {
- name: { type: GraphQLString }
- }
-})
-```
-
-### GraphQLUnionType
-
-```ts
-class GraphQLUnionType {
- constructor(config: GraphQLUnionTypeConfig)
-}
-
-type GraphQLUnionTypeConfig = {
- name: string,
- types: GraphQLObjectsThunk | GraphQLObjectType[],
- resolveType?: (value: any, info?: GraphQLResolveInfo) => GraphQLObjectType;
- description?: string;
-};
-
-type GraphQLObjectsThunk = () => GraphQLObjectType[];
-```
-
-When a field can return one of a heterogeneous set of types, a Union type
-is used to describe what types are possible as well as providing a function
-to determine which type is actually used when the field is resolved.
-
-### Example
-
-```js
-var PetType = new GraphQLUnionType({
- name: "Pet",
- types: [DogType, CatType],
- resolveType(value) {
- if (value instanceof Dog) {
- return DogType
- }
- if (value instanceof Cat) {
- return CatType
- }
- },
-})
-```
-
-### GraphQLEnumType
-
-```ts
-class GraphQLEnumType {
- constructor(config: GraphQLEnumTypeConfig)
-}
-
-type GraphQLEnumTypeConfig = {
- name: string;
- values: GraphQLEnumValueConfigMap;
- description?: string;
-}
-
-type GraphQLEnumValueConfigMap = {
- [valueName: string]: GraphQLEnumValueConfig;
-};
-
-type GraphQLEnumValueConfig = {
- value?: any;
- deprecationReason?: string;
- description?: string;
-}
-
-type GraphQLEnumValueDefinition = {
- name: string;
- value?: any;
- deprecationReason?: string;
- description?: string;
-}
-```
-
-Some leaf values of requests and input values are Enums. GraphQL serializes
-Enum values as strings, however internally Enums can be represented by any
-kind of type, often integers.
-
-Note: If a value is not provided in a definition, the name of the enum value
-will be used as its internal value.
-
-#### Example
-
-```js
-var RGBType = new GraphQLEnumType({
- name: "RGB",
- values: {
- RED: { value: 0 },
- GREEN: { value: 1 },
- BLUE: { value: 2 },
- },
-})
-```
-
-### GraphQLInputObjectType
-
-```ts
-class GraphQLInputObjectType {
- constructor(config: GraphQLInputObjectConfig)
-}
-
-type GraphQLInputObjectConfig = {
- name: string;
- fields: GraphQLInputObjectConfigFieldMapThunk | GraphQLInputObjectConfigFieldMap;
- description?: string;
-}
-
-type GraphQLInputObjectConfigFieldMapThunk = () => GraphQLInputObjectConfigFieldMap;
-
-type GraphQLInputObjectFieldConfig = {
- type: GraphQLInputType;
- defaultValue?: any;
- description?: string;
-}
-
-type GraphQLInputObjectConfigFieldMap = {
- [fieldName: string]: GraphQLInputObjectFieldConfig;
-};
-
-type GraphQLInputObjectField = {
- name: string;
- type: GraphQLInputType;
- defaultValue?: any;
- description?: string;
-}
-
-type GraphQLInputObjectFieldMap = {
- [fieldName: string]: GraphQLInputObjectField;
-};
-```
-
-An input object defines a structured collection of fields which may be
-supplied to a field argument.
-
-Using `NonNull` will ensure that a value must be provided by the query
-
-#### Example
-
-```js
-var GeoPoint = new GraphQLInputObjectType({
- name: "GeoPoint",
- fields: {
- lat: { type: new GraphQLNonNull(GraphQLFloat) },
- lon: { type: new GraphQLNonNull(GraphQLFloat) },
- alt: { type: GraphQLFloat, defaultValue: 0 },
- },
-})
-```
-
-### GraphQLList
-
-```ts
-class GraphQLList {
- constructor(type: GraphQLType)
-}
-```
-
-A list is a kind of type marker, a wrapping type which points to another
-type. Lists are often created within the context of defining the fields of
-an object type.
-
-#### Example
-
-```js
-var PersonType = new GraphQLObjectType({
- name: "Person",
- fields: () => ({
- parents: { type: new GraphQLList(PersonType) },
- children: { type: new GraphQLList(PersonType) },
- }),
-})
-```
-
-### GraphQLNonNull
-
-```ts
-class GraphQLNonNull {
- constructor(type: GraphQLType)
-}
-```
-
-A non-null is a kind of type marker, a wrapping type which points to another
-type. Non-null types enforce that their values are never null and can ensure
-an error is raised if this ever occurs during a request. It is useful for
-fields which you can make a strong guarantee on non-nullability, for example
-usually the id field of a database row will never be null.
-
-#### Example
-
-```js
-var RowType = new GraphQLObjectType({
- name: "Row",
- fields: () => ({
- id: { type: new GraphQLNonNull(String) },
- }),
-})
-```
-
-## Predicates
-
-### isInputType
-
-```js
-function isInputType(type: GraphQLType): boolean
-```
-
-These types may be used as input types for arguments and directives.
-
-### isOutputType
-
-```ts
-function isOutputType(type: GraphQLType): boolean
-```
-
-These types may be used as output types as the result of fields
-
-### isLeafType
-
-```ts
-function isLeafType(type: GraphQLType): boolean
-```
-
-These types may describe types which may be leaf values
-
-### isCompositeType
-
-```ts
-function isCompositeType(type: GraphQLType): boolean
-```
-
-These types may describe the parent context of a selection set
-
-### isAbstractType
-
-```ts
-function isAbstractType(type: GraphQLType): boolean
-```
-
-These types may describe a combination of object types
-
-## Un-modifiers
-
-### getNullableType
-
-```ts
-function getNullableType(type: GraphQLType): GraphQLNullableType
-```
-
-If a given type is non-nullable, this strips the non-nullability and
-returns the underlying type.
-
-### getNamedType
-
-```ts
-function getNamedType(type: GraphQLType): GraphQLNamedType
-```
-
-If a given type is non-nullable or a list, this repeated strips the
-non-nullability and list wrappers and returns the underlying type.
-
-## Scalars
-
-### GraphQLInt
-
-```ts
-let GraphQLInt: GraphQLScalarType
-```
-
-A `GraphQLScalarType` that represents an int.
-
-### GraphQLFloat
-
-```ts
-let GraphQLFloat: GraphQLScalarType
-```
-
-A `GraphQLScalarType` that represents a float.
-
-### GraphQLString
-
-```ts
-let GraphQLString: GraphQLScalarType
-```
-
-A `GraphQLScalarType` that represents a string.
-
-### GraphQLBoolean
-
-```ts
-let GraphQLBoolean: GraphQLScalarType
-```
-
-A `GraphQLScalarType` that represents a boolean.
-
-### GraphQLID
-
-```ts
-let GraphQLID: GraphQLScalarType
-```
-
-A `GraphQLScalarType` that represents an ID.
diff --git a/src/pages/graphql-js/utilities.mdx b/src/pages/graphql-js/utilities.mdx
deleted file mode 100644
index ed8f5cb229..0000000000
--- a/src/pages/graphql-js/utilities.mdx
+++ /dev/null
@@ -1,234 +0,0 @@
----
-title: graphql/utilities
----
-
-{/* title can be removed in Nextra 4, since sidebar title will take from first h1 */}
-
-# `graphql/utilities`
-
-The `graphql/utilities` module contains common useful computations to use with
-the GraphQL language and type objects. You can import either from the `graphql/utilities` module, or from the root `graphql` module. For example:
-
-```js
-import { introspectionQuery } from "graphql" // ES6
-var { introspectionQuery } = require("graphql") // CommonJS
-```
-
-## Overview
-
-### Introspection
-
-
-
-### Schema Language
-
-
-
-### Visitors
-
-
-
-### Value Validation
-
-
-
-## Introspection
-
-### introspectionQuery
-
-```js
-var introspectionQuery: string
-```
-
-A GraphQL query that queries a server's introspection system for enough
-information to reproduce that server's type system.
-
-### `buildClientSchema`
-
-```ts
-function buildClientSchema(
- introspection: IntrospectionQuery
-): GraphQLSchema
-```
-
-Build a GraphQLSchema for use by client tools.
-
-Given the result of a client running the introspection query, creates and
-returns a GraphQLSchema instance which can be then used with all GraphQL.js
-tools, but cannot be used to execute a query, as introspection does not
-represent the "resolver", "parse" or "serialize" functions or any other
-server-internal mechanisms.
-
-## Schema Representation
-
-### `buildSchema`
-
-```ts
-function buildSchema(source: string | Source): GraphQLSchema
-```
-
-Creates a GraphQLSchema object from GraphQL schema language. The schema will use default resolvers. For more detail on the GraphQL schema language, see the [schema language docs](/learn/schema/) or this [schema language cheat sheet](https://wehavefaces.net/graphql-shorthand-notation-cheatsheet-17cd715861b6#.9oztv0a7n).
-
-### `printSchema`
-
-```ts
-function printSchema(schema: GraphQLSchema): string
-```
-
-Prints the provided schema in the Schema Language format.
-
-### `printIntrospectionSchema`
-
-```ts
-function printIntrospectionSchema(schema: GraphQLSchema): string
-```
-
-Prints the built-in introspection schema in the Schema Language format.
-
-### `buildASTSchema`
-
-```ts
-function buildASTSchema(
- ast: SchemaDocument,
- queryTypeName: string,
- mutationTypeName: string
-): GraphQLSchema
-```
-
-This takes the ast of a schema document produced by `parseSchemaIntoAST` in
-`graphql/language/schema` and constructs a GraphQLSchema instance which can be
-then used with all GraphQL.js tools, but cannot be used to execute a query, as
-introspection does not represent the "resolver", "parse" or "serialize"
-functions or any other server-internal mechanisms.
-
-### `typeFromAST`
-
-```ts
-function typeFromAST(
- schema: GraphQLSchema,
- inputTypeAST: Type
-): GraphQLType
-```
-
-Given the name of a Type as it appears in a GraphQL AST and a Schema, return the
-corresponding GraphQLType from that schema.
-
-### `astFromValue`
-
-```ts
-function astFromValue(
- value: any,
- type: GraphQLInputType
-): Value
-```
-
-Produces a GraphQL Input Value AST given a JavaScript value.
-
-Optionally, a GraphQL type may be provided, which will be used to
-disambiguate between value primitives.
-
-## Visitors
-
-### `TypeInfo`
-
-```ts
-class TypeInfo {
- constructor(schema: GraphQLSchema)
- getType(): GraphQLOutputType
- getParentType(): GraphQLCompositeType
- getInputType(): GraphQLInputType
- getFieldDef(): GraphQLFieldDefinition
- getDirective(): GraphQLDirective
- getArgument(): GraphQLArgument
-}
-```
-
-TypeInfo is a utility class which, given a GraphQL schema, can keep track
-of the current field and type definitions at any point in a GraphQL document
-AST during a recursive descent by calling `enter(node)` and `leave(node)`.
-
-## Value Validation
-
-### `isValidJSValue`
-
-```ts
-function isValidJSValue(value: any, type: GraphQLInputType): string[]
-```
-
-Given a JavaScript value and a GraphQL type, determine if the value will be
-accepted for that type. This is primarily useful for validating the
-runtime values of query variables.
-
-### `isValidLiteralValue`
-
-```ts
-function isValidLiteralValue(
- type: GraphQLInputType,
- valueAST: Value
-): string[]
-```
-
-Utility for validators which determines if a value literal AST is valid given
-an input type.
-
-Note that this only validates literal values, variables are assumed to
-provide values of the correct type.
diff --git a/src/pages/graphql-js/validation.mdx b/src/pages/graphql-js/validation.mdx
deleted file mode 100644
index fdcfb21b3d..0000000000
--- a/src/pages/graphql-js/validation.mdx
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: graphql/validation
----
-
-{/* title can be removed in Nextra 4, since sidebar title will take from first h1 */}
-
-# `graphql/validation`
-
-The `graphql/validation` module fulfills the Validation phase of fulfilling a
-GraphQL result. You can import either from the `graphql/validation` module, or from the root `graphql` module. For example:
-
-```js
-import { validate } from "graphql/validation" // ES6
-var { validate } = require("graphql/validation") // CommonJS
-```
-
-## Overview
-
-
-
-## Validation
-
-### `validate`
-
-```ts
-function validate(
- schema: GraphQLSchema,
- ast: Document,
- rules?: any[]
-): GraphQLError[]
-```
-
-Implements the "Validation" section of the spec.
-
-Validation runs synchronously, returning an array of encountered errors, or
-an empty array if no errors were encountered and the document is valid.
-
-A list of specific validation rules may be provided. If not provided, the
-default list of rules defined by the GraphQL specification will be used.
-
-Each validation rules is a function which returns a visitor
-(see the language/visitor API). Visitor methods are expected to return
-GraphQLErrors, or Arrays of GraphQLErrors when invalid.
-
-Visitors can also supply `visitSpreadFragments: true` which will alter the
-behavior of the visitor to skip over top level defined fragments, and instead
-visit those fragments at every point a spread is encountered.
-
-### `specifiedRules`
-
-```ts
-let specifiedRules: Array<(context: ValidationContext) => any>
-```
-
-This set includes all validation rules defined by the GraphQL spec
diff --git a/src/pages/learn/authorization.mdx b/src/pages/learn/authorization.mdx
index da91da0089..c05a1fc88f 100644
--- a/src/pages/learn/authorization.mdx
+++ b/src/pages/learn/authorization.mdx
@@ -2,7 +2,7 @@
Delegate authorization logic to the business logic layer
-Most APIs will need to secure access to certain types of data depending on who requested it, and GraphQL is no different. GraphQL execution should begin after [authentication](/graphql-js/authentication-and-express-middleware/) middleware confirms the user's identity and passes that information to the GraphQL layer. But after that, you still need to determine if the authenticated user is allowed to view the data provided by the specific fields that were included in the request. On this page, we'll explore how a GraphQL schema can support authorization.
+Most APIs will need to secure access to certain types of data depending on who requested it, and GraphQL is no different. GraphQL execution should begin after [authentication](https://www.graphql-js.org/docs/authentication-and-express-middleware/) middleware confirms the user's identity and passes that information to the GraphQL layer. But after that, you still need to determine if the authenticated user is allowed to view the data provided by the specific fields that were included in the request. On this page, we'll explore how a GraphQL schema can support authorization.
## Type and field authorization
@@ -60,7 +60,7 @@ function Post_body(obj, args, context, info) {
}
```
-In the example above, we see that the business logic layer requires the caller to provide a user object, which is available in the `context` object for the GraphQL request. We recommend passing a fully-hydrated user object instead of an opaque token or API key to your business logic layer. This way, we can handle the distinct concerns of [authentication](/graphql-js/authentication-and-express-middleware/) and authorization in different stages of the request processing pipeline.
+In the example above, we see that the business logic layer requires the caller to provide a user object, which is available in the `context` object for the GraphQL request. We recommend passing a fully-hydrated user object instead of an opaque token or API key to your business logic layer. This way, we can handle the distinct concerns of [authentication](https://www.graphql-js.org/docs/authentication-and-express-middleware/) and authorization in different stages of the request processing pipeline.
## Using type system directives
diff --git a/src/pages/learn/execution.mdx b/src/pages/learn/execution.mdx
index 5fca44a03a..3eec931a53 100644
--- a/src/pages/learn/execution.mdx
+++ b/src/pages/learn/execution.mdx
@@ -70,7 +70,7 @@ This example is written in JavaScript, however GraphQL servers can be built in [
- `obj`: The previous object (for a field on the root `Query` type, this argument is often not used).
- `args`: The arguments provided to the field in the GraphQL operation.
- `context`: A value provided to every resolver that may hold important contextual information like the currently logged in user, or access to a database.
-- `info`: generally only used in advanced use-cases, this is a value holding field-specific information relevant to the current operation as well as the schema details; refer to [type GraphQLResolveInfo](/graphql-js/type/#graphqlobjecttype) for more details.
+- `info`: generally only used in advanced use-cases, this is a value holding field-specific information relevant to the current operation as well as the schema details; refer to [type GraphQLResolveInfo](https://www.graphql-js.org/api-v16/type/#graphqlobjecttype) for more details.
Note that while a query operation could technically write data to the underlying data system during its execution, mutation operations are conventionally used for requests that produce side effects during their execution. And because mutation operations produce side effects, GraphQL implementations can be expected to execute these fields serially.