Stricter types: semantic non null may only wrap output types

src/type/definition.ts

@@ -73,8 +73,7 @@ export type GraphQLType =
       | GraphQLInterfaceType
       | GraphQLUnionType
       | GraphQLEnumType
-      | GraphQLInputObjectType
-      | GraphQLList<GraphQLType>
+      | GraphQLList<GraphQLOutputType>
     >;
 
 export function isType(type: unknown): type is GraphQLType {
@@ -213,24 +212,15 @@ export function assertNonNullType(type: unknown): GraphQLNonNull<GraphQLType> {
   return type;
 }
 
-export function isSemanticNonNullType(
-  type: GraphQLInputType,
-): type is GraphQLSemanticNonNull<GraphQLInputType>;
-export function isSemanticNonNullType(
-  type: GraphQLOutputType,
-): type is GraphQLSemanticNonNull<GraphQLOutputType>;
-export function isSemanticNonNullType(
-  type: unknown,
-): type is GraphQLSemanticNonNull<GraphQLType>;
 export function isSemanticNonNullType(
   type: unknown,
-): type is GraphQLSemanticNonNull<GraphQLType> {
+): type is GraphQLSemanticNonNull<GraphQLNullableType & GraphQLOutputType> {
   return instanceOf(type, GraphQLSemanticNonNull);
 }
 
 export function assertSemanticNonNullType(
   type: unknown,
-): GraphQLSemanticNonNull<GraphQLType> {
+): GraphQLSemanticNonNull<GraphQLNullableType & GraphQLOutputType> {
   if (!isSemanticNonNullType(type)) {
     throw new Error(
       `Expected ${inspect(type)} to be a GraphQL Semantic-Non-Null type.`,
@@ -485,7 +475,9 @@ export class GraphQLNonNull<T extends GraphQLNullableType> {
  *
  * @experimental
  */
-export class GraphQLSemanticNonNull<T extends GraphQLNullableType> {
+export class GraphQLSemanticNonNull<
+  T extends GraphQLNullableType & GraphQLOutputType,
+> {
   readonly ofType: T;
 
   constructor(ofType: T) {
@@ -516,8 +508,8 @@ export class GraphQLSemanticNonNull<T extends GraphQLNullableType> {
 
 export type GraphQLWrappingType =
   | GraphQLList<GraphQLType>
-  | GraphQLNonNull<GraphQLType>
-  | GraphQLSemanticNonNull<GraphQLType>;
+  | GraphQLNonNull<GraphQLNullableType>
+  | GraphQLSemanticNonNull<GraphQLNullableType & GraphQLOutputType>;
 
 export function isWrappingType(type: unknown): type is GraphQLWrappingType {
   return isListType(type) || isNonNullType(type) || isSemanticNonNullType(type);
@@ -555,7 +547,10 @@ export function assertNullableType(type: unknown): GraphQLNullableType {
 
 export function getNullableType(type: undefined | null): void;
 export function getNullableType<T extends GraphQLNullableType>(
-  type: T | GraphQLNonNull<T> | GraphQLSemanticNonNull<T>,
+  type:
+    | T
+    | GraphQLNonNull<T>
+    | GraphQLSemanticNonNull<T extends GraphQLOutputType ? T : never>,
 ): T;
 export function getNullableType(
   type: Maybe<GraphQLType>,

src/utilities/buildClientSchema.ts

@@ -139,13 +139,18 @@
       return new GraphQLNonNull(assertNullableType(nullableType));
     }
     if (typeRef.kind === TypeKind.SEMANTIC_NON_NULL) {
       const nullableRef = typeRef.ofType;
       if (!nullableRef) {
         throw new Error('Decorated type deeper than introspection query.');
       }
-      const nullableType = getType(nullableRef);
-      return new GraphQLSemanticNonNull(assertNullableType(nullableType));
+      const nullableType = assertNullableType(getType(nullableRef));
+      if (!isOutputType(nullableType)) {
+        throw new Error(
+          'A semantic non-null wrapper must wrap an output type.',
+        );
+      }
+      return new GraphQLSemanticNonNull(nullableType);
     }
     return getNamedType(typeRef);
   }
 

src/utilities/extendSchema.ts

@@ -61,6 +61,7 @@
   isListType,
   isNonNullType,
   isObjectType,
+  isOutputType,
   isScalarType,
   isSemanticNonNullType,
   isUnionType,
@@ -228,9 +229,9 @@
       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);
   }
@@ -439,8 +440,12 @@
       return new GraphQLNonNull(getWrappedType(node.type));
     }
     if (node.kind === Kind.SEMANTIC_NON_NULL_TYPE) {
-      return new GraphQLSemanticNonNull(getWrappedType(node.type));
+      const wrapped = getWrappedType(node.type);
+      if (!isOutputType(wrapped)) {
+        throw new Error('A semantic non-null type cannot wrap an input type.');
+      }
+      return new GraphQLSemanticNonNull(wrapped);
     }
     return getNamedType(node);
   }
 

src/utilities/typeFromAST.ts

@@ -11,6 +11,7 @@
   GraphQLList,
   GraphQLNonNull,
   GraphQLSemanticNonNull,
+  isOutputType,
 } from '../type/definition';
 import type { GraphQLSchema } from '../type/schema';
 
@@ -51,9 +52,12 @@
       return innerType && new GraphQLNonNull(innerType);
     }
     case Kind.SEMANTIC_NON_NULL_TYPE: {
       const innerType = typeFromAST(schema, typeNode.type);
+      if (!isOutputType(innerType)) {
+        throw new Error('A semantic non-null type must wrap an output type.');
+      }
       return innerType && new GraphQLSemanticNonNull(innerType);
     }
     case Kind.NAMED_TYPE:
       return schema.getType(typeNode.name.value);
   }