How to use pass TypeGraphQL resolver into buildSubgraphSchema when federating a GraphQL service

When federating a GraphQL service with TypeGraphQL, you can use the buildSubgraphSchema function to create a federated schema. This function allows you to combine multiple schemas, including resolvers, into a single federated schema. However, TypeGraphQL's buildSubgraphSchema function does not directly accept resolvers. Instead, you need to create the resolvers using the @Resolver decorator and then pass the resolver classes to the buildSubgraphSchema function.

Here's a step-by-step guide on how to use TypeGraphQL to federate a GraphQL service with resolvers:

1. Create Resolver Classes: Define your resolver classes using the @Resolver decorator from TypeGraphQL. Each resolver class should be responsible for handling a specific GraphQL type or field.

   typescriptCopy code
   // UserResolver.ts
   import { Resolver, Query } from 'type-graphql';
   
   @Resolver()
   class UserResolver {
     @Query(() => String)
     hello() {
       return 'Hello from User Resolver!';
     }
   }
   

   typescriptCopy code
   // PostResolver.ts
   import { Resolver, Query } from 'type-graphql';
   
   @Resolver()
   class PostResolver {
     @Query(() => String)
     hello() {
       return 'Hello from Post Resolver!';
     }
   }
   

2. Create Schema and Federate: Next, you need to create the schema and federate it. In this step, you use the buildSchema function from TypeGraphQL to create the executable schema from your resolver classes, and then you use the buildSubgraphSchema function from Apollo Federation to federate the schemas.

   typescriptCopy code
   // index.ts
   import 'reflect-metadata';
   import { buildSchema } from 'type-graphql';
   import { ApolloServer } from 'apollo-server';
   import { buildSubgraphSchema } from '@apollo/federation';
   
   import { UserResolver } from './UserResolver';
   import { PostResolver } from './PostResolver';
   
   async function startServer() {
     // Create the schema using buildSchema from TypeGraphQL
     const schema = await buildSchema({
       resolvers: [UserResolver, PostResolver],
     });
   
     // Federate the schema using buildSubgraphSchema from Apollo Federation
     const federatedSchema = buildSubgraphSchema([{ schema }]);
   
     // Create the ApolloServer with the federated schema
     const server = new ApolloServer({ schema: federatedSchema });
   
     // Start the server
     const { url } = await server.listen(4000);
     console.log(`Server is running, GraphQL Playground available at ${url}`);
   }
   
   startServer();
   

3. Start the Server: Run your Node.js application (e.g., node index.js) to start the federated GraphQL server. The server will be available at the specified URL (e.g., http://localhost:4000) and will have both User and Post types federated into a single schema.

By following these steps, you can federate multiple GraphQL schemas, each with its own TypeGraphQL resolvers, into a single federated schema using the buildSubgraphSchema function from Apollo Federation.