Switch to errorBehavior, replace contextual introspection to simple includeSemanticNonNull

benjie · benjie · commit 8fcacc85db72 · 2025-03-26T17:20:15.000Z
diff --git a/src/__tests__/starWarsIntrospection-test.ts b/src/__tests__/starWarsIntrospection-test.ts
@@ -42,7 +42,6 @@ describe('Star Wars Introspection Tests', () => {
             { name: '__TypeKind' },
             { name: '__Field' },
             { name: '__InputValue' },
-            { name: '__TypeNullability' },
             { name: '__EnumValue' },
             { name: '__Directive' },
             { name: '__DirectiveLocation' },
diff --git a/src/execution/__tests__/executor-test.ts b/src/execution/__tests__/executor-test.ts
@@ -263,7 +263,7 @@ describe('Execute: Handles basic execution tasks', () => {
       'rootValue',
       'operation',
       'variableValues',
-      'errorPropagation',
+      'errorBehavior',
     );
 
     const operation = document.definitions[0];
@@ -276,7 +276,7 @@ describe('Execute: Handles basic execution tasks', () => {
       schema,
       rootValue,
       operation,
-      errorPropagation: true,
+      errorBehavior: 'PROPAGATE',
     });
 
     const field = operation.selectionSet.selections[0];
diff --git a/src/execution/execute.ts b/src/execution/execute.ts
@@ -116,7 +116,7 @@ export interface ExecutionContext {
   typeResolver: GraphQLTypeResolver<any, any>;
   subscribeFieldResolver: GraphQLFieldResolver<any, any>;
   errors: Array<GraphQLError>;
-  errorPropagation: boolean;
+  errorBehavior: 'PROPAGATE' | 'NULL' | 'ABORT';
 }
 
 /**
@@ -155,11 +155,14 @@ export interface ExecutionArgs {
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   /**
-   * Set to `false` to disable error propagation. Experimental.
+   * Experimental. Set to NULL to prevent error propagation. Set to ABORT to
+   * abort a request when any error occurs.
+   *
+   * Default: PROPAGATE
    *
    * @experimental
    */
-  errorPropagation?: boolean;
+  errorBehavior?: 'PROPAGATE' | 'NULL' | 'ABORT';
 }
 
 /**
@@ -294,7 +297,7 @@ export function buildExecutionContext(
     fieldResolver,
     typeResolver,
     subscribeFieldResolver,
-    errorPropagation,
+    errorBehavior,
   } = args;
 
   let operation: OperationDefinitionNode | undefined;
@@ -356,7 +359,7 @@ export function buildExecutionContext(
     typeResolver: typeResolver ?? defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
     errors: [],
-    errorPropagation: errorPropagation ?? true,
+    errorBehavior: errorBehavior ?? 'PROPAGATE',
   };
 }
 
@@ -595,7 +598,7 @@ export function buildResolveInfo(
     rootValue: exeContext.rootValue,
     operation: exeContext.operation,
     variableValues: exeContext.variableValues,
-    errorPropagation: exeContext.errorPropagation,
+    errorBehavior: exeContext.errorBehavior,
   };
 }
 
@@ -604,10 +607,25 @@ function handleFieldError(
   returnType: GraphQLOutputType,
   exeContext: ExecutionContext,
 ): null {
-  // If the field type is non-nullable, then it is resolved without any
-  // protection from errors, however it still properly locates the error.
-  if (exeContext.errorPropagation && isNonNullType(returnType)) {
+  if (exeContext.errorBehavior === 'PROPAGATE') {
+    // If the field type is non-nullable, then it is resolved without any
+    // protection from errors, however it still properly locates the error.
+    // Note: semantic non-null types are treated as nullable for the purposes
+    // of error handling.
+    if (isNonNullType(returnType)) {
+      throw error;
+    }
+  } else if (exeContext.errorBehavior === 'ABORT') {
+    // In this mode, any error aborts the request
     throw error;
+  } else if (exeContext.errorBehavior === 'NULL') {
+    // In this mode, the client takes responsibility for error handling, so we
+    // treat the field as if it were nullable.
+  } else {
+    invariant(
+      false,
+      'Unexpected errorBehavior setting: ' + inspect(exeContext.errorBehavior),
+    );
   }
 
   // Otherwise, error protection is applied, logging the error and resolving
diff --git a/src/graphql.ts b/src/graphql.ts
@@ -67,11 +67,14 @@ export interface GraphQLArgs {
   fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   /**
-   * Set to `false` to disable error propagation. Experimental.
+   * Experimental. Set to NULL to prevent error propagation. Set to ABORT to
+   * abort a request when any error occurs.
+   *
+   * Default: PROPAGATE
    *
    * @experimental
    */
-  errorPropagation?: boolean;
+  errorBehavior?: 'PROPAGATE' | 'NULL' | 'ABORT';
 }
 
 export function graphql(args: GraphQLArgs): Promise<ExecutionResult> {
@@ -112,7 +115,7 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
     operationName,
     fieldResolver,
     typeResolver,
-    errorPropagation,
+    errorBehavior,
   } = args;
 
   // Validate Schema
@@ -145,6 +148,6 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
     operationName,
     fieldResolver,
     typeResolver,
-    errorPropagation,
+    errorBehavior,
   });
 }
diff --git a/src/index.ts b/src/index.ts
@@ -75,7 +75,6 @@ export {
   __Schema,
   __Directive,
   __DirectiveLocation,
-  __TypeNullability,
   __Type,
   __Field,
   __InputValue,
diff --git a/src/type/__tests__/introspection-test.ts b/src/type/__tests__/introspection-test.ts
@@ -513,17 +513,17 @@ describe('Introspection', () => {
                   name: 'type',
                   args: [
                     {
-                      name: 'nullability',
+                      name: 'includeSemanticNonNull',
                       type: {
                         kind: 'NON_NULL',
                         name: null,
                         ofType: {
-                          kind: 'ENUM',
-                          name: '__TypeNullability',
+                          kind: 'SCALAR',
+                          name: 'Boolean',
                           ofType: null,
                         },
                       },
-                      defaultValue: 'AUTO',
+                      defaultValue: 'false',
                     },
                   ],
                   type: {
@@ -659,37 +659,6 @@ describe('Introspection', () => {
               enumValues: null,
               possibleTypes: null,
             },
-            {
-              kind: 'ENUM',
-              name: '__TypeNullability',
-              specifiedByURL: null,
-              fields: null,
-              inputFields: null,
-              interfaces: null,
-              enumValues: [
-                {
-                  name: 'AUTO',
-                  isDeprecated: false,
-                  deprecationReason: null,
-                },
-                {
-                  name: 'TRADITIONAL',
-                  isDeprecated: false,
-                  deprecationReason: null,
-                },
-                {
-                  name: 'SEMANTIC',
-                  isDeprecated: false,
-                  deprecationReason: null,
-                },
-                {
-                  name: 'FULL',
-                  isDeprecated: false,
-                  deprecationReason: null,
-                },
-              ],
-              possibleTypes: null,
-            },
             {
               kind: 'OBJECT',
               name: '__EnumValue',
diff --git a/src/type/__tests__/schema-test.ts b/src/type/__tests__/schema-test.ts
@@ -301,7 +301,6 @@ describe('Type System: Schema', () => {
       '__TypeKind',
       '__Field',
       '__InputValue',
-      '__TypeNullability',
       '__EnumValue',
       '__Directive',
       '__DirectiveLocation',
diff --git a/src/type/definition.ts b/src/type/definition.ts
@@ -1088,7 +1088,7 @@ export interface GraphQLResolveInfo {
   readonly operation: OperationDefinitionNode;
   readonly variableValues: { [variable: string]: unknown };
   /** @experimental */
-  readonly errorPropagation: boolean;
+  readonly errorBehavior: 'PROPAGATE' | 'NULL' | 'ABORT';
 }
 
 /**
diff --git a/src/type/index.ts b/src/type/index.ts
@@ -170,7 +170,6 @@ export {
   __Schema,
   __Directive,
   __DirectiveLocation,
-  __TypeNullability,
   __Type,
   __Field,
   __InputValue,
diff --git a/src/type/introspection.ts b/src/type/introspection.ts
@@ -12,14 +12,14 @@ import type {
   GraphQLFieldConfigMap,
   GraphQLInputField,
   GraphQLNamedType,
+  GraphQLOutputType,
   GraphQLType,
 } from './definition';
 import {
   GraphQLEnumType,
   GraphQLList,
   GraphQLNonNull,
   GraphQLObjectType,
-  GraphQLSemanticNonNull,
   isAbstractType,
   isEnumType,
   isInputObjectType,
@@ -206,40 +206,6 @@ export const __DirectiveLocation: GraphQLEnumType = new GraphQLEnumType({
   },
 });
 
-// TODO: rename enum and options
-enum TypeNullability {
-  AUTO = 'AUTO',
-  TRADITIONAL = 'TRADITIONAL',
-  SEMANTIC = 'SEMANTIC',
-  FULL = 'FULL',
-}
-
-// TODO: rename
-export const __TypeNullability: GraphQLEnumType = new GraphQLEnumType({
-  name: '__TypeNullability',
-  description: 'TODO',
-  values: {
-    AUTO: {
-      value: TypeNullability.AUTO,
-      description:
-        'Determines nullability mode based on errorPropagation mode.',
-    },
-    TRADITIONAL: {
-      value: TypeNullability.TRADITIONAL,
-      description: 'Turn semantic-non-null types into nullable types.',
-    },
-    SEMANTIC: {
-      value: TypeNullability.SEMANTIC,
-      description: 'Turn non-null types into semantic-non-null types.',
-    },
-    FULL: {
-      value: TypeNullability.FULL,
-      description:
-        'Render the true nullability in the schema; be prepared for new types of nullability in future!',
-    },
-  },
-});
-
 export const __Type: GraphQLObjectType = new GraphQLObjectType({
   name: '__Type',
   description:
@@ -406,22 +372,17 @@ export const __Field: GraphQLObjectType = new GraphQLObjectType({
       type: {
         type: new GraphQLNonNull(__Type),
         args: {
-          nullability: {
-            type: new GraphQLNonNull(__TypeNullability),
-            defaultValue: TypeNullability.AUTO,
+          includeSemanticNonNull: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            defaultValue: false,
           },
         },
-        resolve: (field, { nullability }, _context, info) => {
-          if (nullability === TypeNullability.FULL) {
+        resolve: (field, { includeSemanticNonNull }, _context) => {
+          if (includeSemanticNonNull) {
             return field.type;
           }
-          const mode =
-            nullability === TypeNullability.AUTO
-              ? info.errorPropagation
-                ? TypeNullability.TRADITIONAL
-                : TypeNullability.SEMANTIC
-              : nullability;
-          return convertOutputTypeToNullabilityMode(field.type, mode);
+          // TODO: memoize
+          return stripSemanticNonNullTypes(field.type);
         },
       },
       isDeprecated: {
@@ -436,32 +397,21 @@ export const __Field: GraphQLObjectType = new GraphQLObjectType({
 });
 
 // TODO: move this elsewhere, rename, memoize
-function convertOutputTypeToNullabilityMode(
-  type: GraphQLType,
-  mode: TypeNullability.TRADITIONAL | TypeNullability.SEMANTIC,
-): GraphQLType {
-  if (mode === TypeNullability.TRADITIONAL) {
-    if (isNonNullType(type)) {
-      return new GraphQLNonNull(
-        convertOutputTypeToNullabilityMode(type.ofType, mode),
-      );
-    } else if (isSemanticNonNullType(type)) {
-      return convertOutputTypeToNullabilityMode(type.ofType, mode);
-    } else if (isListType(type)) {
-      return new GraphQLList(
-        convertOutputTypeToNullabilityMode(type.ofType, mode),
-      );
+function stripSemanticNonNullTypes(type: GraphQLOutputType): GraphQLOutputType {
+  if (isNonNullType(type)) {
+    const convertedInner = stripSemanticNonNullTypes(type.ofType);
+    if (convertedInner === type.ofType) {
+      return type; // No change needed
     }
-    return type;
-  }
-  if (isNonNullType(type) || isSemanticNonNullType(type)) {
-    return new GraphQLSemanticNonNull(
-      convertOutputTypeToNullabilityMode(type.ofType, mode),
-    );
+    return new GraphQLNonNull(convertedInner);
   } else if (isListType(type)) {
-    return new GraphQLList(
-      convertOutputTypeToNullabilityMode(type.ofType, mode),
-    );
+    const convertedInner = stripSemanticNonNullTypes(type.ofType);
+    if (convertedInner === type.ofType) {
+      return type; // No change needed
+    }
+    return new GraphQLList(convertedInner);
+  } else if (isSemanticNonNullType(type)) {
+    return stripSemanticNonNullTypes(type.ofType);
   }
   return type;
 }
@@ -646,7 +596,6 @@ export const introspectionTypes: ReadonlyArray<GraphQLNamedType> =
     __Schema,
     __Directive,
     __DirectiveLocation,
-    __TypeNullability,
     __Type,
     __Field,
     __InputValue,
diff --git a/src/utilities/__tests__/printSchema-test.ts b/src/utilities/__tests__/printSchema-test.ts
diff --git a/src/utilities/getIntrospectionQuery.ts b/src/utilities/getIntrospectionQuery.ts

Original file line number	Diff line number	Diff line change
`@@ -1088,7 +1088,7 @@ export interface GraphQLResolveInfo {`
`1088`	`1088`	`readonly operation: OperationDefinitionNode;`
`1089`	`1089`	`readonly variableValues: { [variable: string]: unknown };`
`1090`	`1090`	`/** @experimental */`
`1091`		`- readonly errorPropagation: boolean;`
	`1091`	`+ readonly errorBehavior: 'PROPAGATE' \| 'NULL' \| 'ABORT';`
`1092`	`1092`	`}`
`1093`	`1093`
`1094`	`1094`	`/**`