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.

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: {
          id,
        },
        context,
        info,
      });
    },
  },
});

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'],
  },
});

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;

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.

Runs the example in watch mode for development.

Run the tests

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.