Reintroduce legacy constructor on Query classes for backward compatability (#813)

* Reintroduce legacy constructor on Query classes for backward compatibility.

* Add tests for legacy query constructor

---------

Co-authored-by: pbakker <$(git --no-pager log --format=format:'%ae' -n 1)>

Author: paulbakker

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

@@ -206,6 +206,12 @@ class ClientApiGenerator(
                 .addModifiers(Modifier.PUBLIC)
         constructorBuilder.addStatement("super(\$S, queryName)", operation.lowercase())
 
+        val legacyConstructorBuilder =
+            MethodSpec
+                .constructorBuilder()
+                .addModifiers(Modifier.PUBLIC)
+        legacyConstructorBuilder.addStatement("super(\$S, queryName)", operation.lowercase())
+
         it.inputValueDefinitions.forEach { inputValue ->
             val findReturnType = TypeUtils(getDatatypesPackageName(), config, document).findReturnType(inputValue.type)
 
@@ -252,21 +258,24 @@ class ClientApiGenerator(
             builderClass.addMethod(referenceMethodBuilder.build())
 
             constructorBuilder.addParameter(findReturnType, ReservedKeywordSanitizer.sanitize(inputValue.name))
+            legacyConstructorBuilder.addParameter(findReturnType, ReservedKeywordSanitizer.sanitize(inputValue.name))
 
             if (findReturnType.isPrimitive) {
-                constructorBuilder.addCode(
+                val code =
                     """
                     |getInput().put("${inputValue.name}", ${ReservedKeywordSanitizer.sanitize(inputValue.name)});                   
-                    """.trimMargin(),
-                )
+                    """.trimMargin()
+                constructorBuilder.addCode(code)
+                legacyConstructorBuilder.addCode(code)
             } else {
-                constructorBuilder.addCode(
+                val code =
                     """
                     |if (${ReservedKeywordSanitizer.sanitize(inputValue.name)} != null || fieldsSet.contains("${inputValue.name}")) {
                     |    getInput().put("${inputValue.name}", ${ReservedKeywordSanitizer.sanitize(inputValue.name)});
                     |}
-                    """.trimMargin(),
-                )
+                    """.trimMargin()
+                constructorBuilder.addCode(code)
+                legacyConstructorBuilder.addCode(code)
             }
         }
 
@@ -303,11 +312,16 @@ class ClientApiGenerator(
             .addMethod(nameMethodBuilder.build())
 
         constructorBuilder.addParameter(String::class.java, "queryName")
+        legacyConstructorBuilder.addParameter(String::class.java, "queryName")
 
-        if (it.inputValueDefinitions.size > 0) {
+        if (it.inputValueDefinitions.isNotEmpty()) {
             constructorBuilder.addParameter(setOfStringType, "fieldsSet")
+            legacyConstructorBuilder.addParameter(setOfStringType, "fieldsSet")
             constructorBuilder.addParameter(mapOfStringsType, "variableReferences")
             constructorBuilder.addParameter(listOfVariablesType, "variableDefinitions")
+
+            // We only need this backward compatible constructor if we added the new fields to the main constructor.
+            javaType.addMethod(legacyConstructorBuilder.build())
         }
 
         javaType.addMethod(constructorBuilder.build())

graphql-dgs-codegen-core/src/test/kotlin/com/netflix/graphql/dgs/codegen/CodeGenTest.kt

@@ -5814,12 +5814,28 @@ It takes a title and such.
 
         assertCompilesJava(result)
         assertThat(result.javaQueryTypes).hasSize(1)
-        val parameters =
+        val constructors =
             result.javaQueryTypes[0]
                 .typeSpec.methodSpecs
-                .filter { it.isConstructor && !it.parameters.isEmpty() }
-                .get(0)
-                .parameters
+                .filter { it.isConstructor }
+        assertThat(constructors).hasSize(3).withFailMessage {
+            "There should be a no-arg constructor, a legacy constructor without variable references, and one with variable references"
+        }
+
+        val noArg = constructors.find { it.parameters.isEmpty() }
+        assertThat(noArg).isNotNull.withFailMessage { "Missing no-arg constructor" }
+
+        val legacy = constructors.find { it.parameters.isNotEmpty() && it.parameters.none { p -> p.name == "variableReferences" } }
+        assertThat(legacy).isNotNull.withFailMessage { "Missing legacy constructor without variableReferences" }
+
+        val withVariableReferences =
+            constructors.find {
+                it.parameters.isNotEmpty() &&
+                    it.parameters.any { p -> p.name == "variableReferences" }
+            }
+        assertThat(withVariableReferences).isNotNull.withFailMessage { "Missing constructor with variableReferences" }
+
+        val parameters = withVariableReferences!!.parameters
         assertThat(parameters).extracting("name").contains("variableReferences", "variableDefinitions")
         assertThat(
             parameters
@@ -5855,6 +5871,35 @@ It takes a title and such.
         )
     }
 
+    @Test
+    fun `Generated queries should not contain conflicting constructors when no input arguments exist`() {
+        val schema =
+            """
+            type Query {
+               findPeople: [String]
+            }      
+            """.trimIndent()
+
+        val result =
+            CodeGen(
+                CodeGenConfig(
+                    schemas = setOf(schema),
+                    packageName = "com.netflix.test",
+                    generateClientApi = true,
+                ),
+            ).generate()
+
+        assertCompilesJava(result)
+        assertThat(result.javaQueryTypes).hasSize(1)
+        val constructors =
+            result.javaQueryTypes[0]
+                .typeSpec.methodSpecs
+                .filter { it.isConstructor }
+        assertThat(
+            constructors,
+        ).hasSize(2).withFailMessage { "There should be a no-arg constructor and a constructor without variable references" }
+    }
+
     @Test
     fun generateInputTrackFieldSet() {
         val schema =