fix: references to inputs with consolidated classes

src/definitions/interface.ts

@@ -36,7 +36,12 @@ export function buildInterfaceDefinition(
         config,
         definitionNode: fieldNode,
       });
-      const fieldDefinition = buildFieldDefinition(fieldNode, node, config);
+      const fieldDefinition = buildFieldDefinition(
+        fieldNode,
+        node,
+        schema,
+        config,
+      );
       const fieldText = indent(
         `${fieldDefinition}: ${typeToUse.typeName}${
           typeToUse.isNullable ? "?" : ""

src/definitions/object.ts

@@ -85,7 +85,7 @@ function getDataClassMembers({
 
   return node.fields
     ?.map((fieldNode) => {
-      const typeToUse = buildTypeMetadata(fieldNode.type, schema, config);
+      const typeMetadata = buildTypeMetadata(fieldNode.type, schema, config);
       const shouldOverrideField =
         !completableFuture &&
         node.interfaces?.some((i) => {
@@ -98,19 +98,20 @@ function getDataClassMembers({
       const fieldDefinition = buildFieldDefinition(
         fieldNode,
         node,
+        schema,
         config,
         completableFuture,
       );
-      const completableFutureDefinition = `java.util.concurrent.CompletableFuture<${typeToUse.typeName}${typeToUse.isNullable ? "?" : ""}>`;
-      const defaultDefinition = `${typeToUse.typeName}${isExternalField(fieldNode) ? (typeToUse.isNullable ? "?" : "") : typeToUse.defaultValue}`;
+      const completableFutureDefinition = `java.util.concurrent.CompletableFuture<${typeMetadata.typeName}${typeMetadata.isNullable ? "?" : ""}>`;
+      const defaultDefinition = `${typeMetadata.typeName}${isExternalField(fieldNode) ? (typeMetadata.isNullable ? "?" : "") : typeMetadata.defaultValue}`;
       const field = indent(
         `${shouldOverrideField ? "override " : ""}${fieldDefinition}: ${completableFuture ? completableFutureDefinition : defaultDefinition}`,
         2,
       );
       const annotations = buildAnnotations({
         config,
         definitionNode: fieldNode,
-        resolvedType: typeToUse,
+        typeMetadata,
       });
       return `${annotations}${field}`;
     })

src/helpers/build-annotations.ts

@@ -32,25 +32,25 @@ export type DefinitionNode =
 export function buildAnnotations({
   config,
   definitionNode,
-  resolvedType,
+  typeMetadata,
 }: {
   config: CodegenConfigWithDefaults;
   definitionNode: DefinitionNode;
-  resolvedType?: TypeMetadata;
+  typeMetadata?: TypeMetadata;
 }) {
   const description = definitionNode?.description?.value ?? "";
   const descriptionAnnotation = buildDescriptionAnnotation(
     description,
     definitionNode,
     config,
-    resolvedType,
+    typeMetadata,
   );
   const directiveAnnotations = buildDirectiveAnnotations(
     definitionNode,
     config,
   );
-  const unionAnnotation = resolvedType?.unionAnnotation
-    ? `@${resolvedType.unionAnnotation}\n`
+  const unionAnnotation = typeMetadata?.unionAnnotation
+    ? `@${typeMetadata.unionAnnotation}\n`
     : "";
 
   const annotations = [

src/helpers/build-description-annotation.ts

@@ -8,13 +8,13 @@ export function buildDescriptionAnnotation(
   description: string,
   definitionNode: DefinitionNode,
   config: CodegenConfigWithDefaults,
-  resolvedType?: TypeMetadata,
+  typeMetadata?: TypeMetadata,
 ) {
   const trimmedDescription = trimDescription(description);
   const isDeprecatedDescription = trimmedDescription.startsWith(
     deprecatedDescriptionPrefix,
   );
-  if (isDeprecatedDescription && resolvedType?.unionAnnotation) {
+  if (isDeprecatedDescription && typeMetadata?.unionAnnotation) {
     return `@GraphQLDescription("${trimmedDescription}")\n`;
   } else if (isDeprecatedDescription) {
     const descriptionValue = description.replace(
@@ -36,7 +36,7 @@ export function buildDescriptionAnnotation(
       : "";
   const trimmedDeprecatedReason = trimDescription(deprecatedReason);
 
-  if (deprecatedDirective && resolvedType?.unionAnnotation) {
+  if (deprecatedDirective && typeMetadata?.unionAnnotation) {
     return `@GraphQLDescription("${trimmedDeprecatedReason}")\n`;
   } else if (deprecatedDirective) {
     const graphqlDescription = trimmedDescription

src/helpers/build-field-definition.ts

@@ -11,10 +11,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { buildListType } from "./build-type-metadata";
-import { getFieldTypeName } from "./dependent-type-utils";
+import { buildTypeMetadata } from "./build-type-metadata";
 import {
   FieldDefinitionNode,
+  GraphQLSchema,
   InterfaceTypeDefinitionNode,
   Kind,
   ObjectTypeDefinitionNode,
@@ -26,6 +26,7 @@ import { CodegenConfigWithDefaults } from "./build-config-with-defaults";
 export function buildFieldDefinition(
   fieldNode: FieldDefinitionNode,
   definitionNode: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
+  schema: GraphQLSchema,
   config: CodegenConfigWithDefaults,
   completableFuture?: boolean,
 ) {
@@ -36,10 +37,10 @@ export function buildFieldDefinition(
       ? "fun"
       : "suspend fun"
     : "val";
-  const existingFieldArguments = fieldNode.arguments?.map(
-    (arg) =>
-      `${arg.name.value}: ${buildListType(arg.type, getFieldTypeName(arg.type))}${arg.type.kind === Kind.NON_NULL_TYPE ? "" : "?"}`,
-  );
+  const existingFieldArguments = fieldNode.arguments?.map((arg) => {
+    const typeMetadata = buildTypeMetadata(arg.type, schema, config);
+    return `${arg.name.value}: ${typeMetadata.typeName}${arg.type.kind === Kind.NON_NULL_TYPE ? "" : "?"}`;
+  });
   const additionalFieldArguments = config.extraResolverArguments
     ?.map(({ typeNames, argumentType, argumentName }) => {
       const shouldIncludeArg =

src/helpers/build-type-metadata.ts

@@ -22,6 +22,10 @@ import {
 import { getBaseTypeNode } from "@graphql-codegen/visitor-plugin-common";
 import { wrapTypeWithModifiers } from "@graphql-codegen/java-common";
 import { CodegenConfigWithDefaults } from "./build-config-with-defaults";
+import {
+  getTypeNameWithoutInput,
+  inputTypeHasMatchingOutputType,
+} from "./input-type-has-matching-output-type";
 
 export interface TypeMetadata {
   typeName: string;
@@ -73,14 +77,21 @@ export function buildTypeMetadata(
       ),
     };
   } else {
+    const typeWillBeConsolidated =
+      schemaType?.name.endsWith("Input") &&
+      schemaType?.astNode?.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION &&
+      inputTypeHasMatchingOutputType(schemaType.astNode, schema);
+    const typeName = typeWillBeConsolidated
+      ? getTypeNameWithoutInput(schemaType.name)
+      : schemaType.name;
     return {
       ...commonMetadata,
-      typeName: buildListType(typeNode, schemaType.name),
+      typeName: buildListType(typeNode, typeName),
     };
   }
 }
 
-export function buildListType(typeNode: TypeNode, typeName: string) {
+function buildListType(typeNode: TypeNode, typeName: string) {
   const isNullable = typeNode.kind !== Kind.NON_NULL_TYPE;
   const listTypeNullableWithNullableMember =
     typeNode.kind == Kind.LIST_TYPE &&

src/helpers/dependent-type-utils.ts

@@ -19,6 +19,7 @@ import {
   TypeNode,
 } from "graphql";
 import { CodegenConfigWithDefaults } from "./build-config-with-defaults";
+import { getBaseTypeNode } from "@graphql-codegen/visitor-plugin-common";
 
 export function getDependentFieldTypeNames(
   node: TypeDefinitionNode,
@@ -35,20 +36,8 @@ export function getDependentFieldTypeNames(
     : [];
 }
 
-export function getFieldTypeName(fieldType: TypeNode) {
-  switch (fieldType.kind) {
-    case Kind.NAMED_TYPE:
-      return fieldType.name.value;
-    case Kind.LIST_TYPE:
-      return getFieldTypeName(fieldType.type);
-    case Kind.NON_NULL_TYPE:
-      switch (fieldType.type.kind) {
-        case Kind.NAMED_TYPE:
-          return fieldType.type.name.value;
-        case Kind.LIST_TYPE:
-          return getFieldTypeName(fieldType.type.type);
-      }
-  }
+function getFieldTypeName(fieldType: TypeNode) {
+  return getBaseTypeNode(fieldType).name.value;
 }
 
 export function getDependentInterfaceNames(node: TypeDefinitionNode) {

src/helpers/input-type-has-matching-output-type.ts

@@ -24,7 +24,7 @@ export function inputTypeHasMatchingOutputType(
   return Boolean(matchingTypeFields?.length && fieldsMatch);
 }
 
-function getTypeNameWithoutInput(name: string) {
+export function getTypeNameWithoutInput(name: string) {
   return name.endsWith("Input") ? name.replace("Input", "") : name;
 }
 

test/unit/should_consolidate_input_and_output_types/expected.kt

@@ -57,3 +57,23 @@ data class MyTypeWhereFieldsDoNotMatchInput(
     val field: String? = null,
     val field2: Int? = null
 )
+
+@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
+data class MyTypeToConsolidateParent(
+    val field: MyTypeToConsolidate? = null
+)
+
+@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.INPUT_OBJECT])
+data class MyTypeToConsolidateInputParent(
+    val field: MyTypeToConsolidate? = null
+)
+
+@GraphQLIgnore
+interface MyTypeToConsolidateParent2 {
+    suspend fun field(input: MyTypeToConsolidate): String? = null
+}
+
+@GraphQLIgnore
+interface MyTypeToConsolidateParent2CompletableFuture {
+    fun field(input: MyTypeToConsolidate): java.util.concurrent.CompletableFuture<String?>
+}

test/unit/should_consolidate_input_and_output_types/schema.graphql

@@ -84,3 +84,17 @@ input MyTypeWhereFieldsDoNotMatchInput {
   field: String
   field2: Int
 }
+
+# case where parent types reference consolidated types
+
+type MyTypeToConsolidateParent {
+  field: MyTypeToConsolidate
+}
+
+input MyTypeToConsolidateInputParent {
+  field: MyTypeToConsolidateInput
+}
+
+type MyTypeToConsolidateParent2 {
+  field(input: MyTypeToConsolidateInput!): String
+}