[WIP] Experimental support for semantic-non-null

src/execution/execute.ts

@@ -45,6 +45,7 @@ import {
   isListType,
   isNonNullType,
   isObjectType,
+  isSemanticNonNullType,
 } from '../type/definition';
 import {
   SchemaMetaFieldDef,
@@ -679,9 +680,9 @@ function completeValue(
     throw result;
   }
 
-  // If field type is NonNull, complete for inner type, and throw field error
+  // If field type is non-nullable, complete for inner type, and throw field error
   // if result is null.
-  if (isNonNullType(returnType)) {
+  if (isNonNullType(returnType) || isSemanticNonNullType(returnType)) {
     const completed = completeValue(
       exeContext,
       returnType.ofType,
@@ -692,7 +693,9 @@ function completeValue(
     );
     if (completed === null) {
       throw new Error(
-        `Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`,
+        `Cannot return null for ${
+          isSemanticNonNullType(returnType) ? 'semantically ' : ''
+        }non-nullable field ${info.parentType.name}.${info.fieldName}.`,
       );
     }
     return completed;

src/index.ts

@@ -48,6 +48,7 @@ export {
   GraphQLInputObjectType,
   GraphQLList,
   GraphQLNonNull,
+  GraphQLSemanticNonNull,
   // Standard GraphQL Scalars
   specifiedScalarTypes,
   GraphQLInt,
@@ -95,6 +96,7 @@ export {
   isInputObjectType,
   isListType,
   isNonNullType,
+  isSemanticNonNullType,
   isInputType,
   isOutputType,
   isLeafType,
@@ -120,6 +122,7 @@ export {
   assertInputObjectType,
   assertListType,
   assertNonNullType,
+  assertSemanticNonNullType,
   assertInputType,
   assertOutputType,
   assertLeafType,
@@ -148,6 +151,7 @@ export type {
   GraphQLAbstractType,
   GraphQLWrappingType,
   GraphQLNullableType,
+  GraphQLNullableOutputType,
   GraphQLNamedType,
   GraphQLNamedInputType,
   GraphQLNamedOutputType,
@@ -287,6 +291,7 @@ export type {
   NamedTypeNode,
   ListTypeNode,
   NonNullTypeNode,
+  SemanticNonNullTypeNode,
   TypeSystemDefinitionNode,
   SchemaDefinitionNode,
   OperationTypeDefinitionNode,
@@ -482,6 +487,7 @@ export type {
   IntrospectionNamedTypeRef,
   IntrospectionListTypeRef,
   IntrospectionNonNullTypeRef,
+  IntrospectionSemanticNonNullTypeRef,
   IntrospectionField,
   IntrospectionInputValue,
   IntrospectionEnumValue,

src/jsutils/memoize1.ts

@@ -0,0 +1,22 @@
+/**
+ * Memoizes the provided single-argument function.
+ */
+export function memoize1<A1 extends object, R>(
+  fn: (a1: A1) => R,
+): (a1: A1) => R {
+  let cache0: WeakMap<A1, R>;
+
+  return function memoized(a1) {
+    if (cache0 === undefined) {
+      cache0 = new WeakMap();
+    }
+
+    let fnResult = cache0.get(a1);
+    if (fnResult === undefined) {
+      fnResult = fn(a1);
+      cache0.set(a1, fnResult);
+    }
+
+    return fnResult;
+  };
+}

src/language/__tests__/parser-test.ts

@@ -636,6 +636,23 @@ describe('Parser', () => {
       });
     });
 
+    it('parses semantic-non-null types', () => {
+      const result = parseType('MyType*');
+      expectJSON(result).toDeepEqual({
+        kind: Kind.SEMANTIC_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',
+          },
+        },
+      });
+    });
+
     it('parses nested types', () => {
       const result = parseType('[MyType!]');
       expectJSON(result).toDeepEqual({

src/language/__tests__/predicates-test.ts

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

src/language/ast.ts

@@ -161,6 +161,7 @@ export type ASTNode =
   | NamedTypeNode
   | ListTypeNode
   | NonNullTypeNode
+  | SemanticNonNullTypeNode
   | SchemaDefinitionNode
   | OperationTypeDefinitionNode
   | ScalarTypeDefinitionNode
@@ -235,6 +236,7 @@ export const QueryDocumentKeys: {
   NamedType: ['name'],
   ListType: ['type'],
   NonNullType: ['type'],
+  SemanticNonNullType: ['type'],
 
   SchemaDefinition: ['description', 'directives', 'operationTypes'],
   OperationTypeDefinition: ['type'],
@@ -521,7 +523,11 @@ export interface ConstDirectiveNode {
 
 /** Type Reference */
 
-export type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
+export type TypeNode =
+  | NamedTypeNode
+  | ListTypeNode
+  | NonNullTypeNode
+  | SemanticNonNullTypeNode;
 
 export interface NamedTypeNode {
   readonly kind: Kind.NAMED_TYPE;
@@ -541,6 +547,12 @@ export interface NonNullTypeNode {
   readonly type: NamedTypeNode | ListTypeNode;
 }
 
+export interface SemanticNonNullTypeNode {
+  readonly kind: Kind.SEMANTIC_NON_NULL_TYPE;
+  readonly loc?: Location;
+  readonly type: NamedTypeNode | ListTypeNode;
+}
+
 /** Type System Definition */
 
 export type TypeSystemDefinitionNode =

src/language/index.ts

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

src/language/kinds.ts

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

src/language/lexer.ts

@@ -91,6 +91,7 @@ export class Lexer {
 export function isPunctuatorTokenKind(kind: TokenKind): boolean {
   return (
     kind === TokenKind.BANG ||
+    kind === TokenKind.ASTERISK ||
     kind === TokenKind.DOLLAR ||
     kind === TokenKind.AMP ||
     kind === TokenKind.PAREN_L ||
@@ -246,7 +247,7 @@ function readNextToken(lexer: Lexer, start: number): Token {
       //   - FloatValue
       //   - StringValue
       //
-      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      // Punctuator :: one of ! $ & ( ) * ... : = @ [ ] { | }
       case 0x0021: // !
         return createToken(lexer, TokenKind.BANG, position, position + 1);
       case 0x0024: // $
@@ -257,6 +258,8 @@ function readNextToken(lexer: Lexer, start: number): Token {
         return createToken(lexer, TokenKind.PAREN_L, position, position + 1);
       case 0x0029: // )
         return createToken(lexer, TokenKind.PAREN_R, position, position + 1);
+      case 0x002a: // *
+        return createToken(lexer, TokenKind.ASTERISK, position, position + 1);
       case 0x002e: // .
         if (
           body.charCodeAt(position + 1) === 0x002e &&

src/language/parser.ts

@@ -50,6 +50,7 @@ import type {
   SchemaExtensionNode,
   SelectionNode,
   SelectionSetNode,
+  SemanticNonNullTypeNode,
   StringValueNode,
   Token,
   TypeNode,
@@ -749,6 +750,7 @@ export class Parser {
    *   - NamedType
    *   - ListType
    *   - NonNullType
+   *   - SemanticNonNullType
    */
   parseTypeReference(): TypeNode {
     const start = this._lexer.token;
@@ -770,6 +772,12 @@ export class Parser {
         type,
       });
     }
+    if (this.expectOptionalToken(TokenKind.ASTERISK)) {
+      return this.node<SemanticNonNullTypeNode>(start, {
+        kind: Kind.SEMANTIC_NON_NULL_TYPE,
+        type,
+      });
+    }
 
     return type;
   }

src/language/predicates.ts

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

src/language/printer.ts

@@ -131,6 +131,7 @@ const printDocASTReducer: ASTReducer<string> = {
   NamedType: { leave: ({ name }) => name },
   ListType: { leave: ({ type }) => '[' + type + ']' },
   NonNullType: { leave: ({ type }) => type + '!' },
+  SemanticNonNullType: { leave: ({ type }) => type + '*' },
 
   // Type System Definitions
 

src/language/tokenKind.ts

@@ -6,6 +6,7 @@ enum TokenKind {
   SOF = '<SOF>',
   EOF = '<EOF>',
   BANG = '!',
+  ASTERISK = '*',
   DOLLAR = '$',
   AMP = '&',
   PAREN_L = '(',

src/type/__tests__/introspection-test.ts

@@ -437,6 +437,11 @@ describe('Introspection', () => {
                   isDeprecated: false,
                   deprecationReason: null,
                 },
+                {
+                  name: 'SEMANTIC_NON_NULL',
+                  isDeprecated: false,
+                  deprecationReason: null,
+                },
               ],
               possibleTypes: null,
             },
@@ -506,7 +511,21 @@ describe('Introspection', () => {
                 },
                 {
                   name: 'type',
-                  args: [],
+                  args: [
+                    {
+                      name: 'includeSemanticNonNull',
+                      type: {
+                        kind: 'NON_NULL',
+                        name: null,
+                        ofType: {
+                          kind: 'SCALAR',
+                          name: 'Boolean',
+                          ofType: null,
+                        },
+                      },
+                      defaultValue: 'false',
+                    },
+                  ],
                   type: {
                     kind: 'NON_NULL',
                     name: null,