[Validation] Factor out and memoize recursively referenced fragments.

This adds a new method to the validation context which when given an Operation definition, returns a list of all Fragment definitions recursively referenced via fragment spreads.

This new method is then used to ensure no fragments are unused.

The implementation of this method is the same in principle as the one which used to be inline in the validation rule, but has been unfolded from recursion to use a while loop.

Author: leebyron

src/validation/rules/NoUnusedFragments.js

@@ -23,34 +23,27 @@ export function unusedFragMessage(fragName: any): string {
  * within operations, or spread within other fragments spread within operations.
  */
 export function NoUnusedFragments(context: ValidationContext): any {
-  var spreadsWithinOperation = [];
+  var operationDefs = [];
   var fragmentDefs = [];
 
   return {
     OperationDefinition(node) {
-      spreadsWithinOperation.push(context.getFragmentSpreads(node));
+      operationDefs.push(node);
       return false;
     },
-    FragmentDefinition(def) {
-      fragmentDefs.push(def);
+    FragmentDefinition(node) {
+      fragmentDefs.push(node);
       return false;
     },
     Document: {
       leave() {
-        var fragmentNameUsed = {};
-        var reduceSpreadFragments = function (spreads) {
-          spreads.forEach(spread => {
-            const fragName = spread.name.value;
-            if (fragmentNameUsed[fragName] !== true) {
-              fragmentNameUsed[fragName] = true;
-              const fragment = context.getFragment(fragName);
-              if (fragment) {
-                reduceSpreadFragments(context.getFragmentSpreads(fragment));
-              }
-            }
-          });
-        };
-        spreadsWithinOperation.forEach(reduceSpreadFragments);
+        const fragmentNameUsed = Object.create(null);
+        operationDefs.forEach(operation => {
+          context.getRecursivelyReferencedFragments(operation).forEach(
+            fragment => { fragmentNameUsed[fragment.name.value] = true; }
+          );
+        });
+
         var errors = fragmentDefs
           .filter(def => fragmentNameUsed[def.name.value] !== true)
           .map(def => new GraphQLError(

src/validation/validate.js

@@ -187,12 +187,15 @@ export class ValidationContext {
   _typeInfo: TypeInfo;
   _fragments: {[name: string]: FragmentDefinition};
   _fragmentSpreads: Map<HasSelectionSet, Array<FragmentSpread>>;
+  _recursivelyReferencedFragments:
+    Map<OperationDefinition, Array<FragmentDefinition>>;
 
   constructor(schema: GraphQLSchema, ast: Document, typeInfo: TypeInfo) {
     this._schema = schema;
     this._ast = ast;
     this._typeInfo = typeInfo;
     this._fragmentSpreads = new Map();
+    this._recursivelyReferencedFragments = new Map();
   }
 
   getSchema(): GraphQLSchema {
@@ -227,6 +230,34 @@ export class ValidationContext {
     return spreads;
   }
 
+  getRecursivelyReferencedFragments(
+    operation: OperationDefinition
+  ): Array<FragmentDefinition> {
+    let fragments = this._recursivelyReferencedFragments.get(operation);
+    if (!fragments) {
+      fragments = [];
+      const collectedNames = Object.create(null);
+      const nodesToVisit: Array<HasSelectionSet> = [ operation ];
+      while (nodesToVisit.length !== 0) {
+        const node = nodesToVisit.pop();
+        const spreads = this.getFragmentSpreads(node);
+        for (let i = 0; i < spreads.length; i++) {
+          const fragName = spreads[i].name.value;
+          if (collectedNames[fragName] !== true) {
+            collectedNames[fragName] = true;
+            const fragment = this.getFragment(fragName);
+            if (fragment) {
+              fragments.push(fragment);
+              nodesToVisit.push(fragment);
+            }
+          }
+        }
+      }
+      this._recursivelyReferencedFragments.set(operation, fragments);
+    }
+    return fragments;
+  }
+
   getType(): ?GraphQLOutputType {
     return this._typeInfo.getType();
   }