Merging schemas

[MidnightDesign]

Our project is separated by domain into multiple Composer packages, like acme/user and acme/event. We want to build a GraphQL API now and have the code be split into multiple packages like acme/user-graphql and acme/event-graphql. How would you recommend doing that?

Right now, we have a schema.graphql and resolvers.config.php in each package:

schema.graphql:

type Query {
    user(id: ID!): User
}
type User {
    # ...
}

resolvers.config.php:

<?php

return [
    'Query' => [
        'user' => QueryUser::class
    ]
];

We then want to combine the schemas into a single monolithic one. I thought we could do that by just concatenating the contents of the schema files, but then I get the error that there are multiple definitions of Query because every one of the packages tries to add something to the Query. I've also tried using the SchemaExtender but I get the same error.

The next thing I tried was using extend type Query but then I get the error Schema does not define the required query root type..

I would really appreciate it if you could point me in the right direction with this.

[vladar]

SchemaExtender expects "main" schema with all types defined + additional schema which explicitly extends types (with extends keyword). It doesn't merge two arbitrary schemas. You could get some insights on how it works in related tests and in the related issue (#180).

Merging arbitrary schemas is not a part of this lib (and not a part of the spec or reference implementation). But you can implement it yourself by parsing all schemas separately and then merging resulting ASTs into single AST instance which can be later passed to BuildSchema::build().

[MidnightDesign]

Thank you very much, that actually helps a lot.

Can you see any problems with this approach?

final class SchemaFromSourceFiles
{
    public static function build(string ...$files): Schema
    {
        $schema = new Schema([
            'query' => new ObjectType(['name' => 'Query']),
            'mutation' => new ObjectType(['name' => 'Mutation']),
        ]);
        $sources = array_map('\Safe\file_get_contents', $files);
        foreach ($sources as $source) {
            $ast = Parser::parse($source);
            $schema = SchemaExtender::extend($schema, $ast);
        }
        return $schema;
    }
}

...basically creating an empty schema and building on top of that.

[vladar]

If all of your types are unique then probably yes. But if you have overlapping types (say type User in multiple schemas) - then I think no because there should be one type User in one schema, and extends type User in other schemas.

[MidnightDesign]

Well, each type is "owned" by a single package. acme/user defines User and other packages extend it.

[vladar]

Also, you should try concatenating all of your schemas into a single string and extend in one go (vs extending in the loop). It should be faster. Not sure though that it would work but you should definitely try it. Please post here a short example if it doesn't work for some reason.

[MidnightDesign]

That worked!

final class SchemaFromSourceFiles
{
    public static function build(string ...$files): Schema
    {
        $schema = new Schema([
            'query' => new ObjectType(['name' => 'Query']),
            'mutation' => new ObjectType(['name' => 'Mutation']),
        ]);
        $sources = array_map('\Safe\file_get_contents', $files);
        $extensionSource = implode("\n", $sources);
        $ast = Parser::parse($extensionSource);
        return SchemaExtender::extend($schema, $ast);
    }
}

Thank you so much for the support.

[Warxcell]

That worked!

final class SchemaFromSourceFiles
{
    public static function build(string ...$files): Schema
    {
        $schema = new Schema([
            'query' => new ObjectType(['name' => 'Query']),
            'mutation' => new ObjectType(['name' => 'Mutation']),
        ]);
        $sources = array_map('\Safe\file_get_contents', $files);
        $extensionSource = implode("\n", $sources);
        $ast = Parser::parse($extensionSource);
        return SchemaExtender::extend($schema, $ast);
    }
}

Thank you so much for the support.

Here is another approach.

        $document =Parser::parse('all concatenated SDLs');

        $nonExtendDefs = [];
        $extendDefs = [];

        foreach ($document->definitions as $definition) {
            if ($definition instanceof TypeExtensionNode) {
                $extendDefs[] = $definition;
            } else {
                $nonExtendDefs[] = $definition;
            }
        }

        $schema = BuildSchema::build(
            new DocumentNode(['definitions' => new NodeList($nonExtendDefs)])
        );

        return SchemaExtender::extend(
            $schema,
            new DocumentNode(['definitions' => new NodeList($extendDefs)]),
        );