[WIP] Nonnull operator

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Mocha Tests",
+      "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+      "args": [
+        "src/execution/__tests__/executor-test.ts"
+      ],
+      "internalConsoleOptions": "openOnSessionStart",
+      "skipFiles": ["<node_internals>/**"]
+    }
+  ]
+}

src/__testUtils__/kitchenSinkQuery.ts

@@ -10,6 +10,10 @@ query queryName($foo: ComplexType, $site: Site = MOBILE) @onQuery {
           ...frag @onFragmentSpread
         }
       }
+      field3!
+      requiredField4: field4!
+      field5?
+      optionalField6: field6?
     }
     ... @skip(unless: $foo) {
       id

src/execution/__tests__/executor-test.ts

@@ -1220,4 +1220,140 @@ describe('Execute: Handles basic execution tasks', () => {
     expect(result).to.deep.equal({ data: { foo: { bar: 'bar' } } });
     expect(possibleTypes).to.deep.equal([fooObject]);
   });
+
+  it('bubbles null up to nearest nullable parent', async () => {
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          food: {
+            type: new GraphQLObjectType({
+              name: 'Food',
+              fields: {
+                name: { type: GraphQLString },
+                calories: { type: GraphQLInt },
+              },
+            }),
+            resolve() {
+              return {
+                name: null,
+                calories: 10,
+              }
+            }
+          },
+        },
+      }),
+    });
+
+    const plainDocument = parse(`
+      query {
+        food {
+          name
+          calories
+        }
+      }
+    `);
+    const plainResult = executeSync({ schema, document: plainDocument });
+
+    expect(plainResult).to.deep.equal({
+      data: { food: { name: null, calories: 10 } },
+    });
+
+    const singleNonnullOnNullValueDocument = parse(`
+      query {
+        food {
+          name!
+          calories
+        }
+      }
+    `);
+    const singleNonnullOnNullValueResult = executeSync({ schema, document: singleNonnullOnNullValueDocument });
+
+    expect(singleNonnullOnNullValueResult).to.deep.equal({
+      data: { food: null },
+      errors: [
+        {
+          locations: [{ column: 11, line: 4 }],
+          message: 'Cannot return null for non-nullable field Food.name.',
+          path: ['food', 'name'],
+        },
+      ],
+    });
+
+    const bothNonnullOnNullValueDocument = parse(`
+      query {
+        food {
+          name!
+          calories!
+        }
+      }
+    `);
+    const bothNonnullOnNullValueResult = executeSync({ schema, document: bothNonnullOnNullValueDocument });
+
+    expect(bothNonnullOnNullValueResult).to.deep.equal({
+      data: { food: null },
+      errors: [
+        {
+          locations: [{ column: 11, line: 4 }],
+          message: 'Cannot return null for non-nullable field Food.name.',
+          path: ['food', 'name'],
+        },
+      ],
+    });
+
+    const singleNonnullOnNonnullValueDocument = parse(`
+      query {
+        food {
+          calories!
+        }
+      }
+    `);
+    const singleNonnullOnNonnullValueResult = executeSync({ schema, document: singleNonnullOnNonnullValueDocument });
+
+    expect(singleNonnullOnNonnullValueResult).to.deep.equal({
+      data: { food: { calories: 10 } },
+    });
+
+    const nonnullAliasOnNullValueDocument = parse(`
+      query {
+        food {
+          theNameOfTheFood: name!
+        }
+      }
+    `);
+    const nonnullAliasOnNullValueResult = executeSync({ schema, document: nonnullAliasOnNullValueDocument });
+
+    expect(nonnullAliasOnNullValueResult).to.deep.equal({
+      data: { food: null },
+      errors: [
+        {
+          locations: [{ column: 11, line: 4 }],
+          message: 'Cannot return null for non-nullable field Food.name.',
+          path: ['food', 'theNameOfTheFood'],
+        },
+      ],
+    });
+
+    const nonnullInFragmentDocument = parse(`
+      query {
+        food {
+          ... on Food {
+            name!
+          }
+        }
+      }
+    `);
+    const nonnullInFragmentResult = executeSync({ schema, document: nonnullInFragmentDocument });
+
+    expect(nonnullInFragmentResult).to.deep.equal({
+      data: { food: null },
+      errors: [
+        {
+          locations: [{ column: 13, line: 5 }],
+          message: 'Cannot return null for non-nullable field Food.name.',
+          path: ['food', 'name'],
+        },
+      ],
+    });
+  });
 });

src/execution/execute.ts

@@ -39,6 +39,7 @@ import type {
   GraphQLResolveInfo,
   GraphQLTypeResolver,
   GraphQLList,
+  getNullableType,
 } from '../type/definition';
 import { assertValidSchema } from '../type/validate';
 import {
@@ -51,6 +52,7 @@ import {
   GraphQLSkipDirective,
 } from '../type/directives';
 import {
+  GraphQLNonNull,
   isObjectType,
   isAbstractType,
   isLeafType,
@@ -66,6 +68,7 @@ import {
   getArgumentValues,
   getDirectiveValues,
 } from './values';
+import { modifiedOutputType } from '../utilities/applyRequiredStatus';
 
 /**
  * Terminology
@@ -600,7 +603,8 @@ function resolveField(
     return;
   }
 
-  const returnType = fieldDef.type;
+  const returnType = modifiedOutputType(fieldDef.type, fieldNodes[0].required)
+
   const resolveFn = fieldDef.resolve ?? exeContext.fieldResolver;
 
   const info = buildResolveInfo(

src/index.ts

@@ -221,6 +221,7 @@ export {
   isTypeDefinitionNode,
   isTypeSystemExtensionNode,
   isTypeExtensionNode,
+  RequiredStatus,
 } from './language/index';
 
 export type {
@@ -436,6 +437,7 @@ export {
   DangerousChangeType,
   findBreakingChanges,
   findDangerousChanges,
+  modifiedOutputType,
 } from './utilities/index';
 
 export type {

src/language/__tests__/lexer-test.ts

@@ -162,16 +162,16 @@ describe('Lexer', () => {
   it('errors respect whitespace', () => {
     let caughtError;
     try {
-      lexOne(['', '', '    ?', ''].join('\n'));
+      lexOne(['', '', '    ~', ''].join('\n'));
     } catch (error) {
       caughtError = error;
     }
     expect(String(caughtError)).to.equal(dedent`
-      Syntax Error: Cannot parse the unexpected character "?".
+      Syntax Error: Cannot parse the unexpected character "~".
 
       GraphQL request:3:5
       2 |
-      3 |     ?
+      3 |     ~
         |     ^
       4 |
     `);
@@ -180,18 +180,18 @@ describe('Lexer', () => {
   it('updates line numbers in error for file context', () => {
     let caughtError;
     try {
-      const str = ['', '', '     ?', ''].join('\n');
+      const str = ['', '', '     ~', ''].join('\n');
       const source = new Source(str, 'foo.js', { line: 11, column: 12 });
       new Lexer(source).advance();
     } catch (error) {
       caughtError = error;
     }
     expect(String(caughtError)).to.equal(dedent`
-      Syntax Error: Cannot parse the unexpected character "?".
+      Syntax Error: Cannot parse the unexpected character "~".
 
       foo.js:13:6
       12 |
-      13 |      ?
+      13 |      ~
          |      ^
       14 |
     `);
@@ -200,16 +200,16 @@ describe('Lexer', () => {
   it('updates column numbers in error for file context', () => {
     let caughtError;
     try {
-      const source = new Source('?', 'foo.js', { line: 1, column: 5 });
+      const source = new Source('~', 'foo.js', { line: 1, column: 5 });
       new Lexer(source).advance();
     } catch (error) {
       caughtError = error;
     }
     expect(String(caughtError)).to.equal(dedent`
-      Syntax Error: Cannot parse the unexpected character "?".
+      Syntax Error: Cannot parse the unexpected character "~".
 
       foo.js:1:5
-      1 |     ?
+      1 |     ~
         |     ^
     `);
   });
@@ -820,8 +820,8 @@ describe('Lexer', () => {
       locations: [{ line: 1, column: 1 }],
     });
 
-    expectSyntaxError('?').to.deep.equal({
-      message: 'Syntax Error: Cannot parse the unexpected character "?".',
+    expectSyntaxError('~').to.deep.equal({
+      message: 'Syntax Error: Cannot parse the unexpected character "~".',
       locations: [{ line: 1, column: 1 }],
     });
 

src/language/__tests__/parser-test.ts

@@ -205,6 +205,66 @@ describe('Parser', () => {
     ).to.not.throw();
   });
 
+  it('parses required field', () => {
+    expect(() =>
+      parse(`
+      query {
+        requiredField!
+      }
+    `),
+    ).to.not.throw();
+  });
+
+  it('parses optional field', () => {
+    expect(() =>
+      parse(`
+      query {
+        optionalField?
+      }
+    `),
+    ).to.not.throw();
+  });
+
+  it('parses required with alias', () => {
+    expect(() =>
+      parse(`
+      query {
+        requiredField: field!
+      }
+    `),
+    ).to.not.throw();
+  });
+
+  it('does not parse aliased field with bang on left of colon', () => {
+    expect(() =>
+      parse(`
+      query {
+        requiredField!: field
+      }
+    `),
+    ).to.throw();
+  });
+
+  it('does not parse aliased field with bang on left and right of colon', () => {
+    expect(() =>
+      parse(`
+      query {
+        requiredField!: field!
+      }
+    `),
+    ).to.throw();
+  });
+
+  it('parses required within fragment', () => {
+    expect(() =>
+      parse(`
+      fragment MyFragment on Query {
+        field!
+      }
+    `),
+    ).to.not.throw();
+  });
+
   it('creates ast', () => {
     const result = parse(dedent`
       {
@@ -256,6 +316,7 @@ describe('Parser', () => {
                   },
                 ],
                 directives: [],
+                required: 'unset',
                 selectionSet: {
                   kind: Kind.SELECTION_SET,
                   loc: { start: 16, end: 38 },
@@ -271,6 +332,7 @@ describe('Parser', () => {
                       },
                       arguments: [],
                       directives: [],
+                      required: 'unset',
                       selectionSet: undefined,
                     },
                     {
@@ -284,6 +346,7 @@ describe('Parser', () => {
                       },
                       arguments: [],
                       directives: [],
+                      required: 'unset',
                       selectionSet: undefined,
                     },
                   ],
@@ -331,6 +394,7 @@ describe('Parser', () => {
                 },
                 arguments: [],
                 directives: [],
+                required: 'unset',
                 selectionSet: {
                   kind: Kind.SELECTION_SET,
                   loc: { start: 15, end: 27 },
@@ -346,6 +410,7 @@ describe('Parser', () => {
                       },
                       arguments: [],
                       directives: [],
+                      required: 'unset',
                       selectionSet: undefined,
                     },
                   ],