Generates data fetcher interface for query types

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

@@ -98,7 +98,13 @@ class CodeGen(private val config: CodeGenConfig) {
             codeGenResult.kotlinInputTypes.forEach { it.writeTo(config.outputDir) }
             codeGenResult.kotlinInterfaces.forEach { it.writeTo(config.outputDir) }
             codeGenResult.kotlinEnumTypes.forEach { it.writeTo(config.outputDir) }
-            codeGenResult.kotlinDataFetchers.forEach { it.writeTo(config.examplesOutputDir) }
+            codeGenResult.kotlinDataFetchers.forEach {
+                if (config.generateDataFetcherInterfaces) {
+                    it.writeTo(config.outputDir)
+                } else {
+                    it.writeTo(config.examplesOutputDir)
+                }
+            }
             codeGenResult.kotlinConstants.forEach { it.writeTo(config.outputDir) }
             codeGenResult.kotlinClientTypes.forEach { it.writeTo(config.outputDir) }
             codeGenResult.docFiles.forEach { it.writeTo(config.generatedDocsFolder) }
@@ -359,7 +365,8 @@ class CodeGen(private val config: CodeGenConfig) {
                 kotlinInputTypes = generateKotlin2InputTypes(config, document, requiredTypes),
                 kotlinInterfaces = generateKotlin2Interfaces(config, document),
                 kotlinEnumTypes = generateKotlin2EnumTypes(config, document, requiredTypes),
-                kotlinConstants = KotlinConstantsGenerator(config, document).generate().kotlinConstants
+                kotlinConstants = KotlinConstantsGenerator(config, document).generate().kotlinConstants,
+                kotlinDataFetchers = generateKotlin2DataFetcherInterfaces(config, document)
             )
         } else {
             val datatypesResult = generateKotlinDataTypes(definitions)
@@ -387,12 +394,23 @@ class CodeGen(private val config: CodeGenConfig) {
 
             val constantsClass = KotlinConstantsGenerator(config, document).generate()
 
+            val dataFetchers = if (config.generateDataFetcherInterfaces) {
+                definitions.asSequence()
+                    .filterIsInstance<ObjectTypeDefinition>()
+                    .filter { it.name == "Query" || it.name == "Mutation" || it.name == "Subscription" }
+                    .map { KotlinDataFetcherGenerator(config, document).generate(it) }
+                    .fold(CodeGenResult()) { result, next -> result.merge(next) }
+            } else {
+                CodeGenResult()
+            }
+
             datatypesResult
                 .merge(inputTypes)
                 .merge(interfacesResult)
                 .merge(unionResult)
                 .merge(enumsResult)
                 .merge(constantsClass)
+                .merge(dataFetchers)
         }
 
         val clientTypes = if (config.generateKotlinClosureProjections) {
@@ -505,6 +523,7 @@ class CodeGenConfig(
     var generateInterfaces: Boolean = false,
     var generateKotlinNullableClasses: Boolean = false,
     var generateKotlinClosureProjections: Boolean = false,
+    var generateDataFetcherInterfaces: Boolean = false,
     var typeMapping: Map<String, String> = emptyMap(),
     var includeQueries: Set<String> = emptySet(),
     var includeMutations: Set<String> = emptySet(),

graphql-dgs-codegen-core/src/main/kotlin/com/netflix/graphql/dgs/codegen/generators/kotlin/KotlinDataFetcherGenerator.kt

@@ -0,0 +1,92 @@
+package com.netflix.graphql.dgs.codegen.generators.kotlin
+
+import com.netflix.graphql.dgs.DgsComponent
+import com.netflix.graphql.dgs.DgsData
+import com.netflix.graphql.dgs.InputArgument
+import com.netflix.graphql.dgs.codegen.CodeGenConfig
+import com.netflix.graphql.dgs.codegen.CodeGenResult
+import com.netflix.graphql.dgs.codegen.generators.shared.CodeGeneratorUtils.capitalized
+import com.squareup.kotlinpoet.AnnotationSpec
+import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.TypeSpec
+import graphql.language.Document
+import graphql.language.FieldDefinition
+import graphql.language.ObjectTypeDefinition
+import graphql.schema.DataFetchingEnvironment
+
+class KotlinDataFetcherGenerator(private val config: CodeGenConfig, private val document: Document) {
+
+    private val packageName = config.packageNameDatafetchers
+    private val typeUtils = KotlinTypeUtils(config.packageNameTypes, config, document)
+    private val dsgConstantsPackageName = config.packageName
+
+    fun generate(topLevelObject: ObjectTypeDefinition): CodeGenResult =
+        topLevelObject.fieldDefinitions
+            .map { generateField(it, topLevelObject.name) }
+            .fold(CodeGenResult()) { left, right -> left.merge(right) }
+
+    private fun generateField(field: FieldDefinition, topLevelObjectName: String): CodeGenResult {
+        val fieldName = field.name.capitalized()
+        val className = fieldName + topLevelObjectName
+
+        val returnType = if (topLevelObjectName == "Subscription") {
+            val genericType = typeUtils.findReturnType(field.type)
+            ClassName.bestGuess("org.reactivestreams.Publisher").parameterizedBy(genericType)
+        } else {
+            typeUtils.findReturnType(field.type)
+        }
+
+        val dsgConstantPrefix = when (topLevelObjectName) {
+            "Query" -> "DgsConstants.QUERY"
+            "Mutation" -> "DgsConstants.MUTATION"
+            "Subscription" -> "DgsConstants.SUBSCRIPTION"
+            else -> error("not supported top level object type: $topLevelObjectName")
+        }
+
+        val annotationParentType = "$dsgConstantPrefix.TYPE_NAME"
+
+        val annotationFieldName = "$dsgConstantPrefix.$fieldName"
+
+        val dsgDataAnnotation = AnnotationSpec.builder(DgsData::class)
+            .addMember("parentType = $annotationParentType")
+            .addMember("field = $annotationFieldName")
+            .build()
+
+        val methodSpec = FunSpec.builder("${field.name}")
+            .addAnnotation(dsgDataAnnotation)
+            .addModifiers(KModifier.ABSTRACT)
+            .addInputArguments(field, dsgConstantPrefix)
+            .addParameter("dataFetchingEnvironment", DataFetchingEnvironment::class)
+            .returns(returnType)
+            .build()
+
+        val interfaceBuilder = TypeSpec.interfaceBuilder(className)
+            .addAnnotation(DgsComponent::class)
+            .addFunction(methodSpec)
+            .build()
+
+        val fileSpec = FileSpec.builder(packageName, interfaceBuilder.name!!)
+            .addType(interfaceBuilder)
+            .addImport(dsgConstantsPackageName, "DgsConstants")
+            .build()
+
+        return CodeGenResult(kotlinDataFetchers = listOf(fileSpec))
+    }
+
+    private fun FunSpec.Builder.addInputArguments(field: FieldDefinition, prefix: String): FunSpec.Builder = apply {
+        field.inputValueDefinitions.forEach { input ->
+            val inputAnnotation = AnnotationSpec.builder(InputArgument::class)
+                .addMember("$prefix.${field.name.uppercase()}_INPUT_ARGUMENT.${input.name.capitalized()}")
+                .build()
+            val inputType = ParameterSpec.builder(input.name, typeUtils.findReturnType(input.type))
+                .addAnnotation(inputAnnotation)
+                .build()
+            addParameter(inputType)
+        }
+    }
+}

graphql-dgs-codegen-core/src/main/kotlin/com/netflix/graphql/dgs/codegen/generators/kotlin2/GenerateKotlin2DataFetcherInterfaces.kt

@@ -0,0 +1,38 @@
+/*
+ *
+ *  Copyright 2020 Netflix, Inc.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package com.netflix.graphql.dgs.codegen.generators.kotlin2
+
+import com.netflix.graphql.dgs.codegen.CodeGenConfig
+import com.netflix.graphql.dgs.codegen.CodeGenResult
+import com.netflix.graphql.dgs.codegen.generators.kotlin.KotlinDataFetcherGenerator
+import com.squareup.kotlinpoet.FileSpec
+import graphql.language.Document
+import graphql.language.ObjectTypeDefinition
+
+fun generateKotlin2DataFetcherInterfaces(config: CodeGenConfig, document: Document): List<FileSpec> =
+    if (config.generateDataFetcherInterfaces) {
+        document.definitions.asSequence()
+            .filterIsInstance<ObjectTypeDefinition>()
+            .filter { it.name == "Query" || it.name == "Mutation" || it.name == "Subscription" }
+            .map { KotlinDataFetcherGenerator(config, document).generate(it) }
+            .fold(CodeGenResult()) { result, next -> result.merge(next) }
+            .kotlinDataFetchers
+    } else {
+        emptyList()
+    }