add integration tests

Author: Andy2003

core/pom.xml

@@ -26,6 +26,11 @@
             <version>2.0.0-SNAPSHOT</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.threeten</groupId>
+            <artifactId>threeten-extra</artifactId>
+            <version>1.7.0</version>
+        </dependency>
         <dependency>
             <groupId>org.neo4j.driver</groupId>
             <artifactId>neo4j-java-driver</artifactId>
@@ -122,6 +127,13 @@
             <version>2.17.2</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-csv</artifactId>
+            <version>1.12.0</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
     <dependencyManagement>

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

@@ -30,6 +30,8 @@ fun String.toLowerCase(): String = lowercase(Locale.getDefault())
 
 infix fun Condition?.and(rhs: Condition) = this?.and(rhs) ?: rhs
 infix fun Condition?.or(rhs: Condition) = this?.or(rhs) ?: rhs
+infix fun Condition?.xor(rhs: Condition) = this?.xor(rhs) ?: rhs
+
 fun Collection<Condition?>.foldWithAnd(): Condition? = this
     .filterNotNull()
     .takeIf { it.isNotEmpty() }
@@ -169,3 +171,4 @@ fun Iterable<Any?>.toDict(): List<Dict> = this.mapNotNull { Dict.create(it) }
 
 fun String.toDeprecatedDirective() = Directive("deprecated", listOf(Argument("reason", StringValue(this))))
 
+fun Collection<Statement>.union(): Statement = if (this.size == 1) this.first() else Cypher.union(this)

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

@@ -38,61 +38,45 @@ import org.neo4j.graphql.schema.model.outputs.NodeSelection
  */
 class SchemaBuilder @JvmOverloads constructor(
     val typeDefinitionRegistry: TypeDefinitionRegistry,
-    val schemaConfig: SchemaConfig = SchemaConfig()
+    val schemaConfig: SchemaConfig = SchemaConfig(),
 ) {
 
     companion object {
-        /**
-         * @param sdl the schema to augment
-         * @param neo4jAdapter the adapter to run the generated cypher queries
-         * @param config defines how the schema should get augmented
-         */
+
         @JvmStatic
         @JvmOverloads
-        fun buildSchema(
-            sdl: String,
-            config: SchemaConfig = SchemaConfig(),
-            neo4jAdapter: Neo4jAdapter = Neo4jAdapter.NO_OP,
-            addLibraryDirectivesToSchema: Boolean = true,
-        ): GraphQLSchema {
+        fun fromSchema(sdl: String, config: SchemaConfig = SchemaConfig()): SchemaBuilder {
             val schemaParser = SchemaParser()
             val typeDefinitionRegistry = schemaParser.parse(sdl)
-            return buildSchema(typeDefinitionRegistry, config, neo4jAdapter, addLibraryDirectivesToSchema)
+            return SchemaBuilder(typeDefinitionRegistry, config)
         }
 
         /**
-         * @param typeDefinitionRegistry a registry containing all the types, that should be augmented
-         * @param config defines how the schema should get augmented
+         * @param sdl the schema to augment
          * @param neo4jAdapter the adapter to run the generated cypher queries
+         * @param config defines how the schema should get augmented
          */
         @JvmStatic
         @JvmOverloads
         fun buildSchema(
-            typeDefinitionRegistry: TypeDefinitionRegistry,
+            sdl: String,
             config: SchemaConfig = SchemaConfig(),
-            neo4jAdapter: Neo4jAdapter,
+            neo4jAdapter: Neo4jAdapter = Neo4jAdapter.NO_OP,
             addLibraryDirectivesToSchema: Boolean = true,
-        ): GraphQLSchema {
-
-            val builder = RuntimeWiring.newRuntimeWiring()
-            val codeRegistryBuilder = GraphQLCodeRegistry.newCodeRegistry()
-            val schemaBuilder = SchemaBuilder(typeDefinitionRegistry, config)
-            schemaBuilder.augmentTypes(addLibraryDirectivesToSchema)
-            schemaBuilder.registerScalars(builder)
-            schemaBuilder.registerTypeNameResolver(builder)
-            schemaBuilder.registerNeo4jAdapter(codeRegistryBuilder, neo4jAdapter)
-
-            return SchemaGenerator().makeExecutableSchema(
-                typeDefinitionRegistry,
-                builder.codeRegistry(codeRegistryBuilder).build()
-            )
-        }
+        ): GraphQLSchema = fromSchema(sdl, config)
+            .withNeo4jAdapter(neo4jAdapter)
+            .addLibraryDirectivesToSchema(addLibraryDirectivesToSchema)
+            .build()
     }
 
     private val handler: List<AugmentationHandler>
     private val neo4jTypeDefinitionRegistry: TypeDefinitionRegistry = getNeo4jEnhancements()
     private val augmentedFields = mutableListOf<AugmentationHandler.AugmentedField>()
     private val ctx = AugmentationContext(schemaConfig, typeDefinitionRegistry)
+    private var addLibraryDirectivesToSchema: Boolean = false;
+    private var codeRegistryBuilder: GraphQLCodeRegistry.Builder? = null
+    private var runtimeWiringBuilder: RuntimeWiring.Builder? = null
+    private var neo4jAdapter: Neo4jAdapter = Neo4jAdapter.NO_OP
 
     init {
         handler = mutableListOf(
@@ -102,6 +86,42 @@ class SchemaBuilder @JvmOverloads constructor(
         )
     }
 
+    fun addLibraryDirectivesToSchema(addLibraryDirectivesToSchema: Boolean): SchemaBuilder {
+        this.addLibraryDirectivesToSchema = addLibraryDirectivesToSchema
+        return this
+    }
+
+    fun withCodeRegistryBuilder(codeRegistryBuilder: GraphQLCodeRegistry.Builder): SchemaBuilder {
+        this.codeRegistryBuilder = codeRegistryBuilder
+        return this
+    }
+
+    fun withRuntimeWiringBuilder(runtimeWiring: RuntimeWiring.Builder): SchemaBuilder {
+        this.runtimeWiringBuilder = runtimeWiring
+        return this
+    }
+
+    fun withNeo4jAdapter(neo4jAdapter: Neo4jAdapter): SchemaBuilder {
+        this.neo4jAdapter = neo4jAdapter
+        return this
+    }
+
+    fun build(): GraphQLSchema {
+        augmentTypes(addLibraryDirectivesToSchema)
+        val runtimeWiringBuilder = this.runtimeWiringBuilder ?: RuntimeWiring.newRuntimeWiring()
+        registerScalars(runtimeWiringBuilder)
+        registerTypeNameResolver(runtimeWiringBuilder)
+
+        val codeRegistryBuilder = this.codeRegistryBuilder ?: GraphQLCodeRegistry.newCodeRegistry()
+        registerNeo4jAdapter(codeRegistryBuilder, neo4jAdapter)
+
+        return SchemaGenerator().makeExecutableSchema(
+            typeDefinitionRegistry,
+            runtimeWiringBuilder.codeRegistry(codeRegistryBuilder).build()
+        )
+
+    }
+
 
     /**
      * Generated additionally query and mutation fields according to the types present in the [typeDefinitionRegistry].

core/src/main/kotlin/org/neo4j/graphql/scalars/DurationScalar.kt

@@ -6,24 +6,17 @@ import graphql.execution.CoercedVariables
 import graphql.language.*
 import graphql.schema.*
 import org.neo4j.graphql.Constants
-import java.time.Duration
-import java.time.Period
-import java.time.format.DateTimeParseException
-import java.time.temporal.TemporalAmount
+import org.threeten.extra.PeriodDuration
 import java.util.*
 
 object DurationScalar {
 
     val INSTANCE: GraphQLScalarType = GraphQLScalarType.newScalar()
         .name(Constants.DURATION)
-        .coercing(object : Coercing<TemporalAmount, String> {
+        .coercing(object : Coercing<PeriodDuration, String> {
 
-            private fun  parse(value: String): TemporalAmount {
-                try {
-                    return Duration.parse(value)
-                } catch (e: DateTimeParseException){
-                    return Period.parse(value)
-                }
+            private fun parse(value: String): PeriodDuration {
+                return PeriodDuration.parse(value)
             }
 
             @Throws(CoercingSerializeException::class)
@@ -32,7 +25,7 @@ object DurationScalar {
             }
 
             @Throws(CoercingParseValueException::class)
-            override fun parseValue(input: Any, graphQLContext: GraphQLContext, locale: Locale): TemporalAmount? {
+            override fun parseValue(input: Any, graphQLContext: GraphQLContext, locale: Locale): PeriodDuration? {
                 return when (input) {
                     is StringValue -> parse(input.value)
                     is String -> parse(input)
@@ -46,7 +39,7 @@ object DurationScalar {
                 variables: CoercedVariables,
                 graphQLContext: GraphQLContext,
                 locale: Locale
-            ): TemporalAmount? {
+            ): PeriodDuration? {
                 return parseValue(input, graphQLContext, locale)
             }
         })

core/src/main/kotlin/org/neo4j/graphql/schema/model/outputs/PageInfoSelection.kt

@@ -2,6 +2,7 @@ package org.neo4j.graphql.schema.model.outputs
 
 import org.neo4j.graphql.Constants
 import org.neo4j.graphql.NonNull
+import org.neo4j.graphql.asDescription
 import org.neo4j.graphql.schema.AugmentationBase
 import org.neo4j.graphql.schema.AugmentationContext
 import org.neo4j.graphql.utils.IResolveTree
@@ -18,7 +19,9 @@ class PageInfoSelection(
     object Augmentation : AugmentationBase {
 
         fun generateNodeSelection(ctx: AugmentationContext) =
-            ctx.getOrCreateObjectType(TYPE_NAME) { fields, _ ->
+            ctx.getOrCreateObjectType(
+                TYPE_NAME,
+                { description("Pagination information (Relay)".asDescription()) }) { fields, _ ->
                 fields += field(PageInfoSelection::startCursor, Constants.Types.String)
                 fields += field(PageInfoSelection::endCursor, Constants.Types.String)
                 fields += field(PageInfoSelection::hasNextPage, Constants.Types.Boolean.NonNull)

core/src/main/kotlin/org/neo4j/graphql/translate/ProjectionTranslator.kt

@@ -16,6 +16,7 @@ import org.neo4j.graphql.translate.projection.createInterfaceProjectionAndParams
 import org.neo4j.graphql.translate.projection.projectScalarField
 import org.neo4j.graphql.translate.where.createWhere
 import org.neo4j.graphql.utils.ResolveTree
+import org.neo4j.graphql.utils.SelectionOfType
 
 class ProjectionTranslator {
 
@@ -41,19 +42,27 @@ class ProjectionTranslator {
         }
 
         var selectedFields = resolveTree?.fieldsByTypeName?.get(node.name)
-            ?: return Projection(projection = projections)
 
-        selectedFields.values.forEach { field ->
-            val nodeField = node.getField(field.name) as? ComputedField ?: return@forEach
-            nodeField.annotations.customResolver?.requires?.run {
-                selectedFields = selectedFields.merge(this)
+        for (it in node.interfaces) {
+            val interfaceSelection = resolveTree?.fieldsByTypeName?.get(it.name)
+            if (selectedFields == null) {
+                selectedFields = interfaceSelection
+            } else if (interfaceSelection != null) {
+                selectedFields = selectedFields.merge(interfaceSelection)
             }
         }
+        var requiredSelection: SelectionOfType = selectedFields ?: return Projection(projection = projections)
+
+        requiredSelection.values.forEach { field ->
+            val requirements = (node.getField(field.name) as? ComputedField)?.annotations?.customResolver?.requires
+                ?: return@forEach
+            requiredSelection = requiredSelection.merge(requirements)
+        }
 
         val subQueries = mutableListOf<Statement>()
         val subQueriesBeforeSort = mutableListOf<Statement>()
 
-        selectedFields.values.forEach { field ->
+        requiredSelection.values.forEach { field ->
             val alias = field.aliasOrName
             val nodeField = node.getField(field.name) ?: return@forEach
 
@@ -72,8 +81,13 @@ class ProjectionTranslator {
                     projections += returnVariable
 
                 } else if (nodeField.isUnion) {
+                    val unionWhere = arguments.where as? WhereInput.UnionWhereInput
 
-                    val referenceNodes = requireNotNull(nodeField.union).nodes.values
+                    var referenceNodes = requireNotNull(nodeField.union).nodes.values
+                    if (unionWhere != null) {
+                        referenceNodes =
+                            referenceNodes.filter { !unionWhere.getDataForNode(it)?.predicates.isNullOrEmpty() }
+                    }
                     val aliasVar = queryContext.getNextVariable(alias)
 
                     val unionSubQueries = referenceNodes.map { refNode ->
@@ -114,7 +128,7 @@ class ProjectionTranslator {
                     }
 
                     subQueries += Cypher.with(varName)
-                        .call(Cypher.union(unionSubQueries))
+                        .call(unionSubQueries.union())
                         .with(aliasVar) // TODO remove
                         .applySortingSkipAndLimit(aliasVar, arguments.options, queryContext)
                         .returning(Cypher.collect(aliasVar).`as`(aliasVar))

core/src/main/kotlin/org/neo4j/graphql/translate/connection_clause/CreateConnectionClause.kt

@@ -39,7 +39,8 @@ fun createConnectionClause(
         },
         onInterface = {
             createConnectionClauseForMultipleNodes(
-                it.implementations.values, arguments,
+                it.implementations.values,
+                arguments,
                 resolveTree,
                 field,
                 context,
@@ -48,9 +49,15 @@ fun createConnectionClause(
                 returnVariable,
             )
         },
-        onUnion = {
+        onUnion = { union ->
+            val unionConnectionWhere = arguments.where as? ConnectionWhere.UnionConnectionWhere
+            var nodes = union.nodes.values
+            if (unionConnectionWhere != null) {
+                nodes = nodes.filter { !unionConnectionWhere.getDataForNode(it)?.predicates.isNullOrEmpty() }
+            }
             createConnectionClauseForMultipleNodes(
-                it.nodes.values, arguments,
+                nodes,
+                arguments,
                 resolveTree,
                 field,
                 context,
@@ -98,7 +105,7 @@ private fun createConnectionClauseForMultipleNodes(
     var targetEdges = edges
     return Cypher
         .with(nodeVariable)
-        .call(Cypher.union(subQueries))
+        .call(subQueries.union())
         .with(Cypher.collect(collectUnionVariable).`as`(edges))
         .with(edges, Cypher.size(edges).`as`(totalCount))
         .let {

core/src/main/kotlin/org/neo4j/graphql/translate/where/CreateWhere.kt

@@ -9,6 +9,7 @@ import org.neo4j.graphql.domain.fields.HasCoalesceValue
 import org.neo4j.graphql.domain.fields.RelationField
 import org.neo4j.graphql.domain.predicates.ConnectionFieldPredicate
 import org.neo4j.graphql.domain.predicates.RelationFieldPredicate
+import org.neo4j.graphql.domain.predicates.RelationOperator
 import org.neo4j.graphql.domain.predicates.ScalarFieldPredicate
 import org.neo4j.graphql.schema.model.inputs.WhereInput
 import org.neo4j.graphql.schema.model.inputs.connection.ConnectionWhere
@@ -71,9 +72,15 @@ fun createWhere(
             if (field is RelationField) {
                 val relation = field.createDslRelation(propertyContainer, endNode)
                 val cond = op.createRelationCondition(relation, nestedCondition)
-                allConditions = allConditions and cond.let {
+
+                val condition = cond.let {
                     if (predicate.where == null) it.not() else it
                 }
+                allConditions = when (op) {
+                    RelationOperator.SOME -> allConditions or condition
+                    RelationOperator.SINGLE -> allConditions xor condition
+                    else -> allConditions and condition
+                }
             } else {
                 TODO()
             }