Provide a helper function to calculate query complexity independently of query execution.

Author: BeeHiveJava

src/QueryComplexity.ts

@@ -15,6 +15,8 @@ import {
   InlineFragmentNode,
   assertCompositeType,
   GraphQLField, isCompositeType, GraphQLCompositeType, GraphQLFieldMap,
+  GraphQLSchema, DocumentNode, TypeInfo,
+  visit, visitWithTypeInfo
 } from 'graphql';
 import {
   GraphQLUnionType,
@@ -74,6 +76,26 @@ function queryComplexityMessage(max: number, actual: number): string {
   );
 }
 
+export function calculateComplexity(options: {
+  estimators: ComplexityEstimator[],
+  schema: GraphQLSchema,
+  query: DocumentNode,
+  variables?: Object
+}): number {
+  const typeInfo = new TypeInfo(options.schema);
+
+  const context = new ValidationContext(options.schema, options.query, typeInfo);
+  const visitor = new QueryComplexity(context, {
+    // Maximum complexity does not matter since we're only interested in the calculated complexity.
+    maximumComplexity: Infinity,
+    estimators: options.estimators,
+    variables: options.variables
+  });
+
+  visit(options.query, visitWithTypeInfo(typeInfo, visitor));
+  return visitor.complexity;
+}
+
 export default class QueryComplexity {
   context: ValidationContext;
   complexity: number;

src/__tests__/QueryComplexity-test.ts

@@ -14,7 +14,7 @@ import {expect} from 'chai';
 
 import schema from './fixtures/schema';
 
-import ComplexityVisitor from '../QueryComplexity';
+import ComplexityVisitor, {calculateComplexity} from '../QueryComplexity';
 import {
   simpleEstimator,
   fieldConfigEstimator,
@@ -23,6 +23,23 @@ import {
 describe('QueryComplexity analysis', () => {
   const typeInfo = new TypeInfo(schema);
 
+  it('should calculate complexity', () => {
+    const ast = parse(`
+      query {
+        variableScalar(count: -100)
+      }
+    `);
+
+    const complexity = calculateComplexity({
+      estimators: [
+        simpleEstimator({defaultComplexity: -100})
+      ],
+      schema: schema,
+      query: ast
+    });
+    expect(complexity).to.equal(0);
+  });
+
   it('should not allow negative cost', () => {
     const ast = parse(`
       query {