Further improve infer fields recursion (#2452)

* add another test for type inference recursion, convert checking to use Set()

* also test type inference recursion for objects with no further keys, and ID scalar

* handle ID scalars in type inference, and ensure no fieldless object types

packages/gatsby/src/schema/__tests__/infer-graphql-input-type-from-fields-test.js

@@ -2,6 +2,7 @@ const {
   GraphQLBoolean,
   GraphQLFloat,
   GraphQLInt,
+  GraphQLID,
   GraphQLNonNull,
   GraphQLString,
   GraphQLObjectType,
@@ -23,6 +24,14 @@ function isIntInput(type) {
   })
 }
 
+function isIdInput(type) {
+  expect(type instanceof GraphQLInputObjectType).toBeTruthy()
+  expect(type.getFields()).toEqual({
+    eq: { name: `eq`, type: GraphQLID },
+    ne: { name: `ne`, type: GraphQLID },
+  })
+}
+
 function isStringInput(type) {
   expect(type instanceof GraphQLInputObjectType).toBeTruthy()
   expect(type.getFields()).toEqual({
@@ -133,12 +142,42 @@ describe(`GraphQL Input args from fields, test-only`, () => {
     isStringInput(innerObjFields.foo.type)
   })
 
+  it(`handles lists within lists`, async () => {
+    const Row = new GraphQLObjectType({
+      name: `Row`,
+      fields: () => {
+        return {
+          cells: typeField(new GraphQLList(Cell)),
+        }
+      },
+    })
+
+    const Cell = new GraphQLObjectType({
+      name: `Cell`,
+      fields: () => {
+        return {
+          value: typeField(GraphQLInt),
+        }
+      },
+    })
+
+    const fields = {
+      rows: typeField(new GraphQLList(Row)),
+    }
+
+    expect(() => {
+      inferInputObjectStructureFromFields({
+        fields,
+        typeName: `ListTypes`,
+      })
+    }).not.toThrow()
+  })
+
   it(`protects against infinite recursion on circular definitions`, async () => {
     const TypeA = new GraphQLObjectType({
       name: `TypeA`,
       fields: () => {
         return {
-          foo: typeField(GraphQLInt),
           typeb: typeField(TypeB),
         }
       },
@@ -148,7 +187,7 @@ describe(`GraphQL Input args from fields, test-only`, () => {
       name: `TypeB`,
       fields: () => {
         return {
-          bar: typeField(GraphQLInt),
+          bar: typeField(GraphQLID),
           typea: typeField(TypeA),
         }
       },
@@ -175,17 +214,20 @@ describe(`GraphQL Input args from fields, test-only`, () => {
 
     expect(entryPointA instanceof GraphQLInputObjectType).toBeTruthy()
     expect(entryPointB instanceof GraphQLInputObjectType).toBeTruthy()
-    isIntInput(entryPointAFields.foo.type)
-    isIntInput(entryPointBFields.bar.type)
+    isIdInput(entryPointBFields.bar.type)
 
     // next level should also work, ie. typeA -> type B
     const childAB = entryPointAFields.typeb.type
     const childABFields = childAB.getFields()
     expect(childAB instanceof GraphQLInputObjectType).toBeTruthy()
-    isIntInput(childABFields.bar.type)
+    isIdInput(childABFields.bar.type)
 
     // circular level should not be here, ie. typeA -> typeB -> typeA
     expect(childABFields.typea).toBeUndefined()
+
+    // in the other direction, from entryPointB -> typeA, the latter shouldn't exist, 
+    // due to having no further non-circular fields to filter
+    expect(entryPointBFields.typea).toBeUndefined()
   })
 
   it(`recovers from unknown output types`, async () => {

packages/gatsby/src/schema/infer-graphql-input-fields-from-fields.js

@@ -6,6 +6,7 @@ const {
   GraphQLString,
   GraphQLFloat,
   GraphQLInt,
+  GraphQLID,
   GraphQLList,
   GraphQLEnumType,
   GraphQLNonNull,
@@ -37,23 +38,27 @@ function makeNullable(type: GraphQLInputType): GraphQLNullableInputType<any> {
 
 function convertToInputType(
   type: GraphQLType,
-  typeMap: any
+  typeMap: Set
 ): ?GraphQLInputType {
   // track types already processed in current tree, to avoid infinite recursion
-  if (typeMap[type.name]) {
+  if (typeMap.has(type)) {
     return null
   }
-  const nextTypeMap = { ...typeMap, [type.name]: true }
+  const nextTypeMap = new Set([...typeMap, type])
 
   if (type instanceof GraphQLScalarType || type instanceof GraphQLEnumType) {
     return type
   } else if (type instanceof GraphQLObjectType) {
+    const fields = _.transform(type.getFields(), (out, fieldConfig, key) => {
+      const type = convertToInputType(fieldConfig.type, nextTypeMap)
+      if (type) out[key] = { type }
+    })
+    if (Object.keys(fields).length===0) {
+      return null
+    }
     return new GraphQLInputObjectType({
       name: createTypeName(`${type.name}InputObject`),
-      fields: _.transform(type.getFields(), (out, fieldConfig, key) => {
-        const type = convertToInputType(fieldConfig.type, nextTypeMap)
-        if (type) out[key] = { type }
-      }),
+      fields,
     })
   } else if (type instanceof GraphQLList) {
     let innerType = convertToInputType(type.ofType, nextTypeMap)
@@ -85,6 +90,10 @@ const scalarFilterMap = {
     eq: { type: GraphQLFloat },
     ne: { type: GraphQLFloat },
   },
+  ID: {
+    eq: { type: GraphQLID },
+    ne: { type: GraphQLID },
+  },
   String: {
     eq: { type: GraphQLString },
     ne: { type: GraphQLString },
@@ -169,7 +178,7 @@ export function inferInputObjectStructureFromFields({
   const sort = []
 
   _.each(fields, (fieldConfig, key) => {
-    const inputType = convertToInputType(fieldConfig.type, {})
+    const inputType = convertToInputType(fieldConfig.type, new Set())
     const inputFilter =
       inputType && convertToInputFilter(_.upperFirst(key), inputType)