Added configurable schema augmentation for each type

- mutation: create, delete, update
- query
- ordering enum
- input type
- filter input type

Added GraphQLServer.kt example in tests

TODO: docs

Author: jexp

pom.xml

@@ -25,7 +25,7 @@
         <kotlin.version>1.3.11</kotlin.version>
         <kotlin.compiler.jvmTarget>${java.version}</kotlin.compiler.jvmTarget>
         <neo4j.version>3.4.1</neo4j.version>
-        <driver.version>1.6.2</driver.version>
+        <driver.version>1.7.2</driver.version>
     </properties>
 
     <organization>
@@ -55,6 +55,18 @@
             <version>${driver.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.sparkjava</groupId>
+            <artifactId>spark-core</artifactId>
+            <version>2.7.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.5</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.neo4j.test</groupId>
             <artifactId>neo4j-harness</artifactId>

readme.adoc

@@ -154,6 +154,39 @@ And can run queries like:
 
 image::docs/graphiql.jpg[]
 
+You can also test it with `curl`
+
+----
+curl -XPOST http://localhost:4567/graphql -d'{"query":"{person {name}}"}'
+----
+
+== Advanced Queries
+
+----
+{
+  person(filter: {name_starts_with: "L"}, orderBy: "born_asc", first: 5, offset: 2) {
+    name
+    born
+    actedIn(first: 1) {
+      title
+    }
+  }
+}
+----
+
+----
+{
+  person(filter: {name_starts_with: "J", born_gte: 1970}, first:2) {
+    name
+    born
+    actedIn(first:1) {
+      title
+      released
+    }
+  }
+}
+----
+
 == Features
 
 === Current

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

@@ -0,0 +1,42 @@
+package org.neo4j.graphql
+
+import graphql.language.FieldDefinition
+import graphql.language.ObjectTypeDefinition
+
+data class Augmentation(val create: String = "", val update: String = "", val delete: String = "",
+                        val inputType: String = "", val ordering: String = "", val filterType: String = "", val query: String = "")
+
+fun augmentedSchema(ctx: Translator.Context, type: ObjectTypeDefinition): Augmentation {
+    val typeName = type.name
+    val idField = type.fieldDefinitions.find { it.type.name() == "ID" }
+    val scalarFields = type.fieldDefinitions.filter { it.type.isScalar() }.sortedByDescending { it == idField }
+    val idFieldArg = idField?.let { it.name + ":" + it.type.render() }
+
+    val result = if (ctx.mutation.enabled && !ctx.mutation.exclude.contains(typeName) && scalarFields.isNotEmpty()) {
+        val fieldArgs = scalarFields.map { it.name + ":" + it.type.render() }.joinToString(", ")
+        Augmentation().copy(create = """create$typeName($fieldArgs) : $typeName """)
+                .let { aug ->
+                    if (idField != null) aug.copy(
+                            delete = """delete$typeName($idFieldArg) : Boolean """,
+                            update = """update$typeName($fieldArgs) : $typeName """)
+                    else aug
+                }
+    } else Augmentation()
+
+    return if (ctx.query.enabled && !ctx.query.exclude.contains(typeName) && scalarFields.isNotEmpty()) {
+        val fieldArgs = scalarFields.map { it.name + ":" + it.type.render(false) }.joinToString(", ")
+        result.copy(inputType = """input _${typeName}Input { $fieldArgs } """,
+                ordering = """enum _${typeName}Ordering { ${scalarFields.map { it.name + "_asc ," + it.name + "_desc" }.joinToString(",")} } """,
+                filterType = filterType(typeName, scalarFields), // TODO
+                query = """${typeName.decapitalize()}(${fieldArgs} , _id: Int, filter:_${typeName}Filter, orderBy:_${typeName}Ordering, first:Int, offset:Int) : [$typeName] """)
+    } else result
+}
+
+private fun filterType(name: String?, fieldArgs: List<FieldDefinition>) : String {
+    val fName = """_${name}Filter"""
+    val fields = (listOf("AND","OR","NOT").map { "$it:[$fName!]" } +
+            fieldArgs.flatMap { field -> Operators.forType(field.type).map { op -> op.fieldName(field.name) + ":" + field.type.render(false) } }).joinToString(", ")
+    return """input $fName { $fields } """
+}
+
+

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

@@ -1,18 +1,36 @@
 package org.neo4j.graphql
 
 import graphql.language.*
-import graphql.schema.GraphQLList
-import graphql.schema.GraphQLNonNull
-import graphql.schema.GraphQLSchema
-import graphql.schema.GraphQLType
+import graphql.schema.*
 
 fun GraphQLType.inner() : GraphQLType = when(this) {
     is GraphQLList -> this.wrappedType.inner()
     is GraphQLNonNull -> this.wrappedType.inner()
     else -> this
 }
+val SCALAR_TYPES = listOf("String","ID","Boolean","Int","Float")
+
+fun Type.isScalar() = this.inner().name()?.let { SCALAR_TYPES.contains(it) } ?: false
+fun Type.name() : String? = if (this.inner() is TypeName) (this.inner() as TypeName).name else null
+
+fun Type.inner() : Type = when(this) {
+    is ListType -> this.type.inner()
+    is NonNullType -> this.type.inner()
+    else -> this
+}
+fun Type.render(nonNull:Boolean = true) : String = when(this) {
+    is ListType -> "[${this.type.render()}]"
+    is NonNullType -> this.type.render()+ (if (nonNull) "!" else "")
+    is TypeName -> this.name
+    else -> throw IllegalStateException("Can't render $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.isRelationship() = this.inner().let { it is GraphQLObjectType } // && relationship directive
+
+fun GraphQLObjectType.hasRelationship(name:String) = this.getFieldDefinition(name)?.isRelationship() ?: false
+fun GraphQLFieldDefinition.isRelationship() = this.type.isRelationship()
 
 fun Field.aliasOrName() = (this.alias ?: this.name).quote()
 

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

@@ -2,6 +2,7 @@ package org.neo4j.graphql
 
 import graphql.Scalars
 import graphql.language.Directive
+import graphql.language.Type
 import graphql.schema.*
 import org.neo4j.graphql.Predicate.Companion.resolvePredicate
 
@@ -47,8 +48,6 @@ fun toExpression(name: String, value: Any?, type: GraphQLObjectType): Predicate
             resolvePredicate(name, value, type)
         }
 
-fun GraphQLObjectType.hasRelationship(name:String) = this.getFieldDefinition(name)?.let { it.type is GraphQLObjectType } ?: false
-
 fun GraphQLObjectType.relationshipFor(name:String, schema: GraphQLSchema) : RelationshipInfo {
     val field = this.getFieldDefinition(name)
     val fieldObjectType = schema.getType(field.type.inner().name) as GraphQLObjectType
@@ -196,6 +195,14 @@ enum class Operators(val suffix:String, val op:String, val not :Boolean = false)
                 else listOf(EQ, NEQ, IN, NIN,LT,LTE,GT,GTE) +
                         if (type == Scalars.GraphQLString || type == Scalars.GraphQLID) listOf(C,NC, SW, NSW,EW,NEW) else emptyList()
 
+        fun forType(type: Type) : List<Operators> =
+                if (type.name() == "Boolean") listOf(EQ, NEQ)
+                // todo list types
+                // todo proper enum + object types and reference types
+                else if (!type.isScalar()) listOf(EQ, NEQ, IN, NIN)
+                else listOf(EQ, NEQ, IN, NIN,LT,LTE,GT,GTE) +
+                        if (type.name() == "String" || type.name() == "ID") listOf(C,NC, SW, NSW,EW,NEW) else emptyList()
+
     }
 
     fun fieldName(fieldName: String) = if (this == EQ) fieldName else fieldName + "_" + suffix

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

@@ -8,11 +8,18 @@ import graphql.schema.*
 import graphql.schema.idl.RuntimeWiring
 import graphql.schema.idl.SchemaGenerator
 import graphql.schema.idl.SchemaParser
+import graphql.schema.idl.TypeDefinitionRegistry
 import org.antlr.v4.runtime.misc.ParseCancellationException
+import java.lang.RuntimeException
 import java.util.*
 
 class Translator(val schema: GraphQLSchema) {
-    data class Context @JvmOverloads constructor(val topLevelWhere: Boolean = true, val fragments : Map<String,FragmentDefinition> = emptyMap(),val temporal : Boolean = false)
+    data class Context @JvmOverloads constructor(val topLevelWhere: Boolean = true,
+                                                 val fragments : Map<String,FragmentDefinition> = emptyMap(),
+                                                 val temporal : Boolean = false,
+                                                 val query: CRUDConfig = CRUDConfig(),
+                                                 val mutation: CRUDConfig = CRUDConfig())
+    data class CRUDConfig(val enabled:Boolean = true, val exclude: List<String> = emptyList())
     data class Cypher( val query: String, val params : Map<String,Any?> = emptyMap()) {
         companion object {
             val EMPTY = Cypher("")
@@ -239,22 +246,68 @@ class Translator(val schema: GraphQLSchema) {
 
 
 object SchemaBuilder {
-    @JvmStatic fun buildSchema(sdl: String) : GraphQLSchema {
+    @JvmStatic fun buildSchema(sdl: String, ctx: Translator.Context = Translator.Context() ) : GraphQLSchema {
         val schemaParser = SchemaParser()
-        val typeDefinitionRegistry = schemaParser.parse(sdl)
+        val typeDefinitionRegistry = augmentSchema(schemaParser.parse(sdl), schemaParser, ctx)
 
         val runtimeWiring = RuntimeWiring.newRuntimeWiring()
                 .type("Query")
                 { it.dataFetcher("hello") { env -> "Hello ${env.getArgument<Any>("what")}!" } }
                 .build()
 
         val schemaGenerator = SchemaGenerator()
+        return schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring)
+                .transform { bc -> bc.additionalDirectives(additionalDirectives()).build() }
+                .transform { sc -> sc.build() } // todo add new queries, filters, enums etc.
+    }
+
+    private fun additionalDirectives(): Set<GraphQLDirective> {
         val directives = setOf(GraphQLDirective("relation", "relation directive",
-                EnumSet.of(Introspection.DirectiveLocation.FIELD,Introspection.DirectiveLocation.OBJECT),
-                listOf(GraphQLArgument("name",Scalars.GraphQLString),
-                        GraphQLArgument("direction","relationship direction",Scalars.GraphQLString,"OUT"),
-                        GraphQLArgument("from","from field name",Scalars.GraphQLString,"from"),
-                        GraphQLArgument("to","to field name",Scalars.GraphQLString,"to")),false,false,true))
-        return schemaGenerator.makeExecutableSchema(typeDefinitionRegistry, runtimeWiring).transform { bc -> bc.additionalDirectives(directives).build() }
+                EnumSet.of(Introspection.DirectiveLocation.FIELD, Introspection.DirectiveLocation.OBJECT),
+                listOf(GraphQLArgument("name", Scalars.GraphQLString),
+                        GraphQLArgument("direction", "relationship direction", Scalars.GraphQLString, "OUT"),
+                        GraphQLArgument("from", "from field name", Scalars.GraphQLString, "from"),
+                        GraphQLArgument("to", "to field name", Scalars.GraphQLString, "to")), false, false, true))
+        return directives
+    }
+
+    private fun augmentSchema(typeDefinitionRegistry: TypeDefinitionRegistry, schemaParser: SchemaParser, ctx: Translator.Context): TypeDefinitionRegistry {
+
+        val augmentations = typeDefinitionRegistry.types().values.filterIsInstance<ObjectTypeDefinition>().map { augmentedSchema(ctx, it) }
+
+        val augmentedTypesSdl = augmentations.flatMap { listOf(it.filterType, it.ordering, it.inputType).filter { it.isNotBlank() } }.joinToString("\n")
+        typeDefinitionRegistry.merge(schemaParser.parse(augmentedTypesSdl))
+
+        val schemaDefinition = typeDefinitionRegistry.schemaDefinition().orElseGet { SchemaDefinition() }
+        if (!typeDefinitionRegistry.schemaDefinition().isPresent) typeDefinitionRegistry.add(schemaDefinition).ifPresent { throw RuntimeException(it.toSpecification().toString()) }
+
+        val operations = schemaDefinition.operationTypeDefinitions.associate { it.name to typeDefinitionRegistry.getType(it.type).get() as ObjectTypeDefinition }.toMap()
+
+        val queryDefinition = operations.getOrElse("query") {
+            ObjectTypeDefinition("Query").also {
+                schemaDefinition.operationTypeDefinitions.add(OperationTypeDefinition("query",TypeName(it.name)))
+                typeDefinitionRegistry.add(it)
+            }
+        }
+        val mutationDefinition = operations.getOrElse("mutation") {
+                ObjectTypeDefinition("Mutation").also { schemaDefinition.operationTypeDefinitions.add(OperationTypeDefinition("mutation",TypeName(it.name)))
+                typeDefinitionRegistry.add(it)
+            }
+        }
+
+        augmentations.filter { it.query.isNotBlank() }.map { it.query }.let {
+            if (!it.isEmpty()) {
+                val newQueries = schemaParser.parse("type AugmentedQuery { ${it.joinToString("\n")} }").getType("AugmentedQuery").get() as ObjectTypeDefinition
+                queryDefinition.fieldDefinitions.addAll(newQueries.fieldDefinitions)
+            }
+        }
+        augmentations.flatMap { listOf(it.create,it.update,it.delete).filter{ it.isNotBlank() }}.let {
+            if (!it.isEmpty()) {
+                val newQueries = schemaParser.parse("type AugmentedMutation { ${it.joinToString("\n")} }").getType("AugmentedMutation").get() as ObjectTypeDefinition
+                mutationDefinition.fieldDefinitions.addAll(newQueries.fieldDefinitions)
+            }
+        }
+
+        return typeDefinitionRegistry
     }
 }

src/test/kotlin/GraphQLServer.kt

@@ -0,0 +1,72 @@
+package demo
+
+// Simplistic GraphQL Server using SparkJava
+
+import com.google.gson.Gson
+import org.neo4j.driver.v1.AuthTokens
+import org.neo4j.driver.v1.GraphDatabase
+import org.neo4j.driver.v1.Values
+import org.neo4j.graphql.SchemaBuilder
+import org.neo4j.graphql.Translator
+import spark.Request
+import spark.Response
+import spark.Spark
+import graphql.*
+import java.math.BigDecimal
+import java.math.BigInteger
+
+val schema = """
+type Person {
+  name: String
+  born: Int
+  actedIn: [Movie] @relation(name:"ACTED_IN")
+}
+type Movie {
+  title: String
+  released: Int
+  tagline: String
+}
+"""
+
+fun main(args: Array<String>) {
+    val gson = Gson()
+    fun render(value:Any) =  gson.toJson(value)
+    fun query(value:String) = (gson.fromJson(value, Map::class.java)["query"] as String).also { println(it) }
+
+    val graphQLSchema = SchemaBuilder.buildSchema(schema)
+    println(graphQLSchema)
+    val build = GraphQL.newGraphQL(graphQLSchema).build()
+    val graphql = Translator(graphQLSchema)
+    fun translate(query:String) = graphql.translate(query)
+
+    val driver = GraphDatabase.driver("bolt://localhost",AuthTokens.basic("neo4j","password"))
+    fun run(cypher:Translator.Cypher) = driver.session().use {
+        println(cypher.query)
+        println(cypher.params)
+        try {
+            // todo fix parameter mapping in translator
+            val result = it.run(cypher.query, Values.value(cypher.params.mapValues {
+                it.value.let {
+                    when (it) {
+                        is BigInteger -> it.longValueExact()
+                        is BigDecimal -> it.toDouble()
+                        else -> it
+                    }
+                }
+            }))
+            // result.list{ it.asMap().toList() }.flatten().groupBy({ it.first },{it.second})
+            result.keys().map { key -> key to result.list().map { it.get(key).asObject() } }.toMap(LinkedHashMap())
+        } catch(e:Exception) {
+            e.printStackTrace()
+        }
+    }
+
+
+    fun handler(req: Request, res: Response) = query(req.body()).let { query ->
+        if (query.contains("__schema"))
+            build.execute(query).let { println(it.errors);it.getData<Any>() }
+        else run(translate(query).first()) }
+
+    Spark.post("/graphql","application/json", ::handler, ::render)
+}
+