refactored the type complexity analysis to use several functions, each handling the nuance of a different AST node.

Author: evanmcneely

src/@types/buildTypeWeights.d.ts

@@ -1,5 +1,5 @@
 interface Fields {
-    readonly [index: string]: number | ((arg: number, type: Type) => number);
+    readonly [index: string]: number | ((arg: { [index: string]: any }) => number);
 }
 
 interface Type {

src/analysis/ASTnodefunctions.ts

@@ -1,33 +1,70 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
 import {
     DocumentNode,
     FieldNode,
     SelectionSetNode,
     DefinitionNode,
     Kind,
     SelectionNode,
+    ArgumentNode,
 } from 'graphql';
 
+// const getArgObj = (args: ArgumentNode[]): { [index: string]: any } => {
+//     const argObj: { [index: string]: any } = {};
+//     for (let i = 0; i < args.length; i + 1) {
+//         if (args[i].kind === Kind.BOOLEAN) {
+//             argObj[args[i].name.value] = args[i].value.value;
+//         }
+//     }
+//     return argObj;
+// };
+
 export function fieldNode(
     node: FieldNode,
     typeWeights: TypeWeightObject,
     variables: any | undefined,
-    parent: FieldNode | DefinitionNode
+    parentName: string
 ): number {
-    const complexity = 0;
+    let complexity = 0;
+    // check if the field name is in the type weight object.
+    if (node.name.value.toLocaleLowerCase() in typeWeights) {
+        // if it is, than the field is an object type, add itss type weight to the total
+        complexity += typeWeights[node.name.value].weight;
+        // call the function to handle selection set node with selectionSet property if it is not undefined
+        if (node.selectionSet)
+            complexity *= selectionSetNode(
+                node.selectionSet,
+                typeWeights,
+                variables,
+                node.name.value
+            );
+    } else {
+        // otherwise the field is a scalar or a list.
+        const fieldWeight = typeWeights[parentName].fields[node.name.value];
+        if (typeof fieldWeight === 'number') {
+            // if the feild weight is a number, add the number to the total complexity
+            complexity += fieldWeight;
+        } else {
+            // otherwise the the feild weight is a list, invoke the function with variables
+            // TODO: calculate the complexity for lists with arguments and varibales
+            // iterate through the arguments to build the object to
+            // complexity += fieldWeight(getArgObj(node.arguments));
+        }
+    }
     return complexity;
 }
 
 export function selectionNode(
     node: SelectionNode,
     typeWeights: TypeWeightObject,
     variables: any | undefined,
-    parent: DefinitionNode | FieldNode
+    parentName: string
 ): number {
     let complexity = 0;
     // check the kind property against the set of selection nodes that are possible
     if (node.kind === Kind.FIELD) {
-        // call the function that handle field nodes and multiply the result into complexity to accound for nested fields
-        complexity *= fieldNode(node, typeWeights, variables, parent);
+        // call the function that handle field nodes
+        complexity += fieldNode(node, typeWeights, variables, parentName);
     }
     // TODO: add checks for Kind.FRAGMENT_SPREAD and Kind.INLINE_FRAGMENT here
     return complexity;
@@ -37,14 +74,14 @@ export function selectionSetNode(
     node: SelectionSetNode,
     typeWeights: TypeWeightObject,
     variables: any | undefined,
-    parent: DefinitionNode | FieldNode
+    parentName: string
 ): number {
     let complexity = 0;
     // iterate shrough the 'selections' array on the seletion set node
     for (let i = 0; i < node.selections.length; i + 1) {
         // call the function to handle seletion nodes
         // pass the current parent through because selection sets act only as intermediaries
-        complexity += selectionNode(node.selections[i], typeWeights, variables, parent);
+        complexity += selectionNode(node.selections[i], typeWeights, variables, parentName);
     }
     return complexity;
 }
@@ -63,7 +100,12 @@ export function definitionNode(
             complexity += typeWeights[node.operation].weight;
             // call the function to handle selection set node with selectionSet property if it is not undefined
             if (node.selectionSet)
-                complexity += selectionSetNode(node.selectionSet, typeWeights, variables, node);
+                complexity += selectionSetNode(
+                    node.selectionSet,
+                    typeWeights,
+                    variables,
+                    node.operation
+                );
         }
     }
     // TODO: add checks for Kind.FRAGMENT_DEFINITION here (there are other type definition nodes that i think we can ignore. see ast.d.ts in 'graphql')

src/analysis/typeComplexityAnalysis.ts

@@ -16,7 +16,6 @@ import {
  * @param {any | undefined} varibales
  * @param {TypeWeightObject} typeWeights
  */
-// TODO add queryVaribables parameter
 function getQueryTypeComplexity(
     queryAST: DocumentNode,
     variables: any | undefined,