Fix linter setup

.eslintignore

@@ -0,0 +1,2 @@
+/node_modules
+/dist

.eslintrc

@@ -13,15 +13,8 @@
     "env": {
         "browser": true,
         "es6": true,
-        "node": true
-    },
-
-    "globals": {
-        "describe": true,
-        "expect": true,
-        "it": true,
-        "before": true,
-        "after": true
+        "node": true,
+        "mocha": true
     },
 
     "parserOptions": {
@@ -226,4 +219,4 @@
         "wrap-regex": 0,
         "yoda": [2, "never", {"exceptRange": true}]
     }
-}
+}

package.json

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

src/QueryComplexity.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-use-before-define */
 /**
  * Created by Ivo Meißner on 28.07.17.
  */
@@ -11,11 +13,9 @@ import {
   ValidationContext,
   FragmentDefinitionNode,
   OperationDefinitionNode,
-  DirectiveNode,
   FieldNode,
   FragmentSpreadNode,
   InlineFragmentNode,
-  assertCompositeType,
   GraphQLField, isCompositeType, GraphQLCompositeType, GraphQLFieldMap,
   GraphQLSchema, DocumentNode, TypeInfo,
   visit, visitWithTypeInfo,
@@ -31,11 +31,11 @@ import {
 } from 'graphql';
 
 export type ComplexityEstimatorArgs = {
-  type: GraphQLCompositeType,
-  field: GraphQLField<any, any>,
-  node: FieldNode,
-  args: {[key: string]: any},
-  childComplexity: number
+  type: GraphQLCompositeType;
+  field: GraphQLField<any, any>;
+  node: FieldNode;
+  args: {[key: string]: any};
+  childComplexity: number;
 }
 
 export type ComplexityEstimator = (options: ComplexityEstimatorArgs) => number | void;
@@ -45,27 +45,27 @@ export type Complexity = any;
 
 // Map of complexities for possible types (of Union, Interface types)
 type ComplexityMap = {
-  [typeName: string]: number,
+  [typeName: string]: number;
 }
 
 export interface QueryComplexityOptions {
   // The maximum allowed query complexity, queries above this threshold will be rejected
-  maximumComplexity: number,
+  maximumComplexity: number;
 
   // The query variables. This is needed because the variables are not available
   // in the visitor of the graphql-js library
-  variables?: Object,
+  variables?: Record<string, any>;
 
   // specify operation name only when pass multi-operation documents
-  operationName?: string,
+  operationName?: string;
 
   // Optional callback function to retrieve the determined query complexity
   // Will be invoked whether the query is rejected or not
   // This can be used for logging or to implement rate limiting
-  onComplete?: (complexity: number) => void,
+  onComplete?: (complexity: number) => void;
 
   // Optional function to create a custom error
-  createError?: (max: number, actual: number) => GraphQLError,
+  createError?: (max: number, actual: number) => GraphQLError;
 
   // An array of complexity estimators to use for estimating the complexity
   estimators: Array<ComplexityEstimator>;
@@ -79,11 +79,11 @@ function queryComplexityMessage(max: number, actual: number): string {
 }
 
 export function getComplexity(options: {
-  estimators: ComplexityEstimator[],
-  schema: GraphQLSchema,
-  query: DocumentNode,
-  variables?: Object,
-  operationName?: string
+  estimators: ComplexityEstimator[];
+  schema: GraphQLSchema;
+  query: DocumentNode;
+  variables?: Record<string, any>;
+  operationName?: string;
 }): number {
   const typeInfo = new TypeInfo(options.schema);
 
@@ -104,7 +104,7 @@ export default class QueryComplexity {
   context: ValidationContext;
   complexity: number;
   options: QueryComplexityOptions;
-  OperationDefinition: Object;
+  OperationDefinition: Record<string, any>;
   estimators: Array<ComplexityEstimator>;
   includeDirectiveDef: GraphQLDirective;
   skipDirectiveDef: GraphQLDirective;
@@ -123,15 +123,15 @@ export default class QueryComplexity {
 
     this.includeDirectiveDef = this.context.getSchema().getDirective('include');
     this.skipDirectiveDef = this.context.getSchema().getDirective('skip');
-    this.estimators = options.estimators
+    this.estimators = options.estimators;
 
     this.OperationDefinition = {
       enter: this.onOperationDefinitionEnter,
       leave: this.onOperationDefinitionLeave
     };
   }
 
-  onOperationDefinitionEnter(operation: OperationDefinitionNode) {
+  onOperationDefinitionEnter(operation: OperationDefinitionNode): void {
     if (typeof this.options.operationName === 'string' && this.options.operationName !== operation.name.value) {
       return;
     }
@@ -181,7 +181,7 @@ export default class QueryComplexity {
     typeDef: GraphQLObjectType | GraphQLInterfaceType | GraphQLUnionType,
   ): number {
     if (node.selectionSet) {
-      let fields:GraphQLFieldMap<any, any> = {};
+      let fields: GraphQLFieldMap<any, any> = {};
       if (typeDef instanceof GraphQLObjectType || typeDef instanceof GraphQLInterfaceType) {
         fields = typeDef.getFields();
       }
@@ -191,18 +191,19 @@ export default class QueryComplexity {
       if (isAbstractType(typeDef)) {
         possibleTypeNames = this.context.getSchema().getPossibleTypes(typeDef).map(t => t.name);
       } else {
-        possibleTypeNames = [typeDef.name];
+        possibleTypeNames = [ typeDef.name ];
       }
 
       // Collect complexities for all possible types individually
       const selectionSetComplexities: ComplexityMap = node.selectionSet.selections.reduce(
         (complexities: ComplexityMap, childNode: FieldNode | FragmentSpreadNode | InlineFragmentNode) => {
           // let nodeComplexity = 0;
+          let innerComplexities = complexities;
 
           let includeNode = true;
           let skipNode = false;
 
-          childNode.directives?.forEach((directive: DirectiveNode) => {
+          for (const directive of childNode.directives ?? []) {
             const directiveName = directive.name.value;
             switch (directiveName) {
               case 'include': {
@@ -216,7 +217,7 @@ export default class QueryComplexity {
                 break;
               }
             }
-          });
+          }
 
           if (!includeNode || skipNode) {
             return complexities;
@@ -258,7 +259,7 @@ export default class QueryComplexity {
                 const tmpComplexity = estimator(estimatorArgs);
 
                 if (typeof tmpComplexity === 'number' && !isNaN(tmpComplexity)) {
-                  complexities = addComplexities(
+                  innerComplexities = addComplexities(
                     tmpComplexity,
                     complexities,
                     possibleTypeNames,
@@ -292,17 +293,17 @@ export default class QueryComplexity {
               const nodeComplexity = this.nodeComplexity(fragment, fragmentType);
               if (isAbstractType(fragmentType)) {
                 // Add fragment complexity for all possible types
-                complexities = addComplexities(
+                innerComplexities = addComplexities(
                   nodeComplexity,
                   complexities,
                   this.context.getSchema().getPossibleTypes(fragmentType).map(t => t.name),
                 );
               } else {
                 // Add complexity for object type
-                complexities = addComplexities(
+                innerComplexities = addComplexities(
                   nodeComplexity,
                   complexities,
-                  [fragmentType.name],
+                  [ fragmentType.name ],
                 );
               }
               break;
@@ -319,23 +320,23 @@ export default class QueryComplexity {
               const nodeComplexity = this.nodeComplexity(childNode, inlineFragmentType);
               if (isAbstractType(inlineFragmentType)) {
                 // Add fragment complexity for all possible types
-                complexities = addComplexities(
+                innerComplexities = addComplexities(
                   nodeComplexity,
                   complexities,
                   this.context.getSchema().getPossibleTypes(inlineFragmentType).map(t => t.name),
                 );
               } else {
                 // Add complexity for object type
-                complexities = addComplexities(
+                innerComplexities = addComplexities(
                   nodeComplexity,
                   complexities,
-                  [inlineFragmentType.name],
+                  [ inlineFragmentType.name ],
                 );
               }
               break;
             }
             default: {
-              complexities = addComplexities(
+              innerComplexities = addComplexities(
                 this.nodeComplexity(childNode, typeDef),
                 complexities,
                 possibleTypeNames,
@@ -344,7 +345,7 @@ export default class QueryComplexity {
             }
           }
 
-          return complexities;
+          return innerComplexities;
         }, {});
       // Only return max complexity of all possible types
       if (!selectionSetComplexities) {
@@ -381,8 +382,8 @@ function addComplexities(
   possibleTypes: string[],
 ): ComplexityMap {
   for (const type of possibleTypes) {
-    if (complexityMap.hasOwnProperty(type)) {
-      complexityMap[type] = complexityMap[type] + complexity;
+    if (Object.prototype.hasOwnProperty.call(complexityMap, type)) {
+      complexityMap[type] += complexity;
     } else {
       complexityMap[type] = complexity;
     }

src/__tests__/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  rules: {
+    '@typescript-eslint/explicit-function-return-type': "off"
+  }
+}

src/__tests__/fixtures/CompatibleValidationContext.ts

@@ -1,6 +1,6 @@
-import { GraphQLError, TypeInfo, ValidationContext } from "graphql";
-import { GraphQLSchema } from "graphql/type/schema";
-import { DocumentNode } from "graphql/language/ast";
+import { GraphQLError, TypeInfo, ValidationContext } from 'graphql';
+import { GraphQLSchema } from 'graphql/type/schema';
+import { DocumentNode } from 'graphql/language/ast';
 
 /**
  * This class is used to test that validation errors are raised correctly
@@ -18,11 +18,12 @@ export class CompatibleValidationContext extends ValidationContext {
     private errors: GraphQLError[] = []
 
     constructor(schema: GraphQLSchema, ast: DocumentNode, typeInfo: TypeInfo) {
-        super(schema, ast, typeInfo, err => this.errors.push(err));
+      super(schema, ast, typeInfo, err => this.errors.push(err));
     }
 
     getErrors(): ReadonlyArray<GraphQLError> {
-        // @ts-ignore
-        return super.getErrors ? super.getErrors() : this.errors
+      // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+      // @ts-ignore
+      return super.getErrors ? super.getErrors() : this.errors;
     }
 }

src/__tests__/fixtures/schema.ts

@@ -63,14 +63,6 @@ const NameInterface = new GraphQLInterfaceType({
   resolveType: () => Item
 });
 
-const UnionInterface = new GraphQLInterfaceType({
-  name: 'UnionInterface',
-  fields: () => ({
-    union: { type: Union }
-  }),
-  resolveType: () => Item
-});
-
 const SecondItem = new GraphQLObjectType({
   name: 'SecondItem',
   fields: () => ({
@@ -95,6 +87,14 @@ const Union = new GraphQLUnionType({
   resolveType: () => Item
 });
 
+const UnionInterface = new GraphQLInterfaceType({
+  name: 'UnionInterface',
+  fields: () => ({
+    union: { type: Union }
+  }),
+  resolveType: () => Item
+});
+
 const SDLInterface = new GraphQLInterfaceType({
   name: 'SDLInterface',
   fields: {
@@ -108,7 +108,7 @@ const SDL = new GraphQLObjectType({
   fields: {
     sdl: { type: GraphQLString }
   },
-  interfaces: () => [SDLInterface],
+  interfaces: () => [ SDLInterface ],
 });
 
 const Query = new GraphQLObjectType({
@@ -161,7 +161,7 @@ const Query = new GraphQLObjectType({
     },
     _service: {type: SDLInterface},
   }),
-  interfaces: () => [NameInterface, UnionInterface,]
+  interfaces: () => [ NameInterface, UnionInterface, ]
 });
 
 export default new GraphQLSchema({

src/estimators/directive/__tests__/directiveEstimator-test.ts

@@ -253,7 +253,7 @@ describe('directiveEstimator analysis', () => {
   it('should create complexity directive that can be used to generate directive definition', () => {
     const complexityDirective = createComplexityDirective();
     const codeFirstSchema = new GraphQLSchema({
-      directives: [complexityDirective]
+      directives: [ complexityDirective ]
     });
 
     // rebuilding code first schema
@@ -270,7 +270,7 @@ describe('directiveEstimator analysis', () => {
   it('should create complexity directive with configured name', () => {
     const complexityDirective = createComplexityDirective({name: 'cost'});
     const codeFirstSchema = new GraphQLSchema({
-      directives: [complexityDirective]
+      directives: [ complexityDirective ]
     });
 
     // rebuilding code first schema

src/estimators/directive/index.ts

@@ -5,10 +5,10 @@ import { DirectiveLocation } from 'graphql/language/directiveLocation';
 import get from 'lodash.get';
 
 export type ComplexityDirectiveOptions = {
-  name?: string
+  name?: string;
 }
 
-export function createComplexityDirective(options?: ComplexityDirectiveOptions) {
+export function createComplexityDirective(options?: ComplexityDirectiveOptions): GraphQLDirective {
   const mergedOptions = {
     name: 'complexity',
     ...(options || {})
@@ -35,7 +35,7 @@ export function createComplexityDirective(options?: ComplexityDirectiveOptions)
 export default function (options: ComplexityDirectiveOptions = {}): ComplexityEstimator {
   const directive = createComplexityDirective(options);
 
-  return (args: ComplexityEstimatorArgs) => {
+  return (args: ComplexityEstimatorArgs): number | void => {
     // Ignore if astNode is undefined
     if (!args.field.astNode) {
       return;

src/estimators/fieldExtensions/__tests__/fixtures/schema.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
 /**
  * Created by Ivo Meißner on 28.07.17.
  */