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__/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,
@@ -658,6 +659,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/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,

src/language/__tests__/parser-test.ts

@@ -657,4 +657,64 @@ describe('Parser', () => {
       });
     });
   });
+
+  describe('parseDocumentDirective', () => {
+    it("doesn't throw on document-level directive", () => {
+      parse(dedent`
+        @SemanticNullability
+        type Query {
+          hello: String
+          world: String?
+          foo: String!
+        }
+      `);
+    });
+
+    it('parses semantic-non-null types', () => {
+      const result = parseType('MyType', { allowSemanticNullability: true });
+      expectJSON(result).toDeepEqual({
+        kind: Kind.SEMANTIC_NON_NULL_TYPE,
+        loc: { start: 0, end: 6 },
+        type: {
+          kind: Kind.NAMED_TYPE,
+          loc: { start: 0, end: 6 },
+          name: {
+            kind: Kind.NAME,
+            loc: { start: 0, end: 6 },
+            value: 'MyType',
+          },
+        },
+      });
+    });
+
+    it('parses nullable types', () => {
+      const result = parseType('MyType?', { allowSemanticNullability: true });
+      expectJSON(result).toDeepEqual({
+        kind: Kind.NAMED_TYPE,
+        loc: { start: 0, end: 6 },
+        name: {
+          kind: Kind.NAME,
+          loc: { start: 0, end: 6 },
+          value: 'MyType',
+        },
+      });
+    });
+
+    it('parses non-nullable types', () => {
+      const result = parseType('MyType!', { allowSemanticNullability: true });
+      expectJSON(result).toDeepEqual({
+        kind: Kind.NON_NULL_TYPE,
+        loc: { start: 0, end: 7 },
+        type: {
+          kind: Kind.NAMED_TYPE,
+          loc: { start: 0, end: 6 },
+          name: {
+            kind: Kind.NAME,
+            loc: { start: 0, end: 6 },
+            value: 'MyType',
+          },
+        },
+      });
+    });
+  });
 });

src/language/__tests__/predicates-test.ts

@@ -92,6 +92,7 @@ describe('AST node predicates', () => {
       'NamedType',
       'ListType',
       'NonNullType',
+      'SemanticNonNullType',
     ]);
   });
 

src/language/__tests__/schema-printer-test.ts

@@ -5,7 +5,7 @@ import { dedent } from '../../__testUtils__/dedent';
 import { kitchenSinkSDL } from '../../__testUtils__/kitchenSinkSDL';
 
 import { Kind } from '../kinds';
-import { parse } from '../parser';
+import { parse, parseType } from '../parser';
 import { print } from '../printer';
 
 describe('Printer: SDL document', () => {
@@ -180,4 +180,41 @@ describe('Printer: SDL document', () => {
       }
     `);
   });
+
+  it('prints NamedType', () => {
+    expect(
+      print(parseType('MyType', { allowSemanticNullability: false }), {
+        useSemanticNullability: false,
+      }),
+    ).to.equal(dedent`MyType`);
+  });
+
+  it('prints SemanticNullableType', () => {
+    expect(
+      print(parseType('MyType?', { allowSemanticNullability: true }), {
+        useSemanticNullability: true,
+      }),
+    ).to.equal(dedent`MyType?`);
+  });
+
+  it('prints SemanticNonNullType', () => {
+    expect(
+      print(parseType('MyType', { allowSemanticNullability: true }), {
+        useSemanticNullability: true,
+      }),
+    ).to.equal(dedent`MyType`);
+  });
+
+  it('prints NonNullType', () => {
+    expect(
+      print(parseType('MyType!', { allowSemanticNullability: true }), {
+        useSemanticNullability: true,
+      }),
+    ).to.equal(dedent`MyType!`);
+    expect(
+      print(parseType('MyType!', { allowSemanticNullability: false }), {
+        useSemanticNullability: true,
+      }),
+    ).to.equal(dedent`MyType!`);
+  });
 });