add custom field names for relationship directives on object type

Author: jexp

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

@@ -1,13 +1,15 @@
 package org.neo4j.graphql
 
 import graphql.Scalars
+import graphql.introspection.Introspection
 import graphql.language.*
 import graphql.parser.Parser
 import graphql.schema.*
 import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.SchemaGenerator
 import graphql.schema.idl.SchemaParser
 import org.antlr.v4.runtime.misc.ParseCancellationException
+import java.util.*
 
 class Translator(val schema: GraphQLSchema) {
     data class Context(val topLevelWhere: Boolean = true, val fragments : Map<String,FragmentDefinition> = emptyMap())
@@ -173,18 +175,22 @@ class Translator(val schema: GraphQLSchema) {
         }
     }
 
+    private fun Directive.argumentString(name:String) : String {
+        return this.getArgument(name)?.value?.toJavaValue()?.toString()
+                ?: schema.getDirective(this.name).getArgument(name)?.defaultValue?.toString()
+        ?: throw IllegalStateException("No default value for ${this.name}.${name}")
+    }
+
     private fun relDetails(relDirective: Directive): Triple<String,Boolean?,String> {
-        val arguments = relDirective.argumentsByName
-        val relType = arguments.getValue("name").value.toJavaValue().toString()
-        val relDirection = arguments.get("direction")?.value?.toJavaValue()
-                ?: schema.getDirective("relation").getArgument("direction").defaultValue
-        val outgoing =  when (relDirection.toString()) {
+        val relType = relDirective.argumentString("name")
+        val outgoing =  when (relDirective.argumentString("direction")) {
             "IN" -> false
             "BOTH" -> null
             "OUT" -> true
-            else -> throw IllegalStateException("Unknown direction $relDirection")
+            else -> throw IllegalStateException("Unknown direction ${relDirective.argumentString("direction")}")
         }
-        val endField = if (outgoing == true) "end" else "start"
+        val endField = if (outgoing == true) relDirective.argumentString("end")
+        else relDirective.argumentString("end")
         return Triple(relType, outgoing, endField)
     }
 
@@ -280,7 +286,12 @@ object SchemaBuilder {
                 .build()
 
         val schemaGenerator = SchemaGenerator()
-        val directives = setOf(GraphQLDirective.newDirective().name("relation").argument { it.name("name").type(Scalars.GraphQLString).also { it.name("direction").type(Scalars.GraphQLString).defaultValue("OUT") } }.build())
+        val directives = setOf(GraphQLDirective("relation", "relation directive",
+                EnumSet.of(Introspection.DirectiveLocation.FIELD,Introspection.DirectiveLocation.OBJECT),
+                listOf(GraphQLArgument("name",Scalars.GraphQLString),
+                        GraphQLArgument("direction","relationship direction",Scalars.GraphQLString,"OUT"),
+                        GraphQLArgument("start","start field name",Scalars.GraphQLString,"start"),
+                        GraphQLArgument("end","end field name",Scalars.GraphQLString,"end")),false,false,true))
         return schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring).transform { bc -> bc.additionalDirectives(directives).build() }
     }
 }

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

@@ -15,12 +15,18 @@ class TranslatorTest {
                   livesIn : Location @relation(name:"LIVES_IN", direction:"OUT")
                   livedIn : [Location] @relation(name:"LIVED_IN", direction:"OUT")
                   born : Birth
+                  died : Death
                 }
                 type Birth @relation(name:"BORN") {
                    start: Person
                    end: Location
                    date: String
                 }
+                type Death @relation(name:"DIED",start:"who",end:"where") {
+                   who: Person
+                   where: Location
+                   date: String
+                }
                 type Location {
                    name: String
                    founded: Person @relation(name:"FOUNDED", direction:"IN")
@@ -67,6 +73,12 @@ class TranslatorTest {
         assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornEnd:Location) | personBorn { .date,end:personBornEnd { .name } }][0] } AS person")
     }
 
+    @Test
+    fun richRelationshipCustomFieldNames() {
+        val query = " { person { name died { date where { name } } } } "
+        assertQuery(query, "MATCH (person:Person) RETURN person { .name,died:[(person)-[personDied:DIED]->(personDiedWhere:Location) | personDied { .date,where:personDiedWhere { .name } }][0] } AS person")
+    }
+
     @Test
     fun richRelationship2ndHop() {
         val query = " { person { name born { date end { name founded { name } } } } } "