Handle isNonNullType

graphql · twof · Sep 14, 2024 · Sep 14, 2024 · Sep 14, 2024 · Sep 14, 2024
commit 16a2114f3e203cef115aaf944d11ea37605fd6db
@@ -42,6 +42,7 @@ import {
   isLeafType,
   isListType,
   isNonNullType,
+  isSemanticNonNullType,
   isObjectType,
 } from '../type/definition';
 import {
@@ -115,6 +116,7 @@ export interface ExecutionContext {
   typeResolver: GraphQLTypeResolver<any, any>;
   subscribeFieldResolver: GraphQLFieldResolver<any, any>;
   errors: Array<GraphQLError>;
+  errorPropagation: boolean;
 }
 
 /**
@@ -595,7 +597,7 @@ function handleFieldError(
 ): null {
   // If the field type is non-nullable, then it is resolved without any
   // protection from errors, however it still properly locates the error.
-  if (isNonNullType(returnType)) {
+  if (exeContext.errorPropagation && isNonNullType(returnType)) {
     throw error;
   }
 
@@ -658,6 +660,25 @@ function completeValue(
     return completed;
   }
 
+  // If field type is SemanticNonNull, complete for inner type, and throw field error
+  // if result is null.
+  if (isSemanticNonNullType(returnType)) {
+    const completed = completeValue(
+      exeContext,
+      returnType.ofType,
+      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 result value is null or undefined then return null.
   if (result == null) {
     return null;

@@ -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,
@@ -287,6 +290,7 @@ export type {
   NamedTypeNode,
   ListTypeNode,
   NonNullTypeNode,
+  SemanticNonNullTypeNode,
   TypeSystemDefinitionNode,
   SchemaDefinitionNode,
   OperationTypeDefinitionNode,
@@ -480,6 +484,7 @@ export type {
   IntrospectionNamedTypeRef,
   IntrospectionListTypeRef,
   IntrospectionNonNullTypeRef,
+  IntrospectionSemanticNonNullTypeRef,
   IntrospectionField,
   IntrospectionInputValue,
   IntrospectionEnumValue,

@@ -540,6 +540,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 =

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

@@ -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',

@@ -19,6 +19,7 @@ import {
   assertListType,
   assertNamedType,
   assertNonNullType,
+  assertSemanticNonNullType,
   assertNullableType,
   assertObjectType,
   assertOutputType,
@@ -33,6 +34,7 @@ import {
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
+  GraphQLSemanticNonNull,
   GraphQLObjectType,
   GraphQLScalarType,
   GraphQLUnionType,
@@ -46,6 +48,7 @@ import {
   isListType,
   isNamedType,
   isNonNullType,
+  isSemanticNonNullType,
   isNullableType,
   isObjectType,
   isOutputType,
@@ -298,6 +301,45 @@ describe('Type predicates', () => {
       expect(() =>
         assertNonNullType(new GraphQLList(new GraphQLNonNull(ObjectType))),
       ).to.throw();
+      expect(isNonNullType(new GraphQLSemanticNonNull(ObjectType))).to.equal(
+        false,
+      );
+      expect(() =>
+        assertNonNullType(new GraphQLSemanticNonNull(ObjectType)),
+      ).to.throw();
+    });
+  });
+
+  describe('isSemanticNonNullType', () => {
+    it('returns true for a semantic-non-null wrapped type', () => {
+      expect(
+        isSemanticNonNullType(new GraphQLSemanticNonNull(ObjectType)),
+      ).to.equal(true);
+      expect(() =>
+        assertSemanticNonNullType(new GraphQLSemanticNonNull(ObjectType)),
+      ).to.not.throw();
+    });
+
+    it('returns false for an unwrapped type', () => {
+      expect(isSemanticNonNullType(ObjectType)).to.equal(false);
+      expect(() => assertSemanticNonNullType(ObjectType)).to.throw();
+    });
+
+    it('returns false for a not non-null wrapped type', () => {
+      expect(
+        isSemanticNonNullType(
+          new GraphQLList(new GraphQLSemanticNonNull(ObjectType)),
+        ),
+      ).to.equal(false);
+      expect(() =>
+        assertSemanticNonNullType(
+          new GraphQLList(new GraphQLSemanticNonNull(ObjectType)),
+        ),
+      ).to.throw();
+      expect(isNonNullType(new GraphQLNonNull(ObjectType))).to.equal(false);
+      expect(() =>
+        assertNonNullType(new GraphQLNonNull(ObjectType)),
+      ).to.throw();
     });
   });
 

@@ -260,7 +260,9 @@ export function isInputType(type: unknown): type is GraphQLInputType {
     isScalarType(type) ||
     isEnumType(type) ||
     isInputObjectType(type) ||
-    (isWrappingType(type) && isInputType(type.ofType))
+    (!isSemanticNonNullType(type) &&
+      isWrappingType(type) &&
+      isInputType(type.ofType))
   );
 }
 
@@ -1167,6 +1169,7 @@ export interface GraphQLArgument {
 }
 
 export function isRequiredArgument(arg: GraphQLArgument): boolean {
+  // Note: input types cannot be SemanticNonNull
   return isNonNullType(arg.type) && arg.defaultValue === undefined;
 }
 
@@ -1858,6 +1861,7 @@ export interface GraphQLInputField {
 }
 
 export function isRequiredInputField(field: GraphQLInputField): boolean {
+  // Note: input types cannot be SemanticNonNull
   return isNonNullType(field.type) && field.defaultValue === undefined;
 }
 

@@ -23,6 +23,7 @@ export {
   isInputObjectType,
   isListType,
   isNonNullType,
+  isSemanticNonNullType,
   isInputType,
   isOutputType,
   isLeafType,
@@ -43,6 +44,7 @@ export {
   assertInputObjectType,
   assertListType,
   assertNonNullType,
+  assertSemanticNonNullType,
   assertInputType,
   assertOutputType,
   assertLeafType,
@@ -64,6 +66,7 @@ export {
   // Type Wrappers
   GraphQLList,
   GraphQLNonNull,
+  GraphQLSemanticNonNull,
 } from './definition';
 
 export type {

@@ -6,13 +6,14 @@ import { print } from '../language/printer';
 
 import { astFromValue } from '../utilities/astFromValue';
 
-import type {
+import {
   GraphQLEnumValue,
   GraphQLField,
   GraphQLFieldConfigMap,
   GraphQLInputField,
   GraphQLNamedType,
   GraphQLType,
+  isSemanticNonNullType,
 } from './definition';
 import {
   GraphQLEnumType,
@@ -237,6 +238,9 @@ export const __Type: GraphQLObjectType = new GraphQLObjectType({
           if (isNonNullType(type)) {
             return TypeKind.NON_NULL;
           }
+          if (isSemanticNonNullType(type)) {
+            return TypeKind.SEMANTIC_NON_NULL;
+          }
           /* c8 ignore next 3 */
           // Not reachable, all possible types have been considered)
           invariant(false, `Unexpected type: "${inspect(type)}".`);
@@ -452,6 +456,7 @@ enum TypeKind {
   INPUT_OBJECT = 'INPUT_OBJECT',
   LIST = 'LIST',
   NON_NULL = 'NON_NULL',
+  SEMANTIC_NON_NULL = 'SEMANTIC_NON_NULL',
 }
 export { TypeKind };
 

@@ -42,6 +42,7 @@ export function astFromValue(
   value: unknown,
   type: GraphQLInputType,
 ): Maybe<ValueNode> {
+  // Note: input types cannot be SemanticNonNull
   if (isNonNullType(type)) {
     const astValue = astFromValue(value, type.ofType);
     if (astValue?.kind === Kind.NULL) {

@@ -59,6 +59,7 @@ import {
   isInterfaceType,
   isListType,
   isNonNullType,
+  isSemanticNonNullType,
   isObjectType,
   isScalarType,
   isUnionType,
@@ -225,6 +226,10 @@ export function extendSchemaImpl(
       // @ts-expect-error
       return new GraphQLNonNull(replaceType(type.ofType));
     }
+    if (isSemanticNonNullType(type)) {
+      // @ts-expect-error
+      return new GraphQLSemanticNonNull(replaceType(type.ofType));
+    }
     // @ts-expect-error FIXME
     return replaceNamedType(type);
   }

@@ -22,6 +22,7 @@ import {
   isListType,
   isNamedType,
   isNonNullType,
+  isSemanticNonNullType,
   isObjectType,
   isRequiredArgument,
   isRequiredInputField,
@@ -458,7 +459,10 @@ function isChangeSafeForObjectOrInterfaceField(
         )) ||
       // moving from nullable to non-null of the same underlying type is safe
       (isNonNullType(newType) &&
-        isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))
+        isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)) ||
+      // moving from nullable to semantic-non-null of the same underlying type is safe
+      (isSemanticNonNullType(newType) &&
+        isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)) ||
     );
   }
 
@@ -470,11 +474,25 @@ function isChangeSafeForObjectOrInterfaceField(
     );
   }
 
+  if (isSemanticNonNullType(oldType)) {
+    return (
+      // if they're both semantic-non-null, make sure the underlying types are compatible
+        (isSemanticNonNullType(newType) &&
+        isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType)) ||
+      // moving from semantic-non-null to non-null of the same underlying type is safe
+        isNonNullType(newType) &&
+        isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType)
+    );
+  }
+
   return (
     // if they're both named types, see if their names are equivalent
     (isNamedType(newType) && oldType.name === newType.name) ||
     // moving from nullable to non-null of the same underlying type is safe
     (isNonNullType(newType) &&
+      isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType)) ||
+    // moving from nullable to semantic-non-null of the same underlying type is safe
+    (isSemanticNonNullType(newType) &&
       isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))
   );
 }

@@ -285,6 +285,13 @@ export interface IntrospectionNonNullTypeRef<
   readonly ofType: T;
 }
 
+export interface IntrospectionSemanticNonNullTypeRef<
+  T extends IntrospectionTypeRef = IntrospectionTypeRef,
+> {
+  readonly kind: 'SEMANTIC_NON_NULL';
+  readonly ofType: T;
+}
+
 export type IntrospectionTypeRef =
   | IntrospectionNamedTypeRef
   | IntrospectionListTypeRef

@@ -20,6 +20,7 @@ export type {
   IntrospectionNamedTypeRef,
   IntrospectionListTypeRef,
   IntrospectionNonNullTypeRef,
+  IntrospectionSemanticNonNullTypeRef,
   IntrospectionField,
   IntrospectionInputValue,
   IntrospectionEnumValue,

@@ -25,6 +25,7 @@ import {
   isInterfaceType,
   isListType,
   isNonNullType,
+  isSemanticNonNullType,
   isObjectType,
   isScalarType,
   isUnionType,
@@ -62,6 +63,9 @@ export function lexicographicSortSchema(schema: GraphQLSchema): GraphQLSchema {
     } else if (isNonNullType(type)) {
       // @ts-expect-error
       return new GraphQLNonNull(replaceType(type.ofType));
+    } else if (isSemanticNonNullType(type)) {
+      // @ts-expect-error
+      return new GraphQLSemanticNonNull(replaceType(type.ofType));
     }
     // @ts-expect-error FIXME: TS Conversion
     return replaceNamedType<GraphQLNamedType>(type);