Refactored Type Weights Object to better handle lists and nesting when calculating query complexity

.vscode/launch.json

@@ -3,7 +3,9 @@
     // Hover to view descriptions of existing attributes.
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
-    "configurations": [{
+    "configurations": [
+
+    {
         "type": "node",
         "request": "launch",
         "name": "Jest Tests",

src/@types/buildTypeWeights.d.ts

@@ -1,7 +1,11 @@
+export interface Field {
+    resolveTo?: string;
+    weight?: FieldWeight;
+}
 export interface Fields {
-    [index: string]: FieldWeight;
+    [index: string]: Field;
 }
-export type WeightFunction = (args: ArgumentNode[]) => number;
+export type WeightFunction = (args: ArgumentNode[], variables, selectionsCost: number) => number;
 export type FieldWeight = number | WeightFunction;
 export interface Type {
     readonly weight: number;
@@ -17,7 +21,13 @@ export interface TypeWeightConfig {
     scalar?: number;
     connection?: number;
 }
-
+export interface TypeWeightSet {
+    mutation: number;
+    query: number;
+    object: number;
+    scalar: number;
+    connection: number;
+}
 type Variables = {
     [index: string]: readonly unknown;
 };

src/analysis/ASTnodefunctions.ts

@@ -6,25 +6,9 @@ import {
     DefinitionNode,
     Kind,
     SelectionNode,
-    ArgumentNode,
+    isConstValueNode,
 } from 'graphql';
 import { FieldWeight, TypeWeightObject, Variables } from '../@types/buildTypeWeights';
-
-// TODO: handle variables and arguments
-// ! this is not functional
-const getArgObj = (args: ArgumentNode[]): { [index: string]: any } => {
-    const argObj: { [index: string]: any } = {};
-    for (let i = 0; i < args.length; i + 1) {
-        const node = args[i];
-        if (args[i].value.kind !== Kind.VARIABLE) {
-            if (args[i].value.kind === Kind.INT) {
-                // FIXME: this does not work
-                argObj[args[i].name.value] = args[i].value;
-            }
-        }
-    }
-    return argObj;
-};
 /**
  * The AST node functions call each other following the nested structure below
  * Each function handles a specific GraphQL AST node type
@@ -52,34 +36,39 @@ export function fieldNode(
     parentName: string
 ): number {
     let complexity = 0;
-    // console.log('fieldNode', node, parentName);
-    // 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;
+    // 'resolvedTypeName' is the name of the Schema Type that this field resolves to
+    const resolvedTypeName =
+        node.name.value in typeWeights
+            ? node.name.value
+            : typeWeights[parentName].fields[node.name.value]?.resolveTo || null;
+
+    if (resolvedTypeName) {
+        // field resolves to an object or a list with possible selections
+        let selectionsCost = 0;
+        let calculatedWeight = 0;
+        const weightFunction = typeWeights[parentName]?.fields[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(
+            selectionsCost += selectionSetNode(
                 node.selectionSet,
                 typeWeights,
                 variables,
-                node.name.value
+                resolvedTypeName
             );
         }
+        // if there are arguments and this is a list, call the 'weightFunction' to get the weight of this field. otherwise the weight is static and can be accessed through the typeWeights object
+        if (node.arguments && typeof weightFunction === 'function') {
+            calculatedWeight += weightFunction([...node.arguments], variables, selectionsCost);
+        } else {
+            calculatedWeight += typeWeights[resolvedTypeName].weight + selectionsCost;
+        }
+        complexity += calculatedWeight;
     } else {
-        // otherwise the field is a scalar or a list.
-        const fieldWeight: 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 if (node.arguments) {
-            // BUG: This code is reached when fieldWeight is undefined, which could result from an invalid query or this type
-            // missing from the typeWeight object. If left unhandled an error is thrown
-            // otherwise the the feild weight is a list, invoke the function with variables
-            // TODO: calculate the complexity for lists with arguments and varibales
-            // ! this is not functional
-            // iterate through the arguments to build the object to
-            complexity += fieldWeight([...node.arguments]);
+        // field is a scalar and 'weight' is a number
+        const { weight } = typeWeights[parentName].fields[node.name.value];
+        if (typeof weight === 'number') {
+            complexity += weight;
         }
     }
     return complexity;
@@ -92,7 +81,6 @@ export function selectionNode(
     parentName: string
 ): number {
     let complexity = 0;
-    // console.log('selectionNode', node, parentName);
     // 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
@@ -101,7 +89,6 @@ export function selectionNode(
     // TODO: add checks for Kind.FRAGMENT_SPREAD and Kind.INLINE_FRAGMENT here
     return complexity;
 }
-
 export function selectionSetNode(
     node: SelectionSetNode,
     typeWeights: TypeWeightObject,
@@ -130,14 +117,16 @@ export function definitionNode(
         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;
+            // console.log(`the weight of ${node.operation} is ${complexity}`);
             // call the function to handle selection set node with selectionSet property if it is not undefined
-            if (node.selectionSet)
+            if (node.selectionSet) {
                 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')