changed relation field defaults to "from" and "to" like neo4j-graphql-js

Author: jexp

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

@@ -189,8 +189,8 @@ class Translator(val schema: GraphQLSchema) {
             "OUT" -> true
             else -> throw IllegalStateException("Unknown direction ${relDirective.argumentString("direction")}")
         }
-        val endField = if (outgoing == true) relDirective.argumentString("end")
-        else relDirective.argumentString("end")
+        val endField = if (outgoing == true) relDirective.argumentString("to")
+        else relDirective.argumentString("from")
         return Triple(relType, outgoing, endField)
     }
 
@@ -290,8 +290,8 @@ object SchemaBuilder {
                 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))
+                        GraphQLArgument("from","from field name",Scalars.GraphQLString,"from"),
+                        GraphQLArgument("to","to field name",Scalars.GraphQLString,"to")),false,false,true))
         return schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring).transform { bc -> bc.additionalDirectives(directives).build() }
     }
 }

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

@@ -18,11 +18,11 @@ class TranslatorTest {
                   died : Death
                 }
                 type Birth @relation(name:"BORN") {
-                   start: Person
-                   end: Location
+                   from: Person
+                   to: Location
                    date: String
                 }
-                type Death @relation(name:"DIED",start:"who",end:"where") {
+                type Death @relation(name:"DIED",from:"who",to:"where") {
                    who: Person
                    where: Location
                    date: String
@@ -69,8 +69,8 @@ class TranslatorTest {
 
     @Test
     fun richRelationship() {
-        val query = " { person { name born { date end { name } } } } "
-        assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornEnd:Location) | personBorn { .date,end:personBornEnd { .name } }][0] } AS person")
+        val query = " { person { name born { date to { name } } } } "
+        assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornTo:Location) | personBorn { .date,to:personBornTo { .name } }][0] } AS person")
     }
 
     @Test
@@ -81,13 +81,13 @@ class TranslatorTest {
 
     @Test
     fun richRelationship2ndHop() {
-        val query = " { person { name born { date end { name founded { name } } } } } "
-        assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornEnd:Location) | personBorn { .date,end:personBornEnd { .name,founded:[(personBornEnd)<-[:FOUNDED]-(personBornEndFounded:Person) | personBornEndFounded { .name }][0] } }][0] } AS person")
+        val query = " { person { name born { date to { name founded { name } } } } } "
+        assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornTo:Location) | personBorn { .date,to:personBornTo { .name,founded:[(personBornTo)<-[:FOUNDED]-(personBornToFounded:Person) | personBornToFounded { .name }][0] } }][0] } AS person")
     }
     @Test
     fun richRelationship3rdHop() {
-        val query = " { person { name born { date end { name founded { name born { date end { name } } } } } } } "
-        assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornEnd:Location) | personBorn { .date,end:personBornEnd { .name,founded:[(personBornEnd)<-[:FOUNDED]-(personBornEndFounded:Person) | personBornEndFounded { .name,born:[(personBornEndFounded)-[personBornEndFoundedBorn:BORN]->(personBornEndFoundedBornEnd:Location) | personBornEndFoundedBorn { .date,end:personBornEndFoundedBornEnd { .name } }][0] }][0] } }][0] } AS person")
+        val query = " { person { name born { date to { name founded { name born { date to { name } } } } } } } "
+        assertQuery(query, "MATCH (person:Person) RETURN person { .name,born:[(person)-[personBorn:BORN]->(personBornTo:Location) | personBorn { .date,to:personBornTo { .name,founded:[(personBornTo)<-[:FOUNDED]-(personBornToFounded:Person) | personBornToFounded { .name,born:[(personBornToFounded)-[personBornToFoundedBorn:BORN]->(personBornToFoundedBornTo:Location) | personBornToFoundedBorn { .date,to:personBornToFoundedBornTo { .name } }][0] }][0] } }][0] } AS person")
     }
 
     @Test