first case

Author: danadajian

src/definitions/object.ts

@@ -12,6 +12,7 @@ limitations under the License.
 */
 
 import {
+  FieldDefinitionNode,
   GraphQLSchema,
   isInputObjectType,
   ObjectTypeDefinitionNode,
@@ -23,7 +24,6 @@ import {
   getDependentInterfaceNames,
   getDependentUnionsForType,
 } from "../helpers/dependent-type-utils";
-import { shouldGenerateResolverClass } from "../helpers/should-generate-resolver-class";
 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";
@@ -59,32 +59,44 @@ export function buildObjectTypeDefinition(
     ? ""
     : "@GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])\n";
 
-  const shouldGenerateFunctions = shouldGenerateResolverClass(node, config);
+  const shouldGenerateFunctions = node.fields?.some(
+    (fieldNode) => fieldNode.arguments?.length,
+  );
   if (shouldGenerateFunctions) {
     const fieldsWithNoArguments = node.fields?.filter(
       (fieldNode) => !fieldNode.arguments?.length,
     );
-    const constructor = fieldsWithNoArguments?.length
-      ? `(\n${fieldsWithNoArguments
-          .map((fieldNode) => {
-            const typeMetadata = buildTypeMetadata(
-              fieldNode.type,
-              schema,
-              config,
-            );
-            return buildFieldDefinition(
-              node,
-              fieldNode,
-              schema,
-              config,
-              typeMetadata,
-            );
-          })
-          .join(",\n")}\n)`
-      : "";
+    const resolverClassesContainsType = config.resolverClasses?.includes(
+      node.name.value,
+    );
+    const constructor =
+      !resolverClassesContainsType && fieldsWithNoArguments?.length
+        ? `(\n${fieldsWithNoArguments
+            .map((fieldNode) => {
+              const typeMetadata = buildTypeMetadata(
+                fieldNode.type,
+                schema,
+                config,
+              );
+              return buildFieldDefinition(
+                node,
+                fieldNode,
+                schema,
+                config,
+                typeMetadata,
+              );
+            })
+            .join(",\n")}\n)`
+        : "";
 
+    const fieldsWithArguments = node.fields?.filter(
+      (fieldNode) => fieldNode.arguments?.length,
+    );
+    const fieldNodes = resolverClassesContainsType
+      ? node.fields
+      : fieldsWithArguments;
     return `${annotations}${outputRestrictionAnnotation}open class ${name}${constructor}${interfaceInheritance} {
-${getDataClassMembers({ node, schema, config, shouldGenerateFunctions })}
+${getDataClassMembers({ node, fieldNodes, schema, config, shouldGenerateFunctions })}
 }`;
   }
 
@@ -95,19 +107,18 @@ ${getDataClassMembers({ node, schema, config })}
 
 function getDataClassMembers({
   node,
+  fieldNodes,
   schema,
   config,
   shouldGenerateFunctions,
 }: {
   node: ObjectTypeDefinitionNode;
+  fieldNodes?: readonly FieldDefinitionNode[];
   schema: GraphQLSchema;
   config: CodegenConfigWithDefaults;
   shouldGenerateFunctions?: boolean;
 }) {
-  return node.fields
-    ?.filter(
-      (fieldNode) => !shouldGenerateFunctions || fieldNode.arguments?.length,
-    )
+  return (fieldNodes ?? node.fields)
     ?.map((fieldNode) => {
       const typeMetadata = buildTypeMetadata(fieldNode.type, schema, config);
       return buildFieldDefinition(

src/helpers/build-field-definition.ts

@@ -32,8 +32,8 @@ export function buildFieldDefinition(
   typeMetadata: TypeMetadata,
   shouldUseFunction?: boolean,
 ) {
-  const modifier = buildFieldModifier(node, fieldNode, schema);
-  const fieldArguments = buildFieldArguments(fieldNode, schema, config);
+  const modifier = buildFieldModifier(node, fieldNode, schema, config);
+  const fieldArguments = buildFieldArguments(node, fieldNode, schema, config);
   const fieldDefinition = `${modifier} ${fieldNode.name.value}${fieldArguments}`;
   const annotations = buildAnnotations({
     config,
@@ -66,12 +66,16 @@ function buildFieldModifier(
   node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
   fieldNode: FieldDefinitionNode,
   schema: GraphQLSchema,
+  config: CodegenConfigWithDefaults,
 ) {
+  const resolverClassesContainsType = config.resolverClasses?.includes(
+    node.name.value,
+  );
   const completableFuture = false;
   const shouldOverrideField =
     !completableFuture &&
     shouldModifyFieldWithOverride(node, fieldNode, schema);
-  if (!fieldNode.arguments?.length) {
+  if (!resolverClassesContainsType && !fieldNode.arguments?.length) {
     return shouldOverrideField ? "override val" : "val";
   }
   if (completableFuture || node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
@@ -83,6 +87,31 @@ function buildFieldModifier(
   return "open fun";
 }
 
+function buildFieldArguments(
+  node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
+  fieldNode: FieldDefinitionNode,
+  schema: GraphQLSchema,
+  config: CodegenConfigWithDefaults,
+) {
+  const resolverClassesContainsType = config.resolverClasses?.includes(
+    node.name.value,
+  );
+  if (!resolverClassesContainsType && !fieldNode.arguments?.length) {
+    return "";
+  }
+  const existingFieldArguments = fieldNode.arguments?.map((arg) => {
+    const argMetadata = buildTypeMetadata(arg.type, schema, config);
+    return `${arg.name.value}: ${argMetadata.typeName}${arg.type.kind === Kind.NON_NULL_TYPE ? "" : "?"}`;
+  });
+  const dataFetchingEnvironmentArgument =
+    "dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment";
+  const extraFieldArguments = [dataFetchingEnvironmentArgument];
+  const allFieldArguments = existingFieldArguments?.concat(extraFieldArguments);
+  return allFieldArguments?.length
+    ? `(${allFieldArguments?.join(", ")})`
+    : "()";
+}
+
 function shouldModifyFieldWithOverride(
   node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
   fieldNode: FieldDefinitionNode,
@@ -112,24 +141,3 @@ function buildInterfaceFieldDefinition(
   );
   return `${annotations}${fieldText}`;
 }
-
-function buildFieldArguments(
-  fieldNode: FieldDefinitionNode,
-  schema: GraphQLSchema,
-  config: CodegenConfigWithDefaults,
-) {
-  if (!fieldNode.arguments?.length) {
-    return "";
-  }
-  const existingFieldArguments = fieldNode.arguments.map((arg) => {
-    const argMetadata = buildTypeMetadata(arg.type, schema, config);
-    return `${arg.name.value}: ${argMetadata.typeName}${arg.type.kind === Kind.NON_NULL_TYPE ? "" : "?"}`;
-  });
-  const dataFetchingEnvironmentArgument =
-    "dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment";
-  const extraFieldArguments = [dataFetchingEnvironmentArgument];
-  const allFieldArguments = existingFieldArguments?.concat(extraFieldArguments);
-  return allFieldArguments?.length
-    ? `(${allFieldArguments?.join(", ")})`
-    : "()";
-}

src/helpers/should-generate-resolver-class.ts

@@ -7,15 +7,15 @@ open class MyResolverType {
     open fun nullableField(dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("MyResolverType.nullableField must be implemented.")
     open fun nonNullableField(dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MyResolverType.nonNullableField must be implemented.")
     open fun nullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("MyResolverType.nullableResolver must be implemented.")
-    open fun nonNullableResolver(arg: InputTypeForResolver, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MyResolverType.nonNullableResolver must be implemented.")
+    open fun nonNullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MyResolverType.nonNullableResolver must be implemented.")
 }
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])
 open class MySuspendResolverType {
     open suspend fun nullableField(dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("MySuspendResolverType.nullableField must be implemented.")
     open suspend fun nonNullableField(dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MySuspendResolverType.nonNullableField must be implemented.")
     open suspend fun nullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String? = throw NotImplementedError("MySuspendResolverType.nullableResolver must be implemented.")
-    open suspend fun nonNullableResolver(arg: InputTypeForResolver, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MySuspendResolverType.nonNullableResolver must be implemented.")
+    open suspend fun nonNullableResolver(arg: String, dataFetchingEnvironment: graphql.schema.DataFetchingEnvironment): String = throw NotImplementedError("MySuspendResolverType.nonNullableResolver must be implemented.")
 }
 
 @GraphQLValidObjectLocations(locations = [GraphQLValidObjectLocations.Locations.OBJECT])