[typescript-operations] Add missing enum tests & fix enum generating logic for standalone approach (#10525)

eddeee888 · eddeee888 · commit 322949464de8 · 2026-04-19T20:24:27.000+10:00
* Add tests for enum

* Baselin tests

* Ensure correctness of enumValues import

* Split enum tests

* Abstract import printing functions

* Add missing enum tests

* Format to minimise conflict

* Add changeset
diff --git a/.changeset/tidy-jobs-unite.md b/.changeset/tidy-jobs-unite.md
@@ -0,0 +1,9 @@
+---
+'@graphql-codegen/visitor-plugin-common': patch
+'@graphql-codegen/typescript-operations': patch
+'@graphql-codegen/typescript': patch
+'@graphql-codegen/typescript-resolvers': patch
+'@graphql-codegen/client-preset': patch
+---
+
+Abstract how enum imports are generated into visitor-plugin-common package
diff --git a/packages/plugins/other/visitor-plugin-common/src/base-types-visitor.ts b/packages/plugins/other/visitor-plugin-common/src/base-types-visitor.ts
@@ -20,6 +20,7 @@ import { BaseVisitor, ParsedConfig, RawConfig } from './base-visitor.js';
 import { buildEnumValuesBlock } from './convert-schema-enum-to-declaration-block-string.js';
 import { normalizeDeclarationKind } from './declaration-kinds.js';
 import { parseEnumValues } from './enum-values.js';
+import { buildTypeImport, getEnumsImports } from './imports.js';
 import { transformDirectiveArgumentAndInputFieldMappings } from './mappers.js';
 import { DEFAULT_SCALARS } from './scalars.js';
 import {
@@ -562,21 +563,23 @@ export class BaseTypesVisitor<
 
       if (mappedValue.input.isExternal) {
         res.push(
-          this._buildTypeImport(
-            mappedValue.input.import,
-            mappedValue.input.source,
-            mappedValue.input.default,
-          ),
+          buildTypeImport({
+            identifier: mappedValue.input.import,
+            source: mappedValue.input.source,
+            asDefault: mappedValue.input.default,
+            useTypeImports: this.config.useTypeImports,
+          }),
         );
       }
 
       if (mappedValue.output.isExternal) {
         res.push(
-          this._buildTypeImport(
-            mappedValue.output.import,
-            mappedValue.output.source,
-            mappedValue.output.default,
-          ),
+          buildTypeImport({
+            identifier: mappedValue.output.import,
+            source: mappedValue.output.source,
+            asDefault: mappedValue.output.default,
+            useTypeImports: this.config.useTypeImports,
+          }),
         );
       }
 
@@ -590,7 +593,12 @@ export class BaseTypesVisitor<
         const mappedValue = this.config.directiveArgumentAndInputFieldMappings[directive];
 
         if (mappedValue.isExternal) {
-          return this._buildTypeImport(mappedValue.import, mappedValue.source, mappedValue.default);
+          return buildTypeImport({
+            identifier: mappedValue.import,
+            source: mappedValue.source,
+            asDefault: mappedValue.default,
+            useTypeImports: this.config.useTypeImports,
+          });
         }
 
         return null;
@@ -856,60 +864,11 @@ export class BaseTypesVisitor<
     return '';
   }
 
-  protected _buildTypeImport(identifier: string, source: string, asDefault = false): string {
-    const { useTypeImports } = this.config;
-    if (asDefault) {
-      if (useTypeImports) {
-        return `import type { default as ${identifier} } from '${source}';`;
-      }
-      return `import ${identifier} from '${source}';`;
-    }
-    return `import${useTypeImports ? ' type' : ''} { ${identifier} } from '${source}';`;
-  }
-
-  protected handleEnumValueMapper(
-    typeIdentifier: string,
-    importIdentifier: string | null,
-    sourceIdentifier: string | null,
-    sourceFile: string | null,
-  ): string[] {
-    if (importIdentifier !== sourceIdentifier) {
-      // use namespace import to dereference nested enum
-      // { enumValues: { MyEnum: './my-file#NS.NestedEnum' } }
-      return [
-        this._buildTypeImport(importIdentifier || sourceIdentifier, sourceFile),
-        `import ${typeIdentifier} = ${sourceIdentifier};`,
-      ];
-    }
-    if (sourceIdentifier !== typeIdentifier) {
-      return [this._buildTypeImport(`${sourceIdentifier} as ${typeIdentifier}`, sourceFile)];
-    }
-    return [this._buildTypeImport(importIdentifier || sourceIdentifier, sourceFile)];
-  }
-
   public getEnumsImports(): string[] {
-    return Object.keys(this.config.enumValues)
-      .flatMap(enumName => {
-        const mappedValue = this.config.enumValues[enumName];
-
-        if (mappedValue.sourceFile) {
-          if (mappedValue.isDefault) {
-            return [
-              this._buildTypeImport(mappedValue.typeIdentifier, mappedValue.sourceFile, true),
-            ];
-          }
-
-          return this.handleEnumValueMapper(
-            mappedValue.typeIdentifier,
-            mappedValue.importIdentifier,
-            mappedValue.sourceIdentifier,
-            mappedValue.sourceFile,
-          );
-        }
-
-        return [];
-      })
-      .filter(Boolean);
+    return getEnumsImports({
+      enumValues: this.config.enumValues,
+      useTypeImports: this.config.useTypeImports,
+    });
   }
 
   EnumTypeDefinition(node: EnumTypeDefinitionNode): string {
diff --git a/packages/plugins/other/visitor-plugin-common/src/imports.ts b/packages/plugins/other/visitor-plugin-common/src/imports.ts
@@ -1,6 +1,7 @@
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import parse from 'parse-filepath';
 import { normalizeImportExtension } from '@graphql-codegen/plugin-helpers';
+import type { ParsedEnumValuesMap } from './types';
 
 export type ImportDeclaration<T = string> = {
   outputPath: string;
@@ -105,3 +106,88 @@ export function clearExtension(path: string): string {
 export function fixLocalFilePath(path: string): string {
   return path.startsWith('..') ? path : `./${path}`;
 }
+
+export function getEnumsImports({
+  enumValues,
+  useTypeImports,
+}: {
+  enumValues: ParsedEnumValuesMap;
+  useTypeImports: boolean;
+}): string[] {
+  function handleEnumValueMapper({
+    typeIdentifier,
+    importIdentifier,
+    sourceIdentifier,
+    sourceFile,
+    useTypeImports,
+  }: {
+    typeIdentifier: string;
+    importIdentifier: string | null;
+    sourceIdentifier: string | null;
+    sourceFile: string | null;
+    useTypeImports: boolean;
+  }): string[] {
+    if (importIdentifier !== sourceIdentifier) {
+      // use namespace import to dereference nested enum
+      // { enumValues: { MyEnum: './my-file#NS.NestedEnum' } }
+      return [
+        buildTypeImport({ identifier: importIdentifier || sourceIdentifier, source: sourceFile, useTypeImports }),
+        `import ${typeIdentifier} = ${sourceIdentifier};`,
+      ];
+    }
+    if (sourceIdentifier !== typeIdentifier) {
+      return [
+        buildTypeImport({ identifier: `${sourceIdentifier} as ${typeIdentifier}`, source: sourceFile, useTypeImports }),
+      ];
+    }
+    return [buildTypeImport({ identifier: importIdentifier || sourceIdentifier, source: sourceFile, useTypeImports })];
+  }
+
+  return Object.keys(enumValues)
+    .flatMap(enumName => {
+      const mappedValue = enumValues[enumName];
+      if (mappedValue.sourceFile) {
+        if (mappedValue.isDefault) {
+          return [
+            buildTypeImport({
+              identifier: mappedValue.typeIdentifier,
+              source: mappedValue.sourceFile,
+              asDefault: true,
+              useTypeImports,
+            }),
+          ];
+        }
+
+        return handleEnumValueMapper({
+          typeIdentifier: mappedValue.typeIdentifier,
+          importIdentifier: mappedValue.importIdentifier,
+          sourceIdentifier: mappedValue.sourceIdentifier,
+          sourceFile: mappedValue.sourceFile,
+          useTypeImports,
+        });
+      }
+
+      return [];
+    })
+    .filter(Boolean);
+}
+
+export function buildTypeImport({
+  identifier,
+  source,
+  useTypeImports,
+  asDefault = false,
+}: {
+  identifier: string;
+  source: string;
+  useTypeImports: boolean;
+  asDefault?: boolean;
+}): string {
+  if (asDefault) {
+    if (useTypeImports) {
+      return `import type { default as ${identifier} } from '${source}';`;
+    }
+    return `import ${identifier} from '${source}';`;
+  }
+  return `import${useTypeImports ? ' type' : ''} { ${identifier} } from '${source}';`;
+}
diff --git a/packages/plugins/typescript/operations/src/index.ts b/packages/plugins/typescript/operations/src/index.ts
@@ -101,6 +101,7 @@ export const plugin: PluginFunction<
   return {
     prepend: [
       ...visitor.getImports(),
+      ...visitor.getEnumsImports(),
       ...visitor.getGlobalDeclarations(visitor.config.noExport),
       'type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };',
     ],
diff --git a/packages/plugins/typescript/operations/src/visitor.ts b/packages/plugins/typescript/operations/src/visitor.ts
@@ -21,6 +21,7 @@ import {
   DeclarationKind,
   generateFragmentImportStatement,
   getConfigValue,
+  getEnumsImports,
   LoadedFragment,
   normalizeAvoidOptionals,
   NormalizedAvoidOptionalsConfig,
@@ -181,6 +182,7 @@ export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor<
     );
     this._declarationBlockConfig = {
       ignoreExport: this.config.noExport,
+      enumNameValueSeparator: ' =',
     };
   }
 
@@ -263,4 +265,11 @@ export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor<
 
     return usedInputTypes;
   }
+
+  public getEnumsImports(): string[] {
+    return getEnumsImports({
+      enumValues: this.config.enumValues,
+      useTypeImports: this.config.useTypeImports,
+    });
+  }
 }
diff --git a/packages/plugins/typescript/operations/tests/ts-documents.standalone.enum.spec.ts b/packages/plugins/typescript/operations/tests/ts-documents.standalone.enum.spec.ts
diff --git a/packages/plugins/typescript/operations/tests/ts-documents.standalone.spec.ts b/packages/plugins/typescript/operations/tests/ts-documents.standalone.spec.ts
