Integrate into introspection

Author: benjie

src/__tests__/starWarsIntrospection-test.ts

@@ -37,6 +37,7 @@ describe('Star Wars Introspection Tests', () => {
             { name: 'Droid' },
             { name: 'Query' },
             { name: 'Boolean' },
+            { name: '__ErrorBehavior' },
             { name: '__Schema' },
             { name: '__Type' },
             { name: '__TypeKind' },

src/index.ts

@@ -79,6 +79,7 @@ export {
   __InputValue,
   __EnumValue,
   __TypeKind,
+  __ErrorBehavior,
   // Meta-field definitions.
   SchemaMetaFieldDef,
   TypeMetaFieldDef,

src/type/__tests__/introspection-test.ts

@@ -80,6 +80,32 @@ describe('Introspection', () => {
               enumValues: null,
               possibleTypes: null,
             },
+            {
+              enumValues: [
+                {
+                  deprecationReason: null,
+                  isDeprecated: false,
+                  name: 'NO_PROPAGATE',
+                },
+                {
+                  deprecationReason: null,
+                  isDeprecated: false,
+                  name: 'PROPAGATE',
+                },
+                {
+                  deprecationReason: null,
+                  isDeprecated: false,
+                  name: 'ABORT',
+                },
+              ],
+              fields: null,
+              inputFields: null,
+              interfaces: null,
+              kind: 'ENUM',
+              name: '__ErrorBehavior',
+              possibleTypes: null,
+              specifiedByURL: null,
+            },
             {
               kind: 'OBJECT',
               name: '__Schema',
@@ -179,6 +205,21 @@ describe('Introspection', () => {
                   isDeprecated: false,
                   deprecationReason: null,
                 },
+                {
+                  name: 'defaultErrorBehavior',
+                  args: [],
+                  type: {
+                    kind: 'NON_NULL',
+                    name: null,
+                    ofType: {
+                      kind: 'ENUM',
+                      name: '__ErrorBehavior',
+                      ofType: null,
+                    },
+                  },
+                  isDeprecated: false,
+                  deprecationReason: null,
+                },
               ],
               inputFields: null,
               interfaces: [],
@@ -1008,6 +1049,26 @@ describe('Introspection', () => {
               locations: ['INPUT_OBJECT'],
               args: [],
             },
+            {
+              args: [
+                {
+                  defaultValue: 'PROPAGATE',
+                  name: 'onError',
+                  type: {
+                    kind: 'NON_NULL',
+                    name: null,
+                    ofType: {
+                      kind: 'ENUM',
+                      name: '__ErrorBehavior',
+                      ofType: null,
+                    },
+                  },
+                },
+              ],
+              isRepeatable: false,
+              locations: ['SCHEMA'],
+              name: 'behavior',
+            },
           ],
         },
       },
@@ -1768,11 +1829,13 @@ describe('Introspection', () => {
       }
     `);
 
-    const source = getIntrospectionQuery({
-      descriptions: false,
-      specifiedByUrl: true,
-      directiveIsRepeatable: true,
-    });
+    const source = /* GraphQL */ `
+      {
+        __schema {
+          defaultErrorBehavior
+        }
+      }
+    `;
 
     const result = graphqlSync({ schema, source });
     expect(result).to.deep.equal({

src/type/__tests__/schema-test.ts

@@ -296,6 +296,7 @@ describe('Type System: Schema', () => {
       'ASub',
       'Boolean',
       'String',
+      '__ErrorBehavior',
       '__Schema',
       '__Type',
       '__TypeKind',

src/type/directives.ts

@@ -18,6 +18,7 @@ import {
   defineArguments,
   GraphQLNonNull,
 } from './definition';
+import { __ErrorBehavior } from './introspection';
 import { GraphQLBoolean, GraphQLString } from './scalars';
 
 /**
@@ -220,6 +221,21 @@ export const GraphQLOneOfDirective: GraphQLDirective = new GraphQLDirective({
   args: {},
 });
 
+/**
+ * Used to indicate the default error behavior.
+ */
+export const GraphQLBehaviorDirective: GraphQLDirective = new GraphQLDirective({
+  name: 'behavior',
+  description: 'Indicates the default error behavior of the schema.',
+  locations: [DirectiveLocation.SCHEMA],
+  args: {
+    onError: {
+      type: new GraphQLNonNull(__ErrorBehavior),
+      defaultValue: 'PROPAGATE',
+    },
+  },
+});
+
 /**
  * The full list of specified directives.
  */
@@ -230,6 +246,7 @@ export const specifiedDirectives: ReadonlyArray<GraphQLDirective> =
     GraphQLDeprecatedDirective,
     GraphQLSpecifiedByDirective,
     GraphQLOneOfDirective,
+    GraphQLBehaviorDirective,
   ]);
 
 export function isSpecifiedDirective(directive: GraphQLDirective): boolean {

src/type/index.ts

@@ -172,6 +172,7 @@ export {
   __InputValue,
   __EnumValue,
   __TypeKind,
+  __ErrorBehavior,
   // "Enum" of Type Kinds
   TypeKind,
   // Meta-field definitions.

src/type/introspection.ts

@@ -74,6 +74,12 @@ export const __Schema: GraphQLObjectType = new GraphQLObjectType({
         ),
         resolve: (schema) => schema.getDirectives(),
       },
+      defaultErrorBehavior: {
+        description:
+          'The default error behavior that will be used for requests which do not specify `onError`.',
+        type: new GraphQLNonNull(__ErrorBehavior),
+        resolve: (schema) => schema.defaultErrorBehavior,
+      },
     } as GraphQLFieldConfigMap<GraphQLSchema, unknown>),
 });
 
@@ -500,6 +506,29 @@ export const __TypeKind: GraphQLEnumType = new GraphQLEnumType({
   },
 });
 
+export const __ErrorBehavior: GraphQLEnumType = new GraphQLEnumType({
+  name: '__ErrorBehavior',
+  description:
+    'An enum detailing the error behavior a GraphQL request should use.',
+  values: {
+    NO_PROPAGATE: {
+      value: 'NO_PROPAGATE',
+      description:
+        'Indicates that an error should result in the response position becoming null, even if it is marked as non-null.',
+    },
+    PROPAGATE: {
+      value: 'PROPAGATE',
+      description:
+        'Indicates that an error that occurs in a non-null position should propagate to the nearest nullable response position.',
+    },
+    ABORT: {
+      value: 'ABORT',
+      description:
+        'Indicates execution should cease when the first error occurs, and that the response data should be null.',
+    },
+  },
+});
+
 /**
  * Note that these are GraphQLField and not GraphQLFieldConfig,
  * so the format for args is different.
@@ -558,6 +587,7 @@ export const introspectionTypes: ReadonlyArray<GraphQLNamedType> =
     __InputValue,
     __EnumValue,
     __TypeKind,
+    __ErrorBehavior,
   ]);
 
 export function isIntrospectionType(type: GraphQLNamedType): boolean {

src/utilities/__tests__/buildASTSchema-test.ts

@@ -21,6 +21,7 @@ import {
 } from '../../type/definition';
 import {
   assertDirective,
+  GraphQLBehaviorDirective,
   GraphQLDeprecatedDirective,
   GraphQLIncludeDirective,
   GraphQLOneOfDirective,
@@ -223,7 +224,7 @@ describe('Schema Builder', () => {
   it('Maintains @include, @skip & @specifiedBy', () => {
     const schema = buildSchema('type Query');
 
-    expect(schema.getDirectives()).to.have.lengthOf(5);
+    expect(schema.getDirectives()).to.have.lengthOf(6);
     expect(schema.getDirective('skip')).to.equal(GraphQLSkipDirective);
     expect(schema.getDirective('include')).to.equal(GraphQLIncludeDirective);
     expect(schema.getDirective('deprecated')).to.equal(
@@ -232,6 +233,7 @@ describe('Schema Builder', () => {
     expect(schema.getDirective('specifiedBy')).to.equal(
       GraphQLSpecifiedByDirective,
     );
+    expect(schema.getDirective('behavior')).to.equal(GraphQLBehaviorDirective);
     expect(schema.getDirective('oneOf')).to.equal(GraphQLOneOfDirective);
   });
 
@@ -241,10 +243,11 @@ describe('Schema Builder', () => {
       directive @include on FIELD
       directive @deprecated on FIELD_DEFINITION
       directive @specifiedBy on FIELD_DEFINITION
+      directive @behavior on SCHEMA
       directive @oneOf on OBJECT
     `);
 
-    expect(schema.getDirectives()).to.have.lengthOf(5);
+    expect(schema.getDirectives()).to.have.lengthOf(6);
     expect(schema.getDirective('skip')).to.not.equal(GraphQLSkipDirective);
     expect(schema.getDirective('include')).to.not.equal(
       GraphQLIncludeDirective,
@@ -255,19 +258,23 @@ describe('Schema Builder', () => {
     expect(schema.getDirective('specifiedBy')).to.not.equal(
       GraphQLSpecifiedByDirective,
     );
+    expect(schema.getDirective('behavior')).to.not.equal(
+      GraphQLBehaviorDirective,
+    );
     expect(schema.getDirective('oneOf')).to.not.equal(GraphQLOneOfDirective);
   });
 
-  it('Adding directives maintains @include, @skip, @deprecated, @specifiedBy, and @oneOf', () => {
+  it('Adding directives maintains @include, @skip, @deprecated, @specifiedBy, @behavior and @oneOf', () => {
     const schema = buildSchema(`
       directive @foo(arg: Int) on FIELD
     `);
 
-    expect(schema.getDirectives()).to.have.lengthOf(6);
+    expect(schema.getDirectives()).to.have.lengthOf(7);
     expect(schema.getDirective('skip')).to.not.equal(undefined);
     expect(schema.getDirective('include')).to.not.equal(undefined);
     expect(schema.getDirective('deprecated')).to.not.equal(undefined);
     expect(schema.getDirective('specifiedBy')).to.not.equal(undefined);
+    expect(schema.getDirective('behavior')).to.not.equal(undefined);
     expect(schema.getDirective('oneOf')).to.not.equal(undefined);
   });
 

src/utilities/__tests__/findBreakingChanges-test.ts

@@ -2,6 +2,7 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import {
+  GraphQLBehaviorDirective,
   GraphQLDeprecatedDirective,
   GraphQLIncludeDirective,
   GraphQLOneOfDirective,
@@ -803,6 +804,7 @@ describe('findBreakingChanges', () => {
         GraphQLSkipDirective,
         GraphQLIncludeDirective,
         GraphQLSpecifiedByDirective,
+        GraphQLBehaviorDirective,
         GraphQLOneOfDirective,
       ],
     });

src/utilities/__tests__/printSchema-test.ts

@@ -694,6 +694,27 @@ describe('Type System Printer', () => {
       """
       directive @oneOf on INPUT_OBJECT
 
+      """Indicates the default error behavior of the schema."""
+      directive @behavior(onError: __ErrorBehavior! = PROPAGATE) on SCHEMA
+      
+      """An enum detailing the error behavior a GraphQL request should use."""
+      enum __ErrorBehavior {
+        """
+        Indicates that an error should result in the response position becoming null, even if it is marked as non-null.
+        """
+        NO_PROPAGATE
+      
+        """
+        Indicates that an error that occurs in a non-null position should propagate to the nearest nullable response position.
+        """
+        PROPAGATE
+      
+        """
+        Indicates execution should cease when the first error occurs, and that the response data should be null.
+        """
+        ABORT
+      }
+
       """
       A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.
       """
@@ -718,6 +739,11 @@ describe('Type System Printer', () => {
 
         """A list of all directives supported by this server."""
         directives: [__Directive!]!
+
+        """
+        The default error behavior that will be used for requests which do not specify \`onError\`.
+        """
+        defaultErrorBehavior: __ErrorBehavior!
       }
 
       """

src/utilities/extendSchema.ts

@@ -64,6 +64,7 @@ import {
   isUnionType,
 } from '../type/definition';
 import {
+  GraphQLBehaviorDirective,
   GraphQLDeprecatedDirective,
   GraphQLDirective,
   GraphQLOneOfDirective,
@@ -82,6 +83,7 @@ import { assertValidSDLExtension } from '../validation/validate';
 import { getDirectiveValues } from '../execution/values';
 
 import { valueFromAST } from './valueFromAST';
+import type { GraphQLErrorBehavior } from '../error';
 
 interface Options extends GraphQLSchemaValidationOptions {
   /**
@@ -165,6 +167,14 @@ export function extendSchemaImpl(
     }
   }
 
+  let defaultErrorBehavior: Maybe<GraphQLErrorBehavior> = schemaDef
+    ? getDefaultErrorBehavior(schemaDef)
+    : null;
+  for (const extensionNode of schemaExtensions) {
+    defaultErrorBehavior =
+      getDefaultErrorBehavior(extensionNode) ?? defaultErrorBehavior;
+  }
+
   // If this document contains no new types, extensions, or directives then
   // return the same unmodified GraphQLSchema instance.
   if (
@@ -201,6 +211,7 @@ export function extendSchemaImpl(
   // Then produce and return a Schema config with these types.
   return {
     description: schemaDef?.description?.value,
+    defaultErrorBehavior,
     ...operationTypes,
     types: Object.values(typeMap),
     directives: [
@@ -691,3 +702,14 @@ function getSpecifiedByURL(
 function isOneOf(node: InputObjectTypeDefinitionNode): boolean {
   return Boolean(getDirectiveValues(GraphQLOneOfDirective, node));
 }
+
+/**
+ * Given a schema node, returns the GraphQL error behavior from the `@behavior(onError:)` argument.
+ */
+function getDefaultErrorBehavior(
+  node: SchemaDefinitionNode | SchemaExtensionNode,
+): Maybe<GraphQLErrorBehavior> {
+  const behavior = getDirectiveValues(GraphQLBehaviorDirective, node);
+  // @ts-expect-error validated by `getDirectiveValues`
+  return behavior?.onError;
+}