Merge pull request #342 from Netflix/allow-null-for-input-args

Add info logs for better debuggability of schema issues during generation.

Author: srinivasankavitha

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

@@ -25,16 +25,21 @@ import com.netflix.graphql.dgs.codegen.shouldSkip
 import com.squareup.javapoet.*
 import graphql.language.*
 import graphql.language.TypeName
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import javax.lang.model.element.Modifier
 
 class DataTypeGenerator(private val config: CodeGenConfig, private val document: Document) : BaseDataTypeGenerator(config.packageNameTypes, config, document) {
+    private val logger: Logger = LoggerFactory.getLogger(DataTypeGenerator::class.java)
+
     fun generate(definition: ObjectTypeDefinition, extensions: List<ObjectTypeExtensionDefinition>): CodeGenResult {
         if (definition.shouldSkip(config)) {
             return CodeGenResult()
         }
 
-        val name = definition.name
+        logger.info("Generating data type ${definition.name}")
 
+        val name = definition.name
         val unionTypes = document.getDefinitionsOfType(UnionTypeDefinition::class.java).filter { union ->
             union.memberTypes.asSequence().map { it as TypeName }.any { it.name == name }
         }.map { it.name }
@@ -97,13 +102,16 @@ class DataTypeGenerator(private val config: CodeGenConfig, private val document:
 }
 
 class InputTypeGenerator(private val config: CodeGenConfig, document: Document) : BaseDataTypeGenerator(config.packageNameTypes, config, document) {
+    private val logger: Logger = LoggerFactory.getLogger(InputTypeGenerator::class.java)
+
     fun generate(definition: InputObjectTypeDefinition, extensions: List<InputObjectTypeExtensionDefinition>): CodeGenResult {
         if (definition.shouldSkip(config)) {
             return CodeGenResult()
         }
 
-        val name = definition.name
+        logger.info("Generating input type ${definition.name}")
 
+        val name = definition.name
         val fieldDefinitions = definition.inputValueDefinitions.map {
             val defaultValue = it.defaultValue?.let { defVal ->
                 when (defVal) {

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

@@ -24,14 +24,20 @@ import com.netflix.graphql.dgs.codegen.shouldSkip
 import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.TypeSpec
 import graphql.language.EnumTypeDefinition
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import javax.lang.model.element.Modifier
 
 class EnumTypeGenerator(private val config: CodeGenConfig) {
+    private val logger: Logger = LoggerFactory.getLogger(EnumTypeGenerator::class.java)
+
     fun generate(definition: EnumTypeDefinition, extensions: List<EnumTypeDefinition>): CodeGenResult {
         if (definition.shouldSkip(config)) {
             return CodeGenResult()
         }
 
+        logger.info("Generating enum type ${definition.name}")
+
         val javaType =
             TypeSpec
                 .enumBuilder(definition.name)

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

@@ -28,13 +28,16 @@ import com.squareup.javapoet.JavaFile
 import com.squareup.javapoet.MethodSpec
 import com.squareup.javapoet.TypeSpec
 import graphql.language.*
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import javax.lang.model.element.Modifier
 
 class InterfaceGenerator(private val config: CodeGenConfig, private val document: Document) {
 
     private val packageName = config.packageNameTypes
     private val typeUtils = TypeUtils(packageName, config, document)
     private val useInterfaceType = config.generateInterfaces
+    private val logger: Logger = LoggerFactory.getLogger(InterfaceGenerator::class.java)
 
     fun generate(
         definition: InterfaceTypeDefinition,
@@ -45,6 +48,7 @@ class InterfaceGenerator(private val config: CodeGenConfig, private val document
             return CodeGenResult()
         }
 
+        logger.info("Generating type ${definition.name}")
         val javaType = TypeSpec.interfaceBuilder(definition.name)
             .addModifiers(Modifier.PUBLIC)
 

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

@@ -21,6 +21,7 @@ package com.netflix.graphql.dgs.codegen.generators.kotlin
 import com.netflix.graphql.dgs.codegen.CodeGenConfig
 import com.netflix.graphql.dgs.codegen.CodeGenResult
 import com.netflix.graphql.dgs.codegen.filterSkipped
+import com.netflix.graphql.dgs.codegen.generators.java.InputTypeGenerator
 import com.netflix.graphql.dgs.codegen.shouldSkip
 import com.squareup.kotlinpoet.BOOLEAN
 import com.squareup.kotlinpoet.ClassName
@@ -38,14 +39,20 @@ import com.squareup.kotlinpoet.PropertySpec
 import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.TypeSpec
 import graphql.language.*
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 import com.squareup.kotlinpoet.TypeName as KtTypeName
 
 class KotlinDataTypeGenerator(private val config: CodeGenConfig, private val document: Document) : AbstractKotlinDataTypeGenerator(config.packageNameTypes, config) {
+    private val logger: Logger = LoggerFactory.getLogger(InputTypeGenerator::class.java)
+
     fun generate(definition: ObjectTypeDefinition, extensions: List<ObjectTypeExtensionDefinition>): CodeGenResult {
         if (definition.shouldSkip(config)) {
             return CodeGenResult()
         }
 
+        logger.info("Generating data type ${definition.name}")
+
         val fields = definition.fieldDefinitions
             .filterSkipped()
             .filter(ReservedKeywordFilter.filterInvalidNames)
@@ -63,11 +70,15 @@ class KotlinDataTypeGenerator(private val config: CodeGenConfig, private val doc
 }
 
 class KotlinInputTypeGenerator(private val config: CodeGenConfig, private val document: Document) : AbstractKotlinDataTypeGenerator(config.packageNameTypes, config) {
+    private val logger: Logger = LoggerFactory.getLogger(InputTypeGenerator::class.java)
+
     fun generate(definition: InputObjectTypeDefinition, extensions: List<InputObjectTypeExtensionDefinition>): CodeGenResult {
         if (definition.shouldSkip(config)) {
             return CodeGenResult()
         }
 
+        logger.info("Generating input type ${definition.name}")
+
         val fields = definition.inputValueDefinitions
             .filter(ReservedKeywordFilter.filterInvalidNames)
             .map {

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

@@ -20,18 +20,25 @@ package com.netflix.graphql.dgs.codegen.generators.kotlin
 
 import com.netflix.graphql.dgs.codegen.CodeGenConfig
 import com.netflix.graphql.dgs.codegen.CodeGenResult
+import com.netflix.graphql.dgs.codegen.generators.java.EnumTypeGenerator
 import com.netflix.graphql.dgs.codegen.shouldSkip
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.TypeSpec
 import graphql.language.EnumTypeDefinition
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 class KotlinEnumTypeGenerator(private val config: CodeGenConfig) {
+    private val logger: Logger = LoggerFactory.getLogger(EnumTypeGenerator::class.java)
+
     fun generate(definition: EnumTypeDefinition, extensions: List<EnumTypeDefinition>): CodeGenResult {
         if (definition.shouldSkip(config)) {
             return CodeGenResult()
         }
 
+        logger.info("Generating enum type ${definition.name}")
+
         val kotlinType = TypeSpec.classBuilder(definition.name).addModifiers(KModifier.ENUM)
 
         if (definition.description != null) {

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

@@ -24,11 +24,14 @@ import com.netflix.graphql.dgs.codegen.shouldSkip
 import com.squareup.kotlinpoet.*
 import graphql.language.*
 import graphql.language.TypeName
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 class KotlinInterfaceTypeGenerator(private val config: CodeGenConfig) {
 
     private val packageName = config.packageNameTypes
     private val typeUtils = KotlinTypeUtils(packageName, config)
+    private val logger: Logger = LoggerFactory.getLogger(KotlinInterfaceTypeGenerator::class.java)
 
     fun generate(
         definition: InterfaceTypeDefinition,
@@ -39,6 +42,8 @@ class KotlinInterfaceTypeGenerator(private val config: CodeGenConfig) {
             return CodeGenResult()
         }
 
+        logger.info("Generating type ${definition.name}")
+
         val interfaceBuilder = TypeSpec.interfaceBuilder(definition.name)
         if (definition.description != null) {
             interfaceBuilder.addKdoc("%L", definition.description.sanitizeKdoc())