inject defaults in codegen config

Author: danadajian

src/config.ts

@@ -130,6 +130,10 @@ export const configSchema = object({
       }),
     ),
   ),
+  /**
+   * Denotes the generation strategy for union types. Defaults to `MARKER_INTERFACE`.
+   * https://opensource.expediagroup.com/graphql-kotlin/docs/schema-generator/writing-schemas/unions/
+   */
   unionGeneration: optional(
     union([literal("ANNOTATION_CLASS"), literal("MARKER_INTERFACE")]),
   ),

src/definitions/enum.ts

@@ -52,5 +52,5 @@ function buildEnumValueDefinition(
     config,
     definitionNode: node,
   });
-  return `${annotations}${config.convert(node)}`;
+  return `${annotations}${config.convert?.(node)}`;
 }

src/helpers/add-dependent-types.ts

@@ -20,16 +20,17 @@ export function addDependentTypes(
   config: CodegenConfig,
   schema: GraphQLSchema,
 ) {
-  if (config.onlyTypes && (config.includeDependentTypes ?? true)) {
-    const onlyTypesNodes = config.onlyTypes
-      .map((typeName) => schema.getType(typeName)?.astNode)
-      .filter(Boolean);
-    const dependentTypeNames = onlyTypesNodes.flatMap((node) =>
-      getDependentTypeNames(schema, node, config),
-    );
-    const dependentTypesInScope = dependentTypeNames.filter((typeName) =>
-      dependentTypeIsInScope(typeName, config),
-    );
-    config.onlyTypes.push(...dependentTypesInScope);
+  if (!config.onlyTypes) {
+    throw new Error(`config.onlyTypes is required to add dependent types`);
   }
+  const onlyTypesNodes = config.onlyTypes
+    .map((typeName) => schema.getType(typeName)?.astNode)
+    .filter(Boolean);
+  const dependentTypeNames = onlyTypesNodes.flatMap((node) =>
+    getDependentTypeNames(schema, node, config),
+  );
+  const dependentTypesInScope = dependentTypeNames.filter((typeName) =>
+    dependentTypeIsInScope(typeName, config),
+  );
+  config.onlyTypes.push(...dependentTypesInScope);
 }

src/helpers/build-config-with-defaults.ts

@@ -0,0 +1,21 @@
+import { GraphQLKotlinCodegenConfig } from "../plugin";
+import { buildPackageNameFromPath } from "@graphql-codegen/java-common";
+import { dirname, normalize } from "path";
+
+export function buildConfigWithDefaults(
+  config: GraphQLKotlinCodegenConfig,
+  outputFile: string,
+) {
+  const relevantPath = dirname(normalize(outputFile));
+
+  return {
+    packageName: buildPackageNameFromPath(relevantPath),
+    includeDependentTypes: true,
+    unionGeneration: "MARKER_INTERFACE",
+    ...config,
+    extraImports: [
+      "com.expediagroup.graphql.generator.annotations.*",
+      ...(config.extraImports ?? ([] satisfies string[])),
+    ],
+  } as const;
+}

src/helpers/build-directive-annotations.ts

@@ -11,7 +11,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { CodegenConfig, GraphQLKotlinCodegenConfig } from "../plugin";
+import { CodegenConfig } from "../plugin";
 import {
   DefinitionNode,
   isDeprecatedDescription,
@@ -75,7 +75,7 @@ export function buildDirectiveAnnotations(
 function buildKotlinAnnotations(
   directive: ConstDirectiveNode,
   kotlinAnnotations: NonNullable<
-    GraphQLKotlinCodegenConfig["directiveReplacements"]
+    CodegenConfig["directiveReplacements"]
   >[number]["kotlinAnnotations"],
 ) {
   return kotlinAnnotations.map((kotlinAnnotation) => {

src/helpers/build-type-metadata.ts

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

src/helpers/dependent-type-utils.ts

@@ -22,14 +22,15 @@ import { CodegenConfig } from "../plugin";
 
 export function getDependentFieldTypeNames(
   node: TypeDefinitionNode,
-  dependentTypesInScope: CodegenConfig["dependentTypesInScope"],
+  config: CodegenConfig,
 ) {
   return "fields" in node && node.fields
     ? node.fields
         .map((field) => getFieldTypeName(field.type))
         .filter(
           (typeName) =>
-            !dependentTypesInScope || dependentTypesInScope.includes(typeName),
+            !config.dependentTypesInScope ||
+            config.dependentTypesInScope.includes(typeName),
         )
     : [];
 }

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

@@ -18,17 +18,14 @@ import {
   getDependentInterfaceNames,
   getDependentUnionNames,
 } from "./dependent-type-utils";
-import { GraphQLKotlinCodegenConfig } from "../plugin";
+import { CodegenConfig } from "../plugin";
 
 export function getDependentTypeNames(
   schema: GraphQLSchema,
   node: TypeDefinitionNode,
-  config: GraphQLKotlinCodegenConfig,
+  config: CodegenConfig,
 ): string[] {
-  const namedTypes = getDependentFieldTypeNames(
-    node,
-    config.dependentTypesInScope,
-  )
+  const namedTypes = getDependentFieldTypeNames(node, config)
     .concat(getDependentUnionNames(node))
     .concat(getDependentInterfaceNames(node));
   const recursivelyFoundTypes = namedTypes

src/plugin.ts

@@ -11,12 +11,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { dirname, normalize } from "path";
 import {
   getCachedDocumentNodeFromSchema,
   PluginFunction,
 } from "@graphql-codegen/plugin-helpers";
-import { buildPackageNameFromPath } from "@graphql-codegen/java-common";
 import { KotlinVisitor } from "./visitor";
 import {
   ParsedConfig,
@@ -26,13 +24,13 @@ import { Input, safeParse } from "valibot";
 import { configSchema } from "./config";
 import { addDependentTypes } from "./helpers/add-dependent-types";
 import { visit } from "graphql";
+import { buildConfigWithDefaults } from "./helpers/build-config-with-defaults";
 
 export type GraphQLKotlinCodegenConfig = Partial<RawConfig & ParsedConfig> &
   Input<typeof configSchema>;
-export type CodegenConfig = RawConfig &
-  ParsedConfig &
-  Input<typeof configSchema>;
-export const plugin: PluginFunction<CodegenConfig> = (
+export type CodegenConfig = ReturnType<typeof buildConfigWithDefaults>;
+
+export const plugin: PluginFunction<GraphQLKotlinCodegenConfig> = (
   schema,
   _,
   config,
@@ -41,7 +39,6 @@ export const plugin: PluginFunction<CodegenConfig> = (
   if (!info?.outputFile) {
     throw new Error("Missing outputFile in config");
   }
-  const relevantPath = dirname(normalize(info.outputFile));
   const { issues } = safeParse(configSchema, config);
   if (issues) {
     throw new Error(
@@ -54,17 +51,20 @@ export const plugin: PluginFunction<CodegenConfig> = (
     );
   }
 
-  addDependentTypes(config, schema);
-  const visitor = new KotlinVisitor(config, schema);
+  const configWithDefaults = buildConfigWithDefaults(config, info.outputFile);
+
+  if (
+    configWithDefaults.onlyTypes &&
+    configWithDefaults.includeDependentTypes
+  ) {
+    addDependentTypes(configWithDefaults, schema);
+  }
+  const visitor = new KotlinVisitor(configWithDefaults, schema);
   const astNode = getCachedDocumentNodeFromSchema(schema);
   const { definitions } = visit(astNode, visitor);
-  const packageName = `package ${
-    config.packageName ?? buildPackageNameFromPath(relevantPath)
-  }\n`;
-  const defaultImports = ["com.expediagroup.graphql.generator.annotations.*"];
+  const packageName = `package ${configWithDefaults.packageName}\n`;
   const imports =
-    defaultImports
-      .concat(config.extraImports ?? [])
+    configWithDefaults.extraImports
       .map((annotation) => `import ${annotation}`)
       .join("\n") + "\n";
   const typeDefinitions = definitions

src/visitor.ts

@@ -26,8 +26,12 @@ import { buildInterfaceDefinition } from "./definitions/interface";
 import { buildInputObjectDefinition } from "./definitions/input";
 import { buildObjectTypeDefinition } from "./definitions/object";
 import { buildUnionTypeDefinition } from "./definitions/union";
+import { ParsedConfig } from "@graphql-codegen/visitor-plugin-common/typings/base-visitor";
 
-export class KotlinVisitor extends BaseVisitor<RawConfig, CodegenConfig> {
+export class KotlinVisitor extends BaseVisitor<
+  RawConfig,
+  ParsedConfig & CodegenConfig
+> {
   constructor(
     rawConfig: CodegenConfig,
     protected _schema: GraphQLSchema,

test/plugin.test.ts

@@ -1,5 +1,5 @@
 import { buildSchema } from "graphql";
-import { CodegenConfig, plugin } from "../src/plugin";
+import { GraphQLKotlinCodegenConfig, plugin } from "../src/plugin";
 import { describe, expect, it } from "bun:test";
 import { Types } from "@graphql-codegen/plugin-helpers";
 import * as glob from "glob";
@@ -9,7 +9,7 @@ function buildUnitTest({
   config,
 }: {
   testName: string;
-  config: CodegenConfig;
+  config: GraphQLKotlinCodegenConfig;
 }) {
   it(testName, async () => {
     const filePath = `./test/unit/${testName}`;