Added implementation of Mutations

Author: jexp

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

@@ -17,7 +17,7 @@ fun augmentedSchema(ctx: Translator.Context, type: ObjectTypeDefinition): Augmen
         Augmentation().copy(create = """create$typeName($fieldArgs) : $typeName """)
                 .let { aug ->
                     if (idField != null) aug.copy(
-                            delete = """delete$typeName($idFieldArg) : Boolean """,
+                            delete = """delete$typeName($idFieldArg) : $typeName """,
                             update = """update$typeName($fieldArgs) : $typeName """)
                     else aug
                 }

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

@@ -60,10 +60,32 @@ class Translator(val schema: GraphQLSchema) {
             return cypherQueryOrMutation(variable, fieldDefinition, field, cypherDirective, mapProjection, ordering, skipLimit, isQuery)
 
         } else {
-            val where = if (ctx.topLevelWhere) where(variable, fieldDefinition, type, propertyArguments(field)) else Cypher.EMPTY
-            val properties = if (ctx.topLevelWhere) Cypher.EMPTY else properties(variable, fieldDefinition, propertyArguments(field))
-            return Cypher("MATCH ($variable:$label${properties.query})${where.query} RETURN ${mapProjection.query} AS $variable$ordering$skipLimit" ,
-                    (mapProjection.params + properties.params + where.params))
+            if (isQuery) {
+                val where = if (ctx.topLevelWhere) where(variable, fieldDefinition, type, propertyArguments(field)) else Cypher.EMPTY
+                val properties = if (ctx.topLevelWhere) Cypher.EMPTY else properties(variable, fieldDefinition, propertyArguments(field))
+                return Cypher("MATCH ($variable:$label${properties.query})${where.query} RETURN ${mapProjection.query} AS $variable$ordering$skipLimit",
+                        (mapProjection.params + properties.params + where.params))
+            } else {
+                // todo extract method or better object
+                val properties = properties(variable, fieldDefinition, propertyArguments(field))
+                val idProperty = fieldDefinition.arguments.find { it.type.inner() == Scalars.GraphQLID }
+                val returnStatement = " WITH $variable RETURN ${mapProjection.query} AS $variable$ordering$skipLimit";
+                return when (name) {
+                    "create"+type.name -> Cypher("CREATE ($variable:$label${properties.query})"+returnStatement, (mapProjection.params + properties.params))
+                    "update"+type.name -> {
+                        val setProperties = setProperties(variable, fieldDefinition, propertyArguments(field))
+                        Cypher("MATCH ($variable:$label {${idProperty!!.name.quote()}:\$${paramName(variable, idProperty.name, properties.params[idProperty.name])}}) "+setProperties.query + returnStatement,
+                                (mapProjection.params + setProperties.params))
+                    }
+                    "delete"+type.name -> {
+                        val paramName = paramName(variable, idProperty!!.name, properties.params[idProperty.name]) // todo currently wrong, needs to be paramName
+                        Cypher("MATCH ($variable:$label {${idProperty.name.quote()}:\$$paramName}) " +
+                           "WITH $variable as toDelete, ${mapProjection.query} AS $variable $ordering$skipLimit DETACH DELETE toDelete RETURN $variable",
+                                (mapProjection.params + mapOf(paramName to properties.params[paramName])))
+                    }
+                    else -> throw IllegalArgumentException("Unknown Mutation "+name)
+                }
+            }
         }
     }
 
@@ -118,7 +140,12 @@ class Translator(val schema: GraphQLSchema) {
     private fun properties(variable: String, field: GraphQLFieldDefinition, arguments: List<Argument>) : Cypher {
         val all = preparePredicateArguments(field, arguments)
         return Cypher(all.map { (k,p, v) -> "${p.quote()}:\$${paramName(variable, k, v)}"}.joinToString(" , "," {","}") ,
-               all.map { (k,p,v) -> paramName(variable, k, v) to v }.toMap())
+               all.map { (k,_,v) -> paramName(variable, k, v) to v }.toMap())
+    }
+    private fun setProperties(variable: String, field: GraphQLFieldDefinition, arguments: List<Argument>) : Cypher {
+        val all = preparePredicateArguments(field, arguments)
+        return Cypher(all.map { (k,p, v) -> "${variable.quote()}.${p.quote()}=\$${paramName(variable, k, v)}"}.joinToString(","," SET "," ") ,
+               all.map { (k,_,v) -> paramName(variable, k, v) to v }.toMap())
     }
 
     data class CypherArgument(val name:String, val propertyName:String, val value:Any?)

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

@@ -14,6 +14,8 @@ class AugmentationTest {
         type Person2 { name: String, age: [Int] }
         type Person3 { name: String!}
         type Person4 { id:ID!, name: String}
+        type Person5 { id:ID!, movies:[Movie]}
+        type Movie { id:ID! }
     """)
 
     @Test
@@ -33,7 +35,7 @@ class AugmentationTest {
         augmentedSchema(ctx, typeFor("Person4")).let {
             assertEquals("createPerson4(id:ID!, name:String) : Person4 ",it.create)
             assertEquals("updatePerson4(id:ID!, name:String) : Person4 ",it.update)
-            assertEquals("deletePerson4(id:ID!) : Boolean ",it.delete)
+            assertEquals("deletePerson4(id:ID!) : Person4 ",it.delete)
             assertEquals("",it.query)
         }
 
@@ -101,6 +103,7 @@ class AugmentationTest {
         assertEquals("input _Person3Input { name:String } ", augmentedSchema(ctx, typeFor("Person3")).inputType)
         assertEquals("input _Person4Input { id:ID, name:String } ", augmentedSchema(ctx, typeFor("Person4")).inputType)
     }
+
     @Test
     fun testOrderings() {
         val ctx = Translator.Context(mutation = Translator.CRUDConfig(enabled = false), query = Translator.CRUDConfig(enabled = true, exclude = listOf("Person0")))
@@ -118,5 +121,34 @@ class AugmentationTest {
         assertEquals("enum _Person4Ordering { id_asc ,id_desc,name_asc ,name_desc } ", augmentedSchema(ctx, typeFor("Person4")).ordering)
     }
 
+    @Test
+    fun testMutations() {
+        val ctx = Translator.Context(mutation = Translator.CRUDConfig(enabled = true, exclude = listOf("Person0","Person1","Person2","Person3")), query = Translator.CRUDConfig(enabled = false))
+        assertEquals("",augmentedSchema(ctx, typeFor("Person0")).ordering)
+        assertEquals("",augmentedSchema(ctx, typeFor("Person1")).filterType)
+        assertEquals("",augmentedSchema(ctx, typeFor("Person2")).query)
+        assertEquals("",augmentedSchema(ctx, typeFor("Person3")).inputType)
+
+        augmentedSchema(ctx, typeFor("Person4")).let {
+            assertEquals("",it.ordering)
+            assertEquals("",it.filterType)
+            assertEquals("createPerson4(id:ID!, name:String) : Person4 ",it.create)
+            assertEquals("updatePerson4(id:ID!, name:String) : Person4 ",it.update)
+            assertEquals("deletePerson4(id:ID!) : Person4 ",it.delete)
+        }
+    }
+
+    @Test
+    fun testMutationForRelations() {
+        val ctx = Translator.Context(mutation = Translator.CRUDConfig(enabled = true, exclude = listOf("Person0","Person1","Person2","Person3", "Person4")), query = Translator.CRUDConfig(enabled = false))
+        augmentedSchema(ctx, typeFor("Person5")).let {
+            assertEquals("",it.ordering)
+            assertEquals("",it.filterType)
+            assertEquals("createPerson5(id:ID!) : Person5 ",it.create)
+            assertEquals("updatePerson5(id:ID!) : Person5 ",it.update)
+            assertEquals("deletePerson5(id:ID!) : Person5 ",it.delete)
+        }
+    }
+
     private fun typeFor(name: String) = types.getType(name).get() as ObjectTypeDefinition
 }