fix: generate Kotlin interfaces rather than open classes (#64)

* update tests

* pass tests

* refactor

* rename config

* refactor

Author: danadajian

codegen.ts

@@ -12,7 +12,7 @@ export default {
       plugins: [
         {
           "dist/plugin.cjs": {
-            resolverClasses: [
+            resolverInterfaces: [
               {
                 typeName: "Query",
               },

docs/docs/recommended-usage.md

@@ -6,7 +6,7 @@ sidebar_position: 4
 
 In general, the `resolverClasses` config should be used to generate more performant code. This is especially important
 when dealing with expensive operations, such as database queries or network requests. When at least one field has
-arguments in a type, we generate an open class with function signatures to be inherited in source code.
+arguments in a type, we generate an interface with function signatures to be inherited in source code.
 However, when fields have no arguments, we generate data classes by default.
 
 ## Example
@@ -33,8 +33,8 @@ Generated Kotlin:
 ```kotlin
 package com.types.generated
 
-open class Query {
-  open fun resolveMyType(input: String): MyType = throw NotImplementedError("Query.resolveMyType must be implemented.")
+interface Query {
+  fun resolveMyType(input: String): MyType
 }
 
 data class MyType(
@@ -50,7 +50,7 @@ import com.expediagroup.graphql.server.operations.Query
 import com.types.generated.MyType
 import com.types.generated.Query as QueryInterface
 
-class MyQuery : Query, QueryInterface() {
+class MyQuery : Query, QueryInterface {
   override fun resolveMyType(input: String): MyType =
     MyType(
       field1 = myExpensiveCall1(),
@@ -86,13 +86,13 @@ Generated Kotlin:
 ```kotlin
 package com.types.generated
 
-open class Query {
-  open fun resolveMyType(input: String): MyType = throw NotImplementedError("Query.resolveMyType must be implemented.")
+interface Query {
+  fun resolveMyType(input: String): MyType
 }
 
-open class MyType {
-  open fun field1(): String = throw NotImplementedError("MyType.field1 must be implemented.")
-  open fun field2(): String? = throw NotImplementedError("MyType.field2 must be implemented.")
+interface MyType {
+  fun field1(): String
+  fun field2(): String?
 }
 ```
 
@@ -102,12 +102,12 @@ Source code:
 import com.types.generated.MyType as MyTypeInterface
 import com.expediagroup.graphql.generator.annotations.GraphQLIgnore
 
-class MyQuery : Query, QueryInterface() {
+class MyQuery : Query, QueryInterface {
     override fun resolveMyType(input: String): MyType = MyType()
 }
 
 @GraphQLIgnore
-class MyType : MyTypeInterface() {
+class MyType : MyTypeInterface {
   override fun field1(): String = myExpensiveCall1()
   override fun field2(): String? = myExpensiveCall2()
 }

src/config.ts

@@ -108,9 +108,9 @@ export const configSchema = object({
    */
   packageName: optional(string()),
   /**
-   * Denotes types that should be generated as classes. Resolver classes can inherit from these to enforce a type contract.
+   * Denotes types that should be generated as interfaces rather than classes. Resolver classes should inherit from these to enforce a type contract.
    *
-   * Type names can be optionally passed with the classMethods config to generate `suspend` functions or
+   * Type names can be optionally passed with the classMethods config to generate the interface with `suspend` functions or
    * `java.util.concurrent.CompletableFuture` functions.
    * @example
    * [
@@ -128,7 +128,7 @@ export const configSchema = object({
    * ]
    * @link https://opensource.expediagroup.com/graphql-kotlin-codegen/docs/recommended-usage
    */
-  resolverClasses: optional(
+  resolverInterfaces: optional(
     array(
       object({
         typeName: string(),

src/definitions/object.ts

@@ -27,7 +27,7 @@ import {
 import { buildFieldDefinition } from "../helpers/build-field-definition";
 import { CodegenConfigWithDefaults } from "../helpers/build-config-with-defaults";
 import { inputTypeHasMatchingOutputType } from "../helpers/input-type-has-matching-output-type";
-import { findTypeInResolverClassesConfig } from "../helpers/findTypeInResolverClassesConfig";
+import { findTypeInResolverInterfacesConfig } from "../helpers/findTypeInResolverInterfacesConfig";
 
 export function buildObjectTypeDefinition(
   node: ObjectTypeDefinitionNode,
@@ -60,20 +60,20 @@ export function buildObjectTypeDefinition(
     ? ""
     : "@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])\n";
 
-  const typeInResolverClassesConfig = findTypeInResolverClassesConfig(
+  const typeInResolverInterfacesConfig = findTypeInResolverInterfacesConfig(
     node,
     config,
   );
   const shouldGenerateFunctions = Boolean(
-    typeInResolverClassesConfig ||
+    typeInResolverInterfacesConfig ||
       node.fields?.some((fieldNode) => fieldNode.arguments?.length),
   );
   if (shouldGenerateFunctions) {
     const fieldsWithNoArguments = node.fields?.filter(
       (fieldNode) => !fieldNode.arguments?.length,
     );
     const constructor =
-      !typeInResolverClassesConfig && fieldsWithNoArguments?.length
+      !typeInResolverInterfacesConfig && fieldsWithNoArguments?.length
         ? `(\n${fieldsWithNoArguments
             .map((fieldNode) => {
               const typeMetadata = buildTypeMetadata(
@@ -95,11 +95,13 @@ export function buildObjectTypeDefinition(
     const fieldsWithArguments = node.fields?.filter(
       (fieldNode) => fieldNode.arguments?.length,
     );
-    const fieldNodes = typeInResolverClassesConfig
+    const fieldNodes = typeInResolverInterfacesConfig
       ? node.fields
       : fieldsWithArguments;
-    return `${annotations}${outputRestrictionAnnotation}open class ${name}${constructor}${interfaceInheritance} {
-${getDataClassMembers({ node, fieldNodes, schema, config, shouldGenerateFunctions })}
+    const abstractModifier = constructor ? "abstract " : "";
+    const keyWord = constructor ? "abstract class" : "interface";
+    return `${annotations}${outputRestrictionAnnotation}${keyWord} ${name}${constructor}${interfaceInheritance} {
+${getDataClassMembers({ node, fieldNodes, schema, config, shouldGenerateFunctions, abstractModifier })}
 }`;
   }
 
@@ -113,12 +115,14 @@ function getDataClassMembers({
   fieldNodes,
   schema,
   config,
+  abstractModifier,
   shouldGenerateFunctions,
 }: {
   node: ObjectTypeDefinitionNode;
   fieldNodes?: readonly FieldDefinitionNode[];
   schema: GraphQLSchema;
   config: CodegenConfigWithDefaults;
+  abstractModifier?: string;
   shouldGenerateFunctions?: boolean;
 }) {
   return (fieldNodes ?? node.fields)
@@ -131,6 +135,7 @@ function getDataClassMembers({
         config,
         typeMetadata,
         shouldGenerateFunctions,
+        abstractModifier,
       );
     })
     .join(`${shouldGenerateFunctions ? "" : ","}\n`);

src/helpers/build-field-definition.ts

@@ -23,7 +23,7 @@ import {
 import { CodegenConfigWithDefaults } from "./build-config-with-defaults";
 import { indent } from "@graphql-codegen/visitor-plugin-common";
 import { buildAnnotations } from "./build-annotations";
-import { findTypeInResolverClassesConfig } from "./findTypeInResolverClassesConfig";
+import { findTypeInResolverInterfacesConfig } from "./findTypeInResolverInterfacesConfig";
 
 export function buildFieldDefinition(
   node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
@@ -32,8 +32,15 @@ export function buildFieldDefinition(
   config: CodegenConfigWithDefaults,
   typeMetadata: TypeMetadata,
   shouldGenerateFunctions?: boolean,
+  abstractModifier: string = "",
 ) {
-  const modifier = buildFieldModifier(node, fieldNode, schema, config);
+  const modifier = buildFieldModifier(
+    node,
+    fieldNode,
+    schema,
+    config,
+    abstractModifier,
+  );
   const fieldArguments = buildFieldArguments(node, fieldNode, schema, config);
   const fieldDefinition = `${modifier} ${fieldNode.name.value}${fieldArguments}`;
   const annotations = buildAnnotations({
@@ -49,19 +56,18 @@ export function buildFieldDefinition(
     );
   }
 
-  const notImplementedError = ` = throw NotImplementedError("${node.name.value}.${fieldNode.name.value} must be implemented.")`;
-  const defaultFunctionValue = `${typeMetadata.isNullable ? "?" : ""}${notImplementedError}`;
+  const defaultFunctionValue = `${typeMetadata.isNullable ? "?" : ""}`;
   const defaultValue = shouldGenerateFunctions
     ? defaultFunctionValue
     : typeMetadata.defaultValue;
   const defaultDefinition = `${typeMetadata.typeName}${defaultValue}`;
-  const typeInResolverClassesConfig = findTypeInResolverClassesConfig(
+  const typeInResolverInterfacesConfig = findTypeInResolverInterfacesConfig(
     node,
     config,
   );
   const isCompletableFuture =
-    typeInResolverClassesConfig?.classMethods === "COMPLETABLE_FUTURE";
-  const completableFutureDefinition = `java.util.concurrent.CompletableFuture<${typeMetadata.typeName}${typeMetadata.isNullable ? "?" : ""}>${notImplementedError}`;
+    typeInResolverInterfacesConfig?.classMethods === "COMPLETABLE_FUTURE";
+  const completableFutureDefinition = `java.util.concurrent.CompletableFuture<${typeMetadata.typeName}${typeMetadata.isNullable ? "?" : ""}>`;
   const field = indent(
     `${fieldDefinition}: ${isCompletableFuture ? completableFutureDefinition : defaultDefinition}`,
     2,
@@ -74,8 +80,9 @@ function buildFieldModifier(
   fieldNode: FieldDefinitionNode,
   schema: GraphQLSchema,
   config: CodegenConfigWithDefaults,
+  abstractModifier: string,
 ) {
-  const typeInResolverClassesConfig = findTypeInResolverClassesConfig(
+  const typeInResolverInterfacesConfig = findTypeInResolverInterfacesConfig(
     node,
     config,
   );
@@ -84,20 +91,19 @@ function buildFieldModifier(
     fieldNode,
     schema,
   );
-  if (!typeInResolverClassesConfig && !fieldNode.arguments?.length) {
-    return shouldOverrideField ? "override val" : "val";
+  const overrideModifier = shouldOverrideField ? "override " : "";
+  if (!typeInResolverInterfacesConfig && !fieldNode.arguments?.length) {
+    return `${overrideModifier}val`;
   }
   const functionModifier =
-    typeInResolverClassesConfig?.classMethods === "SUSPEND" ? "suspend " : "";
+    typeInResolverInterfacesConfig?.classMethods === "SUSPEND"
+      ? "suspend "
+      : "";
   if (node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
     return `${functionModifier}fun`;
   }
-  const isCompletableFuture =
-    typeInResolverClassesConfig?.classMethods === "COMPLETABLE_FUTURE";
-  if (shouldOverrideField && !isCompletableFuture) {
-    return "override fun";
-  }
-  return `open ${functionModifier}fun`;
+
+  return `${abstractModifier}${overrideModifier}${functionModifier}fun`;
 }
 
 function buildFieldArguments(
@@ -106,8 +112,11 @@ function buildFieldArguments(
   schema: GraphQLSchema,
   config: CodegenConfigWithDefaults,
 ) {
-  const typeIsInResolverClasses = findTypeInResolverClassesConfig(node, config);
-  if (!typeIsInResolverClasses && !fieldNode.arguments?.length) {
+  const typeIsInResolverInterfaces = findTypeInResolverInterfacesConfig(
+    node,
+    config,
+  );
+  if (!typeIsInResolverInterfaces && !fieldNode.arguments?.length) {
     return "";
   }
   const isOverrideFunction = shouldModifyFieldWithOverride(

src/helpers/findTypeInResolverClassesConfig.ts renamed to src/helpers/findTypeInResolverInterfacesConfig.ts

@@ -1,11 +1,11 @@
 import { InterfaceTypeDefinitionNode, ObjectTypeDefinitionNode } from "graphql";
 import { CodegenConfigWithDefaults } from "./build-config-with-defaults";
 
-export function findTypeInResolverClassesConfig(
+export function findTypeInResolverInterfacesConfig(
   node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
   config: CodegenConfigWithDefaults,
 ) {
-  return config.resolverClasses?.find(
-    (resolverClass) => resolverClass.typeName === node.name.value,
+  return config.resolverInterfaces?.find(
+    (resolverInterface) => resolverInterface.typeName === node.name.value,
   );
 }

test/integration/Query.kt

@@ -4,6 +4,6 @@ import com.expediagroup.graphql.server.operations.Query
 import graphql.schema.DataFetchingEnvironment
 import test.integration.Query as QueryInterface
 
-class IntegrationTestQuery() : Query, QueryInterface() {
+class IntegrationTestQuery : Query, QueryInterface {
     override fun testQuery(dataFetchingEnvironment: DataFetchingEnvironment): SomeType = SomeType()
 }

test/unit/should_consolidate_input_and_output_types/expected.kt

@@ -69,8 +69,8 @@ data class MyTypeToConsolidateInputParent(
 )
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
-open class MyTypeToConsolidateParent2 {
-    open fun field(input: MyTypeToConsolidate, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("MyTypeToConsolidateParent2.field must be implemented.")
+interface MyTypeToConsolidateParent2 {
+    fun field(input: MyTypeToConsolidate, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String?
 }
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])

test/unit/should_generate_classes_for_types_with_field_args/expected.kt

@@ -3,18 +3,18 @@ package com.kotlin.generated
 import com.expediagroup.graphql.generator.annotations.*
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
-open class TypeWithOnlyFieldArgs {
-    open fun nullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("TypeWithOnlyFieldArgs.nullableResolver must be implemented.")
-    open fun nonNullableResolver(arg: InputTypeForResolver, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("TypeWithOnlyFieldArgs.nonNullableResolver must be implemented.")
+interface TypeWithOnlyFieldArgs {
+    fun nullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String?
+    fun nonNullableResolver(arg: InputTypeForResolver, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String
 }
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
-open class HybridType(
+abstract class HybridType(
     val nullableField: String? = null,
     val nonNullableField: String
 ) {
-    open fun nullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("HybridType.nullableResolver must be implemented.")
-    open fun nonNullableResolver(arg: InputTypeForResolver, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("HybridType.nonNullableResolver must be implemented.")
+    abstract fun nullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String?
+    abstract fun nonNullableResolver(arg: InputTypeForResolver, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String
 }
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.INPUT_OBJECT])
@@ -30,14 +30,14 @@ interface HybridInterface {
 }
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
-open class TypeImplementingInterface(
+abstract class TypeImplementingInterface(
     override val field1: String? = null,
     override val field2: String,
     val booleanField1: Boolean? = null,
     val booleanField2: Boolean = false,
     val integerField1: Int? = null,
     val integerField2: Int
 ) : HybridInterface {
-    override fun nullableListResolver(arg1: Int?, arg2: Int, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): List<String?>? = throw NotImplementedError("TypeImplementingInterface.nullableListResolver must be implemented.")
-    override fun nonNullableListResolver(arg1: Int, arg2: Int?, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): List<String> = throw NotImplementedError("TypeImplementingInterface.nonNullableListResolver must be implemented.")
+    abstract override fun nullableListResolver(arg1: Int?, arg2: Int, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): List<String?>?
+    abstract override fun nonNullableListResolver(arg1: Int, arg2: Int?, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): List<String>
 }