Input type cannot be recursive from version 6.1 #450

Activity

1. vojtapol

   added

   bug

   on Oct 16, 2020
2. KammererTob commented on May 26, 2021

   

   KammererTob

   on May 26, 2021

   Contributor

   More actions

   Probably fixed with #414
3. oryan-block commented on Jan 31, 2024

   

   oryan-block

   on Jan 31, 2024

   Collaborator

   More actions

   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)
   }
   
4. oryan-block

   closed this as completedon Jan 31, 2024