use semantic nullable wrapper only

Author: yaacovCR

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

@@ -9,7 +9,6 @@ import { parse } from '../../language/parser';
 import {
   GraphQLNonNull,
   GraphQLObjectType,
-  GraphQLSemanticNonNull,
   GraphQLSemanticNullable,
 } from '../../type/definition';
 import { GraphQLString } from '../../type/scalars';
@@ -29,9 +28,9 @@ describe('Execute: Handles Semantic Nullability', () => {
     name: 'DataType',
     fields: () => ({
       a: { type: new GraphQLSemanticNullable(GraphQLString) },
-      b: { type: new GraphQLSemanticNonNull(GraphQLString) },
+      b: { type: GraphQLString },
       c: { type: new GraphQLNonNull(GraphQLString) },
-      d: { type: new GraphQLSemanticNonNull(DeepDataType) },
+      d: { type: DeepDataType },
     }),
   });
 
@@ -49,7 +48,10 @@ describe('Execute: Handles Semantic Nullability', () => {
       `);
 
     const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
+      schema: new GraphQLSchema({
+        useSemanticNullability: true,
+        query: DataType,
+      }),
       document,
       rootValue: data,
     });
@@ -98,7 +100,10 @@ describe('Execute: Handles Semantic Nullability', () => {
       .next().value;
 
     const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
+      schema: new GraphQLSchema({
+        useSemanticNullability: true,
+        query: DataType,
+      }),
       document,
       rootValue: data,
     });
@@ -137,7 +142,10 @@ describe('Execute: Handles Semantic Nullability', () => {
       `);
 
     const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
+      schema: new GraphQLSchema({
+        useSemanticNullability: true,
+        query: DataType,
+      }),
       document,
       rootValue: data,
     });
@@ -180,7 +188,10 @@ describe('Execute: Handles Semantic Nullability', () => {
       `);
 
     const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
+      schema: new GraphQLSchema({
+        useSemanticNullability: true,
+        query: DataType,
+      }),
       document,
       rootValue: data,
     });
@@ -206,7 +217,10 @@ describe('Execute: Handles Semantic Nullability', () => {
       `);
 
     const result = await execute({
-      schema: new GraphQLSchema({ query: DataType }),
+      schema: new GraphQLSchema({
+        useSemanticNullability: true,
+        query: DataType,
+      }),
       document,
       rootValue: data,
     });

src/execution/execute.ts

@@ -43,7 +43,6 @@ import {
   isListType,
   isNonNullType,
   isObjectType,
-  isSemanticNonNullType,
   isSemanticNullableType,
 } from '../type/definition';
 import {
@@ -651,109 +650,83 @@ function completeValue(
     throw result;
   }
 
-  // If field type is NonNull, complete for inner type, and throw field error
-  // if result is null.
+  let nonNull;
+  let semanticNull;
+  let nullableType;
   if (isNonNullType(returnType)) {
-    const completed = completeValue(
-      exeContext,
-      returnType.ofType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-    if (completed === null) {
-      throw new Error(
-        `Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`,
-      );
-    }
-    return completed;
+    nonNull = true;
+    nullableType = returnType.ofType;
+  } else if (isSemanticNullableType(returnType)) {
+    semanticNull = true;
+    nullableType = returnType.ofType;
+  } else {
+    nullableType = returnType;
   }
 
-  // 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(
+  let completed;
+  if (result == null) {
+    // If result value is null or undefined then return null.
+    completed = null;
+  } else if (isListType(nullableType)) {
+    // If field type is List, complete each item in the list with the inner type
+    completed = completeListValue(
       exeContext,
-      returnType.ofType,
+      nullableType,
       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 field type is SemanticNullable, complete for inner type
-  if (isSemanticNullableType(returnType)) {
-    return completeValue(
+  } else if (isLeafType(nullableType)) {
+    // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
+    // returning null if serialization is not possible.
+    completed = completeLeafValue(nullableType, result);
+  } else if (isAbstractType(nullableType)) {
+    // If field type is an abstract type, Interface or Union, determine the
+    // runtime Object type and complete for that type.
+    completed = completeAbstractValue(
       exeContext,
-      returnType.ofType,
+      nullableType,
       fieldNodes,
       info,
       path,
       result,
     );
-  }
-
-  // If result value is null or undefined then return null.
-  if (result == null) {
-    return null;
-  }
-
-  // If field type is List, complete each item in the list with the inner type
-  if (isListType(returnType)) {
-    return completeListValue(
+  } else if (isObjectType(nullableType)) {
+    // If field type is Object, execute and complete all sub-selections.
+    completed = completeObjectValue(
       exeContext,
-      returnType,
+      nullableType,
       fieldNodes,
       info,
       path,
       result,
     );
+  } else {
+    /* c8 ignore next 6 */
+    // Not reachable, all possible output types have been considered.
+    invariant(
+      false,
+      'Cannot complete value of unexpected output type: ' +
+        inspect(nullableType),
+    );
   }
 
-  // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
-  // returning null if serialization is not possible.
-  if (isLeafType(returnType)) {
-    return completeLeafValue(returnType, result);
-  }
+  if (completed === null) {
+    if (nonNull) {
+      throw new Error(
+        `Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`,
+      );
+    }
 
-  // If field type is an abstract type, Interface or Union, determine the
-  // runtime Object type and complete for that type.
-  if (isAbstractType(returnType)) {
-    return completeAbstractValue(
-      exeContext,
-      returnType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
+    if (!semanticNull && exeContext.schema.usingSemanticNullability) {
+      throw new Error(
+        `Cannot return null for semantic-non-nullable field ${info.parentType.name}.${info.fieldName}.`,
+      );
+    }
   }
 
-  // If field type is Object, execute and complete all sub-selections.
-  if (isObjectType(returnType)) {
-    return completeObjectValue(
-      exeContext,
-      returnType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-  }
-  /* c8 ignore next 6 */
-  // Not reachable, all possible output types have been considered.
-  invariant(
-    false,
-    'Cannot complete value of unexpected output type: ' + inspect(returnType),
-  );
+  return completed;
 }
 
 /**

src/index.ts

@@ -48,7 +48,6 @@ export {
   GraphQLInputObjectType,
   GraphQLList,
   GraphQLNonNull,
-  GraphQLSemanticNonNull,
   // Standard GraphQL Scalars
   specifiedScalarTypes,
   GraphQLInt,
@@ -97,7 +96,7 @@ export {
   isInputObjectType,
   isListType,
   isNonNullType,
-  isSemanticNonNullType,
+  isSemanticNullableType,
   isInputType,
   isOutputType,
   isLeafType,
@@ -123,7 +122,7 @@ export {
   assertInputObjectType,
   assertListType,
   assertNonNullType,
-  assertSemanticNonNullType,
+  assertSemanticNullableType,
   assertInputType,
   assertOutputType,
   assertLeafType,
@@ -291,7 +290,7 @@ export type {
   NamedTypeNode,
   ListTypeNode,
   NonNullTypeNode,
-  SemanticNonNullTypeNode,
+  SemanticNullableTypeNode,
   TypeSystemDefinitionNode,
   SchemaDefinitionNode,
   OperationTypeDefinitionNode,
@@ -485,7 +484,7 @@ export type {
   IntrospectionNamedTypeRef,
   IntrospectionListTypeRef,
   IntrospectionNonNullTypeRef,
-  IntrospectionSemanticNonNullTypeRef,
+  IntrospectionSemanticNullableTypeRef,
   IntrospectionField,
   IntrospectionInputValue,
   IntrospectionEnumValue,

src/language/__tests__/parser-test.ts

@@ -669,16 +669,12 @@ describe('Parser', () => {
     it('parses semantic-non-null types', () => {
       const result = parseType('MyType', { useSemanticNullability: true });
       expectJSON(result).toDeepEqual({
-        kind: Kind.SEMANTIC_NON_NULL_TYPE,
+        kind: Kind.NAMED_TYPE,
         loc: { start: 0, end: 6 },
-        type: {
-          kind: Kind.NAMED_TYPE,
+        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

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

src/language/ast.ts

@@ -161,7 +161,6 @@ export type ASTNode =
   | NamedTypeNode
   | ListTypeNode
   | NonNullTypeNode
-  | SemanticNonNullTypeNode
   | SemanticNullableTypeNode
   | SchemaDefinitionNode
   | OperationTypeDefinitionNode
@@ -237,7 +236,6 @@ export const QueryDocumentKeys: {
   NamedType: ['name'],
   ListType: ['type'],
   NonNullType: ['type'],
-  SemanticNonNullType: ['type'],
   SemanticNullableType: ['type'],
 
   SchemaDefinition: ['description', 'directives', 'operationTypes'],
@@ -528,7 +526,6 @@ export type TypeNode =
   | NamedTypeNode
   | ListTypeNode
   | NonNullTypeNode
-  | SemanticNonNullTypeNode
   | SemanticNullableTypeNode;
 
 export interface NamedTypeNode {
@@ -549,12 +546,6 @@ export interface NonNullTypeNode {
   readonly type: NamedTypeNode | ListTypeNode;
 }
 
-export interface SemanticNonNullTypeNode {
-  readonly kind: Kind.SEMANTIC_NON_NULL_TYPE;
-  readonly loc?: Location;
-  readonly type: NamedTypeNode | ListTypeNode;
-}
-
 export interface SemanticNullableTypeNode {
   readonly kind: Kind.SEMANTIC_NULLABLE_TYPE;
   readonly loc?: Location;

src/language/index.ts

@@ -67,7 +67,7 @@ export type {
   NamedTypeNode,
   ListTypeNode,
   NonNullTypeNode,
-  SemanticNonNullTypeNode,
+  SemanticNullableTypeNode,
   TypeSystemDefinitionNode,
   SchemaDefinitionNode,
   OperationTypeDefinitionNode,

src/language/kinds.ts

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