[resolvers] Add avoidCheckingAbstractTypesRecursively option to sup…

…port nested defaultMappers (#10141)

* Add avoidCheckingAbstractTypesRecursively to control whether to recursively checks and generates abstract nested types

* Add changeset

* Add avoidCheckingAbstractTypesRecursively to defaultMapper

.changeset/grumpy-moose-bake.md

@@ -0,0 +1,8 @@
+---
+'@graphql-codegen/visitor-plugin-common': minor
+'@graphql-codegen/typescript-resolvers': minor
+---
+
+Add avoidCheckingAbstractTypesRecursively to avoid checking and generating abstract types recursively
+
+For users that already sets recursive default mappers e.g. `Partial<{T}>` or `DeepPartial<{T}>`, having both options on will cause a nested loop which eventually crashes Codegen. In such case, setting `avoidCheckingAbstractTypesRecursively: true` allows users to continue to use recursive default mappers as before.

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

@@ -81,6 +81,7 @@ export interface ParsedResolversConfig extends ParsedConfig {
  onlyResolveTypeForInterfaces: boolean;
  directiveResolverMappings: Record<string, string>;
  resolversNonOptionalTypename: ResolversNonOptionalTypenameConfig;
+ avoidCheckingAbstractTypesRecursively: boolean;
 }
 
 type FieldDefinitionPrintFn = (parentName: string, avoidResolverOptionals: boolean) => string | null;
@@ -394,6 +395,7 @@ export interface RawResolversConfig extends RawConfig {
  * plugins: ['typescript', 'typescript-resolver', { add: { content: "import { DeepPartial } from 'utility-types';" } }],
  * config: {
  * defaultMapper: 'DeepPartial<{T}>',
+ * avoidCheckingAbstractTypesRecursively: true // required if you have complex nested abstract types
  * },
  * },
  * },
@@ -644,6 +646,13 @@ export interface RawResolversConfig extends RawConfig {
  * ```
  */
  resolversNonOptionalTypename?: boolean | ResolversNonOptionalTypenameConfig;
+ /**
+ * @type boolean
+ * @default false
+ * @description If true, recursively goes through all object type's fields, checks if they have abstract types and generates expected types correctly.
+ * This may not work for cases where provided default mapper types are also nested e.g. `defaultMapper: DeepPartial<{T}>` or `defaultMapper: Partial<{T}>`.
+ */
+ avoidCheckingAbstractTypesRecursively?: boolean;
  /**
  * @ignore
  */
@@ -726,6 +735,7 @@ export class BaseResolversVisitor<
  resolversNonOptionalTypename: normalizeResolversNonOptionalTypename(
  getConfigValue(rawConfig.resolversNonOptionalTypename, false)
  ),
+ avoidCheckingAbstractTypesRecursively: getConfigValue(rawConfig.avoidCheckingAbstractTypesRecursively, false),
  ...additionalConfig,
  } as TPluginConfig);
 
@@ -1851,7 +1861,7 @@ export class BaseResolversVisitor<
  const isObject = isObjectType(baseType);
  let isObjectWithAbstractType = false;
 
- if (isObject) {
+ if (isObject && !this.config.avoidCheckingAbstractTypesRecursively) {
  isObjectWithAbstractType = checkIfObjectTypeHasAbstractTypesRecursively(baseType, {
  isObjectWithAbstractType,
  checkedTypesWithNestedAbstractTypes: this._checkedTypesWithNestedAbstractTypes,

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

@@ -406,4 +406,59 @@ describe('TypeScript Resolvers Plugin - Interfaces', () => {
  };
  `);
  });
+
+ it('does not generate nested types when avoidCheckingAbstractTypesRecursively=true', async () => {
+ const schema = buildSchema(/* GraphQL */ `
+ interface I_Node {
+ id: ID!
+ }
+
+ type T_WithNode {
+ node: I_Node!
+ }
+
+ type T_Type1 {
+ id: ID!
+ type2: T_Type2!
+ withNode: T_WithNode! # abstract type is in T_Type1
+ }
+
+ type T_Type2 {
+ id: ID!
+ type1: T_Type1!
+ }
+ `);
+
+ const result = await plugin(schema, [], { avoidCheckingAbstractTypesRecursively: true }, { outputFile: '' });
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversInterfaceTypes<_RefType extends Record<string, unknown>> = {
+ I_Node: never;
+ };
+ `);
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversTypes = {
+ I_Node: ResolverTypeWrapper<ResolversInterfaceTypes<ResolversTypes>['I_Node']>;
+ ID: ResolverTypeWrapper<Scalars['ID']['output']>;
+ T_WithNode: ResolverTypeWrapper<Omit<T_WithNode, 'node'> & { node: ResolversTypes['I_Node'] }>;
+ T_Type1: ResolverTypeWrapper<T_Type1>;
+ T_Type2: ResolverTypeWrapper<T_Type2>;
+ Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
+ String: ResolverTypeWrapper<Scalars['String']['output']>;
+ };
+ `);
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversParentTypes = {
+ I_Node: ResolversInterfaceTypes<ResolversParentTypes>['I_Node'];
+ ID: Scalars['ID']['output'];
+ T_WithNode: Omit<T_WithNode, 'node'> & { node: ResolversParentTypes['I_Node'] };
+ T_Type1: T_Type1;
+ T_Type2: T_Type2;
+ Boolean: Scalars['Boolean']['output'];
+ String: Scalars['String']['output'];
+ };
+ `);
+ });
 });

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

@@ -94,4 +94,146 @@ describe('TypeScript Resolvers Plugin - Union', () => {
  expect(content.content).not.toBeSimilarStringTo(`export type ResolversUnionTypes`);
  expect(content.content).not.toBeSimilarStringTo(`export type ResolversUnionParentTypes`);
  });
+
+ it('generates nested types when avoidCheckingAbstractTypesRecursively=false (default)', async () => {
+ const schema = buildSchema(/* GraphQL */ `
+ type StandardError {
+ error: String!
+ }
+
+ type User {
+ id: ID!
+ fullName: String!
+ posts: PostsPayload!
+ }
+
+ type UserResult {
+ result: User
+ recommendedPosts: PostsPayload!
+ }
+
+ union UserPayload = UserResult | StandardError
+
+ type Post {
+ author: String
+ comment: String
+ }
+
+ type PostsResult {
+ results: [Post!]!
+ }
+
+ union PostsPayload = PostsResult | StandardError
+ `);
+
+ const result = await plugin(schema, [], {}, { outputFile: '' });
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversUnionTypes<_RefType extends Record<string, unknown>> = {
+ UserPayload: ( Omit<UserResult, 'result' | 'recommendedPosts'> & { result?: Maybe<_RefType['User']>, recommendedPosts: _RefType['PostsPayload'] } ) | ( StandardError );
+ PostsPayload: ( PostsResult ) | ( StandardError );
+ };
+ `);
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversTypes = {
+ StandardError: ResolverTypeWrapper<StandardError>;
+ String: ResolverTypeWrapper<Scalars['String']['output']>;
+ User: ResolverTypeWrapper<Omit<User, 'posts'> & { posts: ResolversTypes['PostsPayload'] }>;
+ ID: ResolverTypeWrapper<Scalars['ID']['output']>;
+ UserResult: ResolverTypeWrapper<Omit<UserResult, 'result' | 'recommendedPosts'> & { result?: Maybe<ResolversTypes['User']>, recommendedPosts: ResolversTypes['PostsPayload'] }>;
+ UserPayload: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UserPayload']>;
+ Post: ResolverTypeWrapper<Post>;
+ PostsResult: ResolverTypeWrapper<PostsResult>;
+ PostsPayload: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['PostsPayload']>;
+ Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
+ };
+ `);
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversParentTypes = {
+ StandardError: StandardError;
+ String: Scalars['String']['output'];
+ User: Omit<User, 'posts'> & { posts: ResolversParentTypes['PostsPayload'] };
+ ID: Scalars['ID']['output'];
+ UserResult: Omit<UserResult, 'result' | 'recommendedPosts'> & { result?: Maybe<ResolversParentTypes['User']>, recommendedPosts: ResolversParentTypes['PostsPayload'] };
+ UserPayload: ResolversUnionTypes<ResolversParentTypes>['UserPayload'];
+ Post: Post;
+ PostsResult: PostsResult;
+ PostsPayload: ResolversUnionTypes<ResolversParentTypes>['PostsPayload'];
+ Boolean: Scalars['Boolean']['output'];
+ };
+ `);
+ });
+
+ it('does not generate nested types when avoidCheckingAbstractTypesRecursively=true', async () => {
+ const schema = buildSchema(/* GraphQL */ `
+ type StandardError {
+ error: String!
+ }
+
+ type User {
+ id: ID!
+ fullName: String!
+ posts: PostsPayload!
+ }
+
+ type UserResult {
+ result: User
+ recommendedPosts: PostsPayload!
+ }
+
+ union UserPayload = UserResult | StandardError
+
+ type Post {
+ author: String
+ comment: String
+ }
+
+ type PostsResult {
+ results: [Post!]!
+ }
+
+ union PostsPayload = PostsResult | StandardError
+ `);
+
+ const result = await plugin(schema, [], { avoidCheckingAbstractTypesRecursively: true }, { outputFile: '' });
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversUnionTypes<_RefType extends Record<string, unknown>> = {
+ UserPayload: ( Omit<UserResult, 'recommendedPosts'> & { recommendedPosts: _RefType['PostsPayload'] } ) | ( StandardError );
+ PostsPayload: ( PostsResult ) | ( StandardError );
+ };
+ `);
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversTypes = {
+ StandardError: ResolverTypeWrapper<StandardError>;
+ String: ResolverTypeWrapper<Scalars['String']['output']>;
+ User: ResolverTypeWrapper<Omit<User, 'posts'> & { posts: ResolversTypes['PostsPayload'] }>;
+ ID: ResolverTypeWrapper<Scalars['ID']['output']>;
+ UserResult: ResolverTypeWrapper<Omit<UserResult, 'recommendedPosts'> & { recommendedPosts: ResolversTypes['PostsPayload'] }>;
+ UserPayload: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['UserPayload']>;
+ Post: ResolverTypeWrapper<Post>;
+ PostsResult: ResolverTypeWrapper<PostsResult>;
+ PostsPayload: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['PostsPayload']>;
+ Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
+ };
+ `);
+
+ expect(result.content).toBeSimilarStringTo(`
+ export type ResolversParentTypes = {
+ StandardError: StandardError;
+ String: Scalars['String']['output'];
+ User: Omit<User, 'posts'> & { posts: ResolversParentTypes['PostsPayload'] };
+ ID: Scalars['ID']['output'];
+ UserResult: Omit<UserResult, 'recommendedPosts'> & { recommendedPosts: ResolversParentTypes['PostsPayload'] };
+ UserPayload: ResolversUnionTypes<ResolversParentTypes>['UserPayload'];
+ Post: Post;
+ PostsResult: PostsResult;
+ PostsPayload: ResolversUnionTypes<ResolversParentTypes>['PostsPayload'];
+ Boolean: Scalars['Boolean']['output'];
+ };
+ `);
+ });
 });