feat: add fields field to filter what resolverInterfaces.classMethods applies to (#186)

Co-authored-by: Steven Schmidt <stschmidt@expediagroup.com>

Author: sjschmidt93

src/config/schema.ts

@@ -161,6 +161,7 @@ export const configSchema = object({
     array(
       object({
         typeName: string(),
+        fields: optional(array(string())),
         classMethods: optional(
           union([literal("SUSPEND"), literal("COMPLETABLE_FUTURE")]),
         ),

src/definitions/field.ts

@@ -87,16 +87,22 @@ export function buildConstructorFieldDefinition({
   fieldNode,
   schema,
   config,
+  typeInResolverInterfacesConfigOverride,
 }: {
   node: ObjectTypeDefinitionNode;
   fieldNode: FieldDefinitionNode;
   schema: GraphQLSchema;
   config: CodegenConfigWithDefaults;
+  typeInResolverInterfacesConfigOverride?: ReturnType<
+    typeof findTypeInResolverInterfacesConfig
+  > | null;
 }) {
-  const typeInResolverInterfacesConfig = findTypeInResolverInterfacesConfig(
-    node,
-    config,
-  );
+  const typeInResolverInterfacesConfig: ReturnType<
+    typeof findTypeInResolverInterfacesConfig
+  > =
+    typeInResolverInterfacesConfigOverride === undefined
+      ? findTypeInResolverInterfacesConfig(node, config)
+      : (typeInResolverInterfacesConfigOverride ?? undefined);
   const functionDefinition = buildConstructorFunctionDefinition(
     node,
     fieldNode,

src/definitions/object.ts

@@ -72,12 +72,15 @@ export function buildObjectTypeDefinition(
     node,
     config,
   );
+  const resolverFields = typeInResolverInterfacesConfig?.fields;
   const fieldsWithArguments = node.fields?.filter(
     (fieldNode) => fieldNode.arguments?.length,
   );
-  const fieldNodes = typeInResolverInterfacesConfig
-    ? node.fields
-    : fieldsWithArguments;
+  const fieldNodes = !typeInResolverInterfacesConfig
+    ? fieldsWithArguments
+    : resolverFields
+      ? node.fields?.filter((f) => resolverFields.includes(f.name.value))
+      : node.fields;
 
   const isTopLevelType =
     node.name.value === "Query" || node.name.value === "Mutation";
@@ -101,23 +104,12 @@ ${getClassMembers({ node, fieldNodes, schema, config })}
     typeInResolverInterfacesConfig,
   );
   if (shouldGenerateFunctions) {
-    const atLeastOneFieldHasNoArguments = node.fields?.some(
-      (fieldNode) => !fieldNode.arguments?.length,
+    const constructor = buildConstructor(
+      node,
+      typeInResolverInterfacesConfig,
+      schema,
+      config,
     );
-    const constructor =
-      !typeInResolverInterfacesConfig && atLeastOneFieldHasNoArguments
-        ? `(\n${node.fields
-            ?.map((fieldNode) => {
-              return buildConstructorFieldDefinition({
-                node,
-                fieldNode,
-                schema,
-                config,
-              });
-            })
-            .join(",\n")}\n)`
-        : "";
-
     return `${annotations}${outputRestrictionAnnotation}open class ${name}${constructor}${interfaceInheritance} {
 ${getClassMembers({ node, fieldNodes, schema, config })}
 }`;
@@ -128,6 +120,50 @@ ${getClassMembers({ node, schema, config })}
 )${interfaceInheritance}`;
 }
 
+function buildConstructor(
+  node: ObjectTypeDefinitionNode,
+  typeInResolverInterfacesConfig: ReturnType<
+    typeof findTypeInResolverInterfacesConfig
+  >,
+  schema: GraphQLSchema,
+  config: CodegenConfigWithDefaults,
+): string {
+  const resolverFields = typeInResolverInterfacesConfig?.fields;
+
+  if (resolverFields) {
+    const nonResolverFields = node.fields?.filter(
+      (f) => !resolverFields.includes(f.name.value),
+    );
+    if (!nonResolverFields?.length) return "";
+    return `(\n${nonResolverFields
+      .map((fieldNode) =>
+        buildConstructorFieldDefinition({
+          node,
+          fieldNode,
+          schema,
+          config,
+          typeInResolverInterfacesConfigOverride: null,
+        }).replace(/,$/, ""),
+      )
+      .join(",\n")}\n)`;
+  }
+
+  if (typeInResolverInterfacesConfig) return "";
+
+  const fieldsForConstructor = node.fields?.filter((f) => !f.arguments?.length);
+  if (!fieldsForConstructor?.length) return "";
+  return `(\n${node.fields
+    ?.map((fieldNode) =>
+      buildConstructorFieldDefinition({
+        node,
+        fieldNode,
+        schema,
+        config,
+      }),
+    )
+    .join(",\n")}\n)`;
+}
+
 function getClassMembers({
   node,
   fieldNodes,

test/unit/should_honor_classMethods_completable_future_with_fields/codegen.config.ts

@@ -0,0 +1,11 @@
+import { GraphQLKotlinCodegenConfig } from "../../../src/plugin";
+
+export default {
+  resolverInterfaces: [
+    {
+      typeName: "MyCompletableFutureFieldsType",
+      classMethods: "COMPLETABLE_FUTURE",
+      fields: ["completableFutureField", "nullableCompletableFutureField"],
+    },
+  ],
+} satisfies GraphQLKotlinCodegenConfig;

test/unit/should_honor_classMethods_completable_future_with_fields/expected.kt

@@ -0,0 +1,12 @@
+package com.kotlin.generated
+
+import com.expediagroup.graphql.generator.annotations.*
+
+@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
+open class MyCompletableFutureFieldsType(
+    val normalField: String,
+    val normalNullableField: String? = null
+) {
+    open fun completableFutureField(dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): java.util.concurrent.CompletableFuture<String> = throw NotImplementedError("MyCompletableFutureFieldsType.completableFutureField must be implemented.")
+    open fun nullableCompletableFutureField(dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): java.util.concurrent.CompletableFuture<String?> = java.util.concurrent.CompletableFuture.completedFuture(null)
+}

test/unit/should_honor_classMethods_completable_future_with_fields/schema.graphql

@@ -0,0 +1,6 @@
+type MyCompletableFutureFieldsType {
+  completableFutureField: String!
+  normalField: String!
+  normalNullableField: String
+  nullableCompletableFutureField: String
+}

test/unit/should_honor_classMethods_suspend_with_fields/codegen.config.ts

@@ -0,0 +1,11 @@
+import { GraphQLKotlinCodegenConfig } from "../../../src/plugin";
+
+export default {
+  resolverInterfaces: [
+    {
+      typeName: "MySuspendFieldsType",
+      classMethods: "SUSPEND",
+      fields: ["suspendField", "nullableSuspendField"],
+    },
+  ],
+} satisfies GraphQLKotlinCodegenConfig;

test/unit/should_honor_classMethods_suspend_with_fields/expected.kt

@@ -0,0 +1,12 @@
+package com.kotlin.generated
+
+import com.expediagroup.graphql.generator.annotations.*
+
+@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
+open class MySuspendFieldsType(
+    val normalField: String,
+    val nullableNormalField: String? = null
+) {
+    open suspend fun suspendField(input: String? = null, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MySuspendFieldsType.suspendField must be implemented.")
+    open suspend fun nullableSuspendField(input: String? = null, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = null
+}

test/unit/should_honor_classMethods_suspend_with_fields/schema.graphql

@@ -0,0 +1,6 @@
+type MySuspendFieldsType {
+  suspendField(input: String): String!
+  nullableSuspendField(input: String): String
+  normalField: String!
+  nullableNormalField: String
+}