Propose single wrapping type (#4339)

This reduces the new AST-nodes to only be for the newly introduced type,
this does make it so that when we invoke `print` we have to rely on the
user to either specify that we're in semantic nullability mode _or_ we
could do a pre-traverse and when we enter a node with semantic-non-null
we toggle it on ourselves.

The main reasoning behind removing the new name for our existing null
type is that I would prefer to be backwards compatible in terms of
schema structure. This because it might become complex for people to
reason about composed schemas, i.e. a lot of individually parsed schemas
that later on compose into a larger one.

I know that _technically_ this is covered because in the classic ones
we'll have the non wrapped null type and in the modern ones we'll have
the semantic nullable wrapped type. For schema-builders like pothos and
others I think this is rather complex to reason about _and_ to supply us
with. I would instead choose to absorb this complexity in the feature
and stay backwards compatible.

This also sets us up for the SDL not being a breaking change, we only
add one AST-type, what's left now is to settle on a semantic non-null
syntax and making everything backwards compatible.

Author: JoviDeCroock

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

@@ -10,7 +10,6 @@ import {
   GraphQLNonNull,
   GraphQLObjectType,
   GraphQLSemanticNonNull,
-  GraphQLSemanticNullable,
 } from '../../type/definition';
 import { GraphQLString } from '../../type/scalars';
 import { GraphQLSchema } from '../../type/schema';
@@ -28,7 +27,7 @@ describe('Execute: Handles Semantic Nullability', () => {
   const DataType: GraphQLObjectType = new GraphQLObjectType({
     name: 'DataType',
     fields: () => ({
-      a: { type: new GraphQLSemanticNullable(GraphQLString) },
+      a: { type: GraphQLString },
       b: { type: new GraphQLSemanticNonNull(GraphQLString) },
       c: { type: new GraphQLNonNull(GraphQLString) },
       d: { type: new GraphQLSemanticNonNull(DeepDataType) },

src/execution/execute.ts

@@ -44,7 +44,6 @@ import {
   isNonNullType,
   isObjectType,
   isSemanticNonNullType,
-  isSemanticNullableType,
 } from '../type/definition';
 import {
   SchemaMetaFieldDef,
@@ -690,18 +689,6 @@ function completeValue(
     return completed;
   }
 
-  // If field type is SemanticNullable, complete for inner type
-  if (isSemanticNullableType(returnType)) {
-    return completeValue(
-      exeContext,
-      returnType.ofType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-  }
-
   // If result value is null or undefined then return null.
   if (result == null) {
     return null;

src/language/__tests__/parser-test.ts

@@ -659,7 +659,7 @@ describe('Parser', () => {
   });
 
   describe('parseDocumentDirective', () => {
-    it('doesn\'t throw on document-level directive', () => {
+    it("doesn't throw on document-level directive", () => {
       parse(dedent`
         @SemanticNullability
         type Query {
@@ -690,16 +690,12 @@ describe('Parser', () => {
     it('parses nullable types', () => {
       const result = parseType('MyType?', { allowSemanticNullability: true });
       expectJSON(result).toDeepEqual({
-        kind: Kind.SEMANTIC_NULLABLE_TYPE,
-        loc: { start: 0, end: 7 },
-        type: {
-          kind: Kind.NAMED_TYPE,
+        kind: Kind.NAMED_TYPE,
+        loc: { start: 0, end: 6 },
+        name: {
+          kind: Kind.NAME,
           loc: { start: 0, end: 6 },
-          name: {
-            kind: Kind.NAME,
-            loc: { start: 0, end: 6 },
-            value: 'MyType',
-          },
+          value: 'MyType',
         },
       });
     });

src/language/__tests__/predicates-test.ts

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

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

@@ -183,28 +183,38 @@ describe('Printer: SDL document', () => {
 
   it('prints NamedType', () => {
     expect(
-      print(parseType('MyType', { allowSemanticNullability: false })),
+      print(parseType('MyType', { allowSemanticNullability: false }), {
+        useSemanticNullability: false,
+      }),
     ).to.equal(dedent`MyType`);
   });
 
   it('prints SemanticNullableType', () => {
     expect(
-      print(parseType('MyType?', { allowSemanticNullability: true })),
+      print(parseType('MyType?', { allowSemanticNullability: true }), {
+        useSemanticNullability: true,
+      }),
     ).to.equal(dedent`MyType?`);
   });
 
   it('prints SemanticNonNullType', () => {
     expect(
-      print(parseType('MyType', { allowSemanticNullability: true })),
+      print(parseType('MyType', { allowSemanticNullability: true }), {
+        useSemanticNullability: true,
+      }),
     ).to.equal(dedent`MyType`);
   });
 
   it('prints NonNullType', () => {
     expect(
-      print(parseType('MyType!', { allowSemanticNullability: true })),
+      print(parseType('MyType!', { allowSemanticNullability: true }), {
+        useSemanticNullability: true,
+      }),
     ).to.equal(dedent`MyType!`);
     expect(
-      print(parseType('MyType!', { allowSemanticNullability: false })),
+      print(parseType('MyType!', { allowSemanticNullability: false }), {
+        useSemanticNullability: true,
+      }),
     ).to.equal(dedent`MyType!`);
   });
 });

src/language/ast.ts

@@ -162,7 +162,6 @@ export type ASTNode =
   | ListTypeNode
   | NonNullTypeNode
   | SemanticNonNullTypeNode
-  | SemanticNullableTypeNode
   | SchemaDefinitionNode
   | OperationTypeDefinitionNode
   | ScalarTypeDefinitionNode
@@ -238,7 +237,6 @@ export const QueryDocumentKeys: {
   ListType: ['type'],
   NonNullType: ['type'],
   SemanticNonNullType: ['type'],
-  SemanticNullableType: ['type'],
 
   SchemaDefinition: ['description', 'directives', 'operationTypes'],
   OperationTypeDefinition: ['type'],
@@ -529,20 +527,13 @@ export interface SemanticNonNullTypeNode {
   readonly type: NamedTypeNode | ListTypeNode;
 }
 
-export interface SemanticNullableTypeNode {
-  readonly kind: Kind.SEMANTIC_NULLABLE_TYPE;
-  readonly loc?: Location;
-  readonly type: NamedTypeNode | ListTypeNode;
-}
-
 /** Type Reference */
 
 export type TypeNode =
   | NamedTypeNode
   | ListTypeNode
   | NonNullTypeNode
-  | SemanticNonNullTypeNode
-  | SemanticNullableTypeNode;
+  | SemanticNonNullTypeNode;
 
 export interface NamedTypeNode {
   readonly kind: Kind.NAMED_TYPE;

src/language/kinds.ts

@@ -38,7 +38,6 @@ enum Kind {
   LIST_TYPE = 'ListType',
   NON_NULL_TYPE = 'NonNullType',
   SEMANTIC_NON_NULL_TYPE = 'SemanticNonNullType',
-  SEMANTIC_NULLABLE_TYPE = 'SemanticNullableType',
 
   /** Type System Definitions */
   SCHEMA_DEFINITION = 'SchemaDefinition',

src/language/parser.ts

@@ -51,7 +51,6 @@ import type {
   SelectionNode,
   SelectionSetNode,
   SemanticNonNullTypeNode,
-  SemanticNullableTypeNode,
   StringValueNode,
   Token,
   TypeNode,
@@ -795,10 +794,7 @@ export class Parser {
           type,
         });
       } else if (this.expectOptionalToken(TokenKind.QUESTION_MARK)) {
-        return this.node<SemanticNullableTypeNode>(start, {
-          kind: Kind.SEMANTIC_NULLABLE_TYPE,
-          type,
-        });
+        return type;
       }
 
       return this.node<SemanticNonNullTypeNode>(start, {

src/language/predicates.ts

@@ -68,8 +68,7 @@ export function isTypeNode(node: ASTNode): node is TypeNode {
     node.kind === Kind.NAMED_TYPE ||
     node.kind === Kind.LIST_TYPE ||
     node.kind === Kind.NON_NULL_TYPE ||
-    node.kind === Kind.SEMANTIC_NON_NULL_TYPE ||
-    node.kind === Kind.SEMANTIC_NULLABLE_TYPE
+    node.kind === Kind.SEMANTIC_NON_NULL_TYPE
   );
 }