Skip to content
Convert your existing GraphQL schema into a federated schema
TypeScript JavaScript
Branch: master
Clone or download
Latest commit 96a65a5 Oct 15, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information.
example Fix formatting Sep 28, 2019
src Rename typeName to objectName and fieldName Sep 28, 2019
.gitignore Prepare for npm release Sep 25, 2019
.prettierignore Ignore dist with prettier Sep 28, 2019
.prettierrc.js Always wrap markdown Sep 28, 2019 Mention blogpost in README Oct 15, 2019
jest.config.js Add requires / provides directives Sep 27, 2019
package-lock.json Release 2.0.1 Oct 15, 2019
package.json Release 2.0.1 Oct 15, 2019
tsconfig.json Prepare for npm release Sep 25, 2019


If you want to use GraphQL federation, but you can't rebuild your current GraphQL schema, you can use this transform to add GraphQL federation functionality to an existing schema. You need this when you are using a managed GraphQL service or a generated schema which doesn't support federation (yet).

If you are using apollo-server or another schema builder that supports federation you don't need this transform you should add the federation directives directly.

This transform will add the resolvers and directives to conform to the federation specification. Much of the federation sourcecode could be reused ensuring it is compliant to the specification.

Check out the blogpost introducing graphql-tranform-federation for more background information.

Architecture diagram for graphql-transform-federation


You can use this transform on a local or a remote GraphQL schema. When using a remote schema your service acts a middleware layer as shown in the diagram above. Check the remote schema documentation for how to get an executable schema that you can use with this transform.

The example below shows a configuration where the transformed schema extends an existing schema. It already had a resolver productById which is used to relate products between the two schemas. This example can be started using npm run example.

import { transformSchemaFederation } from 'graphql-transform-federation';
import { delegateToSchema } from 'graphql-tools';

const schemaWithoutFederation = // your existing executable schema

const federationSchema = transformSchemaFederation(schemaWithoutFederation, {
  Query: {
    // Ensure the root queries of this schema show up the combined schema
    extend: true,
  Product: {
    // extend Product {
    extend: true,
    // Product @key(fields: "id") {
    keyFields: ['id'],
    fields: {
      // id: Int! @external
      id: {
        external: true
    resolveReference({ id }, context, info) {
      return delegateToSchema({
        schema: info.schema,
        operation: 'query',
        fieldName: 'productById',
        args: {

To allow objects of an existing schema to be extended by other schemas it only needs to get @key(...) directives.

const federationSchema = transformSchemaFederation(schemaWithoutFederation, {
  Product: {
    // Product @key(fields: "id") {
    keyFields: ['id'],

API reference

import { GraphQLSchema } from 'graphql';
import { GraphQLReferenceResolver } from '@apollo/federation/dist/types';

interface FederationFieldConfig {
  external?: boolean;
  provides?: string;

interface FederationFieldsConfig {
  [fieldName: string]: FederationFieldConfig;

interface FederationObjectConfig<TContext> {
  // An array so you can add multiple @key(...) directives
  keyFields?: string[];
  extend?: boolean;
  resolveReference?: GraphQLReferenceResolver<TContext>;
  fields?: FederationFieldsConfig;

interface FederationConfig<TContext> {
  [objectName: string]: FederationObjectConfig<TContext>;

function transformSchemaFederation<TContext>(
  schema: GraphQLSchema,
  federationConfig: FederationConfig<TContext>,
): GraphQLSchema;

npm run example

Runs 2 GraphQL servers and a federation gateway to combine both schemas. Transformed-server is a regular GraphQL schema that is tranformed using this library. The federation-server is a federation server which is extended by a type defined by the transformed-server. The gateway combines both schemas using the apollo gateway.

npm run example:watch

Runs the example in watch mode for development.

npm run test

Run the tests

The requires directive

When extending an existing type you can resolve derived properties using the requires directive. When you have an existing schema that you want to transform to a federated schema I'm not sure what you would use if for. So unless I learn of a real world usecase, I can't implement the requires directive.

You can’t perform that action at this time.