Added alias or field name as variable to Cypher.kt (#172)

* append operand name in filter expressions

* added alias or fieldname as variable to Cypher.kt

* use variable everywhere

Co-authored-by: Dirk Mahler <dirk.mahler@asml.com>
Co-authored-by: Andreas Berger <andreas@berger-ecommerce.com>

Author: 3 people

core/src/main/kotlin/org/neo4j/graphql/Cypher.kt

@@ -2,12 +2,7 @@ package org.neo4j.graphql
 
 import graphql.schema.GraphQLType
 
-data class Cypher @JvmOverloads constructor(val query: String, val params: Map<String, Any?> = emptyMap(), var type: GraphQLType? = null) {
+data class Cypher @JvmOverloads constructor(val query: String, val params: Map<String, Any?> = emptyMap(), var type: GraphQLType? = null, val variable: String) {
     fun with(p: Map<String, Any?>) = this.copy(params = this.params + p)
     fun escapedQuery() = query.replace("\"", "\\\"").replace("'", "\\'")
-
-    companion object {
-        @JvmStatic
-        val EMPTY = Cypher("")
-    }
-}
+}

core/src/main/kotlin/org/neo4j/graphql/GraphQLExtensions.kt

@@ -200,8 +200,7 @@ fun <T> GraphQLDirective.getArgument(argumentName: String, defaultValue: T? = nu
             ?: throw IllegalStateException("No default value for @${this.name}::$argumentName")
 }
 
-fun GraphQLFieldDefinition.cypherDirective(): Cypher? = getDirectiveArgument<String>(CYPHER, CYPHER_STATEMENT, null)
-    ?.let { statement -> Cypher(statement) }
+fun GraphQLFieldDefinition.cypherDirective(): String? = getDirectiveArgument<String>(CYPHER, CYPHER_STATEMENT, null)
 
 fun Any.toJavaValue() = when (this) {
     is Value<*> -> this.toJavaValue()

core/src/main/kotlin/org/neo4j/graphql/handler/BaseDataFetcher.kt

@@ -29,7 +29,7 @@ abstract class BaseDataFetcher(val fieldDefinition: GraphQLFieldDefinition) : Pr
             .withPrettyPrint(true)
             .build()
         ).render(statement)
-        return Cypher(query, statement.parameters, fieldDefinition.type)
+        return Cypher(query, statement.parameters, fieldDefinition.type, variable = variable)
     }
 
     protected abstract fun generateCypher(variable: String, field: Field, env: DataFetchingEnvironment): Statement

core/src/main/kotlin/org/neo4j/graphql/handler/CypherDirectiveHandler.kt

@@ -15,7 +15,7 @@ import org.neo4j.graphql.*
 class CypherDirectiveHandler(
         private val type: GraphQLFieldsContainer?,
         private val isQuery: Boolean,
-        private val cypherDirective: Cypher,
+        private val cypherDirective: String,
         fieldDefinition: GraphQLFieldDefinition)
     : BaseDataFetcher(fieldDefinition) {
 

core/src/main/kotlin/org/neo4j/graphql/handler/projection/ProjectionBase.kt

@@ -10,7 +10,6 @@ import org.neo4j.cypherdsl.core.Node
 import org.neo4j.cypherdsl.core.StatementBuilder.TerminalExposesLimit
 import org.neo4j.cypherdsl.core.StatementBuilder.TerminalExposesSkip
 import org.neo4j.graphql.*
-import org.neo4j.graphql.Cypher
 import org.neo4j.graphql.parser.ParsedQuery
 import org.neo4j.graphql.parser.QueryParser.parseArguments
 import org.neo4j.graphql.parser.QueryParser.parseFilter
@@ -276,13 +275,13 @@ open class ProjectionBase {
         return mapOf(*projections.toTypedArray())
     }
 
-    fun cypherDirective(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: Cypher, thisValue: Any? = null): Expression {
+    fun cypherDirective(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: String, thisValue: Any? = null): Expression {
         val suffix = if (fieldDefinition.type.isList()) "Many" else "Single"
         val args = cypherDirectiveQuery(variable, fieldDefinition, field, cypherDirective, thisValue)
         return call("apoc.cypher.runFirstColumn$suffix").withArgs(*args).asFunction()
     }
 
-    fun cypherDirectiveQuery(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: Cypher, thisValue: Any? = null): Array<Expression> {
+    fun cypherDirectiveQuery(variable: String, fieldDefinition: GraphQLFieldDefinition, field: Field, cypherDirective: String, thisValue: Any? = null): Array<Expression> {
         val args = mutableMapOf<String, Any?>()
         if (thisValue != null) args["this"] = thisValue
         field.arguments.forEach { args[it.name] = it.value }
@@ -291,7 +290,7 @@ open class ProjectionBase {
             .forEach { args[it.name] = it.defaultValue }
 
         val argParams = args.map { (name, _) -> "$$name AS $name" }.joinNonEmpty(", ")
-        val query = (if (argParams.isEmpty()) "" else "WITH $argParams ") + cypherDirective.query
+        val query = (if (argParams.isEmpty()) "" else "WITH $argParams ") + cypherDirective
         val argExpressions = args.flatMap { (name, value) -> listOf(name, if (name == "this") value else queryParameter(value, variable, name)) }
         return arrayOf(literalOf<String>(query), mapOf(*argExpressions.toTypedArray()))
     }

core/src/test/kotlin/DataFetcherInterceptorDemo.kt

@@ -21,12 +21,11 @@ fun initBoundSchema(schema: String): GraphQLSchema {
             val cypher = delegate.get(env)
             return driver.session().use { session ->
                 val result = session.run(cypher.query, cypher.params.mapValues { toBoltValue(it.value, env.variables) })
-                val key = result.keys().stream().findFirst().orElse(null)
                 if (isListType(cypher.type)) {
-                    result.list().map { record -> record.get(key).asObject() }
+                    result.list().map { record -> record.get(cypher.variable).asObject() }
 
                 } else {
-                    result.list().map { record -> record.get(key).asObject() }
+                    result.list().map { record -> record.get(cypher.variable).asObject() }
                         .firstOrNull() ?: emptyMap<String, Any>()
                 }
             }

core/src/test/kotlin/GraphQLServer.kt

@@ -14,6 +14,7 @@ import org.neo4j.graphql.*
 import spark.Request
 import spark.Response
 import spark.Spark
+import java.util.*
 
 const val schema = """
 type Person {
@@ -63,11 +64,13 @@ fun main() {
         try {
             // todo fix parameter mapping in translator
             val result = it.run(cypher.query, Values.value(cypher.params))
-            if (cypher.type?.isList() == true) {
-                result.keys().map { key -> key to result.list().map { row -> row.get(key).asObject() } }.toMap(LinkedHashMap())
+            val value = if (cypher.type?.isList() == true) {
+                result.list().map { row -> row.get(cypher.variable).asObject() }
             } else {
-                result.keys().map { key -> key to result.list().map { row -> row.get(key).asObject() }.firstOrNull() }.toMap(LinkedHashMap())
+                result.list().map { record -> record.get(cypher.variable).asObject() }
+                    .firstOrNull() ?: emptyMap<String, Any>()
             }
+            Collections.singletonMap(cypher.variable, value)
         } catch (e: Exception) {
             e.printStackTrace()
         }

core/src/test/kotlin/org/neo4j/graphql/utils/CypherTestSuite.kt

@@ -154,19 +154,15 @@ class CypherTestSuite(fileName: String) : AsciiDocTestSuite(
                         .forEach { server.graph().execute(it) }
                 }
 
-                val (cypher, params, type) = result()
+                val (cypher, params, type, variable) = result()
                 val dbResult = server.graph().execute(cypher, params)
 
-                val values = dbResult.columns().map { key ->
-                    key to dbResult.stream()
-                        .map { it[key] }
-                        .let {
-                            when {
-                                type?.isList() == true -> it.toList()
-                                else -> it.findFirst().orElse(null)
-                            }
-                        }
-                }.toMap(LinkedHashMap())
+                val values = mutableMapOf(variable to dbResult.stream().map { it[variable] }.let {
+                    when {
+                        type?.isList() == true -> it.toList()
+                        else -> it.findFirst().orElse(null)
+                    }
+                })
 
                 if (response.code.isEmpty()) {
                     val actualCode = MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(values)

examples/graphql-spring-boot/src/main/kotlin/org/neo4j/graphql/examples/graphqlspringboot/config/Neo4jConfiguration.kt

@@ -30,13 +30,12 @@ open class Neo4jConfiguration {
                 return driver.session().writeTransaction { tx ->
                     val boltParams = cypher.params.mapValues { toBoltValue(it.value, env.variables) }
                     val result = tx.run(cypher.query, boltParams)
-                    val key = result.keys().stream().findFirst().orElse(null)
                     if (isListType(cypher.type)) {
                         result.list()
-                            .map { record -> record.get(key).asObject() }
+                            .map { record -> record.get(cypher.variable).asObject() }
                     } else {
                         result.list()
-                            .map { record -> record.get(key).asObject() }
+                            .map { record -> record.get(cypher.variable).asObject() }
                             .firstOrNull() ?: emptyMap<String, Any>()
                     }
                 }