Merge pull request #380 from Netflix/query-and-projection-serialization-with-graphql-java

Leverage graphql-java in GraphQLQueryRequest and ProjectionSerializer

Author: srinivasankavitha

graphql-dgs-codegen-client-core/src/main/kotlin/com/netflix/graphql/dgs/client/codegen/EntitiesGraphQLQuery.kt

@@ -17,40 +17,53 @@
 package com.netflix.graphql.dgs.client.codegen
 
 import com.fasterxml.jackson.databind.ObjectMapper
-import java.util.*
+import graphql.language.ListType
+import graphql.language.NonNullType
+import graphql.language.TypeName
+import graphql.language.VariableDefinition
+import graphql.language.VariableReference
 
-class EntitiesGraphQLQuery : GraphQLQuery {
-    val variables: MutableMap<String, Any> = LinkedHashMap()
+class EntitiesGraphQLQuery(representations: List<Any>) : GraphQLQuery() {
 
-    constructor(representations: List<Any>?) {
-        variables["representations"] = representations!!
-    }
-
-    constructor()
+    val variables: Map<String, Any> = mapOf(REPRESENTATIONS_NAME to representations)
 
-    override fun getOperationType(): String {
-        return "query(\$representations: [_Any!]!)"
+    init {
+        variableDefinitions += VariableDefinition.newVariableDefinition()
+            .name(REPRESENTATIONS_NAME)
+            .type(
+                NonNullType.newNonNullType(
+                    ListType.newListType(
+                        NonNullType.newNonNullType(
+                            TypeName.newTypeName("_Any").build()
+                        ).build()
+                    ).build()
+                ).build()
+            )
+            .build()
+        input[REPRESENTATIONS_NAME] = VariableReference.newVariableReference().name(REPRESENTATIONS_NAME).build()
     }
 
     override fun getOperationName(): String {
-        return "_entities(representations: \$representations)"
+        return "_entities"
     }
 
     class Builder {
-        private val representations: MutableList<Any> = ArrayList()
-        val mapper = ObjectMapper()
+        private val representations = mutableListOf<Any>()
 
         fun build(): EntitiesGraphQLQuery {
             return EntitiesGraphQLQuery(representations)
         }
 
         fun addRepresentationAsVariable(representation: Any): Builder {
-            representations.add(mapper.convertValue(representation, HashMap::class.java))
+            representations += mapper.convertValue(representation, HashMap::class.java)
             return this
         }
     }
 
     companion object {
+        private val mapper = ObjectMapper()
+        private const val REPRESENTATIONS_NAME = "representations"
+
         fun newRequest(): Builder {
             return Builder()
         }

graphql-dgs-codegen-client-core/src/main/kotlin/com/netflix/graphql/dgs/client/codegen/GraphQLQuery.kt

@@ -16,10 +16,11 @@
 
 package com.netflix.graphql.dgs.client.codegen
 
-import java.util.*
+import graphql.language.VariableDefinition
 
 abstract class GraphQLQuery(val operation: String, val name: String?) {
-    val input: MutableMap<String, Any> = LinkedHashMap()
+    val input: MutableMap<String, Any> = mutableMapOf()
+    val variableDefinitions = mutableListOf<VariableDefinition>()
 
     constructor(operation: String) : this(operation, null)
     constructor() : this("query")

graphql-dgs-codegen-client-core/src/main/kotlin/com/netflix/graphql/dgs/client/codegen/GraphQLQueryRequest.kt

@@ -16,6 +16,11 @@
 
 package com.netflix.graphql.dgs.client.codegen
 
+import graphql.language.Argument
+import graphql.language.AstPrinter
+import graphql.language.Field
+import graphql.language.OperationDefinition
+import graphql.language.SelectionSet
 import graphql.schema.Coercing
 
 class GraphQLQueryRequest(
@@ -30,35 +35,37 @@ class GraphQLQueryRequest(
     private val projectionSerializer = ProjectionSerializer(inputValueSerializer)
 
     fun serialize(): String {
-        val builder = StringBuilder()
-        builder.append(query.getOperationType())
-        if (query.name != null) {
-            builder.append(" ").append(query.name)
+        val operationDef = OperationDefinition.newOperationDefinition()
+
+        query.name?.let { operationDef.name(it) }
+        query.getOperationType()?.let { operationDef.operation(OperationDefinition.Operation.valueOf(it.uppercase())) }
+
+        if (query.variableDefinitions.isNotEmpty()) {
+            operationDef.variableDefinitions(query.variableDefinitions)
         }
-        builder.append(" {").append(query.getOperationName())
-        val input: Map<String, Any?> = query.input
-        if (input.isNotEmpty()) {
-            builder.append("(")
-            val inputEntryIterator = input.entries.iterator()
-            while (inputEntryIterator.hasNext()) {
-                val (key, value) = inputEntryIterator.next()
-                builder.append(key)
-                builder.append(": ")
-                builder.append(inputValueSerializer.serialize(value))
-                if (inputEntryIterator.hasNext()) {
-                    builder.append(", ")
+
+        val selection = Field.newField(query.getOperationName())
+        if (query.input.isNotEmpty()) {
+            selection.arguments(
+                query.input.map { (name, value) ->
+                    Argument(name, inputValueSerializer.toValue(value))
                 }
-            }
-            builder.append(")")
+            )
         }
 
-        if (projection is BaseSubProjectionNode<*, *>) {
-            builder.append(projectionSerializer.serialize(projection.root() as BaseProjectionNode))
-        } else if (projection != null) {
-            builder.append(projectionSerializer.serialize(projection))
+        if (projection != null) {
+            val selectionSet = if (projection is BaseSubProjectionNode<*, *>) {
+                projectionSerializer.toSelectionSet(projection.root() as BaseProjectionNode)
+            } else {
+                projectionSerializer.toSelectionSet(projection)
+            }
+            if (selectionSet.selections.isNotEmpty()) {
+                selection.selectionSet(selectionSet)
+            }
         }
 
-        builder.append(" }")
-        return builder.toString()
+        operationDef.selectionSet(SelectionSet.newSelectionSet().selection(selection.build()).build())
+
+        return AstPrinter.printAst(operationDef.build())
     }
 }

graphql-dgs-codegen-client-core/src/main/kotlin/com/netflix/graphql/dgs/client/codegen/InputValueSerializer.kt

@@ -68,11 +68,15 @@ class InputValueSerializer(private val scalars: Map<Class<*>, Coercing<*, *>> =
         return AstPrinter.printAst(toValue(input))
     }
 
-    private fun toValue(input: Any?): Value<*> {
+    fun toValue(input: Any?): Value<*> {
         if (input == null) {
             return NullValue.newNullValue().build()
         }
 
+        if (input is Value<*>) {
+            return input
+        }
+
         if (input::class.java in scalars) {
             return scalars.getValue(input::class.java).valueToLiteral(input)
         }

graphql-dgs-codegen-client-core/src/main/kotlin/com/netflix/graphql/dgs/client/codegen/ProjectionSerializer.kt

@@ -16,52 +16,63 @@
 
 package com.netflix.graphql.dgs.client.codegen
 
-import java.util.*
+import graphql.language.Argument
+import graphql.language.AstPrinter
+import graphql.language.Field
+import graphql.language.InlineFragment
+import graphql.language.SelectionSet
+import graphql.language.TypeName
 
 class ProjectionSerializer(private val inputValueSerializer: InputValueSerializer) {
 
-    fun serialize(projection: BaseProjectionNode, isFragment: Boolean = false): String {
-        if (projection.fields.isEmpty() && projection.fragments.isEmpty()) {
-            return ""
-        }
-
-        val prefix = if (isFragment) {
-            val schemaType = projection.schemaType.orElse(
-                projection::class.java.name
-                    .substringAfterLast(".")
-                    .substringAfterLast("_")
-                    .substringBefore("Projection")
-            )
-            "... on $schemaType { "
-        } else {
-            "{ "
-        }
+    fun toSelectionSet(projection: BaseProjectionNode): SelectionSet {
+        val selectionSet = SelectionSet.newSelectionSet()
 
-        val joiner = StringJoiner(" ", prefix, " }")
-        projection.fields.forEach { (key, value) ->
-            val field = if (projection.inputArguments[key] != null) {
-                val inputArgsJoiner = StringJoiner(", ", "(", ")")
-                projection.inputArguments[key]?.forEach {
-                    inputArgsJoiner.add("${it.name}: ${inputValueSerializer.serialize(it.value)}")
+        for ((fieldName, value) in projection.fields) {
+            val fieldSelection = Field.newField()
+                .name(fieldName)
+                .arguments(
+                    projection.inputArguments[fieldName].orEmpty().map { (argName, values) ->
+                        Argument(argName, inputValueSerializer.toValue(values))
+                    }
+                )
+            if (value is BaseProjectionNode) {
+                val fieldSelectionSet = toSelectionSet(value)
+                if (fieldSelectionSet.selections.isNotEmpty()) {
+                    fieldSelection.selectionSet(fieldSelectionSet)
                 }
-
-                key + inputArgsJoiner.toString()
-            } else {
-                key
+            } else if (value != null) {
+                fieldSelection.selectionSet(
+                    SelectionSet.newSelectionSet()
+                        .selection(Field.newField(value.toString()).build())
+                        .build()
+                )
             }
+            selectionSet.selection(fieldSelection.build())
+        }
 
-            joiner.add(field)
-            if (value != null) {
-                if (value is BaseProjectionNode) {
-                    joiner.add(" ").add(serialize(value))
-                } else {
-                    joiner.add(" ").add(value.toString())
+        for (fragment in projection.fragments) {
+            val typeCondition = fragment.schemaType.map { TypeName(it) }
+                .orElseGet {
+                    val className = fragment::class.simpleName
+                        ?: throw AssertionError("Unable to determine class name for projection: $fragment")
+                    TypeName(
+                        className.substringAfterLast("_")
+                            .substringBefore("Projection")
+                    )
                 }
-            }
-        }
 
-        projection.fragments.forEach { joiner.add(serialize(it, true)) }
+            selectionSet.selection(
+                InlineFragment.newInlineFragment()
+                    .typeCondition(typeCondition)
+                    .selectionSet(toSelectionSet(fragment))
+                    .build()
+            )
+        }
+        return selectionSet.build()
+    }
 
-        return joiner.toString()
+    fun serialize(projection: BaseProjectionNode): String {
+        return AstPrinter.printAst(toSelectionSet(projection))
     }
 }