[typescript][typescript-resolvers] Fix enumValues not considering namingConvention in certain scenarios (2) (#10657)

* Ensure enumValues is consistent in typescript and typescript-resolvers

* Add a note to default alias import not doing anything

* Add changeset

Author: eddeee888

.changeset/tasty-waves-trade.md

@@ -0,0 +1,7 @@
+---
+'@graphql-codegen/visitor-plugin-common': patch
+'@graphql-codegen/typescript': patch
+'@graphql-codegen/typescript-resolvers': patch
+---
+
+Fix namingConvention not being applied consistently

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

@@ -941,10 +941,7 @@ export class BaseResolversVisitor<
       if (isEnumType(schemaType) && this.config.enumValues[typeName]) {
         const isExternalFile = !!this.config.enumValues[typeName].sourceFile;
         prev[typeName] = isExternalFile
-          ? this.convertName(this.config.enumValues[typeName].typeIdentifier, {
-              useTypesPrefix: false,
-              useTypesSuffix: false,
-            })
+          ? this.config.enumValues[typeName].typeIdentifierConverted
           : this.config.enumValues[typeName].sourceIdentifier;
       } else if (hasDefaultMapper && !hasPlaceholder(this.config.defaultMapper.type)) {
         prev[typeName] = applyWrapper(this.config.defaultMapper.type);
@@ -1350,7 +1347,7 @@ export class BaseResolversVisitor<
     const exists = groupedMappers[source] ? !!groupedMappers[source].find(m => m.identifier === identifier) : false;
     const existsFromEnums = !!Object.keys(this.config.enumValues)
       .map(key => this.config.enumValues[key])
-      .find(o => o.sourceFile === source && o.typeIdentifier === identifier);
+      .find(o => o.sourceFile === source && o.typeIdentifierConverted === identifier);
 
     return exists || existsFromEnums;
   }

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

@@ -961,7 +961,7 @@ export class BaseTypesVisitor<
       return this._getScalar(typeAsString, isVisitingInputType ? 'input' : 'output');
     }
     if (this.config.enumValues[typeAsString]) {
-      return this.config.enumValues[typeAsString].typeIdentifier;
+      return this.config.enumValues[typeAsString].typeIdentifierConverted;
     }
 
     const schemaType = this._schema.getType(typeAsString);

packages/plugins/typescript/operations/tests/ts-documents.standalone.enum.spec.ts

@@ -847,7 +847,7 @@ describe('TypeScript Operations Plugin - Enum', () => {
           typesPrefix: 'I',
           namingConvention: { enumValues: 'change-case-all#constantCase' },
           enumValues: {
-            UserRole: './files#default as IUserRole',
+            UserRole: './files#default as UserRole', // NOTE: `as UserRole` doesn't do anything here, this is here to demonstrate that it's the same as './files#default'
           },
         },
         { outputFile: '' }

packages/plugins/typescript/resolvers/tests/ts-resolvers.spec.ts

@@ -685,8 +685,8 @@ __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
     expect(mergedOutputs).not.toContain(`NotMapped: NotMapped;`);
     expect(mergedOutputs).toContain(`A: MyA;`);
     expect(mergedOutputs).toContain(`B: GQL_B;`);
-    expect(mergedOutputs).toContain(`C: C;`);
-    expect(mergedOutputs).toContain(`import { MyC as C } from '../enums.js';`);
+    expect(mergedOutputs).toContain(`C: GQL_C;`);
+    expect(mergedOutputs).toContain(`import { MyC as GQL_C } from '../enums.js';`);
   });
 
   it('Should allow to generate optional __resolveType', async () => {
@@ -2375,7 +2375,7 @@ export type ResolverFn<TResult, TParent, TContext, TArgs> = (
         { outputFile: 'graphql.ts' }
       )) as Types.ComplexPluginOutput;
 
-      expect(output.content).toContain(`export type GqlAuthDirectiveArgs = {\n  role?: Maybe<UserRole>;\n};`);
+      expect(output.content).toContain(`export type GqlAuthDirectiveArgs = {\n  role?: Maybe<GqlUserRole>;\n};`); // Note: `GqlUserRole` will be imported from `@org/package` by `typescript` plugin
       expect(output.content).toContain(
         `export type GqlAuthDirectiveResolver<Result, Parent, ContextType = any, Args = GqlAuthDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;`
       );

packages/plugins/typescript/typescript/tests/typescript.spec.ts

@@ -895,13 +895,13 @@ describe('TypeScript', () => {
           typesPrefix: 'I',
           namingConvention: { enumValues: 'change-case-all#constantCase' },
           enumValues: {
-            MyEnum: './files#default as MyEnum',
+            MyEnum: './files#default as MyEnum', // NOTE: `as MyEnum` doesn't do anything, this is here to demonstrate that it's the same as './files#default'
           },
         },
         { outputFile: '' }
       )) as Types.ComplexPluginOutput;
 
-      expect(result.prepend[0]).toBe(`import MyEnum from './files';`);
+      expect(result.prepend[0]).toBe(`import IMyEnum from './files';`);
     });
 
     it('#4834 - enum members should be quoted if numeric', async () => {
@@ -948,14 +948,21 @@ describe('TypeScript', () => {
         { outputFile: '' }
       )) as Types.ComplexPluginOutput;
 
+      expect(result.prepend).toMatchInlineSnapshot(`
+        [
+          "import { MyEnum as IMyEnum } from './files';",
+          "export type Maybe<T> = T | null;",
+          "export type InputMaybe<T> = Maybe<T>;",
+        ]
+      `);
       expect(result.content).toBeSimilarStringTo(`export type ITest = {
         __typename?: 'Test';
-       t?: Maybe<MyEnum>;
+       t?: Maybe<IMyEnum>;
        test?: Maybe<Scalars['String']['output']>;
      };`);
 
       expect(result.content).toBeSimilarStringTo(`export type ITestTestArgs = {
-      a?: InputMaybe<MyEnum>;
+      a?: InputMaybe<IMyEnum>;
     };`);
     });
 
@@ -987,9 +994,9 @@ describe('TypeScript', () => {
         },
         { outputFile: '' }
       )) as Types.ComplexPluginOutput;
-      expect(result.prepend).toContain(`import { MyEnum } from './files';`);
+      expect(result.prepend).toContain(`import { MyEnum as GQL_MyEnum } from './files';`);
       expect(result.content).toContain(`enum GQL_OtherEnum {`);
-      expect(result.content).toContain(`a?: Maybe<MyEnum>;`);
+      expect(result.content).toContain(`a?: Maybe<GQL_MyEnum>;`);
       expect(result.content).toContain(`b?: Maybe<GQL_OtherEnum>`);
     });