Handle fragments on unknown types #35

Author: ivome

package.json

@@ -6,6 +6,7 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint --fix src/**/*.ts",
     "clean": "rimraf dist/*",
     "build": "tsc",
     "test": "npm run lint && npm run testonly",

src/QueryComplexity.ts

@@ -19,7 +19,7 @@ import {
   GraphQLField, isCompositeType, GraphQLCompositeType, GraphQLFieldMap,
   GraphQLSchema, DocumentNode, TypeInfo,
   visit, visitWithTypeInfo,
-  GraphQLDirective, isAbstractType,
+  GraphQLDirective, isAbstractType, GraphQLNamedType,
 } from 'graphql';
 import {
   GraphQLUnionType,
@@ -278,35 +278,40 @@ export default class QueryComplexity {
             }
             case Kind.FRAGMENT_SPREAD: {
               const fragment = this.context.getFragment(childNode.name.value);
-              if (fragment) {
-                const fragmentType = assertCompositeType(
-                  this.context.getSchema().getType(fragment.typeCondition.name.value)
+              // Unknown fragment, should be caught by other validation rules
+              if (!fragment) {
+                break;
+              }
+              const fragmentType = this.context.getSchema().getType(fragment.typeCondition.name.value);
+              // Invalid fragment type, ignore. Should be caught by other validation rules
+              if (!isCompositeType(fragmentType)) {
+                break;
+              }
+              const nodeComplexity = this.nodeComplexity(fragment, fragmentType);
+              if (isAbstractType(fragmentType)) {
+                // Add fragment complexity for all possible types
+                complexities = addComplexities(
+                  nodeComplexity,
+                  complexities,
+                  this.context.getSchema().getPossibleTypes(fragmentType).map(t => t.name),
+                );
+              } else {
+                // Add complexity for object type
+                complexities = addComplexities(
+                  nodeComplexity,
+                  complexities,
+                  [fragmentType.name],
                 );
-                const nodeComplexity = this.nodeComplexity(fragment, fragmentType);
-                if (isAbstractType(fragmentType)) {
-                  // Add fragment complexity for all possible types
-                  complexities = addComplexities(
-                    nodeComplexity,
-                    complexities,
-                    this.context.getSchema().getPossibleTypes(fragmentType).map(t => t.name),
-                  );
-                } else {
-                  // Add complexity for object type
-                  complexities = addComplexities(
-                    nodeComplexity,
-                    complexities,
-                    [fragmentType.name],
-                  );
-                }
               }
               break;
             }
             case Kind.INLINE_FRAGMENT: {
-              let inlineFragmentType = typeDef;
+              let inlineFragmentType: GraphQLNamedType = typeDef;
               if (childNode.typeCondition && childNode.typeCondition.name) {
-                inlineFragmentType = assertCompositeType(
-                  this.context.getSchema().getType(childNode.typeCondition.name.value)
-                );
+                inlineFragmentType = this.context.getSchema().getType(childNode.typeCondition.name.value);
+                if (!isCompositeType(inlineFragmentType)) {
+                  break;
+                }
               }
 
               const nodeComplexity = this.nodeComplexity(childNode, inlineFragmentType);

src/__tests__/QueryComplexity-test.ts

@@ -186,6 +186,49 @@ describe('QueryComplexity analysis', () => {
     expect(visitor.complexity).to.equal(10);
   });
 
+  it('should ignore inline fragment on unknown type', () => {
+    const ast = parse(`
+      query {
+        ...on UnknownType {
+          variableScalar(count: 100)
+        }
+      }
+    `);
+
+    const context = new CompatibleValidationContext(schema, ast, typeInfo);
+    const visitor = new ComplexityVisitor(context, {
+      maximumComplexity: 100,
+      estimators: [
+        simpleEstimator({defaultComplexity: 10})
+      ]
+    });
+
+    visit(ast, visitWithTypeInfo(typeInfo, visitor));
+    expect(visitor.complexity).to.equal(0);
+  });
+
+  it('should ignore fragment on unknown type', () => {
+    const ast = parse(`
+      query {
+        ...F
+      }
+      fragment F on UnknownType {
+        variableScalar(count: 100)
+      }
+    `);
+
+    const context = new CompatibleValidationContext(schema, ast, typeInfo);
+    const visitor = new ComplexityVisitor(context, {
+      maximumComplexity: 100,
+      estimators: [
+        simpleEstimator({defaultComplexity: 10})
+      ]
+    });
+
+    visit(ast, visitWithTypeInfo(typeInfo, visitor));
+    expect(visitor.complexity).to.equal(0);
+  });
+
   it('should ignore unused variables', () => {
     const ast = parse(`
       query ($unusedVar: ID!) {
@@ -205,6 +248,25 @@ describe('QueryComplexity analysis', () => {
     expect(visitor.complexity).to.equal(10);
   });
 
+  it('should ignore unknown field', () => {
+    const ast = parse(`
+      query {
+        unknownField
+      }
+    `);
+
+    const context = new CompatibleValidationContext(schema, ast, typeInfo);
+    const visitor = new ComplexityVisitor(context, {
+      maximumComplexity: 100,
+      estimators: [
+        simpleEstimator({defaultComplexity: 10})
+      ]
+    });
+
+    visit(ast, visitWithTypeInfo(typeInfo, visitor));
+    expect(visitor.complexity).to.equal(0);
+  });
+
   it('should report error above threshold', () => {
     const ast = parse(`
       query {