Add Boolean fields to Data classes for supporting sparse update

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

@@ -46,7 +46,7 @@ class CodeGenCli : CliktCommand("Generate Java sources for SCHEMA file(s)") {
     )
     private val language by option("--language", "-l", help = "Output language").choice("java", "kotlin", ignoreCase = true)
         .default("java")
-    private val generateClient by option("--generate-client", "-c", help = "Genereate client api").flag(default = false)
+    private val generateClient by option("--generate-client", "-c", help = "Generate client api").flag(default = false)
     private val generateDataTypes by option(
         "--generate-data-types",
         help = "Generate data types. Not needed when only generating an API"

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

@@ -19,6 +19,7 @@
 package com.netflix.graphql.dgs.codegen.generators.java
 
 import com.netflix.graphql.dgs.codegen.*
+import com.netflix.graphql.dgs.codegen.generators.shared.CodeGeneratorUtils.capitalized
 import com.netflix.graphql.dgs.codegen.generators.shared.SiteTarget
 import com.netflix.graphql.dgs.codegen.generators.shared.applyDirectivesJava
 import com.squareup.javapoet.*
@@ -228,6 +229,7 @@ abstract class BaseDataTypeGenerator(
         addEquals(javaType)
         addHashcode(javaType)
         addBuilder(javaType)
+        addIsDefinedFieldWithGetters(javaType)
 
         val javaFile = JavaFile.builder(packageName, javaType.build()).build()
 
@@ -342,6 +344,10 @@ abstract class BaseDataTypeGenerator(
                 .addParameter(parameterBuilder.build())
                 .addModifiers(Modifier.PUBLIC)
                 .addStatement("this.\$N = \$N", ReservedKeywordSanitizer.sanitize(it.name), ReservedKeywordSanitizer.sanitize(it.name))
+                .addStatement(
+                    "this.\$N = true",
+                    ReservedKeywordSanitizer.sanitize(generateBooleanFieldName(it.name))
+                )
         }
 
         javaType.addMethod(constructorBuilder.build())
@@ -362,6 +368,33 @@ abstract class BaseDataTypeGenerator(
         addFieldWithGetterAndSetter(fieldDefinition.type, fieldDefinition, javaType)
     }
 
+    private fun addIsDefinedFieldWithGetters(javaType: TypeSpec.Builder) {
+        val fields = javaType.build().fieldSpecs
+        fields.forEach() {
+            val fieldName = "is${it.name.capitalized()}Defined"
+            val field = FieldSpec
+                .builder(com.squareup.javapoet.TypeName.BOOLEAN, fieldName)
+                .addModifiers(Modifier.PRIVATE)
+                .initializer("false")
+                .build()
+            val getterName = "getIs${it.name.capitalized()}Defined"
+            val getter = MethodSpec
+                .methodBuilder(getterName)
+                .addModifiers(Modifier.PUBLIC)
+                .returns(com.squareup.javapoet.TypeName.BOOLEAN)
+                .addStatement(
+                    "return \$N",
+                    ReservedKeywordSanitizer.sanitize("${generateBooleanFieldName(it.name)}")
+                ).build()
+            javaType.addField(field)
+            javaType.addMethod(getter)
+        }
+    }
+
+    private fun generateBooleanFieldName(name: String): String {
+        return "is${name.capitalized()}Defined"
+    }
+
     private fun addFieldWithGetterAndSetter(returnType: com.squareup.javapoet.TypeName?, fieldDefinition: Field, javaType: TypeSpec.Builder) {
         val fieldBuilder = if (fieldDefinition.initialValue != null) {
             FieldSpec
@@ -397,6 +430,10 @@ abstract class BaseDataTypeGenerator(
                 ReservedKeywordSanitizer.sanitize(fieldDefinition.name),
                 ReservedKeywordSanitizer.sanitize(fieldDefinition.name)
             )
+            .addStatement(
+                "this.\$N = true",
+                ReservedKeywordSanitizer.sanitize(generateBooleanFieldName(fieldDefinition.name))
+            )
 
         if (fieldDefinition.directives.isNotEmpty()) {
             val (annotations, comments) = applyDirectivesJava(fieldDefinition.directives, config)
@@ -433,13 +470,23 @@ abstract class BaseDataTypeGenerator(
 
     private fun addBuilder(javaType: TypeSpec.Builder) {
         val className = ClassName.get(packageName, javaType.build().name)
-        val buildMethod = MethodSpec.methodBuilder("build").returns(className).addStatement(
-            """
-            $className result = new $className();
-            ${javaType.build().fieldSpecs.joinToString("\n") { "result.${it.name} = this.${it.name};" }}
-            return result
-            """.trimIndent()
-        ).addModifiers(Modifier.PUBLIC).build()
+
+        val codeBlock = CodeBlock.builder()
+            .addStatement("$className result = new $className()")
+
+        javaType.build().fieldSpecs.forEach() {
+            codeBlock
+                .beginControlFlow("if(this.${generateBooleanFieldName(it.name)})")
+                .addStatement("result.set${it.name.capitalized()}(this.${it.name})")
+                .endControlFlow()
+        }
+        codeBlock.addStatement("return result")
+
+        val buildMethod = MethodSpec
+            .methodBuilder("build")
+            .returns(className)
+            .addCode(codeBlock.build())
+            .addModifiers(Modifier.PUBLIC)
 
         val builderClassName = ClassName.get(packageName, "$className.Builder")
         val newBuilderMethod =
@@ -457,19 +504,21 @@ abstract class BaseDataTypeGenerator(
                 .classBuilder("Builder")
                 .addOptionalGeneratedAnnotation(config)
                 .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
-                .addMethod(buildMethod)
+                .addMethod(buildMethod.build())
 
         javaType.build().fieldSpecs.map {
             MethodSpec.methodBuilder(it.name)
                 .addJavadoc(it.javadoc)
                 .returns(builderClassName)
                 .addStatement("this.${it.name} = ${it.name}")
+                .addStatement("this.${generateBooleanFieldName(it.name)} = true")
                 .addStatement("return this")
                 .addParameter(ParameterSpec.builder(it.type, it.name).build())
                 .addModifiers(Modifier.PUBLIC).build()
         }.forEach { builderType.addMethod(it) }
 
         builderType.addFields(javaType.build().fieldSpecs)
+        addIsDefinedFieldWithGetters(builderType)
         javaType.addType(builderType.build())
     }
 }