Moved complexity field config to dedicated LegacyEstimator

Author: ivome

src/QueryComplexity.ts

@@ -24,24 +24,22 @@ import {
   getNamedType,
   GraphQLError
 } from 'graphql';
-import {simpleEstimator} from './estimators';
-
-/**
- * @deprecated Use new complexity resolver
- */
-type SimpleComplexityEstimator = (args: any, complexity: number) => number;
+import {
+  simpleEstimator,
+  legacyEstimator
+} from './estimators';
 
 export type ComplexityEstimatorArgs = {
   type: GraphQLCompositeType,
-  field: GraphQLField<any, any>,
+  field: ComplexityGraphQLField<any, any>,
   args: {[key: string]: any},
   childComplexity: number
 }
 
 export type ComplexityEstimator = (options: ComplexityEstimatorArgs) => number | void;
 
 type ComplexityGraphQLField<TSource, TContext> = GraphQLField<TSource, TContext> & {
-  complexity?: SimpleComplexityEstimator | number | undefined
+  complexity?: any
 }
 
 type ComplexityGraphQLFieldMap<TSource, TContext> = {
@@ -95,6 +93,7 @@ export default class QueryComplexity {
     this.complexity = 0;
     this.options = options;
     this.estimators = options.estimators || [
+      legacyEstimator(),
       simpleEstimator()
     ];
 
@@ -178,37 +177,29 @@ export default class QueryComplexity {
                 childComplexity = this.nodeComplexity(childNode, fieldType);
               }
 
-              // Calculate complexity score
-              if (typeof field.complexity === 'number') {
-                nodeComplexity = childComplexity + field.complexity;
-              } else if (typeof field.complexity === 'function') {
-                nodeComplexity = field.complexity(args, childComplexity);
-              } else {
-                // Run estimators one after another and return first valid complexity
-                // score
-                const estimatorArgs: ComplexityEstimatorArgs = {
-                  childComplexity,
-                  args,
-                  field,
-                  type: typeDef
-                };
-                const validScore = this.estimators.find(estimator => {
-                  const tmpComplexity = estimator(estimatorArgs);
-
-                  if (typeof tmpComplexity === 'number') {
-                    nodeComplexity = tmpComplexity;
-                    return true;
-                  }
-
-                  return false;
-                });
-                if (!validScore) {
-                  throw new Error(
-                    `No complexity could be calculated for field ${typeDef.astNode}.${field.name}. ` +
-                    'Make sure you always have at least one estimator configured that returns a value.'
-                  );
+              // Run estimators one after another and return first valid complexity
+              // score
+              const estimatorArgs: ComplexityEstimatorArgs = {
+                childComplexity,
+                args,
+                field,
+                type: typeDef
+              };
+              const validScore = this.estimators.find(estimator => {
+                const tmpComplexity = estimator(estimatorArgs);
+
+                if (typeof tmpComplexity === 'number') {
+                  nodeComplexity = tmpComplexity;
+                  return true;
                 }
-                // nodeComplexity = this.getDefaultComplexity(args, childComplexity);
+
+                return false;
+              });
+              if (!validScore) {
+                throw new Error(
+                  `No complexity could be calculated for field ${typeDef.astNode}.${field.name}. ` +
+                  'At least one complexity estimator has to return a complexity score.'
+                );
               }
               break;
             }

src/estimators/index.ts

@@ -1 +1,2 @@
 export {default as simpleEstimator} from './simple';
+export {default as legacyEstimator} from './legacy';

src/estimators/legacy/index.ts

@@ -0,0 +1,12 @@
+import {ComplexityEstimator, ComplexityEstimatorArgs} from '../../QueryComplexity';
+
+export default function (): ComplexityEstimator {
+  return (args: ComplexityEstimatorArgs) => {
+    // Calculate complexity score
+    if (typeof args.field.complexity === 'number') {
+      return args.childComplexity + args.field.complexity;
+    } else if (typeof args.field.complexity === 'function') {
+      return args.field.complexity(args.args, args.childComplexity);
+    }
+  };
+}

src/estimators/simple/README.md

@@ -0,0 +1,20 @@
+# Simple Estimator
+
+The simple estimator just adds a fixed complexity to every field that is queried. 
+This can be used as the last estimator in the chain to return the default value. 
+
+## Usage
+
+````typescript
+import queryComplexity, {simpleEstimator} from 'graphql-query-complexity';
+
+const rule = queryComplexity({
+  estimators: [
+    simpleEstimator({
+      // Add a default complexity of 1 for each queried field
+      defaultComplexity: 1
+    })
+  ]
+  // ... other config
+});
+````

src/estimators/simple.ts renamed to src/estimators/simple/index.ts

@@ -1,4 +1,4 @@
-import {ComplexityEstimator, ComplexityEstimatorArgs} from '../QueryComplexity';
+import {ComplexityEstimator, ComplexityEstimatorArgs} from '../../QueryComplexity';
 
 export default function (options?: {defaultComplexity?: number}): ComplexityEstimator {
   const defaultComplexity = options && typeof options.defaultComplexity === 'number' ? options.defaultComplexity : 1;