Added Cypher Directive for nested Object type fields

Author: jexp

src/main/kotlin/org/neo4j/graphql/Translator.kt

@@ -159,8 +159,16 @@ class Translator(val schema: GraphQLSchema) {
     private fun projectField(variable: String, field: Field, type: GraphQLObjectType, ctx:Context) : Cypher {
         val fieldDefinition = type.getFieldDefinition(field.name) ?: throw IllegalStateException("No field ${field.name} in ${type.name}")
         val cypherDirective = fieldDefinition.cypherDirective()
-        return cypherDirective?.let { cypherFieldDirective(variable, fieldDefinition, field, it) } ?:
-            if (fieldDefinition.type.inner() is GraphQLObjectType) {
+        val isObjectField = fieldDefinition.type.inner() is GraphQLObjectType
+        return cypherDirective?.let {
+            val directive = cypherDirective(variable, fieldDefinition, field, it, listOf(CypherArgument("this", "this", variable)))
+            if (isObjectField) {
+                val patternComprehensions = projectListComprehension(variable, field, fieldDefinition, ctx,directive)
+                Cypher(field.aliasOrName() + ":" + patternComprehensions.query, patternComprehensions.params)
+            } else
+            Cypher(field.aliasOrName() +":"  + directive.query, directive.params)
+
+        } ?: if (isObjectField) {
                 val patternComprehensions = projectRelationship(variable, field, fieldDefinition, type, ctx)
                 Cypher(field.aliasOrName() + ":" + patternComprehensions.query, patternComprehensions.params)
             } else
@@ -170,18 +178,13 @@ class Translator(val schema: GraphQLSchema) {
                     Cypher(field.aliasOrName() + ":" + variable + "." + field.propertyName(fieldDefinition))
     }
 
-    private fun cypherFieldDirective(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: Cypher): Cypher {
-        val (query,params) = cypherDirective(variable, fieldDefinition, field, cypherDirective, listOf(CypherArgument("this", "this", variable)))
-        return Cypher(field.aliasOrName() +":"  + query, params)
-    }
     private fun cypherDirective(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: Cypher, additionalArgs: List<CypherArgument>): Cypher {
         val suffix = if (fieldDefinition.type.isList()) "Many" else "Single"
         val (query, args) = cypherDirectiveQuery(variable, fieldDefinition, field, cypherDirective, additionalArgs)
         return Cypher("apoc.cypher.runFirstColumn$suffix($query)", args)
     }
 
     private fun cypherDirectiveQuery(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: Cypher, additionalArgs: List<CypherArgument>): Cypher {
-        val suffix = if (fieldDefinition.type.isList()) "Many" else "Single"
         val args = additionalArgs + prepareFieldArguments(fieldDefinition, field.arguments)
         val argParams = args.map { '$' + it.name + " AS " + it.name }.joinNonEmpty(",")
         val query = (if (argParams.isEmpty()) "" else "WITH $argParams ") + cypherDirective.escapedQuery()
@@ -217,6 +220,20 @@ class Translator(val schema: GraphQLSchema) {
         }
     }
 
+    private fun projectListComprehension(variable: String, field: Field, fieldDefinition: GraphQLFieldDefinition, ctx: Context, expression:Cypher): Cypher {
+        val fieldType = fieldDefinition.type
+        val fieldObjectType = fieldType.inner() as GraphQLObjectType
+        val childVariable = variable + field.name.capitalize()
+
+        // val where = where(childVariable, fieldDefinition, fieldObjectType, propertyArguments(field))
+        val fieldProjection = projectFields(childVariable, field, fieldObjectType, ctx)
+
+        val comprehension = "[$childVariable IN ${expression.query} | ${fieldProjection.query}]"
+        val skipLimit = skipLimit(field.arguments)
+        val slice = slice(skipLimit, fieldType.isList())
+        return Cypher(comprehension + slice, (expression.params + fieldProjection.params)) // + where.params
+
+    }
     private fun projectRichAndRegularRelationship(variable: String, field: Field, fieldDefinition: GraphQLFieldDefinition, ctx: Context): Cypher {
         val fieldType = fieldDefinition.type
         val fieldObjectType = fieldType.inner() as GraphQLObjectType

src/test/kotlin/GraphQLServer.kt

@@ -28,7 +28,7 @@ type Movie {
 }
 """
 
-fun main(args: Array<String>) {
+fun main() {
     val gson = Gson()
     fun render(value:Any) =  gson.toJson(value)
     fun query(value:String) = (gson.fromJson(value, Map::class.java)["query"] as String).also { println(it) }

src/test/kotlin/org/neo4j/graphql/CypherDirectiveTest.kt

@@ -15,6 +15,7 @@ type Person {
     id: ID
     name: String @cypher(statement:"RETURN this.name")
     age(mult:Int=13) : [Int] @cypher(statement:"RETURN this.age * mult as age")
+    friends: [Person] @cypher(statement:"MATCH (this)-[:KNOWS]-(o) RETURN o")
 }
 type Query {
     person : [Person]
@@ -31,13 +32,20 @@ schema {
 """
 
     @Test
-    fun renderCypherFieldDirective() {
+    fun renderCypherFieldDirectiveScalar() {
 
         val expected = """MATCH (person:Person) RETURN person { name:apoc.cypher.runFirstColumnSingle('WITH ${"$"}this AS this RETURN this.name',{this:person}) } AS person"""
         val query = """{ person { name }}"""
         assertQuery(query, expected, emptyMap())
     }
 
+    @Test
+    fun renderCypherFieldDirectiveNested() {
+        val expected = """MATCH (person:Person) RETURN person { friends:[personFriends IN apoc.cypher.runFirstColumnMany('WITH ${"$"}this AS this MATCH (this)-[:KNOWS]-(o) RETURN o',{this:person}) | personFriends { .id }] } AS person"""
+        val query = """{ person { friends { id } }}"""
+        assertQuery(query, expected, emptyMap())
+    }
+
     @Test
     fun renderCypherFieldDirectiveWithParamsDefaults() {
         val expected = """MATCH (person:Person) RETURN person { age:apoc.cypher.runFirstColumnMany('WITH ${"$"}this AS this,${'$'}mult AS mult RETURN this.age * mult as age',{this:person,mult:${'$'}personMult}) } AS person"""

src/test/resources/movie-test.md

@@ -6,7 +6,7 @@
 
 ```
 
-### Basic Test
+### Basic Query with Parameter
 
 ```graphql
 {  Movie(title: "River Runs Through It, A")  {  title }  }
@@ -20,7 +20,7 @@ WHERE  movie.title = $movieTitle
 RETURN movie { .title } AS movie
 ```
 
-### Testing Paging
+### Paging
 
 ```graphql
 {
@@ -42,7 +42,7 @@ RETURN movie { .title , .year } AS movie
 SKIP $offset LIMIT $first
 ```
 
-### Testing Projection
+### Relationship Expansion
 
 ```graphql
 {
@@ -65,7 +65,7 @@ WHERE movie.title = $movieTitle
 RETURN movie { .title,actors:[(movie)<-[:ACTED_IN]-(movieActors:Actor) | movieActors { .name }] } AS movie 
 ```
 
-### Testing Projection with sub-paging
+### Projection with sub-paging
 
 ```graphql
 {
@@ -87,3 +87,24 @@ MATCH (movie:Movie)
 WHERE movie.title = $movieTitle 
 RETURN movie { .title,actors:[(movie)<-[:ACTED_IN]-(movieActors:Actor) | movieActors { .name }][0..3] } AS movie 
 ```
+### Subquery Cypher Directive
+
+```graphql
+{
+    Movie {
+      title
+      similar {
+        title
+      }
+    }
+  }
+```
+
+```params
+{}
+```
+
+```cypher
+MATCH (movie:Movie)  
+RETURN movie { .title,similar:[movieSimilar IN apoc.cypher.runFirstColumnMany('WITH $this AS this,$first AS first,$offset AS offset MATCH (this)--(:Genre)--(o:Movie) RETURN o',{this:movie,first:$movieFirst,offset:$movieOffset}) | movieSimilar { .title }] } AS movie 
+```

src/test/resources/movies-test-schema.graphql

@@ -8,14 +8,14 @@ type Movie {
   poster: String
   imdbRating: Float
   genres: [Genre] @relation(name: "IN_GENRE", direction: "OUT")
-  similar(first: Int = 3, offset: Int = 0): [Movie] @cypher(statement: "WITH {this} AS this MATCH (this)--(:Genre)--(o:Movie) RETURN o")
-  mostSimilar: Movie @cypher(statement: "WITH {this} AS this RETURN this")
-  degree: Int @cypher(statement: "WITH {this} AS this RETURN SIZE((this)--())")
+  similar(first: Int = 3, offset: Int = 0): [Movie] @cypher(statement: "MATCH (this)--(:Genre)--(o:Movie) RETURN o")
+  mostSimilar: Movie @cypher(statement: "RETURN this")
+  degree: Int @cypher(statement: "RETURN SIZE((this)--())")
   actors(first: Int = 3, offset: Int = 0, name: String): [Actor] @relation(name: "ACTED_IN", direction:"IN")
   avgStars: Float
   filmedIn: State @relation(name: "FILMED_IN", direction:"OUT")
-  scaleRating(scale: Int = 3): Float @cypher(statement: "WITH $this AS this RETURN $scale * this.imdbRating")
-  scaleRatingFloat(scale: Float = 1.5): Float @cypher(statement: "WITH $this AS this RETURN $scale * this.imdbRating")
+  scaleRating(scale: Int = 3): Float @cypher(statement: "RETURN $scale * this.imdbRating")
+  scaleRatingFloat(scale: Float = 1.5): Float @cypher(statement: "RETURN $scale * this.imdbRating")
   actorMovies: [Movie] @cypher(statement: "MATCH (this)-[:ACTED_IN*2]-(other:Movie) RETURN other")
   ratings: [Rated]
 }