How to stitch from a concrete to an abstract type?

[josephktcheung]

Hi,

Not sure if it's asked before. I'm currently stitching 2 graphql schemas together but I'm not sure how can I transform a node interface query result to a concrete type.

Here's a modified apollo stitching example. https://launchpad.graphql.com/0vjzzp49r5

Let's say both Chirp and Author implement Node interface. Instead of providing chirpById and authorById, both schemas only provide node query to query any item that implements Node interface.

import {
  makeExecutableSchema,
  addMockFunctionsToSchema,
  mergeSchemas,
} from 'graphql-tools';

// Mocked chirp schema
// We don't worry about the schema implementation right now since we're just
// demonstrating schema stitching.
const chirpSchema = makeExecutableSchema({
  typeDefs: `
    type Chirp {
      id: ID!
      text: String
      authorId: ID!
    }

    type Query {
      node(id: ID!): Node
      chirpsByAuthorId(authorId: ID!): [Chirp]
    }
  `
});

addMockFunctionsToSchema({ schema: chirpSchema });

// Mocked author schema
const authorSchema = makeExecutableSchema({
  typeDefs: `
    type User implements Node {
      id: ID!
      email: String
    }

    type Query {
      node(id: ID!): Node
    }
  `
});

addMockFunctionsToSchema({ schema: authorSchema });

export const schema = mergeSchemas({
  schemas: [
    chirpSchema,
    authorSchema,
  ],
});

And again we want to extend both Chirp and Author type:

const linkTypeDefs = `
  extend type User {
    chirps: [Chirp]
  }

  extend type Chirp {
    author: User
  }
`;

Then in the resolver map, here's how I resolve Chirp's author field by querying the node query from the Author schema...

{
  ...
    Chirp: {
      author: {
        fragment: `fragment ChirpFragment on Chirp { authorId }`,
        resolve(chirp, args, context, info) {
          return info.mergeInfo.delegateToSchema({
            schema: authorSchema,
            operation: 'query',
            fieldName: 'node',
            args: {
              id: chirp.authorId,
            },
            context,
            info,
          });
        },
      },
    },
}

Now if I perform the following query on the stitched schema, the author's email returns null:

query NotWorking {
  node(id: "fakeUserId") {
    ... on User {
      chirps {
        id
        author {
          email
        }
      }
    }
  }
}

I can get the author's email by doing something like this but it's not desirable:

query KindOfWorking {
  node(id: "fakeUserId") {
    ... on User {
      chirps {
        id
        author {
          ... on User {
            email
          }
        }
      }
    }
  }
}

Is it possible to make NotWorking query works i.e. getting User's fields without using inline fragments? Thanks!

[josephktcheung]

I guess I can utilise the new Transform api to transform the request from:

author {
  email
}

to:

author {
  ... on User {
    email
  }
}

I'm not familiar with how graphql's AST works so I hope someone can shed some light on this!

[josephktcheung]

Solved the problem. I created a new transformer called WrapFieldsInFragment which wraps the selections in a inline fragment of a target type and insert it into the selections of a parent type.

Here's the implementation:

import { Transform, Request } from 'graphql-tools';
import {
  GraphQLSchema,
  TypeInfo,
  visit,
  visitWithTypeInfo,
  parse,
  print,
  InlineFragmentNode,
  Kind,
  SelectionSetNode,
  SelectionNode,
} from 'graphql';

export class WrapFieldsInFragment implements Transform {
  private targetSchema: GraphQLSchema;
  private parentType: string;
  private targetType: string;
  constructor(
    targetSchema: GraphQLSchema,
    parentType: string,
    targetType: string,
  ) {
    this.targetSchema = targetSchema;
    this.parentType = parentType;
    this.targetType = targetType;
  }

  public transformRequest(originalRequest: Request) {
    const typeInfo = new TypeInfo(this.targetSchema);
    const document = visit(
      originalRequest.document,
      visitWithTypeInfo(typeInfo, {
        // tslint:disable-next-line function-name
        [Kind.SELECTION_SET]: (
          node: SelectionSetNode,
        ): SelectionSetNode | null | undefined => {
          const parentType = typeInfo.getParentType();
          let selections = node.selections;

          if (parentType && parentType.name === this.parentType) {
            const fragment = parse(
              `fragment ${this.targetType}Fragment on ${
                this.targetType
              } ${print(node)}`,
            );
            let inlineFragment: InlineFragmentNode;
            for (const definition of fragment.definitions) {
              if (definition.kind === Kind.FRAGMENT_DEFINITION) {
                inlineFragment = {
                  kind: Kind.INLINE_FRAGMENT,
                  typeCondition: definition.typeCondition,
                  selectionSet: definition.selectionSet,
                };
              }
            }
            selections = selections.concat(inlineFragment);
          }

          if (selections !== node.selections) {
            return {
              ...node,
              selections,
            };
          }
        },
      }),
    );
    return { ...originalRequest, document };
  }
}

To use it:

{
  ...
    Chirp: {
      author: {
        fragment: `fragment ChirpFragment on Chirp { authorId }`,
        resolve(chirp, args, context, info) {
          return info.mergeInfo.delegateToSchema({
            schema: authorSchema,
            operation: 'query',
            fieldName: 'node',
            args: {
              id: chirp.authorId,
            },
            context,
            info,
            transforms: [new WrapFieldsInFragment(authorSchema, 'Node', 'User')]
          });
        },
      },
    },
}

Then it will transform the request in the delegateToSchema from:

{
  node(id: "id-1") {
    id
    email
  }
}

to:

{
  node(id: "id-1") {
    id
    email
    ... on User {
      id
      email
    }
  }
}

Then the result will include all fields that a specific type contains.

[saerdnaer]

@josephktcheung Any reason why not to create a pull request with this quite useful transform?

[josephktcheung]

Hi @saerdnaer,

Feel free to take my code and create a pull request, I'm busy working on my own project so I don't have time to write the test cases and make a pull request :)

Best,
Joseph

[yaacovCR]

This transform should be built in like ExpandAbstractTypes, which allows delegation from abstract types in gateway to concrete in subschema, the reverse should also be built in.

[saerdnaer]

@yaacovCR Does the transform apply automatically or did you forget to add an export named WrapConcreteTypes in https://github.com/ardatan/graphql-tools/blob/master/packages/delegate/src/transforms/index.ts ?

[yaacovCR]

It applies automatically but I also meant to add an export. PR welcome, traveling....