feat: support marker interfaces for union types

Author: danadajian

.eslintrc.json

@@ -6,6 +6,7 @@
   },
   "plugins": ["@typescript-eslint"],
   "rules": {
+    "no-console": "error",
     "@typescript-eslint/no-non-null-assertion": "error",
     "@typescript-eslint/no-unsafe-argument": "error",
     "@typescript-eslint/no-unsafe-call": "error"

src/config.ts

@@ -129,4 +129,5 @@ export const configSchema = object({
       }),
     ),
   ),
+  useMarkerInterfaces: optional(boolean()),
 });

src/definitions/object.ts

@@ -16,7 +16,10 @@ import { buildAnnotations } from "../helpers/build-annotations";
 import { indent } from "@graphql-codegen/visitor-plugin-common";
 import { buildTypeMetadata } from "../helpers/build-type-metadata";
 import { shouldIncludeTypeDefinition } from "../helpers/should-include-type-definition";
-import { getDependentInterfaceNames } from "../helpers/dependent-type-utils";
+import {
+  getDependentInterfaceNames,
+  getDependentUnionsForType,
+} from "../helpers/dependent-type-utils";
 import { isResolverType } from "../helpers/is-resolver-type";
 import { buildFieldDefinition } from "../helpers/build-field-definition";
 import { isExternalField } from "../helpers/is-external-field";
@@ -36,7 +39,11 @@ export function buildObjectTypeDefinition(
     definitionNode: node,
   });
   const name = node.name.value;
-  const interfacesToInherit = getDependentInterfaceNames(node);
+  const dependentInterfaces = getDependentInterfaceNames(node);
+  const dependentUnions = getDependentUnionsForType(schema, node);
+  const interfacesToInherit = config.useMarkerInterfaces
+    ? dependentInterfaces.concat(dependentUnions)
+    : dependentInterfaces;
   const interfaceInheritance = `${interfacesToInherit.length ? ` : ${interfacesToInherit.join(", ")}` : ""}`;
 
   if (isResolverType(node, config)) {

src/definitions/union.ts

@@ -15,7 +15,10 @@ import { UnionTypeDefinitionNode } from "graphql";
 import { shouldIncludeTypeDefinition } from "../helpers/should-include-type-definition";
 import { buildDirectiveAnnotations } from "../helpers/build-directive-annotations";
 import { CodegenConfig } from "../plugin";
-import { trimDescription } from "../helpers/build-annotations";
+import {
+  buildAnnotations,
+  trimDescription,
+} from "../helpers/build-annotations";
 
 export function buildUnionTypeDefinition(
   node: UnionTypeDefinitionNode,
@@ -24,14 +27,21 @@ export function buildUnionTypeDefinition(
   if (!shouldIncludeTypeDefinition(node, config)) {
     return "";
   }
+  const annotations = buildAnnotations({
+    config,
+    definitionNode: node,
+  });
+  if (config.useMarkerInterfaces) {
+    return `${annotations}interface ${node.name.value}`;
+  }
 
   const directiveAnnotations = buildDirectiveAnnotations(node, config);
   const possibleTypes =
     node.types?.map((type) => `${type.name.value}::class`).join(", ") || "";
   return `${directiveAnnotations}@GraphQLUnion(
     name = "${node.name.value}",
     possibleTypes = [${possibleTypes}],
-    description = "${node.description?.value ? trimDescription(node.description.value) : ""}"
+    description = "${trimDescription(node.description?.value)}"
 )
 annotation class ${node.name.value}`;
 }

src/helpers/add-dependent-types.ts

@@ -25,7 +25,7 @@ export function addDependentTypes(
       .map((typeName) => schema.getType(typeName)?.astNode)
       .filter(Boolean);
     const dependentTypeNames = onlyTypesNodes.flatMap((node) =>
-      getDependentTypeNames(schema, node, config.dependentTypesInScope),
+      getDependentTypeNames(schema, node, config),
     );
     const dependentTypesInScope = dependentTypeNames.filter((typeName) =>
       dependentTypeIsInScope(typeName, config),

src/helpers/build-annotations.ts

@@ -95,10 +95,10 @@ export function isDeprecatedDescription(
   );
 }
 
-export function trimDescription(description: string) {
+export function trimDescription(description?: string) {
   return (
     description
-      .split("\n")
+      ?.split("\n")
       .map((str) => str.trim().replaceAll('"', "").replaceAll("\\", ""))
       .find((str) => str.match(/^[a-zA-Z]/)) ?? ""
   );

src/helpers/build-type-metadata.ts

@@ -60,6 +60,7 @@ export function buildTypeMetadata(
     };
   } else if (isUnionType(schemaType)) {
     const shouldTreatUnionAsInterface =
+      config.useMarkerInterfaces ||
       config.externalUnionsAsInterfaces?.includes(schemaType.name);
     return {
       ...commonMetadata,

src/helpers/dependent-type-utils.ts

@@ -11,7 +11,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { Kind, TypeDefinitionNode, TypeNode } from "graphql";
+import {
+  GraphQLSchema,
+  GraphQLUnionType,
+  Kind,
+  TypeDefinitionNode,
+  TypeNode,
+} from "graphql";
 import { CodegenConfig } from "../plugin";
 
 export function getDependentFieldTypeNames(
@@ -55,3 +61,20 @@ export function getDependentUnionNames(node: TypeDefinitionNode) {
     ? node.types?.map((type) => type.name.value) ?? []
     : [];
 }
+
+export function getDependentUnionsForType(
+  schema: GraphQLSchema,
+  node: TypeDefinitionNode,
+) {
+  const typeMap = schema.getTypeMap();
+  const unions = Object.keys(typeMap)
+    .filter(
+      (type) => typeMap[type]?.astNode?.kind === Kind.UNION_TYPE_DEFINITION,
+    )
+    .map((type) => typeMap[type] as GraphQLUnionType);
+  return unions
+    .filter((union) =>
+      union.getTypes().some((type) => type.name === node.name.value),
+    )
+    .map((union) => union.name);
+}

src/helpers/get-dependent-type-names.ts

@@ -18,21 +18,22 @@ import {
   getDependentInterfaceNames,
   getDependentUnionNames,
 } from "./dependent-type-utils";
-import { CodegenConfig } from "../plugin";
+import { GraphQLKotlinCodegenConfig } from "../plugin";
 
 export function getDependentTypeNames(
   schema: GraphQLSchema,
   node: TypeDefinitionNode,
-  dependentTypesInScope: CodegenConfig["dependentTypesInScope"],
+  config: GraphQLKotlinCodegenConfig,
 ): string[] {
-  const namedTypes = getDependentFieldTypeNames(node, dependentTypesInScope)
+  const namedTypes = getDependentFieldTypeNames(
+    node,
+    config.dependentTypesInScope,
+  )
     .concat(getDependentUnionNames(node))
     .concat(getDependentInterfaceNames(node));
   const recursivelyFoundTypes = namedTypes
     .map((typeName) => schema.getType(typeName)?.astNode)
     .filter(Boolean)
-    .flatMap((node) =>
-      getDependentTypeNames(schema, node, dependentTypesInScope),
-    );
+    .flatMap((node) => getDependentTypeNames(schema, node, config));
   return namedTypes.concat(recursivelyFoundTypes);
 }

test/unit/should_honor_union_config/codegen.config.ts

@@ -0,0 +1,5 @@
+import { GraphQLKotlinCodegenConfig } from "../../../src/plugin";
+
+export default {
+  useMarkerInterfaces: true,
+} satisfies GraphQLKotlinCodegenConfig;