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

.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

packages/plugins/other/visitor-plugin-common/src/base-types-visitor.ts

@@ -43,6 +43,7 @@ import {
 } from './utils.js';
 import { OperationVariablesToObject } from './variables-to-object.js';
 import { buildEnumValuesBlock } from './convert-schema-enum-to-declaration-block-string.js';
+import { buildTypeImport, getEnumsImports } from './imports.js';
 
 export interface ParsedTypesConfig extends ParsedConfig {
   enumValues: ParsedEnumValuesMap;
@@ -559,12 +560,24 @@ export class BaseTypesVisitor<
       const mappedValue = this.config.scalars[enumName];
 
       if (mappedValue.input.isExternal) {
-        res.push(this._buildTypeImport(mappedValue.input.import, mappedValue.input.source, mappedValue.input.default));
+        res.push(
+          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,
+          })
         );
       }
 
@@ -578,7 +591,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;
@@ -811,58 +829,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 {

packages/plugins/other/visitor-plugin-common/src/imports.ts

@@ -1,5 +1,6 @@
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import parse from 'parse-filepath';
+import type { ParsedEnumValuesMap } from './types';
 
 export type ImportDeclaration<T = string> = {
   outputPath: string;
@@ -98,3 +99,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}';`;
+}

packages/plugins/typescript/operations/src/index.ts

@@ -63,6 +63,7 @@ export const plugin: PluginFunction<TypeScriptDocumentsPluginConfig, Types.Compl
   return {
     prepend: [
       ...visitor.getImports(),
+      ...visitor.getEnumsImports(),
       ...visitor.getGlobalDeclarations(visitor.config.noExport),
       'type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };',
     ],

packages/plugins/typescript/operations/src/visitor.ts

@@ -5,6 +5,7 @@ import {
   DeclarationKind,
   generateFragmentImportStatement,
   getConfigValue,
+  getEnumsImports,
   LoadedFragment,
   normalizeAvoidOptionals,
   NormalizedAvoidOptionalsConfig,
@@ -168,6 +169,7 @@ export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor<
     );
     this._declarationBlockConfig = {
       ignoreExport: this.config.noExport,
+      enumNameValueSeparator: ' =',
     };
   }
 
@@ -245,4 +247,11 @@ export class TypeScriptDocumentsVisitor extends BaseDocumentsVisitor<
 
     return usedInputTypes;
   }
+
+  public getEnumsImports(): string[] {
+    return getEnumsImports({
+      enumValues: this.config.enumValues,
+      useTypeImports: this.config.useTypeImports,
+    });
+  }
 }