Semantic nullability rfc implementation

src/__tests__/starWarsIntrospection-test.ts

@@ -42,6 +42,7 @@ describe('Star Wars Introspection Tests', () => {
             { name: '__TypeKind' },
             { name: '__Field' },
             { name: '__InputValue' },
+            { name: '__TypeNullability' },
             { name: '__EnumValue' },
             { name: '__Directive' },
             { name: '__DirectiveLocation' },

src/execution/__tests__/executor-test.ts

@@ -263,6 +263,7 @@ describe('Execute: Handles basic execution tasks', () => {
       'rootValue',
       'operation',
       'variableValues',
+      'errorPropagation',
     );
 
     const operation = document.definitions[0];
@@ -275,6 +276,7 @@ describe('Execute: Handles basic execution tasks', () => {
       schema,
       rootValue,
       operation,
+      errorPropagation: true,
     });
 
     const field = operation.selectionSet.selections[0];

src/execution/__tests__/semantic-nullability-test.ts

@@ -0,0 +1,174 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+
+import { GraphQLError } from '../../error/GraphQLError';
+
+import type { ExecutableDefinitionNode, FieldNode } from '../../language/ast';
+import { parse } from '../../language/parser';
+
+import {
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLSemanticNonNull,
+} from '../../type/definition';
+import { GraphQLString } from '../../type/scalars';
+import { GraphQLSchema } from '../../type/schema';
+
+import { execute } from '../execute';
+
+describe('Execute: Handles Semantic Nullability', () => {
+  const DeepDataType = new GraphQLObjectType({
+    name: 'DeepDataType',
+    fields: {
+      f: { type: new GraphQLNonNull(GraphQLString) },
+    },
+  });
+
+  const DataType: GraphQLObjectType = new GraphQLObjectType({
+    name: 'DataType',
+    fields: () => ({
+      a: { type: GraphQLString },
+      b: { type: new GraphQLSemanticNonNull(GraphQLString) },
+      c: { type: new GraphQLNonNull(GraphQLString) },
+      d: { type: new GraphQLSemanticNonNull(DeepDataType) },
+    }),
+  });
+
+  it('SemanticNonNull throws error on null without error', async () => {
+    const data = {
+      b: () => null,
+    };
+
+    const document = parse(`
+        query {
+          b
+        }
+      `);
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    const executable = document.definitions[0] as ExecutableDefinitionNode;
+    const selectionSet = executable.selectionSet.selections[0];
+
+    expect(result).to.deep.equal({
+      data: {
+        b: null,
+      },
+      errors: [
+        new GraphQLError(
+          'Cannot return null for semantic-non-nullable field DataType.b.',
+          {
+            nodes: selectionSet,
+            path: ['b'],
+          },
+        ),
+      ],
+    });
+  });
+
+  it('SemanticNonNull succeeds on null with error', async () => {
+    const data = {
+      b: () => {
+        throw new Error('Something went wrong');
+      },
+    };
+
+    const document = parse(`
+        query {
+          b
+        }
+      `);
+
+    const executable = document.definitions[0] as ExecutableDefinitionNode;
+    const selectionSet = executable.selectionSet.selections[0];
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    expect(result).to.deep.equal({
+      data: {
+        b: null,
+      },
+      errors: [
+        new GraphQLError('Something went wrong', {
+          nodes: selectionSet,
+          path: ['b'],
+        }),
+      ],
+    });
+  });
+
+  it('SemanticNonNull halts null propagation', async () => {
+    const deepData = {
+      f: () => null,
+    };
+
+    const data = {
+      d: () => deepData,
+    };
+
+    const document = parse(`
+        query {
+          d {
+            f
+          }
+        }
+      `);
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    const executable = document.definitions[0] as ExecutableDefinitionNode;
+    const dSelectionSet = executable.selectionSet.selections[0] as FieldNode;
+    const fSelectionSet = dSelectionSet.selectionSet?.selections[0];
+
+    expect(result).to.deep.equal({
+      data: {
+        d: null,
+      },
+      errors: [
+        new GraphQLError(
+          'Cannot return null for non-nullable field DeepDataType.f.',
+          {
+            nodes: fSelectionSet,
+            path: ['d', 'f'],
+          },
+        ),
+      ],
+    });
+  });
+
+  it('SemanticNullable allows non-null values', async () => {
+    const data = {
+      a: () => 'Apple',
+    };
+
+    const document = parse(`
+        query {
+          a
+        }
+      `);
+
+    const result = await execute({
+      schema: new GraphQLSchema({ query: DataType }),
+      document,
+      rootValue: data,
+    });
+
+    expect(result).to.deep.equal({
+      data: {
+        a: 'Apple',
+      },
+    });
+  });
+});

src/execution/execute.ts

@@ -43,6 +43,7 @@ import {
   isListType,
   isNonNullType,
   isObjectType,
+  isSemanticNonNullType,
 } from '../type/definition';
 import {
   SchemaMetaFieldDef,
@@ -115,6 +116,7 @@ export interface ExecutionContext {
   typeResolver: GraphQLTypeResolver<any, any>;
   subscribeFieldResolver: GraphQLFieldResolver<any, any>;
   errors: Array<GraphQLError>;
+  errorPropagation: boolean;
 }
 
 /**
@@ -152,6 +154,13 @@ export interface ExecutionArgs {
   fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
   subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
+  /**
+   * Set to `false` to disable error propagation. Experimental.
+   * TODO: describe what this does
+   *
+   * @experimental
+   */
+  errorPropagation?: boolean;
 }
 
 /**
@@ -286,6 +295,7 @@ export function buildExecutionContext(
     fieldResolver,
     typeResolver,
     subscribeFieldResolver,
+    errorPropagation,
   } = args;
 
   let operation: OperationDefinitionNode | undefined;
@@ -347,6 +357,7 @@ export function buildExecutionContext(
     typeResolver: typeResolver ?? defaultTypeResolver,
     subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
     errors: [],
+    errorPropagation: errorPropagation ?? true,
   };
 }
 
@@ -585,6 +596,7 @@ export function buildResolveInfo(
     rootValue: exeContext.rootValue,
     operation: exeContext.operation,
     variableValues: exeContext.variableValues,
+    errorPropagation: exeContext.errorPropagation,
   };
 }
 
@@ -658,6 +670,25 @@ function completeValue(
     return completed;
   }
 
+  // If field type is SemanticNonNull, complete for inner type, and throw field error
+  // if result is null and an error doesn't exist.
+  if (isSemanticNonNullType(returnType)) {
+    const completed = completeValue(
+      exeContext,
+      returnType.ofType,
+      fieldNodes,
+      info,
+      path,
+      result,
+    );
+    if (completed === null) {
+      throw new Error(
+        `Cannot return null for semantic-non-nullable field ${info.parentType.name}.${info.fieldName}.`,
+      );
+    }
+    return completed;
+  }
+
   // If result value is null or undefined then return null.
   if (result == null) {
     return null;

src/graphql.ts

@@ -66,6 +66,12 @@ export interface GraphQLArgs {
   operationName?: Maybe<string>;
   fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>;
   typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
+  /**
+   * Set to `false` to disable error propagation. Experimental.
+   *
+   * @experimental
+   */
+  errorPropagation?: boolean;
 }
 
 export function graphql(args: GraphQLArgs): Promise<ExecutionResult> {
@@ -106,6 +112,7 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
     operationName,
     fieldResolver,
     typeResolver,
+    errorPropagation,
   } = args;
 
   // Validate Schema
@@ -138,5 +145,6 @@ function graphqlImpl(args: GraphQLArgs): PromiseOrValue<ExecutionResult> {
     operationName,
     fieldResolver,
     typeResolver,
+    errorPropagation,
   });
 }

src/index.ts

@@ -48,6 +48,7 @@ export {
   GraphQLInputObjectType,
   GraphQLList,
   GraphQLNonNull,
+  GraphQLSemanticNonNull,
   // Standard GraphQL Scalars
   specifiedScalarTypes,
   GraphQLInt,
@@ -74,6 +75,7 @@ export {
   __Schema,
   __Directive,
   __DirectiveLocation,
+  __TypeNullability,
   __Type,
   __Field,
   __InputValue,
@@ -95,6 +97,7 @@ export {
   isInputObjectType,
   isListType,
   isNonNullType,
+  isSemanticNonNullType,
   isInputType,
   isOutputType,
   isLeafType,
@@ -120,6 +123,7 @@ export {
   assertInputObjectType,
   assertListType,
   assertNonNullType,
+  assertSemanticNonNullType,
   assertInputType,
   assertOutputType,
   assertLeafType,
@@ -286,6 +290,7 @@ export type {
   TypeNode,
   NamedTypeNode,
   ListTypeNode,
+  SemanticNonNullTypeNode,
   NonNullTypeNode,
   TypeSystemDefinitionNode,
   SchemaDefinitionNode,
@@ -481,6 +486,7 @@ export type {
   IntrospectionNamedTypeRef,
   IntrospectionListTypeRef,
   IntrospectionNonNullTypeRef,
+  IntrospectionSemanticNonNullTypeRef,
   IntrospectionField,
   IntrospectionInputValue,
   IntrospectionEnumValue,