fix: honor includeDependentTypes false when using onlyTypes (#131)

Author: danadajian

src/config/add-dependent-types-to-only-types.ts

@@ -47,7 +47,7 @@ function getDependentTypeNames(
 ): string[] {
   const namedTypes = getDependentFieldTypeNames(node, config)
     .concat(getDependentUnionNames(node))
-    .concat(getDependentInterfaceNames(node));
+    .concat(getDependentInterfaceNames(node, config));
   const recursivelyFoundTypes = namedTypes
     .map((typeName) => schema.getType(typeName)?.astNode)
     .filter(Boolean)

src/definitions/interface.ts

@@ -45,7 +45,7 @@ export function buildInterfaceDefinition(
     definitionNode: node,
   });
 
-  const interfacesToInherit = getDependentInterfaceNames(node);
+  const interfacesToInherit = getDependentInterfaceNames(node, config);
   const interfaceInheritance = `${interfacesToInherit.length ? ` : ${interfacesToInherit.join(", ")}` : ""}`;
 
   return `${annotations}interface ${sanitizeName(node.name.value)}${interfaceInheritance} {

src/definitions/object.ts

@@ -46,8 +46,8 @@ export function buildObjectTypeDefinition(
     config,
     definitionNode: node,
   });
-  const dependentInterfaces = getDependentInterfaceNames(node);
-  const dependentUnions = getDependentUnionsForType(schema, node);
+  const dependentInterfaces = getDependentInterfaceNames(node, config);
+  const dependentUnions = getDependentUnionsForType(schema, node, config);
   const interfacesToInherit =
     config.unionGeneration === "MARKER_INTERFACE"
       ? dependentInterfaces.concat(dependentUnions)

src/utils/dependent-type-utils.ts

@@ -21,6 +21,7 @@ import {
 } from "graphql";
 import { CodegenConfigWithDefaults } from "../config/build-config-with-defaults";
 import { getBaseTypeNode } from "@graphql-codegen/visitor-plugin-common";
+import { shouldIncludeTypeDefinition } from "../config/should-include-type-definition";
 
 export function getDependentFieldTypeNames(
   node: TypeDefinitionNode,
@@ -41,9 +42,16 @@ function getFieldTypeName(fieldType: TypeNode) {
   return getBaseTypeNode(fieldType).name.value;
 }
 
-export function getDependentInterfaceNames(node: TypeDefinitionNode) {
+export function getDependentInterfaceNames(
+  node: TypeDefinitionNode,
+  config: CodegenConfigWithDefaults,
+) {
   return "interfaces" in node
-    ? (node.interfaces?.map((interfaceNode) => interfaceNode.name.value) ?? [])
+    ? (node.interfaces
+        ?.map((interfaceNode) => interfaceNode.name.value)
+        .filter((interfaceName) =>
+          shouldIncludeDependentType(interfaceName, config),
+        ) ?? [])
     : [];
 }
 
@@ -56,6 +64,7 @@ export function getDependentUnionNames(node: TypeDefinitionNode) {
 export function getDependentUnionsForType(
   schema: GraphQLSchema,
   node: TypeDefinitionNode,
+  config: CodegenConfigWithDefaults,
 ) {
   const typeMap = schema.getTypeMap();
   const unions = Object.values(typeMap).filter((type) =>
@@ -65,5 +74,16 @@ export function getDependentUnionsForType(
     .filter((union) =>
       union.getTypes().some((type) => type.name === node.name.value),
     )
-    .map((union) => union.name);
+    .map((union) => union.name)
+    .filter((unionName) => shouldIncludeDependentType(unionName, config));
+}
+
+function shouldIncludeDependentType(
+  typeName: string,
+  config: CodegenConfigWithDefaults,
+) {
+  return (
+    config.includeDependentTypes ||
+    shouldIncludeTypeDefinition(typeName, config)
+  );
 }

test/unit/should_honor_includeDependentTypes_false_for_external_unions_and_interfaces/codegen.config.ts

@@ -0,0 +1,11 @@
+import { GraphQLKotlinCodegenConfig } from "../../../src/plugin";
+
+export default {
+  onlyTypes: [
+    "MyIncludedType",
+    "MyIncludedInterfaceInOnlyTypes",
+    "MyIncludedType2",
+    "MyIncludedUnion",
+  ],
+  includeDependentTypes: false,
+} satisfies GraphQLKotlinCodegenConfig;

test/unit/should_honor_includeDependentTypes_false_for_external_unions_and_interfaces/expected.kt

@@ -0,0 +1,22 @@
+package com.kotlin.generated
+
+import com.expediagroup.graphql.generator.annotations.*
+
+@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
+data class MyIncludedType(
+    val field: String? = null,
+    val field2: String
+)
+
+@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
+data class MyIncludedType2(
+    val field: String? = null,
+    val field2: String
+) : MyIncludedUnion
+
+interface MyIncludedUnion
+
+interface MyIncludedInterfaceInOnlyTypes {
+    val field: String?
+    val field2: String
+}

test/unit/should_honor_includeDependentTypes_false_for_external_unions_and_interfaces/schema.graphql

@@ -0,0 +1,23 @@
+type MyIncludedType {
+  field: String
+  field2: String!
+}
+
+union MyExcludedUnion = MyIncludedType
+
+type MyIncludedType2 {
+  field: String
+  field2: String!
+}
+
+union MyIncludedUnion = MyIncludedType2
+
+interface MyIncludedInterfaceInOnlyTypes {
+  field: String
+  field2: String!
+}
+
+type MyExcludedType implements MyIncludedInterfaceInOnlyTypes {
+  field: String
+  field2: String!
+}