Can the graphql-yoga build a subgraph?

[hazem-alabiad]

Can yoga-graphql replce apollo-server by running a subgraph server that uses the method buildSubgraphSchema() from @apollo/federation` package?

[saihaj]

Any spec compliant graphql schema can be used. I haven't tried it but most likely will work. Let us know if it doesn't then we can explore more.

[hazem-alabiad]

Here is my code:

const server = new ApolloServer({
  schema: buildSubgraphSchema([
    {
      typeDefs: gql(typeDefs),
      resolvers,
    },
  ]),
});

const { url } = await server.listen({ port: PORT });

console.log(chalk(`🚀  Microservice "${NAME}" ready at ${url}`));

The function buildSubgraphSchema does not work with createServer from graphql-yoga, I am getting unknown directive @key, @extend which are the essential directives of a federated graph. So, is there a way to run the subgraphs on their own port before having all of them run in the federated gateway?

[Urigo]

Answered here

[kinthaiofficial]

Yes, graphql-yoga supports Federation subgraph mode — here's how to wire it up:

import { createYoga } from 'graphql-yoga';
import { buildSubgraphSchema } from '@apollo/subgraph';
import { parse } from 'graphql';

// Define your subgraph schema with Federation directives
const typeDefs = parse(`
  extend schema
    @link(url: "https://specs.apollo.dev/federation/v2.0",
          import: ["@key", "@shareable", "@external", "@requires"])

  type Product @key(fields: "id") {
    id: ID!
    name: String!
    price: Float!
  }

  type Query {
    product(id: ID!): Product
    products: [Product!]!
  }
`);

const resolvers = {
  Product: {
    // Reference resolver — called when the gateway needs to resolve a product
    // from another subgraph that only has the key fields
    __resolveReference: async (reference: { id: string }) => {
      return await getProductById(reference.id);
    },
  },
  Query: {
    product: (_, { id }) => getProductById(id),
    products: () => getAllProducts(),
  },
};

const yoga = createYoga({
  schema: buildSubgraphSchema({ typeDefs, resolvers }),
  graphiql: {
    // Enable Apollo Explorer for schema introspection during development
    title: 'Product Subgraph',
  },
});

Federation v2 features that work well with Yoga:

• @key for entity references
• @shareable for shared types
• @requires for computed fields that need data from another subgraph

Testing without a full gateway:

// Mock the _service query that the gateway expects
// buildSubgraphSchema handles this automatically
fetch('http://localhost:4001/graphql', {
  method: 'POST',
  body: JSON.stringify({ query: '{ _service { sdl } }' }),
  headers: { 'Content-Type': 'application/json' },
});

For multi-agent APIs where each agent exposes its own GraphQL subgraph and a gateway federates them, this pattern works well: https://blog.kinthai.ai/221-agents-multi-agent-coordination-lessons