Fix a few tests

Author: JoviDeCroock

src/execution/__tests__/executor-test.ts

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

src/execution/execute.ts

@@ -161,7 +161,7 @@ export interface ExecutionArgs {
    *
    * @experimental
    */
-    errorPropagation?: boolean;
+  errorPropagation?: boolean;
 }
 
 /**
@@ -296,7 +296,7 @@ export function buildExecutionContext(
     fieldResolver,
     typeResolver,
     subscribeFieldResolver,
-    errorPropagation
+    errorPropagation,
   } = args;
 
   let operation: OperationDefinitionNode | undefined;
@@ -671,7 +671,7 @@ function completeValue(
     return completed;
   }
 
-    // If field type is SemanticNonNull, complete for inner type, and throw field error
+  // 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(

src/language/__tests__/parser-test.ts

@@ -659,7 +659,7 @@ describe('Parser', () => {
   });
 
   describe('parseDocumentDirective', () => {
-    it('doesnt throw on document-level directive', () => {
+    it('doesn\'t throw on document-level directive', () => {
       parse(dedent`
         @SemanticNullability
         type Query {

src/language/__tests__/predicates-test.ts

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

src/language/ast.ts

@@ -523,7 +523,6 @@ export interface ConstDirectiveNode {
   readonly arguments?: ReadonlyArray<ConstArgumentNode>;
 }
 
-
 export interface SemanticNonNullTypeNode {
   readonly kind: Kind.SEMANTIC_NON_NULL_TYPE;
   readonly loc?: Location;

src/language/lexer.ts

@@ -251,7 +251,12 @@ function readNextToken(lexer: Lexer, start: number): Token {
       case 0x0021: // !
         return createToken(lexer, TokenKind.BANG, position, position + 1);
       case 0x003f: // ?
-        return createToken(lexer, TokenKind.QUESTION_MARK, position, position + 1);
+        return createToken(
+          lexer,
+          TokenKind.QUESTION_MARK,
+          position,
+          position + 1,
+        );
       case 0x0024: // $
         return createToken(lexer, TokenKind.DOLLAR, position, position + 1);
       case 0x0026: // &

src/language/parser.ts

@@ -50,9 +50,9 @@ import type {
   SchemaExtensionNode,
   SelectionNode,
   SelectionSetNode,
-  StringValueNode,
   SemanticNonNullTypeNode,
   SemanticNullableTypeNode,
+  StringValueNode,
   Token,
   TypeNode,
   TypeSystemExtensionNode,
@@ -109,10 +109,10 @@ export interface ParseOptions {
   /**
    * When enabled, the parser will understand and parse semantic nullability
    * annotations. This means that every type suffixed with `!` will remain
-   * non-nulllable, every type suffxed with `?` will be the classic nullable, and
+   * non-nullable, every type suffixed with `?` will be the classic nullable, and
    * types without a suffix will be semantically nullable. Semantic nullability
    * will be the new default when this is enabled. A semantically nullable type
-   * can only be null when there's an error assocaited with the field.
+   * can only be null when there's an error associated with the field.
    *
    * @experimental
    */
@@ -788,6 +788,25 @@ export class Parser {
       type = this.parseNamedType();
     }
 
+    if (this._options.allowSemanticNullability) {
+      if (this.expectOptionalToken(TokenKind.BANG)) {
+        return this.node<NonNullTypeNode>(start, {
+          kind: Kind.NON_NULL_TYPE,
+          type,
+        });
+      } else if (this.expectOptionalToken(TokenKind.QUESTION_MARK)) {
+        return this.node<SemanticNullableTypeNode>(start, {
+          kind: Kind.SEMANTIC_NULLABLE_TYPE,
+          type,
+        });
+      }
+
+      return this.node<SemanticNonNullTypeNode>(start, {
+        kind: Kind.SEMANTIC_NON_NULL_TYPE,
+        type,
+      });
+    }
+
     if (this.expectOptionalToken(TokenKind.BANG)) {
       return this.node<NonNullTypeNode>(start, {
         kind: Kind.NON_NULL_TYPE,

src/type/__tests__/introspection-test.ts

@@ -32,7 +32,7 @@ describe('Introspection', () => {
     expect(result).to.deep.equal({
       data: {
         __schema: {
-          queryType: { name: 'SomeObject' },
+          queryType: { kind: 'OBJECT', name: 'SomeObject' },
           mutationType: null,
           subscriptionType: null,
           types: [

src/type/__tests__/predicate-test.ts

@@ -765,4 +765,4 @@ describe('Directive predicates', () => {
       expect(isSpecifiedDirective(Directive)).to.equal(false);
     });
   });
-});
+});

src/type/definition.ts

@@ -67,24 +67,24 @@ export type GraphQLType =
       | GraphQLInputObjectType
       | GraphQLList<GraphQLType>
     >
-  |  GraphQLSemanticNonNull<
-    | GraphQLScalarType
-    | GraphQLObjectType
-    | GraphQLInterfaceType
-    | GraphQLUnionType
-    | GraphQLEnumType
-    | GraphQLInputObjectType
-    | GraphQLList<GraphQLType>
-  >
+  | GraphQLSemanticNonNull<
+      | GraphQLScalarType
+      | GraphQLObjectType
+      | GraphQLInterfaceType
+      | GraphQLUnionType
+      | GraphQLEnumType
+      | GraphQLInputObjectType
+      | GraphQLList<GraphQLType>
+    >
   | GraphQLSemanticNullable<
-    | GraphQLScalarType
-    | GraphQLObjectType
-    | GraphQLInterfaceType
-    | GraphQLUnionType
-    | GraphQLEnumType
-    | GraphQLInputObjectType
-    | GraphQLList<GraphQLType>
-  >;
+      | GraphQLScalarType
+      | GraphQLObjectType
+      | GraphQLInterfaceType
+      | GraphQLUnionType
+      | GraphQLEnumType
+      | GraphQLInputObjectType
+      | GraphQLList<GraphQLType>
+    >;
 
 export function isType(type: unknown): type is GraphQLType {
   return (
@@ -325,13 +325,15 @@ export type GraphQLOutputType =
       | GraphQLUnionType
       | GraphQLEnumType
       | GraphQLList<GraphQLOutputType>
-    >   | GraphQLSemanticNonNull<
-    | GraphQLScalarType
-    | GraphQLObjectType
-    | GraphQLInterfaceType
-    | GraphQLUnionType
-    | GraphQLEnumType
-    | GraphQLList<GraphQLOutputType> >;
+    >
+  | GraphQLSemanticNonNull<
+      | GraphQLScalarType
+      | GraphQLObjectType
+      | GraphQLInterfaceType
+      | GraphQLUnionType
+      | GraphQLEnumType
+      | GraphQLList<GraphQLOutputType>
+    >;
 
 export function isOutputType(type: unknown): type is GraphQLOutputType {
   return (

src/type/introspection.ts

@@ -417,10 +417,10 @@ export const __Field: GraphQLObjectType = new GraphQLObjectType({
           }
 
           const mode =
-          nullability === TypeNullability.AUTO
-            ? info.errorPropagation
-              ? TypeNullability.TRADITIONAL
-              : TypeNullability.SEMANTIC
+            nullability === TypeNullability.AUTO
+              ? info.errorPropagation
+                ? TypeNullability.TRADITIONAL
+                : TypeNullability.SEMANTIC
               : nullability;
           return convertOutputTypeToNullabilityMode(field.type, mode);
         },

src/utilities/buildClientSchema.ts

@@ -22,8 +22,8 @@ import {
   GraphQLNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
-  GraphQLUnionType,
   GraphQLSemanticNonNull,
+  GraphQLUnionType,
   isInputType,
   isOutputType,
 } from '../type/definition';

src/utilities/extendSchema.ts

@@ -53,9 +53,9 @@ import {
   GraphQLNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
-  GraphQLUnionType,
   GraphQLSemanticNonNull,
   GraphQLSemanticNullable,
+  GraphQLUnionType,
   isEnumType,
   isInputObjectType,
   isInterfaceType,

src/utilities/typeFromAST.ts

@@ -11,6 +11,7 @@ import {
   GraphQLList,
   GraphQLNonNull,
   GraphQLSemanticNonNull,
+  GraphQLSemanticNullable,
 } from '../type/definition';
 import type { GraphQLSchema } from '../type/schema';
 
@@ -54,6 +55,10 @@ export function typeFromAST(
       const innerType = typeFromAST(schema, typeNode.type);
       return innerType && new GraphQLSemanticNonNull(innerType);
     }
+    case Kind.SEMANTIC_NULLABLE_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLSemanticNullable(innerType);
+    }
     case Kind.NAMED_TYPE:
       return schema.getType(typeNode.name.value);
   }