[client] fix generation of duplicate classes (#883)

* [client] fix generation of duplicate classes

We were incorrectly using simple class name for the type lookup as all classes are wrapped in some root type (i.e. `Query.MyClass`) whereas GraphQL type name was just the actual type. We were also incorrectly comparing selection sets as we were not unwrapping selection sets of the children fields.

Fixes: #864

* fix caching and correctly compare selection sets of different types

Author: dariuszkuc

plugins/graphql-kotlin-plugin-core/src/main/kotlin/com/expediagroup/graphql/plugin/generator/types/generateTypeName.kt

@@ -22,6 +22,7 @@ import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.FLOAT
 import com.squareup.kotlinpoet.INT
 import com.squareup.kotlinpoet.LIST
+import com.squareup.kotlinpoet.ParameterizedTypeName
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.TypeName
@@ -97,7 +98,7 @@ internal fun generateCustomClassName(context: GraphQLClientGeneratorContext, gra
     } else {
         // verify we got same selection set for interface and/or objects (unions shouldn't have any fields)
         for (cachedType in cachedTypeNames) {
-            if (isCachedTypeApplicable(context, cachedType.simpleName, graphQLTypeDefinition, selectionSet)) {
+            if (isCachedTypeApplicable(context, cachedType.simpleNameWithoutWrapper(), graphQLTypeDefinition, selectionSet)) {
                 return cachedType
             }
         }
@@ -111,11 +112,13 @@ internal fun generateCustomClassName(context: GraphQLClientGeneratorContext, gra
             else -> throw RuntimeException("should never happen")
         }
         val className = ClassName(context.packageName, "${context.rootType}.${typeSpec.name}")
-        context.classNameCache[overriddenName]?.add(className)
+        context.classNameCache[graphQLTypeName]?.add(className)
         className
     }
 }
 
+private fun ClassName.simpleNameWithoutWrapper() = this.simpleName.substringAfter(".")
+
 private fun isCachedTypeApplicable(context: GraphQLClientGeneratorContext, graphQLTypeName: String, graphQLTypeDefinition: TypeDefinition<*>, selectionSet: SelectionSet): Boolean =
     when (graphQLTypeDefinition) {
         is UnionTypeDefinition -> {
@@ -148,21 +151,28 @@ private fun isCachedTypeApplicable(context: GraphQLClientGeneratorContext, graph
 
 private fun verifySelectionSet(context: GraphQLClientGeneratorContext, graphQLTypeName: String, selectionSet: SelectionSet): Boolean {
     val selectedFields = calculateSelectedFields(context, graphQLTypeName, selectionSet)
-    val typeSpec = context.typeSpecs[graphQLTypeName]
-    val properties = typeSpec?.propertySpecs?.map { it.name }?.toSet() ?: emptySet()
-    return selectedFields == properties ||
-        (selectedFields.minus(properties).size == 1 && selectedFields.contains("__typename") && context.objectsWithTypeNameSelection.contains(graphQLTypeName))
+    val properties = calculateGeneratedTypeProperties(context, graphQLTypeName)
+    if (context.objectsWithTypeNameSelection.contains(graphQLTypeName)) {
+        properties.add("__typename")
+    }
+    return selectedFields == properties
 }
 
 private fun calculateSelectedFields(
     context: GraphQLClientGeneratorContext,
     targetType: String,
-    selectionSet: SelectionSet
+    selectionSet: SelectionSet,
+    path: String = ""
 ): Set<String> {
     val result = mutableSetOf<String>()
     selectionSet.selections.forEach { selection ->
         when (selection) {
-            is Field -> result.add(selection.name)
+            is Field -> {
+                result.add(path + selection.name)
+                if (selection.selectionSet != null) {
+                    result.addAll(calculateSelectedFields(context, targetType, selection.selectionSet, "$path${selection.name}."))
+                }
+            }
             is InlineFragment -> if (selection.typeCondition.name == targetType) {
                 result.addAll(calculateSelectedFields(context, targetType, selection.selectionSet))
             }
@@ -178,3 +188,24 @@ private fun calculateSelectedFields(
     }
     return result
 }
+
+private fun calculateGeneratedTypeProperties(context: GraphQLClientGeneratorContext, graphQLTypeName: String, path: String = ""): MutableSet<String> {
+    val props = mutableSetOf<String>()
+
+    val typeSpec = context.typeSpecs[graphQLTypeName]
+    for (property in typeSpec?.propertySpecs ?: emptyList()) {
+        props.add(path + property.name)
+        when (val propertyType = property.type) {
+            is ParameterizedTypeName -> {
+                val genericType = propertyType.typeArguments.firstOrNull() as? ClassName
+                val genericTypeName = genericType?.simpleNameWithoutWrapper() ?: ""
+                props.addAll(calculateGeneratedTypeProperties(context, genericTypeName, "$path${property.name}."))
+            }
+            is ClassName -> {
+                val fieldTypeName = propertyType.simpleNameWithoutWrapper()
+                props.addAll(calculateGeneratedTypeProperties(context, fieldTypeName, "$path${property.name}."))
+            }
+        }
+    }
+    return props
+}