Make use of sub-queries, to get rid of most apoc calls.

resolves #214

Author: Andy2003

core/pom.xml

@@ -58,7 +58,7 @@
         <dependency>
             <groupId>org.neo4j</groupId>
             <artifactId>neo4j-cypher-dsl</artifactId>
-            <version>2021.0.2</version>
+            <version>2021.2.1</version>
         </dependency>
         <dependency>
             <groupId>ch.qos.logback</groupId>

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

@@ -3,6 +3,7 @@ package org.neo4j.graphql
 import graphql.language.VariableReference
 import graphql.schema.GraphQLArgument
 import graphql.schema.GraphQLInputType
+import graphql.schema.GraphQLOutputType
 import graphql.schema.GraphQLType
 import org.neo4j.cypherdsl.core.*
 
@@ -26,6 +27,9 @@ fun queryParameter(value: Any?, vararg parts: String?): Parameter<Any> {
     return org.neo4j.cypherdsl.core.Cypher.parameter(name).withValue(value?.toJavaValue())
 }
 
+fun Expression.collect(type: GraphQLOutputType) = if (type.isList()) Functions.collect(this) else this
+fun StatementBuilder.OngoingReading.withSubQueries(subQueries: List<Statement>) = subQueries.fold(this, { it, sub -> it.call(sub) })
+
 fun normalizeName(vararg parts: String?) = parts.mapNotNull { it?.capitalize() }.filter { it.isNotBlank() }.joinToString("").decapitalize()
 //fun normalizeName(vararg parts: String?) = parts.filterNot { it.isNullOrBlank() }.joinToString("_")
 

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

@@ -18,6 +18,7 @@ import org.neo4j.graphql.DirectiveConstants.Companion.RELATION_FROM
 import org.neo4j.graphql.DirectiveConstants.Companion.RELATION_NAME
 import org.neo4j.graphql.DirectiveConstants.Companion.RELATION_TO
 import org.neo4j.graphql.handler.projection.ProjectionBase
+import org.slf4j.LoggerFactory
 import java.math.BigDecimal
 import java.math.BigInteger
 
@@ -201,10 +202,19 @@ fun <T> GraphQLDirective.getArgument(argumentName: String, defaultValue: T? = nu
             ?: throw IllegalStateException("No default value for @${this.name}::$argumentName")
 }
 
-fun GraphQLFieldDefinition.cypherDirective() :CypherDirective?= getDirective(CYPHER)?.let { CypherDirective(
-        it.getMandatoryArgument(CYPHER_STATEMENT),
-        it.getMandatoryArgument(CYPHER_PASS_THROUGH, false)
-) }
+private val LOGGER = LoggerFactory.getLogger(CypherDirective::class.java)
+
+
+fun GraphQLFieldDefinition.cypherDirective(): CypherDirective? = getDirective(CYPHER)?.let {
+    val originalStatement = it.getMandatoryArgument<String>(CYPHER_STATEMENT)
+    val rewrittenStatement = originalStatement.replace(Regex("\\\$([_a-zA-Z]\\w*)"), "$1")
+    if (originalStatement != rewrittenStatement) {
+        LoggerFactory.getLogger(CypherDirective::class.java)
+            .warn("The field arguments used in the directives statement must not contain parameters. The statement was replaced. Please adjust your GraphQl Schema.\n\tGot        : {}\n\tReplaced by: {}\n\tField      : {} ({})",
+                    originalStatement, rewrittenStatement, this.name, this.definition?.sourceLocation)
+    }
+    CypherDirective(rewrittenStatement, it.getMandatoryArgument(CYPHER_PASS_THROUGH, false))
+}
 
 data class CypherDirective(val statement: String, val passThrough: Boolean)
 

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

@@ -5,14 +5,17 @@ import graphql.language.NullValue
 import graphql.language.ObjectValue
 import graphql.language.Value
 import graphql.schema.*
-import org.neo4j.cypherdsl.core.*
+import org.neo4j.cypherdsl.core.Condition
+import org.neo4j.cypherdsl.core.Expression
+import org.neo4j.cypherdsl.core.Property
+import org.neo4j.cypherdsl.core.PropertyContainer
 import org.slf4j.LoggerFactory
 
 typealias CypherDSL = org.neo4j.cypherdsl.core.Cypher
 
 enum class FieldOperator(
         val suffix: String,
-        val op: String,
+        op: String,
         private val conditionCreator: (Expression, Expression) -> Condition,
         val not: Boolean = false,
         val requireParam: Boolean = true,
@@ -126,17 +129,17 @@ enum class FieldOperator(
     fun fieldName(fieldName: String) = fieldName + suffix
 }
 
-enum class RelationOperator(val suffix: String, val op: String) {
-    SOME("_some", "ANY"),
+enum class RelationOperator(val suffix: String) {
+    SOME("_some"),
 
-    EVERY("_every", "ALL"),
+    EVERY("_every"),
 
-    SINGLE("_single", "SINGLE"),
-    NONE("_none", "NONE"),
+    SINGLE("_single"),
+    NONE("_none"),
 
     // `eq` if queried with an object, `not exists` if  queried with null
-    EQ_OR_NOT_EXISTS("", ""),
-    NOT("_not", "");
+    EQ_OR_NOT_EXISTS(""),
+    NOT("_not");
 
     fun fieldName(fieldName: String) = fieldName + suffix
 

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

@@ -3,7 +3,6 @@ package org.neo4j.graphql.handler
 import graphql.language.Field
 import graphql.schema.*
 import org.neo4j.cypherdsl.core.Statement
-import org.neo4j.cypherdsl.core.StatementBuilder
 import org.neo4j.graphql.*
 
 /**
@@ -41,8 +40,8 @@ class CreateTypeHandler private constructor(
             if (!canHandle(type)) {
                 return null
             }
-            return when {
-                fieldDefinition.name == "create${type.name}" -> CreateTypeHandler(type, fieldDefinition, schemaConfig)
+            return when (fieldDefinition.name) {
+                "create${type.name}" -> CreateTypeHandler(type, fieldDefinition, schemaConfig)
                 else -> null
             }
         }
@@ -82,11 +81,11 @@ class CreateTypeHandler private constructor(
         val node = org.neo4j.cypherdsl.core.Cypher.node(type.name, *additionalTypes.toTypedArray()).named(variable)
 
         val properties = properties(variable, field.arguments)
-        val mapProjection = projectFields(node, field, type, env)
+        val (mapProjection, subQueries) = projectFields(node, field, type, env)
 
-        val update: StatementBuilder.OngoingUpdate = org.neo4j.cypherdsl.core.Cypher.create(node.withProperties(*properties))
-        return update
+        return org.neo4j.cypherdsl.core.Cypher.create(node.withProperties(*properties))
             .with(node)
+            .withSubQueries(subQueries)
             .returning(node.project(mapProjection).`as`(field.aliasOrName()))
             .build()
     }

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

@@ -5,7 +5,6 @@ import graphql.schema.DataFetcher
 import graphql.schema.DataFetchingEnvironment
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLFieldsContainer
-import org.neo4j.cypherdsl.core.Functions
 import org.neo4j.cypherdsl.core.Statement
 import org.neo4j.graphql.*
 
@@ -14,7 +13,6 @@ import org.neo4j.graphql.*
  */
 class CypherDirectiveHandler(
         private val type: GraphQLFieldsContainer?,
-        private val isQuery: Boolean,
         private val cypherDirective: CypherDirective,
         fieldDefinition: GraphQLFieldDefinition,
         schemaConfig: SchemaConfig)
@@ -25,38 +23,26 @@ class CypherDirectiveHandler(
         override fun createDataFetcher(operationType: OperationType, fieldDefinition: GraphQLFieldDefinition): DataFetcher<Cypher>? {
             val cypherDirective = fieldDefinition.cypherDirective() ?: return null
             val type = fieldDefinition.type.inner() as? GraphQLFieldsContainer
-            val isQuery = operationType == OperationType.QUERY
-            return CypherDirectiveHandler(type, isQuery, cypherDirective, fieldDefinition, schemaConfig)
+            return CypherDirectiveHandler(type, cypherDirective, fieldDefinition, schemaConfig)
         }
     }
 
     override fun generateCypher(variable: String, field: Field, env: DataFetchingEnvironment): Statement {
-
-        val query = if (isQuery) {
-            val nestedQuery = cypherDirective(variable, fieldDefinition, field, cypherDirective)
-            org.neo4j.cypherdsl.core.Cypher.unwind(nestedQuery).`as`(variable)
-        } else {
-            val args = cypherDirectiveQuery(variable, fieldDefinition, field, cypherDirective)
-
-            val value = org.neo4j.cypherdsl.core.Cypher.name("value")
-            org.neo4j.cypherdsl.core.Cypher.call("apoc.cypher.doIt")
-                .withArgs(*args)
-                .yield(value)
-                .with(org.neo4j.cypherdsl.core.Cypher.property(value, Functions.head(org.neo4j.cypherdsl.core.Cypher.call("keys").withArgs(value).asFunction())).`as`(variable))
-        }
         val node = org.neo4j.cypherdsl.core.Cypher.anyNode(variable)
-        val readingWithWhere = if (type != null && !cypherDirective.passThrough) {
-            val projectionEntries = projectFields(node, field, type, env)
-            query.returning(node.project(projectionEntries).`as`(field.aliasOrName()))
-        } else {
-            query.returning(node.`as`(field.aliasOrName()))
-        }
-        val ordering = orderBy(node, field.arguments, fieldDefinition, env.variables)
-        val skipLimit = SkipLimit(variable, field.arguments, fieldDefinition)
-
-        val resultWithSkipLimit = readingWithWhere
-            .let { if (ordering != null) skipLimit.format(it.orderBy(*ordering.toTypedArray())) else skipLimit.format(it) }
-
-        return resultWithSkipLimit.build()
+        val ctxVariable = node.requiredSymbolicName
+        val nestedQuery = cypherDirective(ctxVariable, fieldDefinition, field, cypherDirective, null, env)
+
+        return org.neo4j.cypherdsl.core.Cypher.call(nestedQuery)
+            .let { reading ->
+                if (type == null || cypherDirective.passThrough) {
+                    reading.returning(ctxVariable.`as`(field.aliasOrName()))
+                } else {
+                    val (fieldProjection, nestedSubQueries) = projectFields(node, field, type, env)
+                    reading
+                        .withSubQueries(nestedSubQueries)
+                        .returning(ctxVariable.project(fieldProjection).`as`(field.aliasOrName()))
+                }
+            }
+            .build()
     }
 }

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

@@ -5,7 +5,6 @@ import graphql.schema.*
 import org.neo4j.cypherdsl.core.Node
 import org.neo4j.cypherdsl.core.Relationship
 import org.neo4j.cypherdsl.core.Statement
-import org.neo4j.cypherdsl.core.StatementBuilder.OngoingUpdate
 import org.neo4j.graphql.*
 
 /**
@@ -79,12 +78,13 @@ class DeleteHandler private constructor(
                 .where(where)
         }
         val deletedElement = propertyContainer.requiredSymbolicName.`as`("toDelete")
-        val mapProjection = projectFields(propertyContainer, field, type, env)
+        val (mapProjection, subQueries) = projectFields(propertyContainer, field, type, env)
 
         val projection = propertyContainer.project(mapProjection).`as`(variable)
-        val update: OngoingUpdate = select.with(deletedElement, projection)
+        return select
+            .withSubQueries(subQueries)
+            .with(deletedElement, projection)
             .detachDelete(deletedElement)
-        return update
             .returning(projection.asName().`as`(field.aliasOrName()))
             .build()
     }

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

@@ -8,7 +8,6 @@ import graphql.schema.GraphQLFieldsContainer
 import org.neo4j.cypherdsl.core.Node
 import org.neo4j.cypherdsl.core.Relationship
 import org.neo4j.cypherdsl.core.Statement
-import org.neo4j.cypherdsl.core.StatementBuilder.OngoingMatchAndUpdate
 import org.neo4j.graphql.*
 
 /**
@@ -108,12 +107,12 @@ class MergeOrUpdateHandler private constructor(
             }
         }
         val properties = properties(variable, field.arguments)
-        val mapProjection = projectFields(propertyContainer, field, type, env)
-        val update: OngoingMatchAndUpdate = select
-            .mutate(propertyContainer, org.neo4j.cypherdsl.core.Cypher.mapOf(*properties))
+        val (mapProjection, subQueries) = projectFields(propertyContainer, field, type, env)
 
-        return update
+        return select
+            .mutate(propertyContainer, org.neo4j.cypherdsl.core.Cypher.mapOf(*properties))
             .with(propertyContainer)
+            .withSubQueries(subQueries)
             .returning(propertyContainer.project(mapProjection).`as`(field.aliasOrName()))
             .build()
     }

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

@@ -119,17 +119,12 @@ class QueryHandler private constructor(
             match.where(where)
         }
 
-        val ordering = orderBy(propertyContainer, field.arguments, fieldDefinition, env.variables)
-        val skipLimit = SkipLimit(variable, field.arguments, fieldDefinition)
-
-        val projectionEntries = projectFields(propertyContainer, field, type, env)
+        val (projectionEntries, subQueries) = projectFields(propertyContainer, field, type, env)
         val mapProjection = propertyContainer.project(projectionEntries).`as`(field.aliasOrName())
-        val resultWithSkipLimit = ongoingReading.returning(mapProjection)
-            .let {
-                val orderedResult = ordering?.let { o -> it.orderBy(*o.toTypedArray()) } ?: it
-                skipLimit.format(orderedResult)
-            }
-
-        return resultWithSkipLimit.build()
+        return ongoingReading
+            .withSubQueries(subQueries)
+            .returning(mapProjection)
+            .skipLimitOrder(propertyContainer.requiredSymbolicName, fieldDefinition, field, env)
+            .build()
     }
 }