TS: Fix strict issues in src/validation

* Add `"strict": true` to tsconfig.json
* Fix all issues that arise within `src/validation`

Author: leebyron

src/type/definition.ts

@@ -457,6 +457,9 @@ export function getNullableType(type: undefined | null): void;
 export function getNullableType<T extends GraphQLNullableType>(
   type: T | GraphQLNonNull<T>,
 ): T;
+export function getNullableType(
+  type: Maybe<GraphQLType>,
+): GraphQLNullableType | undefined;
 export function getNullableType(
   type: Maybe<GraphQLType>,
 ): GraphQLNullableType | undefined {
@@ -504,6 +507,9 @@ export function getNamedType(type: undefined | null): void;
 export function getNamedType(type: GraphQLInputType): GraphQLNamedInputType;
 export function getNamedType(type: GraphQLOutputType): GraphQLNamedOutputType;
 export function getNamedType(type: GraphQLType): GraphQLNamedType;
+export function getNamedType(
+  type: Maybe<GraphQLType>,
+): GraphQLNamedType | undefined;
 export function getNamedType(
   type: Maybe<GraphQLType>,
 ): GraphQLNamedType | undefined {

src/validation/ValidationContext.ts

@@ -44,15 +44,11 @@ interface VariableUsage {
 export class ASTValidationContext {
   private _ast: DocumentNode;
   private _onError: (error: GraphQLError) => void;
-  private _fragments: Maybe<ObjMap<FragmentDefinitionNode>>;
-  private _fragmentSpreads: Map<
-    SelectionSetNode,
-    ReadonlyArray<FragmentSpreadNode>
-  >;
-
+  private _fragments: ObjMap<FragmentDefinitionNode> | undefined;
+  private _fragmentSpreads: Map<SelectionSetNode, Array<FragmentSpreadNode>>;
   private _recursivelyReferencedFragments: Map<
     OperationDefinitionNode,
-    ReadonlyArray<FragmentDefinitionNode>
+    Array<FragmentDefinitionNode>
   >;
 
   constructor(ast: DocumentNode, onError: (error: GraphQLError) => void) {
@@ -72,15 +68,19 @@ export class ASTValidationContext {
   }
 
   getFragment(name: string): Maybe<FragmentDefinitionNode> {
-    if (!this._fragments) {
-      const fragments = (this._fragments = Object.create(null));
+    let fragments: ObjMap<FragmentDefinitionNode>;
+    if (this._fragments) {
+      fragments = this._fragments;
+    } else {
+      fragments = Object.create(null);
       for (const defNode of this.getDocument().definitions) {
         if (defNode.kind === Kind.FRAGMENT_DEFINITION) {
           fragments[defNode.name.value] = defNode;
         }
       }
+      this._fragments = fragments;
     }
-    return this._fragments[name];
+    return fragments[name];
   }
 
   getFragmentSpreads(
@@ -90,11 +90,10 @@ export class ASTValidationContext {
     if (!spreads) {
       spreads = [];
       const setsToVisit: Array<SelectionSetNode> = [node];
-      while (setsToVisit.length !== 0) {
-        const set = setsToVisit.pop();
+      let set: SelectionSetNode | undefined;
+      while ((set = setsToVisit.pop())) {
         for (const selection of set.selections) {
           if (selection.kind === Kind.FRAGMENT_SPREAD) {
-            // @ts-expect-error FIXME: TS Conversion
             spreads.push(selection);
           } else if (selection.selectionSet) {
             setsToVisit.push(selection.selectionSet);
@@ -114,15 +113,14 @@ export class ASTValidationContext {
       fragments = [];
       const collectedNames = Object.create(null);
       const nodesToVisit: Array<SelectionSetNode> = [operation.selectionSet];
-      while (nodesToVisit.length !== 0) {
-        const node = nodesToVisit.pop();
+      let node: SelectionSetNode | undefined;
+      while ((node = nodesToVisit.pop())) {
         for (const spread of this.getFragmentSpreads(node)) {
           const fragName = spread.name.value;
           if (collectedNames[fragName] !== true) {
             collectedNames[fragName] = true;
             const fragment = this.getFragment(fragName);
             if (fragment) {
-              // @ts-expect-error FIXME: TS Conversion
               fragments.push(fragment);
               nodesToVisit.push(fragment.selectionSet);
             }
@@ -189,7 +187,7 @@ export class ValidationContext extends ASTValidationContext {
   getVariableUsages(node: NodeWithSelectionSet): ReadonlyArray<VariableUsage> {
     let usages = this._variableUsages.get(node);
     if (!usages) {
-      const newUsages = [];
+      const newUsages: Array<VariableUsage> = [];
       const typeInfo = new TypeInfo(this._schema);
       visit(
         node,

src/validation/__tests__/validation-test.ts

@@ -3,6 +3,7 @@ import { describe, it } from 'mocha';
 
 import { GraphQLError } from '../../error/GraphQLError';
 
+import type { DirectiveNode } from '../../language/ast';
 import { parse } from '../../language/parser';
 
 import { TypeInfo } from '../../utilities/TypeInfo';
@@ -15,6 +16,7 @@ import { testSchema } from './harness';
 
 describe('Validate: Supports full validation', () => {
   it('rejects invalid documents', () => {
+    // TODO ts-expect-error (expects a DocumentNode as a second parameter)
     expect(() => validate(testSchema, null)).to.throw('Must provide document.');
   });
 
@@ -96,7 +98,7 @@ describe('Validate: Supports full validation', () => {
 
     function customRule(context: ValidationContext) {
       return {
-        Directive(node) {
+        Directive(node: DirectiveNode) {
           const directiveDef = context.getDirective();
           const error = new GraphQLError(
             'Reporting directive: ' + String(directiveDef),

src/validation/rules/KnownDirectivesRule.ts

@@ -71,12 +71,10 @@ function getDirectiveLocationForASTPath(
   ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>,
 ): DirectiveLocationEnum | undefined {
   const appliedTo = ancestors[ancestors.length - 1];
-  invariant(!Array.isArray(appliedTo));
+  invariant('kind' in appliedTo);
 
-  // @ts-expect-error FIXME: TS Conversion
   switch (appliedTo.kind) {
     case Kind.OPERATION_DEFINITION:
-      // @ts-expect-error FIXME: TS Conversion
       return getDirectiveLocationForOperation(appliedTo.operation);
     case Kind.FIELD:
       return DirectiveLocation.FIELD;
@@ -115,7 +113,7 @@ function getDirectiveLocationForASTPath(
       return DirectiveLocation.INPUT_OBJECT;
     case Kind.INPUT_VALUE_DEFINITION: {
       const parentNode = ancestors[ancestors.length - 3];
-      // @ts-expect-error FIXME: TS Conversion
+      invariant('kind' in parentNode);
       return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION
         ? DirectiveLocation.INPUT_FIELD_DEFINITION
         : DirectiveLocation.ARGUMENT_DEFINITION;

src/validation/rules/KnownTypeNamesRule.ts

@@ -74,8 +74,7 @@ const standardTypeNames = [...specifiedScalarTypes, ...introspectionTypes].map(
 
 function isSDLNode(value: ASTNode | ReadonlyArray<ASTNode>): boolean {
   return (
-    !Array.isArray(value) &&
-    // @ts-expect-error FIXME: TS Conversion
+    'kind' in value &&
     (isTypeSystemDefinitionNode(value) || isTypeSystemExtensionNode(value))
   );
 }

src/validation/rules/NoFragmentCyclesRule.ts

@@ -1,7 +1,12 @@
+import type { ObjMap } from '../../jsutils/ObjMap';
+
 import { GraphQLError } from '../../error/GraphQLError';
 
+import type {
+  FragmentDefinitionNode,
+  FragmentSpreadNode,
+} from '../../language/ast';
 import type { ASTVisitor } from '../../language/visitor';
-import type { FragmentDefinitionNode } from '../../language/ast';
 
 import type { ASTValidationContext } from '../ValidationContext';
 
@@ -10,13 +15,13 @@ export function NoFragmentCyclesRule(
 ): ASTVisitor {
   // Tracks already visited fragments to maintain O(N) and to ensure that cycles
   // are not redundantly reported.
-  const visitedFrags = Object.create(null);
+  const visitedFrags: ObjMap<boolean> = Object.create(null);
 
   // Array of AST nodes used to produce meaningful errors
-  const spreadPath = [];
+  const spreadPath: Array<FragmentSpreadNode> = [];
 
   // Position in the spread path
-  const spreadPathIndexByName = Object.create(null);
+  const spreadPathIndexByName: ObjMap<number | undefined> = Object.create(null);
 
   return {
     OperationDefinition: () => false,

src/validation/rules/NoUnusedFragmentsRule.ts

@@ -1,5 +1,9 @@
 import { GraphQLError } from '../../error/GraphQLError';
 
+import type {
+  FragmentDefinitionNode,
+  OperationDefinitionNode,
+} from '../../language/ast';
 import type { ASTVisitor } from '../../language/visitor';
 
 import type { ASTValidationContext } from '../ValidationContext';
@@ -13,8 +17,8 @@ import type { ASTValidationContext } from '../ValidationContext';
 export function NoUnusedFragmentsRule(
   context: ASTValidationContext,
 ): ASTVisitor {
-  const operationDefs = [];
-  const fragmentDefs = [];
+  const operationDefs: Array<OperationDefinitionNode> = [];
+  const fragmentDefs: Array<FragmentDefinitionNode> = [];
 
   return {
     OperationDefinition(node) {

src/validation/rules/NoUnusedVariablesRule.ts

@@ -1,5 +1,6 @@
 import { GraphQLError } from '../../error/GraphQLError';
 
+import type { VariableDefinitionNode } from '../../language/ast';
 import type { ASTVisitor } from '../../language/visitor';
 
 import type { ValidationContext } from '../ValidationContext';
@@ -11,7 +12,7 @@ import type { ValidationContext } from '../ValidationContext';
  * are used, either directly or within a spread fragment.
  */
 export function NoUnusedVariablesRule(context: ValidationContext): ASTVisitor {
-  let variableDefs = [];
+  let variableDefs: Array<VariableDefinitionNode> = [];
 
   return {
     OperationDefinition: {

src/validation/rules/OverlappingFieldsCanBeMergedRule.ts

@@ -17,7 +17,6 @@ import { print } from '../../language/printer';
 import type {
   GraphQLNamedType,
   GraphQLOutputType,
-  GraphQLCompositeType,
   GraphQLField,
 } from '../../type/definition';
 import {
@@ -97,12 +96,14 @@ type ConflictReason = [string, ConflictReasonMessage];
 type ConflictReasonMessage = string | Array<ConflictReason>;
 // Tuple defining a field node in a context.
 type NodeAndDef = [
-  GraphQLCompositeType,
+  Maybe<GraphQLNamedType>,
   FieldNode,
   Maybe<GraphQLField<unknown, unknown>>,
 ];
 // Map of array of those.
 type NodeAndDefCollection = ObjMap<Array<NodeAndDef>>;
+type FragmentNames = Array<string>;
+type FieldsAndFragmentNames = readonly [NodeAndDefCollection, FragmentNames];
 
 /**
  * Algorithm:
@@ -164,12 +165,12 @@ type NodeAndDefCollection = ObjMap<Array<NodeAndDef>>;
 // GraphQL Document.
 function findConflictsWithinSelectionSet(
   context: ValidationContext,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   parentType: Maybe<GraphQLNamedType>,
   selectionSet: SelectionSetNode,
 ): Array<Conflict> {
-  const conflicts = [];
+  const conflicts: Array<Conflict> = [];
 
   const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(
     context,
@@ -226,7 +227,7 @@ function findConflictsWithinSelectionSet(
 function collectConflictsBetweenFieldsAndFragment(
   context: ValidationContext,
   conflicts: Array<Conflict>,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   areMutuallyExclusive: boolean,
   fieldMap: NodeAndDefCollection,
@@ -280,7 +281,7 @@ function collectConflictsBetweenFieldsAndFragment(
 function collectConflictsBetweenFragments(
   context: ValidationContext,
   conflicts: Array<Conflict>,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   areMutuallyExclusive: boolean,
   fragmentName1: string,
@@ -366,15 +367,15 @@ function collectConflictsBetweenFragments(
 // between the sub-fields of two overlapping fields.
 function findConflictsBetweenSubSelectionSets(
   context: ValidationContext,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   areMutuallyExclusive: boolean,
   parentType1: Maybe<GraphQLNamedType>,
   selectionSet1: SelectionSetNode,
   parentType2: Maybe<GraphQLNamedType>,
   selectionSet2: SelectionSetNode,
 ): Array<Conflict> {
-  const conflicts = [];
+  const conflicts: Array<Conflict> = [];
 
   const [fieldMap1, fragmentNames1] = getFieldsAndFragmentNames(
     context,
@@ -455,7 +456,7 @@ function findConflictsBetweenSubSelectionSets(
 function collectConflictsWithin(
   context: ValidationContext,
   conflicts: Array<Conflict>,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   fieldMap: NodeAndDefCollection,
 ): void {
@@ -496,7 +497,7 @@ function collectConflictsWithin(
 function collectConflictsBetween(
   context: ValidationContext,
   conflicts: Array<Conflict>,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   parentFieldsAreMutuallyExclusive: boolean,
   fieldMap1: NodeAndDefCollection,
@@ -534,7 +535,7 @@ function collectConflictsBetween(
 // comparing their sub-fields.
 function findConflict(
   context: ValidationContext,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   comparedFragmentPairs: PairSet,
   parentFieldsAreMutuallyExclusive: boolean,
   responseName: string,
@@ -677,32 +678,33 @@ function doTypesConflict(
 // referenced via fragment spreads.
 function getFieldsAndFragmentNames(
   context: ValidationContext,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   parentType: Maybe<GraphQLNamedType>,
   selectionSet: SelectionSetNode,
-): [NodeAndDefCollection, Array<string>] {
-  let cached = cachedFieldsAndFragmentNames.get(selectionSet);
-  if (!cached) {
-    const nodeAndDefs = Object.create(null);
-    const fragmentNames = Object.create(null);
-    _collectFieldsAndFragmentNames(
-      context,
-      parentType,
-      selectionSet,
-      nodeAndDefs,
-      fragmentNames,
-    );
-    cached = [nodeAndDefs, Object.keys(fragmentNames)];
-    cachedFieldsAndFragmentNames.set(selectionSet, cached);
+): FieldsAndFragmentNames {
+  const cached = cachedFieldsAndFragmentNames.get(selectionSet);
+  if (cached) {
+    return cached;
   }
-  return cached;
+  const nodeAndDefs: NodeAndDefCollection = Object.create(null);
+  const fragmentNames: ObjMap<boolean> = Object.create(null);
+  _collectFieldsAndFragmentNames(
+    context,
+    parentType,
+    selectionSet,
+    nodeAndDefs,
+    fragmentNames,
+  );
+  const result = [nodeAndDefs, Object.keys(fragmentNames)] as const;
+  cachedFieldsAndFragmentNames.set(selectionSet, result);
+  return result;
 }
 
 // Given a reference to a fragment, return the represented collection of fields
 // as well as a list of nested fragment names referenced via fragment spreads.
 function getReferencedFieldsAndFragmentNames(
   context: ValidationContext,
-  cachedFieldsAndFragmentNames,
+  cachedFieldsAndFragmentNames: Map<SelectionSetNode, FieldsAndFragmentNames>,
   fragment: FragmentDefinitionNode,
 ) {
   // Short-circuit building a type from the node if possible.
@@ -724,8 +726,8 @@ function _collectFieldsAndFragmentNames(
   context: ValidationContext,
   parentType: Maybe<GraphQLNamedType>,
   selectionSet: SelectionSetNode,
-  nodeAndDefs,
-  fragmentNames,
+  nodeAndDefs: NodeAndDefCollection,
+  fragmentNames: ObjMap<boolean>,
 ): void {
   for (const selection of selectionSet.selections) {
     switch (selection.kind) {