discovered bug that calculated query complxity wrong when object weight was set to zero

Author: evanmcneely

src/@types/buildTypeWeights.d.ts

@@ -21,6 +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/buildTypeWeights.ts

@@ -23,30 +23,27 @@ import { ObjMap } from 'graphql/jsutils/ObjMap';
 import { GraphQLSchema } from 'graphql/type/schema';
 import {
     TypeWeightConfig,
+    TypeWeightSet,
     TypeWeightObject,
     Variables,
     Type,
-    Field,
 } from '../@types/buildTypeWeights';
 
 export const KEYWORDS = ['first', 'last', 'limit'];
-type ListType =
-    | GraphQLScalarType<unknown, unknown>
-    | GraphQLObjectType<any, any>
-    | GraphQLList<GraphQLOutputType>
-    | GraphQLOutputType;
+
 // These variables exist to provide a default value for typescript when accessing a weight
 // since all props are optioal in TypeWeightConfig
 const DEFAULT_MUTATION_WEIGHT = 10;
 const DEFAULT_OBJECT_WEIGHT = 1;
 const DEFAULT_SCALAR_WEIGHT = 0;
 const DEFAULT_CONNECTION_WEIGHT = 2;
 const DEFAULT_QUERY_WEIGHT = 1;
-export const defaultTypeWeightsConfig: TypeWeightConfig = {
+export const defaultTypeWeightsConfig: TypeWeightSet = {
     mutation: DEFAULT_MUTATION_WEIGHT,
     object: DEFAULT_OBJECT_WEIGHT,
     scalar: DEFAULT_SCALAR_WEIGHT,
     connection: DEFAULT_CONNECTION_WEIGHT,
+    query: DEFAULT_QUERY_WEIGHT,
 };
 
 // FIXME: What about Interface defaults
@@ -56,24 +53,24 @@ export const defaultTypeWeightsConfig: TypeWeightConfig = {
  *
  * @param {(GraphQLObjectType | GraphQLInterfaceType)} type
  * @param {TypeWeightObject} typeWeightObject
- * @param {TypeWeightConfig} typeWeights
+ * @param {TypeWeightSet} typeWeights
  * @return {*}  {Type}
  */
 function parseObjectFields(
     type: GraphQLObjectType | GraphQLInterfaceType,
     typeWeightObject: TypeWeightObject,
-    typeWeights: TypeWeightConfig
+    typeWeights: TypeWeightSet
 ): Type {
     let result: Type;
     switch (type.name) {
         case 'Query':
-            result = { weight: typeWeights.query || DEFAULT_QUERY_WEIGHT, fields: {} };
+            result = { weight: typeWeights.query, fields: {} };
             break;
         case 'Mutation':
-            result = { weight: typeWeights.mutation || DEFAULT_MUTATION_WEIGHT, fields: {} };
+            result = { weight: typeWeights.mutation, fields: {} };
             break;
         default:
-            result = { weight: typeWeights.object || DEFAULT_OBJECT_WEIGHT, fields: {} };
+            result = { weight: typeWeights.object, fields: {} };
             break;
     }
 
@@ -88,7 +85,7 @@ function parseObjectFields(
             (isNonNullType(fieldType) && isScalarType(fieldType.ofType))
         ) {
             result.fields[field] = {
-                weight: typeWeights.scalar || DEFAULT_SCALAR_WEIGHT,
+                weight: typeWeights.scalar,
             };
         } else if (
             isInterfaceType(fieldType) ||
@@ -105,7 +102,7 @@ function parseObjectFields(
             if (isScalarType(listType) && typeWeights.scalar === 0) {
                 // list won't compound if weight is zero
                 result.fields[field] = {
-                    weight: typeWeights.scalar || DEFAULT_SCALAR_WEIGHT,
+                    weight: typeWeights.scalar,
                 };
             } else if (isEnumType(listType) && typeWeights.scalar === 0) {
                 // list won't compound if weight of enum is zero
@@ -131,7 +128,7 @@ function parseObjectFields(
                                 );
                                 const weight = isCompositeType(listType)
                                     ? typeWeightObject[listType.name.toLowerCase()].weight
-                                    : typeWeights.scalar || DEFAULT_SCALAR_WEIGHT; // Note this includes enums
+                                    : typeWeights.scalar; // Note this includes enums
                                 if (limitArg) {
                                     const node: ValueNode = limitArg.value;
                                     let multiplier = 1;
@@ -175,7 +172,7 @@ function parseObjectFields(
  * @param typeWeights
  * @returns
  */
-function parseTypes(schema: GraphQLSchema, typeWeights: TypeWeightConfig): TypeWeightObject {
+function parseTypes(schema: GraphQLSchema, typeWeights: TypeWeightSet): TypeWeightObject {
     const typeMap: ObjMap<GraphQLNamedType> = schema.getTypeMap();
 
     const result: TypeWeightObject = {};
@@ -193,13 +190,13 @@ function parseTypes(schema: GraphQLSchema, typeWeights: TypeWeightConfig): TypeW
             } else if (isEnumType(currentType)) {
                 result[typeName] = {
                     fields: {},
-                    weight: typeWeights.scalar || DEFAULT_SCALAR_WEIGHT,
+                    weight: typeWeights.scalar,
                 };
             } else if (isUnionType(currentType)) {
                 // FIXME: will need information on fields inorder calculate comlpextiy
                 result[typeName] = {
                     fields: {},
-                    weight: typeWeights.object || DEFAULT_OBJECT_WEIGHT,
+                    weight: typeWeights.object,
                 };
             } else {
                 // ? what else can get through here
@@ -230,7 +227,7 @@ function buildTypeWeightsFromSchema(
     if (!schema) throw new Error('Missing Argument: schema is required');
 
     //  Merge the provided type weights with the default to account for missing values
-    const typeWeights: TypeWeightConfig = {
+    const typeWeights: TypeWeightSet = {
         ...defaultTypeWeightsConfig,
         ...typeWeightsConfig,
     };

test/analysis/buildTypeWeights.test.ts

@@ -565,6 +565,18 @@ describe('Test buildTypeWeightsFromSchema function', () => {
             expect(typeWeightObject).toEqual(expectedOutput);
         });
 
+        test('object parameter set to 0', () => {
+            const typeWeightObject = buildTypeWeightsFromSchema(schema, {
+                object: 0,
+            });
+
+            expectedOutput.user.weight = 0;
+            expectedOutput.movie.weight = 0;
+            // expectedOutput.query.weight = 2;
+
+            expect(typeWeightObject).toEqual(expectedOutput);
+        });
+
         test('scalar parameter', () => {
             const typeWeightObject = buildTypeWeightsFromSchema(schema, {
                 scalar: 2,

test/analysis/typeComplexityAnalysis.test.ts

@@ -228,6 +228,11 @@ describe('Test getQueryTypeComplexity function', () => {
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(2); // Query 1 + Scalars 1
         });
 
+        xtest('with one with capital first letter for field', () => {
+            query = `query { Scalars { num } }`;
+            expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(2); // Query 1 + Scalars 1
+        });
+
         test('with two or more fields', () => {
             query = `query { scalars { num } test { name } }`;
             expect(getQueryTypeComplexity(parse(query), variables, typeWeights)).toBe(3); // Query 1 + scalars 1 + test 1

test/analysis/weightFunction.test.ts

@@ -97,7 +97,7 @@ describe('Weight Function correctly parses Argument Nodes if', () => {
         });
         const query = `query { heroes(episode: NEWHOPE, first: 3) { stars, episode } }`;
         const queryAST: DocumentNode = parse(query);
-        expect(getQueryTypeComplexity(queryAST, {}, customTypeWeights)).toBe(4); // 1 query and 4 enums
+        expect(getQueryTypeComplexity(queryAST, {}, customTypeWeights)).toBe(1); // 1 query
     });
     test('a custom scalar weight was set to greater than 0', () => {
         const customTypeWeights: TypeWeightObject = buildTypeWeightsFromSchema(schema, {