Add support for spatial point values and distance comparisons (#94)

* Add support for spatial point values and distance comparisons (resolves #11)
* Update neo4j-opencypher-dsl dependency

Author: Andy2003

pom.xml

@@ -115,8 +115,8 @@
         </dependency>
         <dependency>
             <groupId>org.neo4j</groupId>
-            <artifactId>neo4j-opencypher-dsl</artifactId>
-            <version>1.1.0</version>
+            <artifactId>neo4j-cypher-dsl</artifactId>
+            <version>2020.0.1</version>
         </dependency>
     </dependencies>
 

readme.adoc

@@ -246,6 +246,7 @@ This example doesn't handle introspection queries, but the one in the test direc
 * date(time)
 * interfaces
 * complex filter parameters, with optional query optimization strategy
+* spatial
 
 === Next
 
@@ -254,7 +255,6 @@ This example doesn't handle introspection queries, but the one in the test direc
 * input types
 * unions
 * scalars
-* spatial
 
 == Documentation
 

src/main/kotlin/org/neo4j/opencypherdsl/PassThrough.kt renamed to src/main/kotlin/org/neo4j/cypherdsl/core/PassThrough.kt

@@ -1,4 +1,4 @@
-package org.neo4j.opencypherdsl
+package org.neo4j.cypherdsl.core
 
 import java.util.*
 
@@ -7,4 +7,4 @@ class PassThrough(content: String) : Literal<String>(content) {
     override fun asString(): String {
         return Objects.requireNonNull(content)
     }
-}
+}

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

@@ -1,5 +1,6 @@
 package org.neo4j.graphql
 
+import graphql.Scalars
 import graphql.schema.*
 
 class BuildingEnv(val types: MutableMap<String, GraphQLType>) {
@@ -95,15 +96,28 @@ class BuildingEnv(val types: MutableMap<String, GraphQLType>) {
                 if (field.isRelationship()) {
                     RelationOperator.createRelationFilterFields(type, field, filterType, builder)
                 } else {
-                    FieldOperator.forType(types[filterType] ?: typeDefinition)
-                        .forEach { op -> builder.addFilterField(op.fieldName(field.name), op.list, filterType) }
+                    val graphQLType = types[filterType] ?: typeDefinition
+                    FieldOperator.forType(graphQLType)
+                        .forEach { op -> builder.addFilterField(op.fieldName(field.name), op.list, filterType, field.description) }
+                    if (graphQLType.isNeo4jSpatialType()) {
+                        val distanceFilterType = getSpatialDistanceFilter(graphQLType)
+                        FieldOperator.forType(distanceFilterType)
+                            .forEach { op -> builder.addFilterField(op.fieldName(field.name + NEO4j_POINT_DISTANCE_FILTER_SUFFIX), op.list, NEO4j_POINT_DISTANCE_FILTER) }
+                    }
                 }
 
             }
         types[filterName] = builder.build()
         return filterName
     }
 
+    private fun getSpatialDistanceFilter(pointType: GraphQLType): GraphQLInputType {
+        return addInputType(NEO4j_POINT_DISTANCE_FILTER, listOf(
+                GraphQLFieldDefinition.newFieldDefinition().name("distance").type(GraphQLNonNull(Scalars.GraphQLFloat)).build(),
+                GraphQLFieldDefinition.newFieldDefinition().name("point").type(GraphQLNonNull(pointType)).build()
+        ))
+    }
+
     fun addOrdering(type: GraphQLFieldsContainer): String? {
         val orderingName = "_${type.name}Ordering"
         var existingOrderingType = types[orderingName]
@@ -163,6 +177,7 @@ class BuildingEnv(val types: MutableMap<String, GraphQLType>) {
             GraphQLInputObjectField
                 .newInputObjectField()
                 .name(it.name)
+                .description(it.description)
                 .type(getInputType(type).ref() as GraphQLInputType)
                 .build()
         }

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

@@ -3,6 +3,8 @@ package org.neo4j.graphql
 import graphql.Scalars
 import graphql.language.*
 import graphql.schema.*
+import org.neo4j.cypherdsl.core.Node
+import org.neo4j.cypherdsl.core.Relationship
 import org.neo4j.graphql.DirectiveConstants.Companion.CYPHER
 import org.neo4j.graphql.DirectiveConstants.Companion.CYPHER_STATEMENT
 import org.neo4j.graphql.DirectiveConstants.Companion.DYNAMIC
@@ -17,8 +19,6 @@ 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.neo4j.opencypherdsl.Node
-import org.neo4j.opencypherdsl.Relationship
 
 fun Type<Type<*>>.name(): String? = if (this.inner() is TypeName) (this.inner() as TypeName).name else null
 fun Type<Type<*>>.inner(): Type<Type<*>> = when (this) {
@@ -35,7 +35,8 @@ fun GraphQLType.inner(): GraphQLType = when (this) {
 
 fun GraphQLType.isList() = this is GraphQLList || (this is GraphQLNonNull && this.wrappedType is GraphQLList)
 fun GraphQLType.isScalar() = this.inner().let { it is GraphQLScalarType || it.name.startsWith("_Neo4j") }
-fun GraphQLType.isNeo4jType() = this.inner().name?.startsWith("_Neo4j") == true
+fun GraphQLType.isNeo4jType() = this.innerName().startsWith("_Neo4j")
+fun GraphQLType.isNeo4jSpatialType() = this.innerName().startsWith("_Neo4jPoint")
 fun GraphQLFieldDefinition.isNeo4jType(): Boolean = this.type.isNeo4jType()
 
 fun GraphQLFieldDefinition.isRelationship() = !type.isNeo4jType() && this.type.inner().let { it is GraphQLFieldsContainer }
@@ -262,4 +263,4 @@ fun GraphQLInputObjectType.Builder.addFilterField(fieldName: String, isList: Boo
         .description(description)
         .type(wrappedType)
     this.field(inputField)
-}
+}

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

@@ -4,14 +4,13 @@ import graphql.language.Field
 import graphql.language.ObjectValue
 import graphql.schema.GraphQLFieldDefinition
 import graphql.schema.GraphQLFieldsContainer
-import java.time.*
-import java.time.temporal.Temporal
 
 const val NEO4j_FORMATTED_PROPERTY_KEY = "formatted"
+const val NEO4j_POINT_DISTANCE_FILTER = "_Neo4jPointDistanceFilter"
+const val NEO4j_POINT_DISTANCE_FILTER_SUFFIX = "_distance"
 
 data class TypeDefinition(
         val name: String,
-        val type: Class<out Temporal>,
         val typeDefinition: String,
         val inputDefinition: String = typeDefinition + "Input"
 )
@@ -75,9 +74,10 @@ data class Neo4jQueryConversion(val name: String, val propertyName: String, val
 }
 
 val neo4jTypeDefinitions = listOf(
-        TypeDefinition("LocalTime", OffsetTime::class.java, "_Neo4jTime"),
-        TypeDefinition("Date", LocalDate::class.java, "_Neo4jDate"),
-        TypeDefinition("DateTime", LocalDateTime::class.java, "_Neo4jDateTime"),
-        TypeDefinition("Time", Instant::class.java, "_Neo4jLocalTime"),
-        TypeDefinition("LocalDateTime", OffsetDateTime::class.java, "_Neo4jLocalDateTime")
+        TypeDefinition("LocalTime", "_Neo4jTime"),
+        TypeDefinition("Date", "_Neo4jDate"),
+        TypeDefinition("DateTime", "_Neo4jDateTime"),
+        TypeDefinition("Time", "_Neo4jLocalTime"),
+        TypeDefinition("LocalDateTime", "_Neo4jLocalDateTime"),
+        TypeDefinition("Point", "_Neo4jPoint")
 )