This is a modified version of graphql-transform-federation by user 0xR. This version is upgraded to use latest versions of @graphql-tools and @apollo/gateway and @apollo/subgraph. This allows you to transform non-federated GraphQL services to GraphQL federation v2. I implemented "resolvable: false" feature for @key as an example. There's might still be issues, I haven't had time to test any edge cases. All credits due to 0xR. Code is as-is, pull requests are welcome.

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;
  requires?: string;
}

interface FederationFieldsConfig {
  [fieldName: string]: FederationFieldConfig;
}

interface FederationObjectConfig<TContext> {
  // An array so you can add multiple @key(...) directives
  keyFields?: string[];
  extend?: boolean;
  resolvable?: 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