Input type cannot be recursive from version 6.1

[heerzhang]

stack overflow!!
my example: WhereTree nested recursive ;

enum LJ_TYPE { AND, OR, NOT, DSELF }

enum OPERATOR { EQ,NE,GE,LE,GT,LT,BTW,IN,LK,
  EMPTY,NULL,EXI,NEXI,TRUE,FALSE,NNULL,NEMPTY  }

input WhereLeaf { s:String, o:OPERATOR, l:ExpressItem, r:ExpressItem,
  sv:String, sa:[String], dt:String, dv:Float, lv:Int,
  dta:[String], da:[Float], la:[Int]
}

input WhereTree { lj:LJ_TYPE,  a:WhereLeaf, as:[WhereLeaf],
  w:WhereTree, ws:[WhereTree], sup:WhereTree
}

input ExpressItem {
  y:String, l:ExpressItem, r:ExpressItem, s:String,
  sub:SubSelect, cwt:[CaseExpression], a:[ExpressItem],
  sv:String, lv:Int, dv:Float, dt:String,
  bv:Boolean, len:Int
}

input SubSelect {
  s:String, e:ExpressItem,  from:String,
  where: WhereTree,  grp:[ExpressItem], hav:WhereTree
}

input CaseExpression {
  w:ExpressItem,  b: WhereTree,   t:ExpressItem
}

extend type Query {
  findAllEQPsFilter_delete(where: WhereTree, offset:Int, first:Int, orderBy:String, asc:Boolean): [EQP]!
}

WhereTree can not use NOW!

[KammererTob]

Probably fixed with #414

[oryan-block]

A simplified version of this works:

class TempTest {
    @Test
    fun test() {
        val schema = SchemaParser.newParser()
                .resolvers(Query())
                .schemaString(
                        """
                    input WhereLeaf {
                        l: ExpressItem
                    }
                    
                    input WhereTree {
                        a:WhereLeaf,
                        as:[WhereLeaf]
                    }
                    
                    input ExpressItem {
                        l:ExpressItem, 
                        sub:SubSelect, 
                        cwt:[CaseExpression], 
                        a:[ExpressItem]
                    }
                    
                    input SubSelect {
                        e:ExpressItem,  
                        where: WhereTree,  
                        grp:[ExpressItem], 
                        hav:WhereTree
                    }
                    
                    input CaseExpression {
                        w:ExpressItem,  b: WhereTree
                    }
                    
                    type Query {
                        find(where: WhereTree): Int
                    }
                    """)
                .build()
                .makeExecutableSchema()

        assertNotNull(schema)
    }

    private class Query : GraphQLQueryResolver { fun find(where: WhereTree): Int = 0 }
    data class WhereTree(val a: WhereLeaf, val `as`: List<WhereLeaf>)
    data class WhereLeaf(val l: ExpressItem)
    data class ExpressItem(val l: ExpressItem?, val sub: SubSelect, val cwt: List<CaseExpression>, val a: List<ExpressItem>)
    data class SubSelect(val e: ExpressItem, val where: WhereTree, val grp: List<ExpressItem>, val hav: WhereTree)
    data class CaseExpression(val w: ExpressItem, val b: WhereTree)
}