requiring list depth to match type

src/execution/__tests__/executor-test.ts

@@ -1613,36 +1613,81 @@ describe('Execute: Handles basic execution tasks', () => {
       });
     });
 
-    it('modifiedOutputType produces correct output types', () => {
-      const type = new GraphQLList(
-        new GraphQLNonNull(
-          new GraphQLList(new GraphQLNonNull(new GraphQLList(GraphQLInt))),
-        ),
-      );
+    it('modifiedOutputType produces correct output types with no overrides', () => {
+      // [[[!]]!]!
+      const type = new GraphQLNonNull(new GraphQLList(
+        new GraphQLNonNull(new GraphQLList(
+          new GraphQLList(
+            new GraphQLNonNull(GraphQLInt)
+          ),
+        )),
+      ));
 
+      // [[[]]]
       const nullabilityNode: NullabilityModifierNode | SupportArrayNode = {
         kind: Kind.LIST_NULLABILITY,
         element: {
-          kind: Kind.OPTIONAL_DESIGNATOR,
+          kind: Kind.LIST_NULLABILITY,
           element: {
             kind: Kind.LIST_NULLABILITY,
-            element: {
+            element: undefined,
+          },
+        }
+      };
+
+      const outputType = modifiedOutputType(type, nullabilityNode);
+      // [[[!]]!]!
+      const expectedOutputType = new GraphQLNonNull(new GraphQLList(
+        new GraphQLNonNull(new GraphQLList(
+          new GraphQLList(
+            new GraphQLNonNull(GraphQLInt)
+          ),
+        )),
+      ));
+
+      expect(outputType).to.deep.equal(expectedOutputType);
+    });
+
+    it('modifiedOutputType produces correct output types with overrides', () => {
+      // [[[!]]!]!
+      const type = new GraphQLNonNull(new GraphQLList(
+        new GraphQLNonNull(new GraphQLList(
+          new GraphQLList(
+            new GraphQLNonNull(GraphQLInt)
+          ),
+        )),
+      ));
+
+      // [[[]]]
+      const nullabilityNode: NullabilityModifierNode | SupportArrayNode = {
+        // kind: Kind.REQUIRED_DESIGNATOR,
+        // element: {
+          kind: Kind.LIST_NULLABILITY,
+          element: {
+            // kind: Kind.REQUIRED_DESIGNATOR,
+            // element: {
               kind: Kind.LIST_NULLABILITY,
               element: {
-                kind: Kind.REQUIRED_DESIGNATOR,
-                element: undefined,
+                // kind: Kind.REQUIRED_DESIGNATOR,
+                // element:  {
+                  kind: Kind.LIST_NULLABILITY,
+                  element: undefined,
+                // }
               },
-            },
-          },
-        },
+            // },
+          }
+        // },
       };
 
       const outputType = modifiedOutputType(type, nullabilityNode);
-      const expectedOutputType = new GraphQLList(
-        new GraphQLList(
-          new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLInt))),
-        ),
-      );
+      // [[[!]]!]!
+      const expectedOutputType = new GraphQLNonNull(new GraphQLList(
+        new GraphQLNonNull(new GraphQLList(
+          new GraphQLList(
+            new GraphQLNonNull(GraphQLInt)
+          ),
+        )),
+      ));
 
       expect(outputType).to.deep.equal(expectedOutputType);
     });

src/utilities/applyRequiredStatus.ts

@@ -1,15 +1,12 @@
-import type { GraphQLOutputType } from '../type/definition';
+import { GraphQLOutputType, isListType } from '../type/definition';
 import {
   getNullableType,
   GraphQLNonNull,
   isNonNullType,
   assertListType,
   GraphQLList,
 } from '../type/definition';
-import type {
-  SupportArrayNode,
-  NullabilityModifierNode,
-} from '../language/ast';
+import type { SupportArrayNode, NullabilityModifierNode } from '../language/ast';
 import type { ASTReducer } from '../language/visitor';
 import { visit } from '../language/visitor';
 import { GraphQLError } from '../error/GraphQLError';
@@ -32,14 +29,17 @@ export function modifiedOutputType(
         if (element) {
           return new GraphQLNonNull(getNullableType(element));
         }
+
+        // We're working with the inner-most type
         const nextType = typeStack.pop();
 
         if (!nextType) {
           throw new GraphQLError(
-            'List nullability designator is too deep.',
+            'List nullability modifier is too deep.',
             nullabilityNode,
           );
         }
+
         return new GraphQLNonNull(getNullableType(nextType));
       },
     },
@@ -48,10 +48,13 @@ export function modifiedOutputType(
         if (element) {
           return getNullableType(element);
         }
+
+        // We're working with the inner-most type
         const nextType = typeStack.pop();
+
         if (!nextType) {
           throw new GraphQLError(
-            'List nullability designator is too deep.',
+            'List nullability modifier is too deep.',
             nullabilityNode,
           );
         }
@@ -61,15 +64,26 @@ export function modifiedOutputType(
     },
     ListNullabilityDesignator: {
       enter() {
-        const list = assertListType(getNullableType(typeStack.at(-1)));
-        const elementType = list.ofType as GraphQLOutputType;
-        typeStack.push(elementType);
+        try {
+          const list = assertListType(getNullableType(typeStack.at(-1)));
+          const elementType = list.ofType as GraphQLOutputType;
+          typeStack.push(elementType);
+        } catch (error) {
+          // assertListType will throw an error if we try to dig into the type and it's not a list
+          throw new GraphQLError(
+            `${error} Was the list nullability modifier's depth more than the field types?`,
+            nullabilityNode
+          );
+        }
       },
       leave({ element }) {
-        const listType = typeStack.pop();
+        let listType = typeStack.pop();
+        // Skip to the inner-most list
+        if (!isListType(getNullableType(listType))) listType = typeStack.pop();
+
         if (!listType) {
           throw new GraphQLError(
-            'List nullability designator is too deep.',
+            'List nullability modifier is too deep.',
             nullabilityNode,
           );
         }
@@ -80,14 +94,22 @@ export function modifiedOutputType(
             : new GraphQLList(element);
         }
 
+        // We're working with the inner-most list
         return isRequired
-          ? new GraphQLNonNull(new GraphQLList(listType))
-          : new GraphQLList(listType);
+            ? new GraphQLNonNull(listType)
+            : listType;
       },
     },
   };
 
   if (nullabilityNode) {
+    // modifiers must be exactly the same depth as the field type
+    if (typeStack.length > 0) {
+      throw new GraphQLError(
+        'List nullability modifier is too shallow.',
+        nullabilityNode,
+      );
+    }
     return visit(nullabilityNode, applyStatusReducer);
   }
 

src/validation/__tests__/RequiredStatusOnFieldMatchesDefinitionRule-test.ts

@@ -22,7 +22,7 @@ const testSchema = buildSchema(`
   type Lists {
     nonList: Int
     list: [Int]
-    mixedThreeDList: [[[Int]!]!]
+    mixedThreeDList: [[[Int]]]
   } 
 
   type Query {
@@ -40,24 +40,39 @@ describe('Validate: Field uses correct list depth', () => {
       }
     `);
   });
+  // notAList: nonList[!]
+  // mixedThreeDList[[!]!]!
 
   it('reports errors when list depth is too high', () => {
     expectErrors(`
       fragment listFragment on Lists {
-        list[[]]
         notAList: nonList[!]
-        mixedThreeDList[[!]!]!
+        list[[]]
       }
     `).toDeepEqual([
       {
         message:
-          'Syntax Error: Something is wrong with the nullability designator on list. The type for that field in the schema is [Int] Is the correct list depth being used?',
-        locations: [{ line: 3, column: 9 }],
+          "Error: Expected Int to be a GraphQL List type. Was the list nullability modifier's depth more than the field types?",
+        locations: [{ line: 3, column: 26 }],
+      },
+      {
+        message:
+          "Error: Expected Int to be a GraphQL List type. Was the list nullability modifier's depth more than the field types?",
+        locations: [{ line: 4, column: 13 }],
       },
+    ]);
+  });
+//mixedThreeDList[[[!]!]!]!
+  it('reports errors when list depth is too low', () => {
+    expectErrors(`
+      fragment listFragment on Lists {
+        mixedThreeDList[[]!]!
+      }
+    `).toDeepEqual([
       {
         message:
-          'Syntax Error: Something is wrong with the nullability designator on notAList. The type for that field in the schema is Int Is the correct list depth being used?',
-        locations: [{ line: 4, column: 9 }],
+          'List nullability modifier is too shallow.',
+        locations: [{ line: 4, column: 7 }],
       },
     ]);
   });

src/validation/rules/RequiredStatusOnFieldMatchesDefinitionRule.ts

@@ -21,24 +21,12 @@ export function RequiredStatusOnFieldMatchesDefinitionRule(
 ): ASTVisitor {
   return {
     Field(node: FieldNode) {
-      if (context.getFieldDef()) {
-        const fieldDef = context.getFieldDef() as GraphQLField<
-          unknown,
-          unknown
-        >;
+      const fieldDef = context.getFieldDef();
+      if (fieldDef) {
         try {
           modifiedOutputType(fieldDef.type, node.required);
         } catch (error) {
-          context.reportError(
-            new GraphQLError(
-              `Syntax Error: Something is wrong with the nullability designator on ${
-                node.alias?.value ?? node.name.value
-              }. The type for that field in the schema is ${
-                fieldDef.type
-              } Is the correct list depth being used?`,
-              node,
-            ),
-          );
+          context.reportError(error);
         }
       }
     },