Merging schemas

[xpepermint]

I work on a huge project. To ensue project's long-term maintainability we decided to split the application into 3 standalone pieces thus we now have 3 specialized teams. Each app exposes its own GraphQL schema. At the end we plan to create the 4th app which will merge all 3 pieces together into a gateway application using the express-graphql package.

What is the best way to merge schemas? What we would need is a mechanism similar to Express Router. Our current plan is to make all 3 apps available as private packages from which we can build a new schema for the main (4th) app. Well, we could make each app act as a standalone private graphql server and then the main application would just send requests to sub-apps but I believe it could potentially represent a huge overhead. Am I wrong?

Are there any plans for supporting this? What do you suggest? How do you handle this at Facebook?

[KyleAMathews]

Just have each project export its types and combine those types together
into a schema.

On Sun, Nov 8, 2015 at 3:43 PM Kristijan Sedlak notifications@github.com
wrote:

I work on a huge project. To ensue project's long-term maintainability we
decided to split the application into 3 standalone pieces thus we now have
3 specialized teams. Each app exposes its own GraphQL schema. At the end we
plan to create the 4th app which will merge all 3 pieces together into a
gateway application using the express-graphql package.

What is the best way to merge schemas? What we would need is a
mechanism similar to Express Router
http://expressjs.com/guide/routing.html. Our current plan is to make
all 3 apps available as private packages from which we can build a new
schema for the main (4th) app. Well, we could make each app act as a
standalone private graphql server and then the main application would just
send requests to sub-apps but I believe it could potentially represent a
huge overhead. Am I wrong?

Are there any plans for supporting this? What do you suggest? How do you
handle this at Facebook?

—
Reply to this email directly or view it on GitHub
#223.

[xpepermint]

@KyleAMathews Thanks, that's what we plan to do. I just want to make sure that our thinking is correct.

[leebyron]

We maintain one schema at Facebook. Different teams are responsible for maintaining the types that are specific to their products, but there is only one final schema that combines all the types together into one GraphQL service available to our client applications.

[xpepermint]

@leebyron Thanks!

[worldsayshi]

@leebyron How is this done when using schema lang? If I run buildSchema it seems that I must first combine all the schema lang code into one string because I can't combine schemas once they are compiled as far as I can see..

[leebyron]

You're correct. If you're using the schema language to build a schema than you need to first combine it into a single string before calling buildSchema. That typically is a nice developer experience for small to medium sized schema, though for more complex schema we recommend building the schema programmatically. Even in this case you still need to collect all the types to assemble the schema. A similar operation to collecting all the strings before calling buildSchema

[worldsayshi]

Hmm, it seems that I don't strictly need to combine it to a string but a list of strings. There seems to be an util for combining schemas however, extendSchema. But it takes a GraphQLSchema and a Document. Not sure how to produce a Document.

[worldsayshi]

Oh! http://graphql.org/graphql-js/language/#parse

And: http://graphql.org/graphql-js/language/#source

[liamcurry]

For anyone else looking for a way to merge .graphql files, I've started working on some helper scripts in this repo: https://github.com/liamcurry/gql

You can use this to merge .graphql files into a single file. For example, if you have these files:

# schema1.graphql
type Query {
    foo: String
}

type Mutation {
    bar(input: String): String
}

# schema2.graphql
type Query {
    hello: String
}

type Mutation {
    world(input: String): String
}

and you ran this:

npm install -g gql-cli
gql merge **/*.graphql

You'd end up with this output:

type Query {
    foo: String
    hello: String
}

type Mutation {
    world(input: String): String
    bar(input: String): String
}

It should work with other type definitions too (enums, interfaces, inputs, etc).

[stubailo]

@liamcurry wow, this would be a really awesome addition to graphql-tools, since it would make it easy to split up stuff like the root Query type: https://github.com/apollostack/graphql-tools

Is it available as a library without the CLI?

[liamcurry]

@stubailo Yes it is. Check out the gql-merge npm package here: https://www.npmjs.com/package/gql-merge

The source for that is all in this file: https://github.com/liamcurry/gql/blob/master/packages/gql-merge/src/index.js

Here's an example (untested):

import {mergeStrings} from 'gql-merge'

const testSchema1 =
`type Query {
    hello: String
}`

const testSchema2 =
`type Query {
    world: String
}`

const resultSchema = mergeStrings([testSchema1, testSchema2])

console.log(resultSchema)
/* Should print this to the console:
type Query {
    hello: String
    world: String
}
*/

[stubailo]

Nice, we should definitely use that in graphql-tools - right now we just concatenate the strings but merging would probably be better!