started to refactor the complexity analysis to use seperate functions for every type of node

Author: evanmcneely

src/analysis/ASTnodefunctions.ts

@@ -0,0 +1,85 @@
+import {
+    DocumentNode,
+    FieldNode,
+    SelectionSetNode,
+    DefinitionNode,
+    Kind,
+    SelectionNode,
+} from 'graphql';
+
+export function fieldNode(
+    node: FieldNode,
+    typeWeights: TypeWeightObject,
+    variables: any | undefined,
+    parent: FieldNode | DefinitionNode
+): number {
+    const complexity = 0;
+    return complexity;
+}
+
+export function selectionNode(
+    node: SelectionNode,
+    typeWeights: TypeWeightObject,
+    variables: any | undefined,
+    parent: DefinitionNode | FieldNode
+): 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);
+    }
+    // TODO: add checks for Kind.FRAGMENT_SPREAD and Kind.INLINE_FRAGMENT here
+    return complexity;
+}
+
+export function selectionSetNode(
+    node: SelectionSetNode,
+    typeWeights: TypeWeightObject,
+    variables: any | undefined,
+    parent: DefinitionNode | FieldNode
+): 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);
+    }
+    return complexity;
+}
+
+export function definitionNode(
+    node: DefinitionNode,
+    typeWeights: TypeWeightObject,
+    variables: any | undefined
+): number {
+    let complexity = 0;
+    // check the kind property against the set of definiton nodes that are possible
+    if (node.kind === Kind.OPERATION_DEFINITION) {
+        // check if the operation is in the type weights object.
+        if (node.operation.toLocaleLowerCase() in typeWeights) {
+            // if it is, it is an object type, add it's type weight to the total
+            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);
+        }
+    }
+    // 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')
+    return complexity;
+}
+
+export function documentNode(
+    node: DocumentNode,
+    typeWeights: TypeWeightObject,
+    variables: any | undefined
+): number {
+    let complexity = 0;
+    // iterate through 'definitions' array on the document node
+    for (let i = 0; i < node.definitions.length; i + 1) {
+        // call the function to handle the various types of definition nodes
+        complexity += definitionNode(node.definitions[i], typeWeights, variables);
+    }
+    return complexity;
+}

src/analysis/typeComplexityAnalysis.ts

@@ -1,4 +1,10 @@
 import { ASTNode, DocumentNode, Kind } from 'graphql';
+import {
+    selectionSetNode,
+    fieldNode,
+    documentNode,
+    operationDefinitionNode,
+} from './ASTnodefunctions';
 
 /**
  * Calculate the complexity for the query by recursivly traversing through the query AST,
@@ -13,55 +19,12 @@ import { ASTNode, DocumentNode, Kind } from 'graphql';
 // TODO add queryVaribables parameter
 function getQueryTypeComplexity(
     queryAST: DocumentNode,
-    varibales: any | undefined,
+    variables: any | undefined,
     typeWeights: TypeWeightObject
 ): number {
-    const getComplexityOfNode = (node: ASTNode, parent: ASTNode = node): number => {
-        let complexity = 0;
-
-        if (node.kind === Kind.DOCUMENT) {
-            // if 'kind' property is a 'Document'
-            // iterate through queryAST.definitions array
-            for (let i = 0; i < node.definitions.length; i + 1) {
-                // call recursive with the definition node
-                complexity += getComplexityOfNode(node.definitions[i], node);
-            }
-        } else if (node.kind === Kind.OPERATION_DEFINITION) {
-            // if 'kind' property is 'operationDefinition'
-            // TODO: case-sensitive
-            if (node.operation.toLocaleLowerCase() in typeWeights) {
-                // check 'operation' value against the type weights and add to total
-                complexity += typeWeights[node.operation].weight;
-                // call recursive with selectionSet property if it is not undefined
-                if (node.selectionSet) complexity += getComplexityOfNode(node.selectionSet, node);
-            }
-        } else if (node.kind === Kind.SELECTION_SET) {
-            // if 'kind' is 'selectionSet'
-            // iterate shrough the 'selections' array of fields
-            for (let i = 0; i < node.selections.length; i + 1) {
-                // call recursive with the field
-                complexity += getComplexityOfNode(node.selections[i], parent); // passing the current parent through because selection sets act only as intermediaries
-            }
-        } else if (node.kind === Kind.FIELD) {
-            // if 'kind' property is 'field'
-            // check the fields name.value against the type weights and total
-            // TODO: case-sensitive
-            if (node.name.value.toLocaleLowerCase() in typeWeights) {
-                // if there is a match, it is an objcet type with feilds,
-                complexity += typeWeights[node.name.value].weight;
-                // call recursive with selectionSet property if it is not undefined
-                if (node.selectionSet) complexity += getComplexityOfNode(node.selectionSet, node);
-                // node.name.value in typeWeights[parent.operation || parent.name.value].fields
-            } else {
-                // TODO: if it is not a match, it is a scalar field or list,
-                // if (parent?.objective !== null) {
-                // }
-                // const weight = typeWeights[parent.name.value].fields[node.name.value];
-            }
-        }
-        return complexity;
-    };
-    return getComplexityOfNode(queryAST);
+    let complexity = 0;
+    complexity += documentNode(queryAST, typeWeights, variables);
+    return complexity;
 }
 
 export default getQueryTypeComplexity;