Generate FederationReferenceTypes once

Author: eddeee888

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

@@ -818,12 +818,9 @@ export class BaseResolversVisitor<
       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}`;
+        const referenceSelectionSetsString = this._federation.getMeta()[typeName]?.referenceSelectionSetsString;
+        if (referenceSelectionSetsString) {
+          result += ` | ${this.convertName('FederationReferenceTypes')}['${typeName}']`;
         }
         return result;
       },
@@ -1306,6 +1303,33 @@ export class BaseResolversVisitor<
       ).string;
   }
 
+  public buildFederationReferenceTypes(): string {
+    const federationMeta = this._federation.getMeta();
+
+    if (Object.keys(federationMeta).length === 0) {
+      return '';
+    }
+
+    const declarationKind = 'type';
+    return new DeclarationBlock(this._declarationBlockConfig)
+      .export()
+      .asKind(declarationKind)
+      .withName(this.convertName('FederationReferenceTypes'))
+      .withComment('Mapping of federation reference types')
+      .withBlock(
+        Object.entries(federationMeta)
+          .map(([typeName, { referenceSelectionSetsString }]) => {
+            if (!referenceSelectionSetsString) {
+              return undefined;
+            }
+
+            return indent(`${typeName}: ${referenceSelectionSetsString}${this.getPunctuation(declarationKind)}`);
+          })
+          .filter(v => v)
+          .join('\n')
+      ).string;
+  }
+
   public get schema(): GraphQLSchema {
     return this._schema;
   }
@@ -1586,13 +1610,6 @@ export class BaseResolversVisitor<
           }
         }
 
-        const parentTypeSignature = this._federation.transformFieldParentType({
-          fieldNode: original,
-          parentType,
-          parentTypeSignature: this.getParentTypeForSignature(node),
-          federationTypeSignature: 'FederationType',
-        });
-
         const { mappedTypeKey, resolverType } = ((): { mappedTypeKey: string; resolverType: string } => {
           const baseType = getBaseTypeNode(original.type);
           const realType = baseType.name.value;
@@ -1637,16 +1654,18 @@ export class BaseResolversVisitor<
           name: typeName,
           modifier: avoidResolverOptionals ? '' : '?',
           type: resolverType,
-          genericTypes: [mappedTypeKey, parentTypeSignature, contextType, argsType].filter(f => f),
+          genericTypes: [mappedTypeKey, this.getParentTypeForSignature(node), contextType, argsType].filter(f => f),
         };
 
         if (this._federation.isResolveReferenceField(node)) {
           if (!this._federation.getMeta()[parentType.name].hasResolveReference) {
             return { value: '', meta };
           }
+          const resultType = `${mappedTypeKey} | FederationReferenceType`;
+          const referenceType = 'FederationReferenceType';
+
           signature.type = 'ReferenceResolver';
-          signature.genericTypes = [mappedTypeKey, parentTypeSignature, contextType];
-          meta.federation = { isResolveReference: true };
+          signature.genericTypes = [resultType, referenceType, contextType];
         }
 
         return {
@@ -1788,7 +1807,7 @@ export class BaseResolversVisitor<
     ];
     this._federation.addFederationTypeGenericIfApplicable({
       genericTypes,
-      federationTypesType: this.convertName('FederationTypes'),
+      federationTypesType: this.convertName('FederationReferenceTypes'),
       typeName,
     });
 

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

@@ -250,6 +250,7 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
 `;
 
   const federationTypes = visitor.buildFederationTypes();
+  const federationReferenceTypes = visitor.buildFederationReferenceTypes();
   const resolversTypeMapping = visitor.buildResolversTypes();
   const resolversParentTypeMapping = visitor.buildResolversParentTypes();
   const resolversUnionTypesMapping = visitor.buildResolversUnionTypes();
@@ -294,6 +295,7 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
     content: [
       header,
       federationTypes,
+      federationReferenceTypes,
       resolversUnionTypesMapping,
       resolversInterfaceTypesMapping,
       resolversTypeMapping,

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

@@ -300,12 +300,20 @@ describe('TypeScript Resolvers Plugin + Apollo Federation', () => {
     expect(content).toBeSimilarStringTo(`
       export type ResolversParentTypes = {
         Query: {};
-        Account: Account |
-          ( { __typename: 'Account' }
-          & GraphQLRecursivePick<FederationTypes['Account'], {"id":true}> );
+        Account: Account | FederationReferenceTypes['Account'];
         ID: Scalars['ID']['output'];
         String: Scalars['String']['output'];
-        User: User |
+        User: User | FederationReferenceTypes['User'];
+        Boolean: Scalars['Boolean']['output'];
+      };
+    `);
+
+    expect(content).toBeSimilarStringTo(`
+      export type FederationReferenceTypes = {
+        Account:
+          ( { __typename: 'Account' }
+          & GraphQLRecursivePick<FederationTypes['Account'], {"id":true}> );
+        User:
           ( { __typename: 'User' }
           & GraphQLRecursivePick<FederationTypes['User'], {"id":true}>
           & ( {}
@@ -323,31 +331,13 @@ describe('TypeScript Resolvers Plugin + Apollo Federation', () => {
               | GraphQLRecursivePick<FederationTypes['User'], {"c":true}>
               | GraphQLRecursivePick<FederationTypes['User'], {"c":true,"d":true}>
               | GraphQLRecursivePick<FederationTypes['User'], {"d":true}> ) );
-        Boolean: Scalars['Boolean']['output'];
       };
     `);
 
     // User should have it
     expect(content).toBeSimilarStringTo(`
-      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}>
-          & ( {}
-              | GraphQLRecursivePick<FederationType, {"a":true}>
-              | GraphQLRecursivePick<FederationType, {"a":true,"b":true}>
-              | GraphQLRecursivePick<FederationType, {"a":true,"c":true}>
-              | GraphQLRecursivePick<FederationType, {"a":true,"d":true}>
-              | GraphQLRecursivePick<FederationType, {"a":true,"b":true,"c":true}>
-              | GraphQLRecursivePick<FederationType, {"a":true,"b":true,"d":true}>
-              | GraphQLRecursivePick<FederationType, {"a":true,"b":true,"c":true,"d":true}>
-              | GraphQLRecursivePick<FederationType, {"b":true}>
-              | GraphQLRecursivePick<FederationType, {"b":true,"c":true}>
-              | GraphQLRecursivePick<FederationType, {"b":true,"d":true}>
-              | GraphQLRecursivePick<FederationType, {"b":true,"c":true,"d":true}>
-              | GraphQLRecursivePick<FederationType, {"c":true}>
-              | GraphQLRecursivePick<FederationType, {"c":true,"d":true}>
-              | GraphQLRecursivePick<FederationType, {"d":true}> ) ), ContextType>;
+      export type UserResolvers<ContextType = any, ParentType extends ResolversParentTypes['User'] = ResolversParentTypes['User'], FederationReferenceType extends FederationReferenceTypes['User'] = FederationReferenceTypes['User']> = {
+        __resolveReference?: ReferenceResolver<Maybe<ResolversTypes['User']> | FederationReferenceType, FederationReferenceType, ContextType>;
         id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
         aRequires?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
         bRequires?: Resolver<ResolversTypes['String'], ParentType, ContextType>;