[resolvers][federation] Bring Federation reference selection set to ResolversParentTypes instead of each resolver (#10297)

* Bring reference selection set to ResolversParentTypes

* Put back old types to extractReferenceSelectionSet

* Update tests for TDD

* Handle parent type consistently for __resolveReference and subsequent resolvers

* Update tests

Author: eddeee888

dev-test/test-schema/resolvers-federation.ts

@@ -154,7 +154,13 @@ export type ResolversParentTypes = {
   ID: Scalars['ID']['output'];
   Lines: Lines;
   Query: {};
-  User: User;
+  User:
+    | User
+    | ({ __typename: 'User' } & (
+        | GraphQLRecursivePick<FederationTypes['User'], { id: true }>
+        | GraphQLRecursivePick<FederationTypes['User'], { name: true }>
+      ) &
+        GraphQLRecursivePick<FederationTypes['User'], { address: { city: true; lines: { line2: true } } }>);
   Int: Scalars['Int']['output'];
   Boolean: Scalars['Boolean']['output'];
 };
@@ -197,22 +203,15 @@ export type UserResolvers<
 > = {
   __resolveReference?: ReferenceResolver<
     Maybe<ResolversTypes['User']>,
-    { __typename: 'User' } & (
-      | GraphQLRecursivePick<FederationType, { id: true }>
-      | GraphQLRecursivePick<FederationType, { name: true }>
-    ),
-    ContextType
-  >;
-
-  email?: Resolver<
-    ResolversTypes['String'],
     { __typename: 'User' } & (
       | GraphQLRecursivePick<FederationType, { id: true }>
       | GraphQLRecursivePick<FederationType, { name: true }>
     ) &
       GraphQLRecursivePick<FederationType, { address: { city: true; lines: { line2: true } } }>,
     ContextType
   >;
+
+  email?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 };
 
 export type Resolvers<ContextType = any> = {

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

@@ -803,13 +803,25 @@ export class BaseResolversVisitor<
       clearWrapper: type => this.clearResolverTypeWrapper(type),
       getTypeToUse: name => this.getTypeToUse(name),
       currentType: 'ResolversTypes',
+      onNotMappedObjectType: ({ initialType }) => initialType,
     });
     this._resolversParentTypes = this.createResolversFields({
       applyWrapper: type => type,
       clearWrapper: type => type,
       getTypeToUse: name => this.getParentTypeToUse(name),
       currentType: 'ResolversParentTypes',
       shouldInclude: namedType => !isEnumType(namedType),
+      onNotMappedObjectType: ({ typeName, initialType }) => {
+        let result = initialType;
+        const federationReferenceTypes = this._federation.printReferenceSelectionSets({
+          typeName,
+          baseFederationType: `${this.convertName('FederationTypes')}['${typeName}']`,
+        });
+        if (federationReferenceTypes) {
+          result += ` | ${federationReferenceTypes}`;
+        }
+        return result;
+      },
     });
     this._resolversUnionTypes = this.createResolversUnionTypes();
     this._resolversInterfaceTypes = this.createResolversInterfaceTypes();
@@ -882,12 +894,14 @@ export class BaseResolversVisitor<
     getTypeToUse,
     currentType,
     shouldInclude,
+    onNotMappedObjectType,
   }: {
     applyWrapper: (str: string) => string;
     clearWrapper: (str: string) => string;
     getTypeToUse: (str: string) => string;
     currentType: 'ResolversTypes' | 'ResolversParentTypes';
     shouldInclude?: (type: GraphQLNamedType) => boolean;
+    onNotMappedObjectType: (params: { initialType: string; typeName: string }) => string;
   }): ResolverTypes {
     const allSchemaTypes = this._schema.getTypeMap();
     const typeNames = this._federation.filterTypeNames(Object.keys(allSchemaTypes));
@@ -976,6 +990,11 @@ export class BaseResolversVisitor<
             if (this.config.mappers[typeName].type && hasPlaceholder(this.config.mappers[typeName].type)) {
               internalType = replacePlaceholder(this.config.mappers[typeName].type, internalType);
             }
+          } else {
+            internalType = onNotMappedObjectType({
+              typeName,
+              initialType: internalType,
+            });
           }
 
           prev[typeName] = applyWrapper(internalType);

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

@@ -147,8 +147,12 @@ describe('TypeScript Resolvers Plugin + Apollo Federation - Interface', () => {
         Query: {};
         Person: ResolversInterfaceTypes<ResolversParentTypes>['Person'];
         ID: Scalars['ID']['output'];
-        User: User;
-        Admin: Admin;
+        User: User |
+          ( { __typename: 'User' }
+          & GraphQLRecursivePick<FederationTypes['User'], {"id":true}> );
+        Admin: Admin |
+          ( { __typename: 'Admin' }
+          & GraphQLRecursivePick<FederationTypes['Admin'], {"id":true}> );
         Boolean: Scalars['Boolean']['output'];
         PersonName: PersonName;
         String: Scalars['String']['output'];
@@ -160,18 +164,24 @@ describe('TypeScript Resolvers Plugin + Apollo Federation - Interface', () => {
 
       export type PersonResolvers<ContextType = any, ParentType extends ResolversParentTypes['Person'] = ResolversParentTypes['Person'], FederationType extends FederationTypes['Person'] = FederationTypes['Person']> = {
         __resolveType: TypeResolveFn<'User' | 'Admin', ParentType, ContextType>;
-        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['Person']>, { __typename: 'Person' } & GraphQLRecursivePick<FederationType, {"id":true}>, ContextType>;
+        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['Person']>,
+          ( { __typename: 'Person' }
+          & GraphQLRecursivePick<FederationType, {"id":true}> ), ContextType>;
       };
 
       export type UserResolvers<ContextType = any, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User'], FederationType extends FederationTypes['User'] = FederationTypes['User']> = {
-        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['User']>, { __typename: 'User' } & GraphQLRecursivePick<FederationType, {"id":true}>, ContextType>;
+        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['User']>,
+          ( { __typename: 'User' }
+          & GraphQLRecursivePick<FederationType, {"id":true}> ), ContextType>;
         id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
         name?: Resolver<ResolversTypes['PersonName'], ParentType, ContextType>;
         __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
       };
 
       export type AdminResolvers<ContextType = any, ParentType extends ResolversParentTypes['Admin'] = ResolversParentTypes['Admin'], FederationType extends FederationTypes['Admin'] = FederationTypes['Admin']> = {
-        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['Admin']>, { __typename: 'Admin' } & GraphQLRecursivePick<FederationType, {"id":true}>, ContextType>;
+        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['Admin']>,
+          ( { __typename: 'Admin' }
+          & GraphQLRecursivePick<FederationType, {"id":true}> ), ContextType>;
         id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
         name?: Resolver<ResolversTypes['PersonName'], ParentType, ContextType>;
         canImpersonate?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;

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

@@ -144,7 +144,9 @@ describe('TypeScript Resolvers Plugin + Apollo Federation - mappers', () => {
       };
 
       export type UserResolvers<ContextType = any, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User'], FederationType extends FederationTypes['User'] = FederationTypes['User']> = {
-        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['User']>, { __typename: 'User' } & GraphQLRecursivePick<FederationType, {"id":true}>, ContextType>;
+        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['User']>,
+          ( { __typename: 'User' }
+          & GraphQLRecursivePick<FederationType, {"id":true}> ), ContextType>;
         id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
         name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
       };