feat: generate searchable aggregateItems 2 additional levels (#268)

Author: sundersc

packages/graphql-docs-generator/__tests__/generator/getFields.test.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLInterfaceType, GraphQLUnionType } from 'graphql';
+import { GraphQLSchema, GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLInterfaceType, GraphQLUnionType, GraphQLFloat } from 'graphql';
 
 import getFields from '../../src/generator/getFields';
 import getFragment from '../../src/generator/getFragment';
@@ -185,4 +185,73 @@ describe('getField', () => {
       expect(getFragment.mock.calls[1][3]).toEqual(commonField);
     });
   });
+
+  describe('aggregateItems should generate two additional levels', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+    const aggregateScalarResult = new GraphQLObjectType({
+      name: 'SearchableAggregateScalarResult',
+      fields: {
+        value: { type: GraphQLFloat },
+      },
+    });
+
+    const aggregateBucketResultItem = new GraphQLObjectType({
+      name: 'SearchableAggregateBucketResultItem',
+      fields: {
+        key: { type: GraphQLString },
+        doc_count: { type: GraphQLInt },
+      },
+    });
+
+    const aggregateBucketResult = new GraphQLObjectType({
+      name: 'SearchableAggregateBucketResult',
+      fields: {
+        buckets: { type: aggregateBucketResultItem },
+      },
+    });
+    
+    const aggregateResult = new GraphQLUnionType({
+      name: 'SearchableAggregateGenericResult',
+      types: [aggregateScalarResult, aggregateBucketResult],
+    });
+
+    const aggregateItemsObject = new GraphQLObjectType({
+      name: 'SearchableAggregateResult',
+      fields: {
+        name: { type: GraphQLString },
+        result: { type: aggregateResult },
+      },
+    });
+
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          aggregateItems: { type: aggregateItemsObject },
+        },
+      }),
+    });
+
+    it('aggregateItems property should traverse two additional levels to generate required fields with default depth 2', () => {
+      const maxDepth = 2;
+      const getPossibleTypeSpy = jest.spyOn(schema, 'getPossibleTypes');
+      getFields(schema.getQueryType().getFields().aggregateItems, schema, maxDepth, { useExternalFragmentForS3Object: false });
+      expect(getPossibleTypeSpy).toHaveBeenCalled();
+      expect(getFragment).toHaveBeenCalled();
+
+      const commonField = []; // unions don't have to have common field
+
+      expect(getFragment.mock.calls[0][0]).toEqual(aggregateScalarResult);
+      expect(getFragment.mock.calls[0][1]).toEqual(schema);
+      expect(getFragment.mock.calls[0][2]).toEqual(maxDepth - 1);
+      expect(getFragment.mock.calls[0][3]).toEqual(commonField);
+
+      expect(getFragment.mock.calls[1][0]).toEqual(aggregateBucketResult);
+      expect(getFragment.mock.calls[1][1]).toEqual(schema);
+      expect(getFragment.mock.calls[1][2]).toEqual(maxDepth - 1);
+      expect(getFragment.mock.calls[1][3]).toEqual(commonField);
+    });
+  });
 });

packages/graphql-docs-generator/src/generator/getFields.ts

@@ -11,6 +11,7 @@ import {
   isUnionType,
   isEnumType,
   isScalarType,
+  isListType,
 } from 'graphql';
 import getFragment from './getFragment';
 import { GQLConcreteType, GQLTemplateField, GQLTemplateFragment, GQLDocsGenOptions } from './types';
@@ -36,7 +37,7 @@ export default function getFields(
   const fields: Array<GQLTemplateField> = Object.keys(subFields)
     .map(fieldName => {
       const subField = subFields[fieldName];
-      return getFields(subField, schema, depth - 1, options);
+      return getFields(subField, schema, adjustDepth(subField, depth), options);
     })
     .filter(f => f);
   const fragments: Array<GQLTemplateFragment> = Object.keys(subFragments)
@@ -61,3 +62,24 @@ export default function getFields(
     hasBody: !!(fields.length || fragments.length),
   };
 }
+
+function adjustDepth(field, depth) {
+  const maxDepth = 100;
+  if (isGraphQLAggregateField(field) && depth < maxDepth) {
+    return depth + 1;
+  } else if (depth >= maxDepth) {
+    throw new Error('Statement generation depth exceeded the maximum allowed limit');
+  }
+  return depth - 1;
+}
+
+function isGraphQLAggregateField(field) {
+  if (
+    field &&
+    field.name == 'aggregateItems' &&
+    field.type?.ofType?.name == 'SearchableAggregateResult'
+  ) {
+    return true;
+  }
+  return false;
+}